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

##### Functions

    AbbrevExpand      X
    BindMtoW          X
    DefGAbbrev        X
    DefMAbbrev        X
    EditAbbrevs       X
    RestAbbrevs       X
    SaveAbbrevs       X
    def_abbrev        X
    define            X
    hash              X
    lookup            X
    rest_abbrevs      X
    save_abbrevs      X

##### Variables

    A_tables          X
    AutoCaseAbbrev    X
    mode_names        X
    private           X

##### Macros

    GLOBAL            X
    HASHSIZE          X
    private           X

##### struct's

    abbrev            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:
      10: #ifdef ABBREV
      11:
      12: #include "io.h"
      13: #include "ctype.h"
      14:
      15: #ifdef MSDOS
      16: #include <io.h>
      17: #endif
      18: #define HASHSIZE    20
      19:
      20: struct abbrev {
      21:     unsigned int    a_hash;
      22:     char    *a_abbrev,
      23:         *a_phrase;
      24:     struct abbrev   *a_next;
      25:     data_obj    *a_cmdhook;
      26: };
      27:
      28: #ifdef MAC
      29: #	undef private
      30: #	define private
      31: #endif
      32:
      33: #ifdef  LINT_ARGS
      34: private void
      35:     define(struct abbrev **, char *, char *),
      36:     def_abbrev(struct abbrev **),
      37:     rest_abbrevs(char *),
      38:     save_abbrevs(char *);
      39:
      40: private unsigned int hash(char *);
      41: private struct abbrev * lookup(struct abbrev **, char *);
      42: #else
      43: private void
      44:     define(),
      45:     def_abbrev(),
      46:     rest_abbrevs(),
      47:     save_abbrevs();
      48:
      49: private unsigned int hash();
      50: private struct abbrev * lookup();
      51: #endif	/* LINT_ARGS */
      52:
      53: #ifdef MAC
      54: #	undef private
      55: #	define private static
      56: #endif
      57:
      58: #define GLOBAL  NMAJORS
      59: private struct abbrev   *A_tables[NMAJORS + 1][HASHSIZE] = {0};
      60:
      61: int AutoCaseAbbrev = 1;
      62:
      63: private unsigned int
      64: hash(a)
      65: register char   *a;
      66: {
      67:     register unsigned int   hashval = 0;
      68:     register int    c;
      69:
      70:     while (c = *a++)
      71:         hashval = (hashval << 2) + c;
      72:
      73:     return hashval;
      74: }
      75:
      76: private void
      77: def_abbrev(table)
      78: struct abbrev   *table[HASHSIZE];
      79: {
      80:     char    abbrev[100],
      81:         phrase[100];
      82:
      83:     strcpy(abbrev, ask((char *) 0, "abbrev: "));
      84:     strcpy(phrase, ask((char *) 0, "abbrev: %s phrase: ", abbrev));
      85:     define(table, abbrev, phrase);
      86: }
      87:
      88: private struct abbrev *
      89: lookup(table, abbrev)
      90: register struct abbrev  *table[HASHSIZE];
      91: register char   *abbrev;
      92: {
      93:     register struct abbrev  *ap;
      94:     unsigned int    h;
      95:
      96:     h = hash(abbrev);
      97:     for (ap = table[h % HASHSIZE]; ap; ap = ap->a_next)
      98:         if (ap->a_hash == h && strcmp(ap->a_abbrev, abbrev) == 0)
      99:             break;
     100:     return ap;
     101: }
     102:
     103: private void
     104: define(table, abbrev, phrase)
     105: register struct abbrev  *table[HASHSIZE];
     106: char    *abbrev,
     107:     *phrase;
     108: {
     109:     register struct abbrev  *ap;
     110:
     111:     ap = lookup(table, abbrev);
     112:     if (ap == 0) {
     113:         register unsigned int   h = hash(abbrev);
     114:
     115:         ap = (struct abbrev *) emalloc(sizeof *ap);
     116:         ap->a_hash = h;
     117:         ap->a_abbrev = copystr(abbrev);
     118:         h %= HASHSIZE;
     119:         ap->a_next = table[h];
     120:         ap->a_cmdhook = 0;
     121:         table[h] = ap;
     122:     } else
     123:         free(ap->a_phrase);
     124:     ap->a_phrase = copystr(phrase);
     125: }
     126:
     127: void
     128: AbbrevExpand()
     129: {
     130:     Bufpos  point;
     131:     char    wordbuf[100];
     132:     register char   *wp = wordbuf,
     133:             *cp;
     134: #if !(defined(IBMPC) || defined(MAC))
     135:     register int    c;
     136: #else
     137:     int c;
     138: #endif
     139:     int UC_count = 0;
     140:     struct abbrev   *ap;
     141:
     142:     DOTsave(&point);
     143:     WITH_TABLE(curbuf->b_major)
     144:     b_word(1);
     145:     while (curchar < point.p_char && ismword(c = linebuf[curchar])) {
     146:         if (AutoCaseAbbrev) {
     147:             if (isupper(c)) {
     148:                 UC_count += 1;
     149: #if (defined(IBMPC) || defined(MAC))
     150:                 lower(&c);
     151: #else
     152:                 c = tolower(c);
     153: #endif
     154:             }
     155:         }
     156:         *wp++ = c;
     157:         curchar += 1;
     158:     }
     159:     *wp = '\0';
     160:     END_TABLE();
     161:
     162:     if ((ap = lookup(A_tables[curbuf->b_major], wordbuf)) == 0 &&
     163:         (ap = lookup(A_tables[GLOBAL], wordbuf)) == 0) {
     164:         SetDot(&point);
     165:         return;
     166:     }
     167:     del_char(BACKWARD, (wp - wordbuf));
     168:
     169:     for (cp = ap->a_phrase; c = *cp; ) {
     170:         if (AutoCaseAbbrev) {
     171:             insert_c(islower(c) && UC_count &&
     172:                    (cp == ap->a_phrase || (UC_count > 1 && (cp[-1] == ' '))) ?
     173:                 toupper(c) : c, 1);
     174:         } else
     175:             insert_c(c, 1);
     176:         cp += 1;
     177:     }
     178:     if (ap->a_cmdhook != 0)
     179:         ExecCmd(ap->a_cmdhook);
     180: }
     181:
     182: private char    *mode_names[NMAJORS + 1] = {
     183:     "Fundamental Mode",
     184:     "Text Mode",
     185:     "C Mode",
     186: #ifdef LISP
     187:     "Lisp Mode",
     188: #endif
     189:     "Global"
     190: };
     191:
     192: private void
     193: save_abbrevs(file)
     194: char    *file;
     195: {
     196:     File    *fp;
     197:     struct abbrev   *ap,
     198:             **tp;
     199:     char    buf[LBSIZE];
     200:     int i,
     201:         count = 0;
     202:
     203:     fp = open_file(file, buf, F_WRITE, COMPLAIN, QUIET);
     204:     for (i = 0; i <= GLOBAL; i++) {
     205:         fprintf(fp, "------%s abbrevs------\n", mode_names[i]);
     206:         for (tp = A_tables[i]; tp < &A_tables[i][HASHSIZE]; tp++)
     207:             for (ap = *tp; ap; ap = ap->a_next) {
     208:                 fprintf(fp, "%s:%s\n",
     209:                     ap->a_abbrev,
     210:                     ap->a_phrase);
     211:                 count += 1;
     212:             }
     213:     }
     214:     f_close(fp);
     215:     add_mess(" %d written.", count);
     216: }
     217:
     218: private void
     219: rest_abbrevs(file)
     220: char    *file;
     221: {
     222:     int eof = 0,
     223:         mode = -1,  /* Will be ++'d immediately */
     224:         lnum = 0;
     225:     char    *phrase_p;
     226:     File    *fp;
     227:     char    buf[LBSIZE];
     228:
     229:     fp = open_file(file, buf, F_READ, COMPLAIN, QUIET);
     230:     while (mode <= GLOBAL) {
     231:         eof = f_gets(fp, genbuf, LBSIZE);
     232:         if (eof || genbuf[0] == '\0')
     233:             break;
     234:         lnum += 1;
     235:         if (strncmp(genbuf, "------", 6) == 0) {
     236:             mode += 1;
     237:             continue;
     238:         }
     239:         if (mode == -1)
     240: fmterr:         complain("Abbrev. format error, line %d.", file, lnum);
     241:         phrase_p = index(genbuf, ':');
     242:         if (phrase_p == 0)
     243:             goto fmterr;
     244:         *phrase_p++ = '\0'; /* Null terminate the abbrev. */
     245:         define(A_tables[mode], genbuf, phrase_p);
     246:     }
     247:     f_close(fp);
     248:     message(NullStr);
     249: }
     250:
     251: void
     252: DefGAbbrev()
     253: {
     254:     def_abbrev(A_tables[GLOBAL]);
     255: }
     256:
     257: void
     258: DefMAbbrev()
     259: {
     260:     def_abbrev(A_tables[curbuf->b_major]);
     261: }
     262:
     263: void
     264: SaveAbbrevs()
     265: {
     266:     char    filebuf[FILESIZE];
     267:
     268:     save_abbrevs(ask_file((char *) 0, (char *) 0, filebuf));
     269: }
     270:
     271: void
     272: RestAbbrevs()
     273: {
     274:     char    filebuf[FILESIZE];
     275:
     276:     rest_abbrevs(ask_file((char *) 0, (char *) 0, filebuf));
     277: }
     278:
     279: void
     280: EditAbbrevs()
     281: {
     282:     char    *tname = "jove_wam.$$$",
     283:         *EditName = "Abbreviation Edit";
     284:     Buffer  *obuf = curbuf,
     285:         *ebuf;
     286:
     287:     if (ebuf = buf_exists(EditName)) {
     288:         if (ebuf->b_type != B_SCRATCH)
     289:             confirm("Over-write buffer %b?", ebuf);
     290:     }
     291:     SetBuf(ebuf = do_select(curwind, EditName));
     292:     ebuf->b_type = B_SCRATCH;
     293:     initlist(ebuf);
     294:     /* Empty buffer.  Save the definitions to a tmp file
     295: 	   and read them into this buffer so we can edit them. */
     296:     save_abbrevs(tname);
     297:     read_file(tname, NO);
     298:     message("[Edit definitions and then type C-X C-C]");
     299:     Recur();        /* We edit them ... now */
     300:     /* RESetBuf in case we deleted the buffer while we were editing. */
     301:     SetBuf(ebuf = do_select(curwind, EditName));
     302:     if (IsModified(ebuf)) {
     303:         SetBuf(ebuf);
     304:         file_write(tname, 0);
     305:         rest_abbrevs(tname);
     306:         unmodify();
     307:     }
     308:     (void) unlink(tname);
     309:     SetBuf(do_select(curwind, obuf->b_name));
     310: }
     311:
     312: void
     313: BindMtoW()
     314: {
     315:     struct abbrev   *ap;
     316:     char    *word;
     317:     data_obj    *hook;
     318:
     319:     word = ask((char *) 0, "Word: ");
     320:
     321:     if ((ap = lookup(A_tables[curbuf->b_major], word)) == 0 &&
     322:         (ap = lookup(A_tables[GLOBAL], word)) == 0)
     323:             complain("%s: unknown abbrev.", word);
     324:
     325:     hook = findmac("Macro: ");
     326:     if (hook == 0)
     327:         complain("[Undefined macro]");
     328:     ap->a_cmdhook = hook;
     329: }
     330:
     331: #endif /* ABBREV */

#### Defined functions

AbbrevExpand defined in line 127; used 3 times

- in /usr/src/new/jove/externs.h line 183, 791
- in /usr/src/new/jove/insert.c line 138

BindMtoW defined in line 312; used 4 times

- in /usr/src/new/jove/externs.h line 196, 804
- in /usr/src/new/jove/funcdefs.c line 247, 300

DefGAbbrev defined in line 251; used 4 times

- in /usr/src/new/jove/externs.h line 235, 843
- in /usr/src/new/jove/funcdefs.c line 243, 331

DefMAbbrev defined in line 257; used 4 times

- in /usr/src/new/jove/externs.h line 237, 845
- in /usr/src/new/jove/funcdefs.c line 242, 332

EditAbbrevs defined in line 279; used 4 times

- in /usr/src/new/jove/externs.h line 273, 881
- in /usr/src/new/jove/funcdefs.c line 246, 370

RestAbbrevs defined in line 271; used 4 times

- in /usr/src/new/jove/externs.h line 365, 973
- in /usr/src/new/jove/funcdefs.c line 245, 501

SaveAbbrevs defined in line 263; used 4 times

- in /usr/src/new/jove/externs.h line 370, 978
- in /usr/src/new/jove/funcdefs.c line 244, 575

def_abbrev defined in line 76; used 4 times

- in line 36, 45, 254, 260

define defined in line 103; used 4 times

- in line 35, 44, 85, 245

hash defined in line 63; used 4 times

- in line 40, 49, 96, 113

lookup defined in line 88; used 7 times

- in line 41, 50, 111, 162-163(2), 321-322(2)

rest_abbrevs defined in line 218; used 4 times

- in line 37, 46, 276, 305

save_abbrevs defined in line 192; used 4 times

- in line 38, 47, 268, 296

#### Defined variables

A_tables defined in line 59; used 9 times

- in line 162-163(2), 206(2), 245, 254, 260, 321-322(2)

AutoCaseAbbrev defined in line 61; used 3 times

- in line 146, 170
- in /usr/src/new/jove/vars.c line 19

mode_names defined in line 182; used 1 times

- in line 205

private defined in line 182; never used

#### Defined struct's

abbrev defined in line 20; used 34 times

- in line 24(2), 35-41(8), 50(2), 59(2), 78(2), 88-93(6), 105-109(4), 115(2), 140(2), 197(2), 315(2)

#### Defined macros

GLOBAL defined in line 58; used 5 times

- in line 163, 204, 230, 254, 322

HASHSIZE defined in line 18; used 7 times

- in line 59, 78, 90, 97, 105, 118, 206

private defined in line 55; used 15 times

- in line 29-34(2), 40-43(3), 49-63(5), 76, 88, 103, 192, 218

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