home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / VILE327.ZIP / VILE327.TAR / vile3.27 / nefunc.h < prev    next >
C/C++ Source or Header  |  1992-12-14  |  20KB  |  704 lines
  1. /* nefunc.h: this header file was produced automatically by
  2.  * the ./mktbls program, based on input from the file cmdtbl
  3.  */
  4. extern int altbuff();
  5.     CMDFUNC f_altbuff = { altbuff,    NONE };
  6. extern int append();
  7.     CMDFUNC f_append = { append,    REDO|UNDO };
  8. extern int appendeol();
  9.     CMDFUNC f_appendeol = { appendeol,    REDO|UNDO };
  10. #if APROP|REBIND
  11. extern int apro();
  12.     CMDFUNC f_apro = { apro,    NONE };
  13. #endif
  14. extern int backchar();
  15.     CMDFUNC f_backchar = { backchar,    MOTION };
  16. extern int backchar_to_bol();
  17.     CMDFUNC f_backchar_to_bol = { backchar_to_bol,    MOTION };
  18. extern int backdelchar();
  19.     CMDFUNC f_backdelchar = { backdelchar,    REDO|UNDO };
  20. #if !SMALLER
  21. extern int backhunt();
  22.     CMDFUNC f_backhunt = { backhunt,    ABS|MOTION };
  23. #endif
  24. extern int backhpage();
  25.     CMDFUNC f_backhpage = { backhpage,    NONE };
  26. extern int backline();
  27.     CMDFUNC f_backline = { backline,    GOAL|MOTION|FL };
  28. extern int backbline();
  29.     CMDFUNC f_backbline = { backbline,    MOTION|FL };
  30. extern int backpage();
  31.     CMDFUNC f_backpage = { backpage,    MOTION };
  32. extern int backword();
  33.     CMDFUNC f_backword = { backword,    MOTION };
  34. extern int backviword();
  35.     CMDFUNC f_backviword = { backviword,    MOTION };
  36. extern int backsearch();
  37.     CMDFUNC f_backsearch = { backsearch,    ABS|MOTION };
  38. extern int bcsrch();
  39.     CMDFUNC f_bcsrch = { bcsrch,    MOTION };
  40. extern int bcsrch_to();
  41.     CMDFUNC f_bcsrch_to = { bcsrch_to,    MOTION };
  42. #if REBIND
  43. extern int bindkey();
  44.     CMDFUNC f_bindkey = { bindkey,    NONE };
  45. #endif
  46. extern int bktoshell();
  47.     CMDFUNC f_bktoshell = { bktoshell,    NONE };
  48. extern int cd();
  49.     CMDFUNC f_cd = { cd,    NONE };
  50. extern int cntl_xf();
  51.     CMDFUNC f_cntl_xf = { cntl_xf,    NONE };
  52. extern int chgchar();
  53.     CMDFUNC f_chgchar = { chgchar,    REDO|UNDO };
  54. extern int chgline();
  55.     CMDFUNC f_chgline = { chgline,    REDO|UNDO };
  56. extern int chgtoeol();
  57.     CMDFUNC f_chgtoeol = { chgtoeol,    REDO|UNDO };
  58. extern int clrmes();
  59.     CMDFUNC f_clrmes = { clrmes,    NONE };
  60. extern int consearch();
  61.     CMDFUNC f_consearch = { consearch,    ABS|MOTION };
  62. extern int opercopy();
  63.     CMDFUNC f_opercopy = { opercopy,    OPER|(RANGE|EXTRA) };
  64. extern int kbd_mac_begin();
  65.     CMDFUNC f_kbd_mac_begin = { kbd_mac_begin,    NONE };
  66. extern int kbd_mac_end();
  67.     CMDFUNC f_kbd_mac_end = { kbd_mac_end,    NONE };
  68. extern int kbd_mac_exec();
  69.     CMDFUNC f_kbd_mac_exec = { kbd_mac_exec,    REDO|UNDO };
  70. extern int kbd_mac_save();
  71.     CMDFUNC f_kbd_mac_save = { kbd_mac_save,    NONE };
  72. extern int cbuf1();
  73.     CMDFUNC f_cbuf1 = { cbuf1,    REDO };
  74. extern int cbuf2();
  75.     CMDFUNC f_cbuf2 = { cbuf2,    REDO };
  76. extern int cbuf3();
  77.     CMDFUNC f_cbuf3 = { cbuf3,    REDO };
  78. extern int cbuf4();
  79.     CMDFUNC f_cbuf4 = { cbuf4,    REDO };
  80. extern int cbuf5();
  81.     CMDFUNC f_cbuf5 = { cbuf5,    REDO };
  82. extern int cbuf6();
  83.     CMDFUNC f_cbuf6 = { cbuf6,    REDO };
  84. extern int cbuf7();
  85.     CMDFUNC f_cbuf7 = { cbuf7,    REDO };
  86. extern int cbuf8();
  87.     CMDFUNC f_cbuf8 = { cbuf8,    REDO };
  88. extern int cbuf9();
  89.     CMDFUNC f_cbuf9 = { cbuf9,    REDO };
  90. extern int cbuf10();
  91.     CMDFUNC f_cbuf10 = { cbuf10,    REDO };
  92. #if !SMALLER
  93. extern int cbuf11();
  94.     CMDFUNC f_cbuf11 = { cbuf11,    REDO };
  95. #endif
  96. #if !SMALLER
  97. extern int cbuf12();
  98.     CMDFUNC f_cbuf12 = { cbuf12,    REDO };
  99. #endif
  100. #if !SMALLER
  101. extern int cbuf13();
  102.     CMDFUNC f_cbuf13 = { cbuf13,    REDO };
  103. #endif
  104. #if !SMALLER
  105. extern int cbuf14();
  106.     CMDFUNC f_cbuf14 = { cbuf14,    REDO };
  107. #endif
  108. #if !SMALLER
  109. extern int cbuf15();
  110.     CMDFUNC f_cbuf15 = { cbuf15,    REDO };
  111. #endif
  112. #if !SMALLER
  113. extern int cbuf16();
  114.     CMDFUNC f_cbuf16 = { cbuf16,    REDO };
  115. #endif
  116. #if !SMALLER
  117. extern int cbuf17();
  118.     CMDFUNC f_cbuf17 = { cbuf17,    REDO };
  119. #endif
  120. #if !SMALLER
  121. extern int cbuf18();
  122.     CMDFUNC f_cbuf18 = { cbuf18,    REDO };
  123. #endif
  124. #if !SMALLER
  125. extern int cbuf19();
  126.     CMDFUNC f_cbuf19 = { cbuf19,    REDO };
  127. #endif
  128. #if !SMALLER
  129. extern int cbuf20();
  130.     CMDFUNC f_cbuf20 = { cbuf20,    REDO };
  131. #endif
  132. #if !SMALLER
  133. extern int cbuf21();
  134.     CMDFUNC f_cbuf21 = { cbuf21,    REDO };
  135. #endif
  136. #if !SMALLER
  137. extern int cbuf22();
  138.     CMDFUNC f_cbuf22 = { cbuf22,    REDO };
  139. #endif
  140. #if !SMALLER
  141. extern int cbuf23();
  142.     CMDFUNC f_cbuf23 = { cbuf23,    REDO };
  143. #endif
  144. #if !SMALLER
  145. extern int cbuf24();
  146.     CMDFUNC f_cbuf24 = { cbuf24,    REDO };
  147. #endif
  148. #if !SMALLER
  149. extern int cbuf25();
  150.     CMDFUNC f_cbuf25 = { cbuf25,    REDO };
  151. #endif
  152. #if !SMALLER
  153. extern int cbuf26();
  154.     CMDFUNC f_cbuf26 = { cbuf26,    REDO };
  155. #endif
  156. #if !SMALLER
  157. extern int cbuf27();
  158.     CMDFUNC f_cbuf27 = { cbuf27,    REDO };
  159. #endif
  160. #if !SMALLER
  161. extern int cbuf28();
  162.     CMDFUNC f_cbuf28 = { cbuf28,    REDO };
  163. #endif
  164. #if !SMALLER
  165. extern int cbuf29();
  166.     CMDFUNC f_cbuf29 = { cbuf29,    REDO };
  167. #endif
  168. #if !SMALLER
  169. extern int cbuf30();
  170.     CMDFUNC f_cbuf30 = { cbuf30,    REDO };
  171. #endif
  172. #if !SMALLER
  173. extern int cbuf31();
  174.     CMDFUNC f_cbuf31 = { cbuf31,    REDO };
  175. #endif
  176. #if !SMALLER
  177. extern int cbuf32();
  178.     CMDFUNC f_cbuf32 = { cbuf32,    REDO };
  179. #endif
  180. #if !SMALLER
  181. extern int cbuf33();
  182.     CMDFUNC f_cbuf33 = { cbuf33,    REDO };
  183. #endif
  184. #if !SMALLER
  185. extern int cbuf34();
  186.     CMDFUNC f_cbuf34 = { cbuf34,    REDO };
  187. #endif
  188. #if !SMALLER
  189. extern int cbuf35();
  190.     CMDFUNC f_cbuf35 = { cbuf35,    REDO };
  191. #endif
  192. #if !SMALLER
  193. extern int cbuf36();
  194.     CMDFUNC f_cbuf36 = { cbuf36,    REDO };
  195. #endif
  196. #if !SMALLER
  197. extern int cbuf37();
  198.     CMDFUNC f_cbuf37 = { cbuf37,    REDO };
  199. #endif
  200. #if !SMALLER
  201. extern int cbuf38();
  202.     CMDFUNC f_cbuf38 = { cbuf38,    REDO };
  203. #endif
  204. #if !SMALLER
  205. extern int cbuf39();
  206.     CMDFUNC f_cbuf39 = { cbuf39,    REDO };
  207. #endif
  208. #if !SMALLER
  209. extern int cbuf40();
  210.     CMDFUNC f_cbuf40 = { cbuf40,    REDO };
  211. #endif
  212. extern int delwind();
  213.     CMDFUNC f_delwind = { delwind,    NONE };
  214. #if AEDIT
  215. extern int deblank();
  216.     CMDFUNC f_deblank = { deblank,    REDO|UNDO };
  217. #endif
  218. extern int delgmode();
  219.     CMDFUNC f_delgmode = { delgmode,    NONE };
  220. extern int delmode();
  221.     CMDFUNC f_delmode = { delmode,    NONE|(EXRCOK|EXTRA) };
  222. extern int deltoeol();
  223.     CMDFUNC f_deltoeol = { deltoeol,    REDO|UNDO };
  224. #if REBIND
  225. extern int desbind();
  226.     CMDFUNC f_desbind = { desbind,    NONE };
  227. #endif
  228. #if REBIND
  229. extern int deskey();
  230.     CMDFUNC f_deskey = { deskey,    NONE };
  231. #endif
  232. extern int dotcmdplay();
  233.     CMDFUNC f_dotcmdplay = { dotcmdplay,    UNDO };
  234. extern int ex();
  235.     CMDFUNC f_ex = { ex,    NONE|(BANG|FILE1) };
  236. #if !SMALLER
  237. extern int execbuf();
  238.     CMDFUNC f_execbuf = { execbuf,    NONE };
  239. #endif
  240. #if NEVER
  241. extern int execcmd();
  242.     CMDFUNC f_execcmd = { execcmd,    NONE };
  243. #endif
  244. #if !SMALLER
  245. extern int execfile();
  246.     CMDFUNC f_execfile = { execfile,    NONE };
  247. #endif
  248. extern int execkreg();
  249.     CMDFUNC f_execkreg = { execkreg,    NONE };
  250. #if PROC
  251. extern int execproc();
  252.     CMDFUNC f_execproc = { execproc,    REDO };
  253. #endif
  254. extern int enlargewind();
  255.     CMDFUNC f_enlargewind = { enlargewind,    NONE };
  256. extern int esc();
  257.     CMDFUNC f_esc = { esc,    NONE };
  258. extern int fcsrch();
  259.     CMDFUNC f_fcsrch = { fcsrch,    MOTION };
  260. extern int fcsrch_to();
  261.     CMDFUNC f_fcsrch_to = { fcsrch_to,    MOTION };
  262. extern int filefind();
  263.     CMDFUNC f_filefind = { filefind,    NONE|(BANG|FILE1|PLUS) };
  264. extern int filename();
  265.     CMDFUNC f_filename = { filename,    NONE|(NAMEDF) };
  266. extern int fileread();
  267.     CMDFUNC f_fileread = { fileread,    NONE };
  268. #if !SMALLER
  269. extern int filesave();
  270.     CMDFUNC f_filesave = { filesave,    NONE };
  271. #endif
  272. extern int filewrite();
  273.     CMDFUNC f_filewrite = { filewrite,    NONE };
  274. extern int filter();
  275.     CMDFUNC f_filter = { filter,    REDO|UNDO };
  276. #if FINDERR
  277. extern int finderr();
  278.     CMDFUNC f_finderr = { finderr,    NONE };
  279. #endif
  280. extern int firstnonwhite();
  281.     CMDFUNC f_firstnonwhite = { firstnonwhite,    MOTION };
  282. #if ISRCH
  283. extern int fisearch();
  284.     CMDFUNC f_fisearch = { fisearch,    NONE };
  285. #endif
  286. extern int flipchar();
  287.     CMDFUNC f_flipchar = { flipchar,    REDO|UNDO };
  288. #if FLABEL
  289. extern int fnclabel();
  290.     CMDFUNC f_fnclabel = { fnclabel,    NONE };
  291. #endif
  292. extern int forwdelchar();
  293.     CMDFUNC f_forwdelchar = { forwdelchar,    REDO|UNDO };
  294. extern int forwhpage();
  295.     CMDFUNC f_forwhpage = { forwhpage,    NONE };
  296. extern int forwchar();
  297.     CMDFUNC f_forwchar = { forwchar,    MOTION };
  298. extern int forwchar_to_eol();
  299.     CMDFUNC f_forwchar_to_eol = { forwchar_to_eol,    MOTION };
  300. extern int forwpage();
  301.     CMDFUNC f_forwpage = { forwpage,    MOTION };
  302. extern int forwline();
  303.     CMDFUNC f_forwline = { forwline,    GOAL|MOTION|FL };
  304. extern int forwbline();
  305.     CMDFUNC f_forwbline = { forwbline,    MOTION|FL };
  306. extern int forwword();
  307.     CMDFUNC f_forwword = { forwword,    MOTION };
  308. extern int forwviword();
  309.     CMDFUNC f_forwviword = { forwviword,    MOTION };
  310. extern int forwendw();
  311.     CMDFUNC f_forwendw = { forwendw,    MOTION };
  312. extern int forwviendw();
  313.     CMDFUNC f_forwviendw = { forwviendw,    MOTION };
  314. #if !SMALLER
  315. extern int forwhunt();
  316.     CMDFUNC f_forwhunt = { forwhunt,    ABS|MOTION };
  317. #endif
  318. extern int forwsearch();
  319.     CMDFUNC f_forwsearch = { forwsearch,    ABS|MOTION };
  320. #if CFENCE
  321. extern int matchfence();
  322.     CMDFUNC f_matchfence = { matchfence,    ABS|MOTION };
  323. #endif
  324. #if CFENCE
  325. extern int matchfenceback();
  326.     CMDFUNC f_matchfenceback = { matchfenceback,    ABS|MOTION };
  327. #endif
  328. #if GLOBALS
  329. extern int globals();
  330.     CMDFUNC f_globals = { globals,    NONE };
  331. #endif
  332. extern int godotplus();
  333.     CMDFUNC f_godotplus = { godotplus,    MOTION|FL };
  334. extern int gomark();
  335.     CMDFUNC f_gomark = { gomark,    MOTION|FL|(RANGE|ZERO) };
  336. #if WORDPRO
  337. extern int gotobop();
  338.     CMDFUNC f_gotobop = { gotobop,    ABS|MOTION };
  339. #endif
  340. #if WORDPRO
  341. extern int gotoeop();
  342.     CMDFUNC f_gotoeop = { gotoeop,    ABS|MOTION };
  343. #endif
  344. #if !SMALLER
  345. extern int gotobob();
  346.     CMDFUNC f_gotobob = { gotobob,    ABS|MOTION };
  347. #endif
  348. #if !SMALLER
  349. extern int gotoeob();
  350.     CMDFUNC f_gotoeob = { gotoeob,    ABS|MOTION };
  351. #endif
  352. extern int gotobol();
  353.     CMDFUNC f_gotobol = { gotobol,    MOTION };
  354. extern int gotoeol();
  355.     CMDFUNC f_gotoeol = { gotoeol,    MOTION|GOAL };
  356. extern int gotobos();
  357.     CMDFUNC f_gotobos = { gotobos,    ABS|MOTION|FL };
  358. extern int gotomos();
  359.     CMDFUNC f_gotomos = { gotomos,    ABS|MOTION|FL };
  360. extern int gotoeos();
  361.     CMDFUNC f_gotoeos = { gotoeos,    ABS|MOTION|FL };
  362. #if WORDPRO
  363. extern int gotobosec();
  364.     CMDFUNC f_gotobosec = { gotobosec,    ABS|MOTION };
  365. #endif
  366. #if WORDPRO
  367. extern int gotoeosec();
  368.     CMDFUNC f_gotoeosec = { gotoeosec,    ABS|MOTION };
  369. #endif
  370. #if WORDPRO
  371. extern int gotobosent();
  372.     CMDFUNC f_gotobosent = { gotobosent,    ABS|MOTION };
  373. #endif
  374. #if WORDPRO
  375. extern int gotoeosent();
  376.     CMDFUNC f_gotoeosent = { gotoeosent,    ABS|MOTION };
  377. #endif
  378. #if TAGS
  379. extern int gototag();
  380.     CMDFUNC f_gototag = { gototag,    NONE|(BANG|WORD1) };
  381. #endif
  382. extern int gotocol();
  383.     CMDFUNC f_gotocol = { gotocol,    MOTION };
  384. extern int gotoline();
  385.     CMDFUNC f_gotoline = { gotoline,    ABS|MOTION|FL|(RANGE) };
  386. extern int golinenmmark();
  387.     CMDFUNC f_golinenmmark = { golinenmmark,    MOTION|FL };
  388. extern int goexactnmmark();
  389.     CMDFUNC f_goexactnmmark = { goexactnmmark,    MOTION };
  390. extern int help();
  391.     CMDFUNC f_help = { help,    NONE };
  392. extern int histbuff();
  393.     CMDFUNC f_histbuff = { histbuff,    NONE };
  394. extern int insert();
  395.     CMDFUNC f_insert = { insert,    REDO|UNDO };
  396. extern int insertbol();
  397.     CMDFUNC f_insertbol = { insertbol,    REDO|UNDO };
  398. extern int insfile();
  399.     CMDFUNC f_insfile = { insfile,    REDO|UNDO|GLOBOK|(FROM|ZERO|NAMEDF) };
  400. #if !SMALLER
  401. extern int insspace();
  402.     CMDFUNC f_insspace = { insspace,    REDO|UNDO };
  403. #endif
  404. #if !SMALLER
  405. extern int istring();
  406.     CMDFUNC f_istring = { istring,    REDO|UNDO };
  407. #endif
  408. extern int join();
  409.     CMDFUNC f_join = { join,    REDO|UNDO };
  410. extern int killbuffer();
  411.     CMDFUNC f_killbuffer = { killbuffer,    NONE };
  412. extern int showlength();
  413.     CMDFUNC f_showlength = { showlength,    NONE };
  414. #if !SMALLER
  415. extern int lastnonwhite();
  416.     CMDFUNC f_lastnonwhite = { lastnonwhite,    MOTION };
  417. #endif
  418. extern int listbuffers();
  419.     CMDFUNC f_listbuffers = { listbuffers,    NONE };
  420. extern int lineputafter();
  421.     CMDFUNC f_lineputafter = { lineputafter,    REDO|UNDO|GLOBOK|(FROM|ZERO|WORD1) };
  422. extern int lineputbefore();
  423.     CMDFUNC f_lineputbefore = { lineputbefore,    REDO|UNDO|GLOBOK|(FROM|WORD1) };
  424. extern int lineundo();
  425.     CMDFUNC f_lineundo = { lineundo,    NONE };
  426. extern int loadkreg();
  427.     CMDFUNC f_loadkreg = { loadkreg,    NONE };
  428. extern int map();
  429.     CMDFUNC f_map = { map,    NONE|(EXRCOK|BANG|EXTRA) };
  430. extern int cntl_af();
  431.     CMDFUNC f_cntl_af = { cntl_af,    NONE };
  432. extern int mvdnnxtwind();
  433.     CMDFUNC f_mvdnnxtwind = { mvdnnxtwind,    NONE };
  434. extern int mvupnxtwind();
  435.     CMDFUNC f_mvupnxtwind = { mvupnxtwind,    NONE };
  436. extern int mvdnwind();
  437.     CMDFUNC f_mvdnwind = { mvdnwind,    GOAL };
  438. extern int mvupwind();
  439.     CMDFUNC f_mvupwind = { mvupwind,    GOAL };
  440. extern int mvrightwind();
  441.     CMDFUNC f_mvrightwind = { mvrightwind,    GOAL };
  442. extern int mvleftwind();
  443.     CMDFUNC f_mvleftwind = { mvleftwind,    GOAL };
  444. extern int nextbuffer();
  445.     CMDFUNC f_nextbuffer = { nextbuffer,    NONE|(BANG|NAMEDFS) };
  446. extern int namebuffer();
  447.     CMDFUNC f_namebuffer = { namebuffer,    NONE };
  448. #if !SMALLER
  449. extern int newline();
  450.     CMDFUNC f_newline = { newline,    REDO|UNDO };
  451. #endif
  452. extern int newlength();
  453.     CMDFUNC f_newlength = { newlength,    NONE };
  454. extern int newwidth();
  455.     CMDFUNC f_newwidth = { newwidth,    NONE };
  456. extern int nextwind();
  457.     CMDFUNC f_nextwind = { nextwind,    NONE };
  458. extern int nullproc();
  459.     CMDFUNC f_nullproc = { nullproc,    NONE };
  460. extern int onamedcmd();
  461.     CMDFUNC f_onamedcmd = { onamedcmd,    NONE };
  462. extern int namedcmd();
  463.     CMDFUNC f_namedcmd = { namedcmd,    NONE };
  464. extern int openup();
  465.     CMDFUNC f_openup = { openup,    REDO|UNDO|(FROM) };
  466. extern int opendown();
  467.     CMDFUNC f_opendown = { opendown,    REDO|UNDO|(FROM|ZERO) };
  468. extern int operchg();
  469.     CMDFUNC f_operchg = { operchg,    OPER|REDO|UNDO };
  470. #if AEDIT
  471. extern int operdetab();
  472.     CMDFUNC f_operdetab = { operdetab,    OPER|REDO|UNDO|GLOBOK|(RANGE) };
  473. #endif
  474. #if AEDIT
  475. extern int operentab();
  476.     CMDFUNC f_operentab = { operentab,    OPER|REDO|UNDO|GLOBOK|(RANGE) };
  477. #endif
  478. extern int opermove();
  479.     CMDFUNC f_opermove = { opermove,    OPER|(RANGE|EXTRA) };
  480. extern int operlinechg();
  481.     CMDFUNC f_operlinechg = { operlinechg,    OPER|REDO|UNDO|(RANGE) };
  482. extern int operdel();
  483.     CMDFUNC f_operdel = { operdel,    OPER|REDO|UNDO };
  484. extern int operlinedel();
  485.     CMDFUNC f_operlinedel = { operlinedel,    OPER|REDO|UNDO|GLOBOK|(RANGE+WORD1) };
  486. extern int operfilter();
  487.     CMDFUNC f_operfilter = { operfilter,    OPER|REDO|UNDO|(EXRCOK|RANGE|NAMEDFS|DFLNONE|NL) };
  488. #if WORDPRO
  489. extern int operformat();
  490.     CMDFUNC f_operformat = { operformat,    OPER|REDO|UNDO|(RANGE) };
  491. #endif
  492. extern int operflip();
  493.     CMDFUNC f_operflip = { operflip,    OPER|REDO|UNDO|GLOBOK|(RANGE) };
  494. #if GLOBALS
  495. extern int operglobals();
  496.     CMDFUNC f_operglobals = { operglobals,    (/*RANGE|*/BANG|EXTRA|DFLALL) };
  497. #endif
  498. #if GLOBALS
  499. extern int opervglobals();
  500.     CMDFUNC f_opervglobals = { opervglobals,    (RANGE|BANG|EXTRA|DFLALL) };
  501. #endif
  502. extern int operlower();
  503.     CMDFUNC f_operlower = { operlower,    OPER|REDO|UNDO|GLOBOK|(RANGE) };
  504. #if GLOBALS
  505. extern int operlist();
  506.     CMDFUNC f_operlist = { operlist,    OPER|GLOBOK|(RANGE) };
  507. #endif
  508. #if GLOBALS
  509. extern int operprint();
  510.     CMDFUNC f_operprint = { operprint,    OPER|GLOBOK|(RANGE) };
  511. #endif
  512. extern int operupper();
  513.     CMDFUNC f_operupper = { operupper,    OPER|REDO|UNDO|GLOBOK|(RANGE) };
  514. extern int operlshift();
  515.     CMDFUNC f_operlshift = { operlshift,    OPER|REDO|UNDO|GLOBOK|(RANGE) };
  516. extern int operrshift();
  517.     CMDFUNC f_operrshift = { operrshift,    OPER|REDO|UNDO|GLOBOK|(RANGE) };
  518. extern int opersubst();
  519.     CMDFUNC f_opersubst = { opersubst,    OPER|REDO|UNDO|GLOBOK|(RANGE|EXTRA) };
  520. #if AEDIT
  521. extern int opertrim();
  522.     CMDFUNC f_opertrim = { opertrim,    REDO|UNDO|GLOBOK|UNDO|(RANGE) };
  523. #endif
  524. extern int operyank();
  525.     CMDFUNC f_operyank = { operyank,    OPER };
  526. extern int operlineyank();
  527.     CMDFUNC f_operlineyank = { operlineyank,    OPER|(RANGE|WORD1) };
  528. extern int opersubstagain();
  529.     CMDFUNC f_opersubstagain = { opersubstagain,    OPER|REDO|UNDO|GLOBOK|(RANGE|EXTRA) };
  530. extern int opertransf();
  531.     CMDFUNC f_opertransf = { opertransf,    OPER|(RANGE+EXTRA) };
  532. extern int operwrite();
  533.     CMDFUNC f_operwrite = { operwrite,    OPER|(RANGE|BANG|FILE1|DFLALL) };
  534. extern int overwrite();
  535.     CMDFUNC f_overwrite = { overwrite,    REDO|UNDO };
  536. extern int onlywind();
  537.     CMDFUNC f_onlywind = { onlywind,    NONE };
  538. extern int poswind();
  539.     CMDFUNC f_poswind = { poswind,    NONE };
  540. extern int prevwind();
  541.     CMDFUNC f_prevwind = { prevwind,    NONE };
  542. extern int pipecmd();
  543.     CMDFUNC f_pipecmd = { pipecmd,    NONE };
  544. extern int putafter();
  545.     CMDFUNC f_putafter = { putafter,    REDO|UNDO };
  546. extern int putbefore();
  547.     CMDFUNC f_putbefore = { putbefore,    REDO|UNDO };
  548. extern int pwd();
  549.     CMDFUNC f_pwd = { pwd,    NONE };
  550. extern int quit();
  551.     CMDFUNC f_quit = { quit,    NONE|(BANG) };
  552. extern int quithard();
  553.     CMDFUNC f_quithard = { quithard,    NONE };
  554. extern int quickexit();
  555.     CMDFUNC f_quickexit = { quickexit,    NONE|(BANG|NL) };
  556. extern int quote();
  557.     CMDFUNC f_quote = { quote,    REDO|UNDO };
  558. extern int refresh();
  559.     CMDFUNC f_refresh = { refresh,    NONE };
  560. #if !SMALLER
  561. extern int reposition();
  562.     CMDFUNC f_reposition = { reposition,    NONE };
  563. #endif
  564. extern int rep_csrch();
  565.     CMDFUNC f_rep_csrch = { rep_csrch,    MOTION };
  566. extern int replacechar();
  567.     CMDFUNC f_replacechar = { replacechar,    REDO|UNDO };
  568. extern int respawn();
  569.     CMDFUNC f_respawn = { respawn,    NONE };
  570. #if !SMALLER
  571. extern int resize();
  572.     CMDFUNC f_resize = { resize,    NONE };
  573. #endif
  574. #if !SMALLER
  575. extern int restwnd();
  576.     CMDFUNC f_restwnd = { restwnd,    NONE };
  577. #endif
  578. extern int rev_csrch();
  579.     CMDFUNC f_rev_csrch = { rev_csrch,    MOTION };
  580. #if ISRCH
  581. extern int risearch();
  582.     CMDFUNC f_risearch = { risearch,    NONE };
  583. #endif
  584. extern int revsearch();
  585.     CMDFUNC f_revsearch = { revsearch,    ABS|MOTION };
  586. extern int scrforwsearch();
  587.     CMDFUNC f_scrforwsearch = { scrforwsearch,    ABS|MOTION };
  588. extern int scrbacksearch();
  589.     CMDFUNC f_scrbacksearch = { scrbacksearch,    ABS|MOTION };
  590. extern int scrsearchpat();
  591.     CMDFUNC f_scrsearchpat = { scrsearchpat,    NONE };
  592. extern int settab();
  593.     CMDFUNC f_settab = { settab,    NONE };
  594. extern int spawncli();
  595.     CMDFUNC f_spawncli = { spawncli,    NONE };
  596. #if !SMALLER
  597. extern int savewnd();
  598.     CMDFUNC f_savewnd = { savewnd,    NONE };
  599. #endif
  600. extern int scrnextup();
  601.     CMDFUNC f_scrnextup = { scrnextup,    NONE };
  602. extern int scrnextdw();
  603.     CMDFUNC f_scrnextdw = { scrnextdw,    NONE };
  604. extern int setfillcol();
  605.     CMDFUNC f_setfillcol = { setfillcol,    NONE };
  606. #if CRYPT
  607. extern int setkey();
  608.     CMDFUNC f_setkey = { setkey,    NONE };
  609. #endif
  610. extern int setmode();
  611.     CMDFUNC f_setmode = { setmode,    NONE|(EXRCOK|EXTRA) };
  612. extern int setgmode();
  613.     CMDFUNC f_setgmode = { setgmode,    NONE };
  614. extern int setnmmark();
  615.     CMDFUNC f_setnmmark = { setnmmark,    NONE|(FROM+WORD1) };
  616. #if !SMALLER
  617. extern int setvar();
  618.     CMDFUNC f_setvar = { setvar,    NONE };
  619. #endif
  620. #if VMALLOC
  621. extern int setvmalloc();
  622.     CMDFUNC f_setvmalloc = { setvmalloc,    NONE };
  623. #endif
  624. extern int showcpos();
  625.     CMDFUNC f_showcpos = { showcpos,    NONE };
  626. extern int listmodes();
  627.     CMDFUNC f_listmodes = { listmodes,    NONE };
  628. extern int showversion();
  629.     CMDFUNC f_showversion = { showversion,    NONE|(EXRCOK) };
  630. extern int shrinkwind();
  631.     CMDFUNC f_shrinkwind = { shrinkwind,    NONE };
  632. extern int source();
  633.     CMDFUNC f_source = { source,    NONE|(EXRCOK|NAMEDF) };
  634. extern int spawn();
  635.     CMDFUNC f_spawn = { spawn,    NONE };
  636. extern int speckey();
  637.     CMDFUNC f_speckey = { speckey,    NONE };
  638. extern int splitwind();
  639.     CMDFUNC f_splitwind = { splitwind,    NONE };
  640. extern int storemac();
  641.     CMDFUNC f_storemac = { storemac,    NONE };
  642. #if PROC
  643. extern int storeproc();
  644.     CMDFUNC f_storeproc = { storeproc,    NONE };
  645. #endif
  646. extern int subst_again();
  647.     CMDFUNC f_subst_again = { subst_again,    REDO|UNDO|GLOBOK };
  648. extern int togglelistbuffers();
  649.     CMDFUNC f_togglelistbuffers = { togglelistbuffers,    NONE };
  650. #if !SMALLER
  651. extern int twiddle();
  652.     CMDFUNC f_twiddle = { twiddle,    REDO|UNDO };
  653. #endif
  654. #if REBIND
  655. extern int unbindkey();
  656.     CMDFUNC f_unbindkey = { unbindkey,    NONE };
  657. #endif
  658. extern int undo();
  659.     CMDFUNC f_undo = { undo,    NONE };
  660. extern int unarg();
  661.     CMDFUNC f_unarg = { unarg,    NONE };
  662. extern int unimpl();
  663.     CMDFUNC f_unimpl = { unimpl,    NONE };
  664. extern int unmark();
  665.     CMDFUNC f_unmark = { unmark,    NONE };
  666. extern int unmap();
  667.     CMDFUNC f_unmap = { unmap,    NONE|(EXRCOK|BANG|EXTRA) };
  668. #if TAGS
  669. extern int untagpop();
  670.     CMDFUNC f_untagpop = { untagpop,    NONE };
  671. #endif
  672. #if !SMALLER
  673. extern int upscreen();
  674.     CMDFUNC f_upscreen = { upscreen,    NONE };
  675. #endif
  676. extern int usebuffer();
  677.     CMDFUNC f_usebuffer = { usebuffer,    NONE };
  678. extern int usekreg();
  679.     CMDFUNC f_usekreg = { usekreg,    REDO };
  680. extern int visual();
  681.     CMDFUNC f_visual = { visual,    NONE };
  682. #if GLOBALS
  683. extern int vglobals();
  684.     CMDFUNC f_vglobals = { vglobals,    NONE };
  685. #endif
  686. extern int viewfile();
  687.     CMDFUNC f_viewfile = { viewfile,    NONE };
  688. extern int writeall();
  689.     CMDFUNC f_writeall = { writeall,    NONE|(NL) };
  690. extern int writequit();
  691.     CMDFUNC f_writequit = { writequit,    NONE|(NL) };
  692. #if !SMALLER
  693. extern int wrapword();
  694.     CMDFUNC f_wrapword = { wrapword,    REDO|UNDO };
  695. #endif
  696. #if !SMALLER
  697. extern int writemsg();
  698.     CMDFUNC f_writemsg = { writemsg,    NONE };
  699. #endif
  700. extern int yankline();
  701.     CMDFUNC f_yankline = { yankline,    NONE };
  702. extern int zzquit();
  703.     CMDFUNC f_zzquit = { zzquit,    NONE|(BANG|NL) };
  704.