# 2.11BSD#431 - /usr/src/new/jove/funcdefs.c

##### Functions

    findcom           X

##### Variables

    commands          X

##### Macros

    WIRED_CMD         X
    hash              X

       1: /***************************************************************************
       2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
       3:  * is provided to you without charge, and with no warranty.  You may give  *
       4:  * away copies of JOVE, including sources, provided that this notice is    *
       5:  * included in all the files.                                              *
       6:  ***************************************************************************/
       7:
       8: #include "jove.h"
       9: #include "ctype.h"
      10:
      11: #if !defined(TXT_TO_C)
      12: extern void
      13:     EscPrefix(),
      14:     CtlxPrefix(),
      15:     MiscPrefix(),
      16:     UnbindC(),
      17:     ShowVersion(),
      18:     WVisSpace(),
      19: #ifdef ANSICODES
      20:     AnsiCodes(),
      21: #endif
      22:     AppReg(),
      23:     Apropos(),
      24:     BackChar(),
      25:     BList(),
      26:     FList(),
      27:     BUpList(),
      28:     FDownList(),
      29:     BSexpr(),
      30:     BackWord(),
      31:     Bof(),
      32:     Bol(),
      33:     Bos(),
      34:     Bow(),
      35:     BindAKey(),
      36:     BindMac(),
      37:     BufPos(),
      38: #ifdef MSDOS
      39:     Buf1Select(),
      40:     Buf2Select(),
      41:     Buf3Select(),
      42:     Buf4Select(),
      43:     Buf5Select(),
      44:     Buf6Select(),
      45:     Buf7Select(),
      46:     Buf8Select(),
      47:     Buf9Select(),
      48:     Buf10Select(),
      49: #endif /* MSDOS */
      50:     CasRegLower(),
      51:     CasRegUpper(),
      52:     CapChar(),
      53:     CapWord(),
      54:     LowWord(),
      55:     UppWord(),
      56: #ifdef CHDIR
      57:     Chdir(),
      58:     prCWD(),
      59:     prDIRS(),
      60:     Pushd(),
      61:     Popd(),
      62: #endif
      63:     prCTIME(),
      64:     ChrToOct(),
      65:     ClAndRedraw(),
      66: #ifndef MAC
      67:     MakeErrors(),
      68: #endif
      69:     CopyRegion(),
      70:     BufSelect(),
      71:     DelBlnkLines(),
      72:     DelNChar(),
      73:     DelNWord(),
      74:     OneWindow(),
      75:     DelPChar(),
      76:     DelPWord(),
      77:     DelReg(),
      78:     KillSome(),
      79:     DelWtSpace(),
      80:     DelCurWindow(),
      81:     KeyDesc(),
      82:     Digit(),
      83:     Digit0(),
      84:     Digit1(),
      85:     Digit2(),
      86:     Digit3(),
      87:     Digit4(),
      88:     Digit5(),
      89:     Digit6(),
      90:     Digit7(),
      91:     Digit8(),
      92:     Digit9(),
      93:     DescBindings(),
      94:     DescCom(),
      95:     Eof(),
      96:     Eol(),
      97:     Eos(),
      98:     Eow(),
      99:     ForPara(),
     100:     BackPara(),
     101:     BufErase(),
     102:     PtToMark(),
     103:     Extend(),
     104:     ExecMacro(),
     105:     RunMacro(),
     106:     Leave(),
     107:     FindFile(),
     108:     WindFind(),
     109:     FindTag(),
     110:     FDotTag(),
     111:     ToIndent(),
     112:     ForChar(),
     113:     FSexpr(),
     114:     ForWord(),
     115:     TimesFour(),
     116:     GoLine(),
     117:     GrowWindow(),
     118:     IncFSearch(),
     119:     IncRSearch(),
     120:     InsFile(),
     121:     Justify(),
     122:     RegJustify(),
     123:     SetLMargin(),
     124:     SetRMargin(),
     125:     BufKill(),
     126:     KillBos(),
     127:     KillEos(),
     128:     KillEOL(),
     129:     KillExpr(),
     130:     BufList(),
     131:     NotModified(),
     132:     NameMac(),
     133:     DelMacro(),
     134:     Newline(),
     135:     OpenLine(),
     136:     LineAI(),
     137: #ifndef MAC
     138:     ShowErr(),
     139:     NextError(),
     140: #endif /* MAC */
     141: #ifdef MSDOS
     142:     PageScrollUp(),
     143:     PageScrollDown(),
     144: #endif /* MSDOS */
     145: #ifndef MAC
     146:     PrevError(),
     147: #endif /* MAC */
     148:     NextLine(),
     149:     NextPage(),
     150:     NextWindow(),
     151:     Recur(),
     152:     PopMark(),
     153:     PageNWind(),
     154:     Tab(),
     155:     DoParen(),
     156: #ifndef MAC
     157:     ParseAll(),
     158: #endif
     159: #ifdef SPELL
     160:     SpelWords(),
     161: #endif
     162: #ifdef JOB_CONTROL
     163:     PauseJove(),
     164: #endif
     165:     PrevLine(),
     166:     PrevPage(),
     167:     PrevWindow(),
     168: #ifndef MAC
     169:     Push(),
     170: #endif
     171:     RegReplace(),
     172:     QRepSearch(),
     173:     QuotChar(),
     174:     ReadFile(),
     175:     DefKBDMac(),
     176:     RedrawDisplay(),
     177:     ReNamBuf(),
     178:     RepSearch(),
     179:     DownScroll(),
     180:     UpScroll(),
     181:     ForSearch(),
     182:     FSrchND(),
     183:     RevSearch(),
     184:     RSrchND(),
     185:     SelfInsert(),
     186:     SetVar(),
     187:     SetMark(),
     188: #ifndef MAC
     189:     ShellCom(),
     190:     ShNoBuf(),
     191:     Shtypeout(),
     192:     ShToBuf(),
     193: #endif
     194:     ShrWindow(),
     195:     Source(),
     196: #ifdef SPELL
     197:     SpelBuffer(),
     198: #endif
     199:     SplitWind(),
     200:     GotoWind(),
     201:     Remember(),
     202:     Forget(),
     203:     StrLength(),
     204:     TransChar(),
     205:     TransLines(),
     206:     SaveFile(),
     207:     WtModBuf(),
     208:     WriteFile(),
     209:     WriteMacs(),
     210:     WrtReg(),
     211:     Yank(),
     212:     YankPop(),  PrVar(),
     213: #ifndef MAC
     214:     FilterRegion(),
     215: #endif
     216:     WNumLines(),
     217: #ifdef IPROCS
     218:     ShellProc(),
     219:     ProcInt(),
     220:     ProcQuit(),
     221:     ProcKill(),
     222: #  ifndef PIPEPROCS
     223:     ProcEof(),
     224:     ProcStop(),
     225:     ProcCont(),
     226:     ProcDStop(),
     227: #  endif
     228:     ProcSendData(),
     229:     ProcNewline(),
     230:     ProcList(),
     231:     ProcBind(),
     232:     Iprocess(),
     233: #endif
     234:
     235: #ifdef LISP
     236:     GSexpr(),   /* Grind S Expression. */
     237:     AddSpecial(),   /* add lisp special form */
     238: #endif
     239:     CAutoExec(),
     240:     MAutoExec(),
     241:
     242:     DefMAbbrev(),
     243:     DefGAbbrev(),
     244:     SaveAbbrevs(),
     245:     RestAbbrevs(),
     246:     EditAbbrevs(),
     247:     BindMtoW(),
     248:
     249: #ifdef CMT_FMT
     250:     Comment(),
     251: #endif
     252:
     253:     ScrollLeft(),
     254:     ScrollRight(),
     255:     MacInter();     /* This is the last one. */
     256:
     257:
     258: #ifdef MAC
     259: #	define WIRED_CMD(c) c,'\0','\0'   /* for About Jove... */
     260: #else
     261: #	define WIRED_CMD(c)   c
     262: #endif /* MAC */
     263:
     264: #else /* TXT_TO_C */
     265:
     266: #ifdef MAC
     267: #	define WIRED_CMD(c) 0,'\0','\0'
     268: #else
     269: #	define WIRED_CMD(c)   0
     270: #endif
     271: #endif /* TXT_TO_C */
     272:
     273: struct cmd  commands[] = {
     274: #ifdef LISP
     275:     FUNCTION, "add-lisp-special", WIRED_CMD(AddSpecial),
     276: #endif
     277: #ifdef ANSICODES
     278:     FUNCTION, "ansi-codes", WIRED_CMD(AnsiCodes),
     279: #endif
     280:     FUNCTION, "append-region", WIRED_CMD(AppReg),
     281:     FUNCTION, "apropos", WIRED_CMD(Apropos),
     282:     FUNCTION, "auto-execute-command", WIRED_CMD(CAutoExec),
     283:     FUNCTION, "auto-execute-macro", WIRED_CMD(MAutoExec),
     284:     DefMinor(Fill), "auto-fill-mode", WIRED_CMD(0),
     285:     DefMinor(Indent), "auto-indent-mode", WIRED_CMD(0),
     286:     FUNCTION, "backward-character", WIRED_CMD(BackChar),
     287:     FUNCTION, "backward-list", WIRED_CMD(BList),
     288:     FUNCTION, "backward-paragraph", WIRED_CMD(BackPara),
     289:     FUNCTION, "backward-s-expression", WIRED_CMD(BSexpr),
     290:     FUNCTION, "backward-sentence", WIRED_CMD(Bos),
     291:     FUNCTION, "backward-up-list", WIRED_CMD(BUpList),
     292:     FUNCTION, "backward-word", WIRED_CMD(BackWord),
     293:     FUNCTION, "begin-kbd-macro", WIRED_CMD(Remember),
     294:     FUNCTION, "beginning-of-file", WIRED_CMD(Bof),
     295:     FUNCTION, "beginning-of-line", WIRED_CMD(Bol),
     296:     FUNCTION, "beginning-of-window", WIRED_CMD(Bow),
     297:     FUNCTION, "bind-to-key", WIRED_CMD(BindAKey),
     298:     FUNCTION, "bind-macro-to-key", WIRED_CMD(BindMac),
     299: #ifdef ABBREV
     300:     FUNCTION, "bind-macro-to-word-abbrev", WIRED_CMD(BindMtoW),
     301: #endif
     302:     FUNCTION, "buffer-position", WIRED_CMD(BufPos),
     303:     DefMajor(CMODE), "c-mode", WIRED_CMD(0),
     304:     FUNCTION, "case-character-capitalize", WIRED_CMD(CapChar),
     305:     FUNCTION, "case-region-lower", WIRED_CMD(CasRegLower),
     306:     FUNCTION, "case-region-upper", WIRED_CMD(CasRegUpper),
     307:     FUNCTION, "case-word-capitalize", WIRED_CMD(CapWord),
     308:     FUNCTION, "case-word-lower", WIRED_CMD(LowWord),
     309:     FUNCTION, "case-word-upper", WIRED_CMD(UppWord),
     310:     FUNCTION, "character-to-octal-insert", WIRED_CMD(ChrToOct),
     311: #ifdef CHDIR
     312:     FUNCTION, "cd", WIRED_CMD(Chdir),
     313: #endif
     314:     FUNCTION, "clear-and-redraw", WIRED_CMD(ClAndRedraw),
     315: #ifndef MAC
     316:     FUNCTION, "compile-it", WIRED_CMD(MakeErrors),
     317: #endif
     318: #ifdef IPROCS
     319: #  ifndef PIPEPROCS
     320: #    ifdef TIOCSLTC
     321:     FUNCTION, "continue-process", WIRED_CMD(ProcCont),
     322: #    endif
     323: #  endif
     324: #endif
     325:     FUNCTION, "copy-region", WIRED_CMD(CopyRegion),
     326: #ifndef MAC
     327:     FUNCTION, "current-error", WIRED_CMD(ShowErr),
     328: #endif
     329:     FUNCTION, "date", WIRED_CMD(prCTIME),
     330: #ifdef ABBREV
     331:     FUNCTION, "define-global-word-abbrev", WIRED_CMD(DefGAbbrev),
     332:     FUNCTION, "define-mode-word-abbrev", WIRED_CMD(DefMAbbrev),
     333: #endif
     334:     FUNCTION, "define-macro", WIRED_CMD(DefKBDMac),
     335:     FUNCTION, "delete-blank-lines", WIRED_CMD(DelBlnkLines),
     336:     FUNCTION, "delete-buffer", WIRED_CMD(BufKill),
     337:     FUNCTION, "delete-macro", WIRED_CMD(DelMacro),
     338:     FUNCTION, "delete-next-character", WIRED_CMD(DelNChar),
     339:     FUNCTION, "delete-other-windows", WIRED_CMD(OneWindow),
     340:     FUNCTION, "delete-previous-character", WIRED_CMD(DelPChar),
     341:     FUNCTION, "delete-white-space", WIRED_CMD(DelWtSpace),
     342:     FUNCTION, "delete-current-window", WIRED_CMD(DelCurWindow),
     343:     FUNCTION, "describe-bindings", WIRED_CMD(DescBindings),
     344:     FUNCTION, "describe-command", WIRED_CMD(DescCom),
     345:     FUNCTION, "describe-key", WIRED_CMD(KeyDesc),
     346:     FUNCTION, "describe-variable", WIRED_CMD(DescCom),
     347:     FUNCTION, "digit", WIRED_CMD(Digit),
     348:     FUNCTION, "digit-1", WIRED_CMD(Digit1),
     349:     FUNCTION, "digit-2", WIRED_CMD(Digit2),
     350:     FUNCTION, "digit-3", WIRED_CMD(Digit3),
     351:     FUNCTION, "digit-4", WIRED_CMD(Digit4),
     352:     FUNCTION, "digit-5", WIRED_CMD(Digit5),
     353:     FUNCTION, "digit-6", WIRED_CMD(Digit6),
     354:     FUNCTION, "digit-7", WIRED_CMD(Digit7),
     355:     FUNCTION, "digit-8", WIRED_CMD(Digit8),
     356:     FUNCTION, "digit-9", WIRED_CMD(Digit9),
     357:     FUNCTION, "digit-0", WIRED_CMD(Digit0),
     358: #ifdef CHDIR
     359:     FUNCTION, "dirs", WIRED_CMD(prDIRS),
     360: #endif
     361:     FUNCTION, "down-list", WIRED_CMD(FDownList),
     362: #ifdef IPROCS
     363: #  ifndef PIPEPROCS
     364: #    ifdef TIOCSLTC
     365:     FUNCTION, "dstop-process", WIRED_CMD(ProcDStop),
     366: #    endif
     367: #  endif
     368: #endif
     369: #ifdef ABBREV
     370:     FUNCTION, "edit-word-abbrevs", WIRED_CMD(EditAbbrevs),
     371: #endif
     372:     FUNCTION, "end-kbd-macro", WIRED_CMD(Forget),
     373:     FUNCTION, "end-of-file", WIRED_CMD(Eof),
     374:     FUNCTION, "end-of-line", WIRED_CMD(Eol),
     375:     FUNCTION, "end-of-window", WIRED_CMD(Eow),
     376: #ifdef IPROCS
     377: #  ifndef PIPEPROCS
     378:     FUNCTION, "eof-process", WIRED_CMD(ProcEof),
     379: #  endif
     380: #endif
     381:     FUNCTION, "erase-buffer", WIRED_CMD(BufErase),
     382:     FUNCTION, "exchange-point-and-mark", WIRED_CMD(PtToMark),
     383:     FUNCTION, "execute-named-command", WIRED_CMD(Extend),
     384:     FUNCTION, "execute-kbd-macro", WIRED_CMD(ExecMacro),
     385:     FUNCTION, "execute-macro", WIRED_CMD(RunMacro),
     386:     FUNCTION, "exit-jove", WIRED_CMD(Leave),
     387: #ifdef CMT_FMT
     388:     FUNCTION, "fill-comment", WIRED_CMD(Comment),
     389: #endif /* CMT_FMT */
     390:     FUNCTION, "fill-paragraph", WIRED_CMD(Justify),
     391:     FUNCTION, "fill-region", WIRED_CMD(RegJustify),
     392: #ifndef MAC
     393:     FUNCTION, "filter-region", WIRED_CMD(FilterRegion),
     394: #endif
     395:     FUNCTION, "find-file", WIRED_CMD(FindFile),
     396:     FUNCTION, "find-tag", WIRED_CMD(FindTag),
     397:     FUNCTION, "find-tag-at-point", WIRED_CMD(FDotTag),
     398:     FUNCTION, "first-non-blank", WIRED_CMD(ToIndent),
     399:     FUNCTION, "forward-character", WIRED_CMD(ForChar),
     400:     FUNCTION, "forward-list", WIRED_CMD(FList),
     401:     FUNCTION, "forward-paragraph", WIRED_CMD(ForPara),
     402:     FUNCTION, "forward-s-expression", WIRED_CMD(FSexpr),
     403:     FUNCTION, "forward-sentence", WIRED_CMD(Eos),
     404:     FUNCTION, "forward-word", WIRED_CMD(ForWord),
     405:     DefMajor(FUNDAMENTAL), "fundamental-mode", WIRED_CMD(0),
     406:     FUNCTION, "gather-numeric-argument", WIRED_CMD(TimesFour),
     407: #ifdef LISP
     408:     FUNCTION, "grind-s-expr", WIRED_CMD(GSexpr),
     409: #endif
     410:     FUNCTION, "goto-line", WIRED_CMD(GoLine),
     411:     FUNCTION, "goto-window-with-buffer", WIRED_CMD(GotoWind),
     412:     FUNCTION, "grow-window", WIRED_CMD(GrowWindow),
     413:     FUNCTION, "handle-tab", WIRED_CMD(Tab),
     414:     FUNCTION, "i-search-forward", WIRED_CMD(IncFSearch),
     415:     FUNCTION, "i-search-reverse", WIRED_CMD(IncRSearch),
     416:     FUNCTION, "insert-file", WIRED_CMD(InsFile),
     417: #ifdef IPROCS
     418:     FUNCTION, "interrupt-process", WIRED_CMD(ProcInt),
     419:     FUNCTION, "i-shell-command", WIRED_CMD(Iprocess),
     420: #endif
     421:     FUNCTION, "kill-next-word", WIRED_CMD(DelNWord),
     422:     FUNCTION, "kill-previous-word", WIRED_CMD(DelPWord),
     423: #ifdef IPROCS
     424:     FUNCTION, "kill-process", WIRED_CMD(ProcKill),
     425: #endif
     426:     FUNCTION, "kill-region", WIRED_CMD(DelReg),
     427:     FUNCTION, "kill-s-expression", WIRED_CMD(KillExpr),
     428:     FUNCTION, "kill-some-buffers", WIRED_CMD(KillSome),
     429:     FUNCTION, "kill-to-beginning-of-sentence", WIRED_CMD(KillBos),
     430:     FUNCTION, "kill-to-end-of-line", WIRED_CMD(KillEOL),
     431:     FUNCTION, "kill-to-end-of-sentence", WIRED_CMD(KillEos),
     432:     FUNCTION, "left-margin-here", WIRED_CMD(SetLMargin),
     433: #ifdef LISP
     434:     DefMajor(LISPMODE), "lisp-mode", WIRED_CMD(0),
     435: #endif
     436:     FUNCTION, "list-buffers", WIRED_CMD(BufList),
     437: #ifdef IPROCS
     438:     FUNCTION, "list-processes", WIRED_CMD(ProcList),
     439: #endif
     440:     FUNCTION, "make-buffer-unmodified", WIRED_CMD(NotModified),
     441:     FUNCTION, "make-macro-interactive", WIRED_CMD(MacInter),
     442:     FUNCTION, "name-kbd-macro", WIRED_CMD(NameMac),
     443:     FUNCTION, "newline", WIRED_CMD(Newline),
     444:     FUNCTION, "newline-and-backup", WIRED_CMD(OpenLine),
     445:     FUNCTION, "newline-and-indent", WIRED_CMD(LineAI),
     446: #ifndef MAC
     447:     FUNCTION, "next-error", WIRED_CMD(NextError),
     448: #endif
     449:     FUNCTION, "next-line", WIRED_CMD(NextLine),
     450:     FUNCTION, "next-page", WIRED_CMD(NextPage),
     451:     FUNCTION, "next-window", WIRED_CMD(NextWindow),
     452:     FUNCTION, "number-lines-in-window", WIRED_CMD(WNumLines),
     453:     DefMinor(OverWrite), "over-write-mode", WIRED_CMD(0),
     454:     FUNCTION, "page-next-window", WIRED_CMD(PageNWind),
     455:     FUNCTION, "paren-flash", WIRED_CMD(DoParen),
     456: #ifndef MAC
     457:     FUNCTION, "parse-errors", WIRED_CMD(ErrParse),
     458: #endif
     459: #ifdef SPELL
     460:     FUNCTION, "parse-spelling-errors-in-buffer", WIRED_CMD(SpelWords),
     461: #endif
     462: #ifdef JOB_CONTROL
     463:     FUNCTION, "pause-jove", WIRED_CMD(PauseJove),
     464: #else
     465: #	ifndef MAC
     466:     FUNCTION, "pause-jove", WIRED_CMD(Push),
     467: #	endif
     468: #endif
     469:     FUNCTION, "pop-mark", WIRED_CMD(PopMark),
     470: #ifdef CHDIR
     471:     FUNCTION, "popd", WIRED_CMD(Popd),
     472: #endif
     473:     FUNCTION, "prefix-1", WIRED_CMD(EscPrefix),
     474:     FUNCTION, "prefix-2", WIRED_CMD(CtlxPrefix),
     475:     FUNCTION, "prefix-3", WIRED_CMD(MiscPrefix),
     476: #ifndef MAC
     477:     FUNCTION, "previous-error", WIRED_CMD(PrevError),
     478: #endif
     479:     FUNCTION, "previous-line", WIRED_CMD(PrevLine),
     480:     FUNCTION, "previous-page", WIRED_CMD(PrevPage),
     481:     FUNCTION, "previous-window", WIRED_CMD(PrevWindow),
     482:     FUNCTION, "print", WIRED_CMD(PrVar),
     483: #ifdef IPROCS
     484:     FUNCTION, "process-bind-to-key", WIRED_CMD(ProcBind),
     485:     FUNCTION, "process-newline", WIRED_CMD(ProcNewline),
     486:     FUNCTION, "process-send-data-no-return", WIRED_CMD(ProcSendData),
     487: #endif
     488: #ifndef MAC
     489:     FUNCTION, "push-shell", WIRED_CMD(Push),
     490: #endif
     491: #ifdef CHDIR
     492:     FUNCTION, "pushd", WIRED_CMD(Pushd),
     493:     FUNCTION, "pwd", WIRED_CMD(prCWD),
     494: #endif
     495:     FUNCTION, "query-replace-string", WIRED_CMD(QRepSearch),
     496: #ifdef IPROCS
     497:     FUNCTION, "quit-process", WIRED_CMD(ProcQuit),
     498: #endif
     499:     FUNCTION, "quoted-insert", WIRED_CMD(QuotChar),
     500: #ifdef ABBREV
     501:     FUNCTION, "read-word-abbrev-file", WIRED_CMD(RestAbbrevs),
     502: #endif
     503:     FUNCTION, "redraw-display", WIRED_CMD(RedrawDisplay),
     504:     FUNCTION, "recursive-edit", WIRED_CMD(Recur),
     505:     FUNCTION, "rename-buffer", WIRED_CMD(ReNamBuf),
     506:     FUNCTION, "replace-in-region", WIRED_CMD(RegReplace),
     507:     FUNCTION, "replace-string", WIRED_CMD(RepSearch),
     508:     FUNCTION, "right-margin-here", WIRED_CMD(SetRMargin),
     509:     FUNCTION, "save-file", WIRED_CMD(SaveFile),
     510:     FUNCTION, "scroll-down", WIRED_CMD(DownScroll),
     511:     FUNCTION, "scroll-left", WIRED_CMD(ScrollLeft),
     512: #ifdef MSDOS
     513:     FUNCTION, "scroll-next-page", WIRED_CMD(PageScrollUp),
     514:     FUNCTION, "scroll-previous-page", WIRED_CMD(PageScrollDown),
     515: #endif /* MSDOS */
     516:     FUNCTION, "scroll-right", WIRED_CMD(ScrollRight),
     517:     FUNCTION, "scroll-up", WIRED_CMD(UpScroll),
     518:     FUNCTION, "search-forward", WIRED_CMD(ForSearch),
     519:     FUNCTION, "search-forward-nd", WIRED_CMD(FSrchND),
     520:     FUNCTION, "search-reverse", WIRED_CMD(RevSearch),
     521:     FUNCTION, "search-reverse-nd", WIRED_CMD(RSrchND),
     522:     FUNCTION, "select-buffer", WIRED_CMD(BufSelect),
     523: #ifdef MSDOS
     524:     FUNCTION, "select-buffer-1", WIRED_CMD(Buf1Select),
     525:     FUNCTION, "select-buffer-2", WIRED_CMD(Buf2Select),
     526:     FUNCTION, "select-buffer-3", WIRED_CMD(Buf3Select),
     527:     FUNCTION, "select-buffer-4", WIRED_CMD(Buf4Select),
     528:     FUNCTION, "select-buffer-5", WIRED_CMD(Buf5Select),
     529:     FUNCTION, "select-buffer-6", WIRED_CMD(Buf6Select),
     530:     FUNCTION, "select-buffer-7", WIRED_CMD(Buf7Select),
     531:     FUNCTION, "select-buffer-8", WIRED_CMD(Buf8Select),
     532:     FUNCTION, "select-buffer-9", WIRED_CMD(Buf9Select),
     533:     FUNCTION, "select-buffer-10", WIRED_CMD(Buf10Select),
     534: #endif /* MSDOS */
     535:     FUNCTION, "self-insert", WIRED_CMD(SelfInsert),
     536:     FUNCTION, "set", WIRED_CMD(SetVar),
     537:     FUNCTION, "set-mark", WIRED_CMD(SetMark),
     538: #ifdef IPROCS   /* for GNU compatibility */
     539:     FUNCTION, "shell", WIRED_CMD(ShellProc),
     540: #endif
     541: #ifndef MAC
     542:     FUNCTION, "shell-command", WIRED_CMD(ShellCom),
     543:     FUNCTION, "shell-command-no-buffer", WIRED_CMD(ShNoBuf),
     544:     FUNCTION, "shell-command-to-buffer", WIRED_CMD(ShToBuf),
     545:     FUNCTION, "shell-command-with-typeout", WIRED_CMD(Shtypeout),
     546: #endif
     547:     DefMinor(ShowMatch), "show-match-mode", WIRED_CMD(0),
     548:     FUNCTION, "shrink-window", WIRED_CMD(ShrWindow),
     549:     FUNCTION, "source", WIRED_CMD(Source),
     550: #ifdef SPELL
     551:     FUNCTION, "spell-buffer", WIRED_CMD(SpelBuffer),
     552: #endif
     553:     FUNCTION, "split-current-window", WIRED_CMD(SplitWind),
     554:     FUNCTION, "start-remembering", WIRED_CMD(Remember),
     555: #ifdef IPROCS
     556: #  ifndef PIPEPROCS
     557:     FUNCTION, "stop-process", WIRED_CMD(ProcStop),
     558: #  endif
     559: #endif
     560:     FUNCTION, "stop-remembering", WIRED_CMD(Forget),
     561:     FUNCTION, "string-length", WIRED_CMD(StrLength),
     562: #ifdef JOB_CONTROL
     563:     FUNCTION, "suspend-jove", WIRED_CMD(PauseJove),
     564: #endif
     565:     DefMajor(TEXT), "text-mode", WIRED_CMD(0),
     566:     FUNCTION, "transpose-characters", WIRED_CMD(TransChar),
     567:     FUNCTION, "transpose-lines", WIRED_CMD(TransLines),
     568:     FUNCTION, "unbind-key", WIRED_CMD(UnbindC),
     569:     FUNCTION, "version", WIRED_CMD(ShowVersion),
     570:     FUNCTION, "visible-spaces-in-window", WIRED_CMD(WVisSpace),
     571:     FUNCTION, "visit-file", WIRED_CMD(ReadFile),
     572:     FUNCTION, "window-find", WIRED_CMD(WindFind),
     573: #ifdef ABBREV
     574:     DefMinor(Abbrev), "word-abbrev-mode", WIRED_CMD(0),
     575:     FUNCTION, "write-word-abbrev-file", WIRED_CMD(SaveAbbrevs),
     576: #endif
     577:     FUNCTION, "write-file", WIRED_CMD(WriteFile),
     578:     FUNCTION, "write-macros-to-file", WIRED_CMD(WriteMacs),
     579:     FUNCTION, "write-modified-files", WIRED_CMD(WtModBuf),
     580:     FUNCTION, "write-region", WIRED_CMD(WrtReg),
     581:     FUNCTION, "yank", WIRED_CMD(Yank),
     582:     FUNCTION, "yank-pop", WIRED_CMD(YankPop),
     583:     FUNCTION, 0, 0
     584: };
     585:
     586: #ifndef TXT_TO_C
     587: data_obj *
     588: findcom(prompt)
     589: char    *prompt;
     590: {
     591:     /* This is for faster startup.  This just reads until a space or a
     592: 	   tab or a newline character is reached, and then does a
     593: 	   semi-hashed lookup on that string.  This should be much faster
     594: 	   than initializing the minibuffer for each line. */
     595:     if (InJoverc) {
     596:         char    cmdbuf[128];
     597:         register struct cmd *cmd;
     598:         register char   *cp = cmdbuf;
     599: #if !(defined(IBMPC) || defined(MAC))
     600:         register int    c;
     601: #else
     602:         int c;
     603: #endif
     604:         struct cmd  *which;
     605:         int cmdlen,
     606:             found = 0;
     607:         static struct cmd   *cmdhash[26];
     608:         static int  beenhere = NO;
     609:
     610: /* special case for prefix commands--only upper case ones */
     611: #define hash(c) (c - 'a')
     612:
     613:         /* initialize the hash table */
     614:         if (beenhere == NO) {
     615:             int lastc = 0;
     616:
     617:             for (cmd = commands; cmd->Name != 0; cmd++)
     618:                 if (lastc != cmd->Name[0]) {
     619:                     lastc = cmd->Name[0];
     620:                     cmdhash[hash(lastc)] = cmd;
     621:                 }
     622:             beenhere = YES;
     623:         }
     624: #ifdef MAC
     625:         menus_off();    /* Block menu choices during input */
     626: #endif
     627:         /* gather the cmd name */
     628:         while (((c = getch()) != EOF) && !index(" \t\r\n", c)) {
     629: #if (defined(IBMPC) || defined(MAC))
     630:             lower(&c);
     631: #else
     632:             if (isupper(c))
     633:                 c = tolower(c);
     634: #endif
     635:             *cp++ = c;
     636:         }
     637:         if (c == EOF)
     638:             return 0;
     639:         *cp = '\0';
     640:         cmdlen = cp - cmdbuf;
     641:         if (cmdlen == 0)
     642:             return 0;
     643:
     644:         /* look it up (in the reduced search space) */
     645:         if (islower(cmdbuf[0]))
     646:             for (cmd = cmdhash[hash(cmdbuf[0])]; cmd != 0 && cmd->Name[0] == cmdbuf[0]; cmd++) {
     647:             if (strncmp(cmd->Name, cmdbuf, cmdlen) == 0) {
     648:                 if (strcmp(cmd->Name, cmdbuf) == 0)
     649:                     return (data_obj *) cmd;
     650:                 found += 1;
     651:                 which = cmd;
     652:             }
     653:             }
     654:         if (found > 1)
     655:             complain("[\"%s\" ambiguous]", cmdbuf);
     656:         else if (found == 0)
     657:             complain("[\"%s\" unknown]", cmdbuf);
     658:         else
     659:             return (data_obj *) which;
     660:     } else {
     661:         static char *strings[(sizeof commands) / sizeof (commands[0])];
     662:         static int  beenhere = NO;
     663:         register int    com;
     664:
     665:         if (beenhere == NO) {
     666:             register char   **strs = strings;
     667:             register struct cmd *c;
     668:
     669:             for (c = commands; c->Name != 0; c++)
     670:                 *strs++ = c->Name;
     671:             *strs = 0;
     672:             beenhere = YES;
     673:         }
     674:
     675:         if ((com = complete(strings, prompt, CASEIND)) < 0)
     676:             return 0;
     677:         return (data_obj *) &commands[com];
     678:     }
     679:     /* NOTREACHED */
     680: }
     681: #endif

#### Defined functions

findcom defined in line 587; used 5 times

- in /usr/src/new/jove/extend.c line 302, 525
- in /usr/src/new/jove/externs.h line 138, 746
- in /usr/src/new/jove/iproc.c line 378

#### Defined variables

commands defined in line 273; used 9 times

- in line 617, 661(2), 669, 677
- in /usr/src/new/jove/mac.c line 907
- in /usr/src/new/jove/macros.c line 370
- in /usr/src/new/jove/setmaps.c line 172
- in /usr/src/new/jove/util.c line 34

#### Defined macros

WIRED_CMD defined in line 269; used 218 times

- in line 275-582(218)

hash defined in line 611; used 2 times

- in line 620, 646

#### Usage of this include

funcdefs.c used 1 times

- in /usr/src/new/jove/setmaps.c line 10

Last modified: 1988-03-15 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2182 |