Return to edit.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed

Annotation of 43BSD/contrib/B/src/bed/edit.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
        !             2: static char rcsid[] = "$Header: edit.c,v 2.5 85/08/22 16:01:43 timo Exp $";
        !             3: 
        !             4: /*
        !             5:  * B editor -- Read unit from file.
        !             6:  */
        !             7: 
        !             8: #include <ctype.h>
        !             9: 
        !            10: #include "b.h"
        !            11: #include "feat.h"
        !            12: #include "erro.h"
        !            13: #include "bobj.h"
        !            14: #include "node.h"
        !            15: #include "tabl.h"
        !            16: #include "gram.h"
        !            17: #include "supr.h"
        !            18: #include "queu.h"
        !            19: 
        !            20: string unixerror();
        !            21: 
        !            22: /*
        !            23:  * TABSIZE sets the number of spaces equivalent to a tab character
        !            24:  * read from the input; INDENT sets the number of spaces for one indentation
        !            25:  * level.
        !            26:  * The definitions here are unrelated to the definition of TABS
        !            27:  * in eval.h (used by show.c and eval.c).  The definition here only
        !            28:  * defines how many spaces must be equivalenced to a tab stop when read
        !            29:  * from a file; tab stops must be caused by editing a unit with another
        !            30:  * editor (vi, ed, ex, emacs), since "save.c" always writes spaces,
        !            31:  * not tabs.  The value '4' is best suited for people at the CWI who
        !            32:  * may have workspaces with units edited with the previous version of
        !            33:  * the B editor, which emitted a tab for each indentation level (and
        !            34:  * assumed 4 spaces for a tab stop on input).
        !            35:  *
        !            36:  * The variables 'spacesused' and 'tabsused' are kept to see if mixed use
        !            37:  * of spaces and tabs was made; this can cause indentation errors.
        !            38:  */
        !            39: 
        !            40: #ifdef CWI
        !            41: #define TABSIZE 4
        !            42: #else
        !            43: #define TABSIZE 8
        !            44: #endif
        !            45: 
        !            46: #define INDENT 4
        !            47: 
        !            48: Hidden bool spacesused;
        !            49: Hidden bool tabsused;
        !            50: 
        !            51: 
        !            52: /*
        !            53:  * Read (edit) parse tree from file into the focus.
        !            54:  * Rather ad hoc, we use ins_string for each line
        !            55:  * and do some magic tricks to get the indentation right
        !            56:  * (most of the time).
        !            57:  * If line > 0, position the focus at that line, if possible;
        !            58:  * otherwise the focus is left at the end of the inserted text.
        !            59:  */
        !            60: 
        !            61: Visible bool
        !            62: edit(ep, filename, line)
        !            63:        register environ *ep;
        !            64:        string filename;
        !            65:        int line;
        !            66: {
        !            67:        int lines = 0;
        !            68:        register FILE *fp = fopen(filename, "r");
        !            69:        register int c;
        !            70:        char buf[BUFSIZ];
        !            71:        auto string cp;
        !            72:        auto queue q = Qnil;
        !            73: 
        !            74:        if (!fp) {
        !            75:                error("%s", unixerror(filename));
        !            76:                return No;
        !            77:        }
        !            78: 
        !            79:        spacesused = tabsused = No;
        !            80:        do {
        !            81:                do {
        !            82:                        for (cp = buf; cp < buf + sizeof buf - 1; ++cp) {
        !            83:                                c = getc(fp);
        !            84:                                if (c == EOF || c == '\n')
        !            85:                                        break;
        !            86:                                if (c < ' ' || c >= 0177)
        !            87:                                        c = ' ';
        !            88:                                *cp = c;
        !            89:                        }
        !            90:                        if (cp > buf) {
        !            91:                                *cp = 0;
        !            92:                                if (!ins_string(ep, buf, &q, 0) || !emptyqueue(q)) {
        !            93:                                        qrelease(q);
        !            94:                                        error(EDIT_BAD);
        !            95:                                        fclose(fp);
        !            96:                                        return No;
        !            97:                                }
        !            98:                                qrelease(q);
        !            99:                        }
        !           100:                } while (c != EOF && c != '\n');
        !           101:                ++lines;
        !           102:                if (c != EOF && !editindentation(ep, fp)) {
        !           103:                        fclose(fp);
        !           104:                        return No;
        !           105:                }
        !           106:        } while (c != EOF);
        !           107:        fclose(fp);
        !           108:        if (ep->mode == FHOLE || ep->mode == VHOLE && (ep->s1&1)) {
        !           109:                cp = "";
        !           110:                soften(ep, &cp, 0);
        !           111:        }
        !           112:        if (lines > 1 && line > 0) {
        !           113:                gotoyx(ep, line-1, 0);
        !           114:                oneline(ep);
        !           115:        }
        !           116:        if (spacesused && tabsused)
        !           117:                error(EDIT_TABS);
        !           118:        return Yes;
        !           119: }
        !           120: 
        !           121: 
        !           122: /*
        !           123:  * Do all the footwork required to get the indentation proper.
        !           124:  */
        !           125: 
        !           126: Hidden Procedure
        !           127: editindentation(ep, fp)
        !           128:        register environ *ep;
        !           129:        register FILE *fp;
        !           130: {
        !           131:        register int tabs = 0;
        !           132:        auto int level;
        !           133:        register int c;
        !           134: 
        !           135:        while ((c = getc(fp)) == ' ' || c == '\t') {
        !           136:                if (c == ' ') {
        !           137:                        spacesused = Yes;
        !           138:                        ++tabs;
        !           139:                }
        !           140:                else {
        !           141:                        tabsused = Yes;
        !           142:                        tabs = (tabs/TABSIZE + 1)*TABSIZE;
        !           143:                }
        !           144:        }
        !           145:        ungetc(c, fp);
        !           146:        if (c == EOF || c == '\n')
        !           147:                return Yes;
        !           148:        tabs = (tabs+(INDENT/2))/INDENT; /* Transform to tab stops */
        !           149:        if (!ins_newline(ep)) {
        !           150: #ifndef NDEBUG
        !           151:                debug("[Burp! Can't insert a newline.]");
        !           152: #endif NDEBUG
        !           153:                return No;
        !           154:        }
        !           155:        level = Level(ep->focus);
        !           156:        for (; tabs < level; --level) {
        !           157:                if (!ins_newline(ep)) {
        !           158: #ifndef NDEBUG
        !           159:                        debug("[Burp, burp! Can't decrease indentation.]");
        !           160: #endif NDEBUG
        !           161:                        return No;
        !           162:                }
        !           163:        }
        !           164:        fixit(ep);
        !           165:        return Yes;
        !           166: }
        !           167: 
        !           168: 
        !           169: /* ------------------------------------------------------------ */
        !           170: 
        !           171: #ifdef SAVEBUF
        !           172: 
        !           173: /*
        !           174:  * Read the next non-space character.
        !           175:  */
        !           176: 
        !           177: Hidden int
        !           178: skipsp(fp)
        !           179:        register FILE *fp;
        !           180: {
        !           181:        register int c;
        !           182: 
        !           183:        do {
        !           184:                c = getc(fp);
        !           185:        } while (c == ' ');
        !           186:        return c;
        !           187: }
        !           188: 
        !           189: 
        !           190: /*
        !           191:  * Read a text in standard B format when the initial quote has already
        !           192:  * been read.
        !           193:  */
        !           194: 
        !           195: Hidden value
        !           196: readtext(fp, quote)
        !           197:        register FILE *fp;
        !           198:        register char quote;
        !           199: {
        !           200:        auto value v = Vnil;
        !           201:        char buf[BUFSIZ];
        !           202:        register string cp = buf;
        !           203:        register int c;
        !           204:        auto int i;
        !           205: 
        !           206:        for (; ; ++cp) {
        !           207:                c = getc(fp);
        !           208:                if (!isascii(c) || c != ' ' && !isprint(c)) {
        !           209:                        if (c == EOF)
        !           210:                                debug("readtext: EOF");
        !           211:                        else
        !           212:                                debug("readtext: bad char (0%02o)", c);
        !           213:                        release(v);
        !           214:                        return Vnil; /* Bad character or EOF */
        !           215:                }
        !           216:                if (c == quote) {
        !           217:                        c = getc(fp);
        !           218:                        if (c != quote) {
        !           219:                                ungetc(c, fp);
        !           220:                                break;
        !           221:                        }
        !           222:                }
        !           223:                else if (c == '`') {
        !           224:                        c = skipsp(fp);
        !           225:                        if (c == '$') {
        !           226:                                i = 0;
        !           227:                                if (fscanf(fp, "%d", &i) != 1
        !           228:                                        || i == 0 || !isascii(i)) {
        !           229:                                        debug("readtext: error in conversion");
        !           230:                                        release(v);
        !           231:                                        return Vnil;
        !           232:                                }
        !           233:                                c = skipsp(fp);
        !           234:                        }
        !           235:                        else
        !           236:                                i = '`';
        !           237:                        if (c != '`') {
        !           238:                                if (c == EOF)
        !           239:                                        debug("readtext: EOF in conversion");
        !           240:                                else
        !           241:                                        debug("readtext: bad char in conversion (0%o)", c);
        !           242:                                release(v);
        !           243:                                return Vnil;
        !           244:                        }
        !           245:                        c = i;
        !           246:                }
        !           247:                if (cp >= &buf[sizeof buf - 1]) {
        !           248:                        *cp = 0;
        !           249:                        if (v)
        !           250:                                concato(&v, buf);
        !           251:                        else
        !           252:                                v = mk_text(buf);
        !           253:                        cp = buf;
        !           254:                }
        !           255:                *cp = c;
        !           256:        }
        !           257:        *cp = 0;
        !           258:        if (!v)
        !           259:                return mk_text(buf);
        !           260:        concato(&v, buf);
        !           261:        return v;
        !           262: }
        !           263: 
        !           264: 
        !           265: Hidden int
        !           266: readsym(fp)
        !           267:        register FILE *fp;
        !           268: {
        !           269:        register int c;
        !           270:        char buf[100];
        !           271:        register string bufp;
        !           272: 
        !           273:        for (bufp = buf; ; ++bufp) {
        !           274:                c = getc(fp);
        !           275:                if (c == EOF)
        !           276:                        return -1;
        !           277:                if (!isascii(c) || !isalnum(c) && c != '_') {
        !           278:                        if (ungetc(c, fp) == EOF)
        !           279:                                syserr("readsym: ungetc failed");
        !           280:                        break;
        !           281:                }
        !           282:                *bufp = c;
        !           283:        }
        !           284:        *bufp = 0;
        !           285:        if (isdigit(buf[0]))
        !           286:                return atoi(buf);
        !           287:        if (strcmp(buf, "Required") == 0) /***** Compatibility hack *****/
        !           288:                return Hole;
        !           289:        return nametosym(buf);
        !           290: }
        !           291: 
        !           292: 
        !           293: /*
        !           294:  * Read a node in internal format (recursively).
        !           295:  * Return nil pointer if EOF or error.
        !           296:  */
        !           297: 
        !           298: Hidden node
        !           299: readnode(fp)
        !           300:        FILE *fp;
        !           301: {
        !           302:        int c;
        !           303:        int nch;
        !           304:        node ch[MAXCHILD];
        !           305:        node n;
        !           306:        int sym;
        !           307: 
        !           308:        c = skipsp(fp);
        !           309:        switch (c) {
        !           310:        case EOF:
        !           311:                return Nnil; /* EOF hit */
        !           312: 
        !           313:        case '(':
        !           314:                sym = readsym(fp);
        !           315:                if (sym < 0) {
        !           316:                        debug("readnode: missing symbol");
        !           317:                        return Nnil; /* No number as first item */
        !           318:                }
        !           319:                if (sym < 0 || sym > Hole) {
        !           320:                        debug("readnode: bad symbol (%d)", sym);
        !           321:                        return Nnil;
        !           322:                }
        !           323:                nch = 0;
        !           324:                while ((c = skipsp(fp)) == ',' && nch < MAXCHILD) {
        !           325:                        n = readnode(fp);
        !           326:                        if (!n) {
        !           327:                                for (; nch > 0; --nch)
        !           328:                                        noderelease(ch[nch-1]);
        !           329:                                return Nnil; /* Error encountered in child */
        !           330:                        }
        !           331:                        ch[nch] = n;
        !           332:                        ++nch;
        !           333:                }
        !           334:                if (c != ')') {
        !           335:                        if (c == ',')
        !           336:                                debug("readnode: node too long (sym=%d)", sym);
        !           337:                        else
        !           338:                                debug("readnode: no ')' where expected (sym=%d)", sym);
        !           339:                        for (; nch > 0; --nch)
        !           340:                                noderelease(ch[nch-1]);
        !           341:                        return Nnil; /* Not terminated with ')' or too many children */
        !           342:                }
        !           343:                if (nch == 0)
        !           344:                        return gram(sym); /* Saves space for Optional/Hole nodes */
        !           345:                return newnode(nch, sym, ch);
        !           346: 
        !           347:        case '\'':
        !           348:        case '"':
        !           349:                return (node) readtext(fp, c);
        !           350: 
        !           351:        default:
        !           352:                debug("readnode: bad initial character");
        !           353:                return Nnil; /* Bad initial character */
        !           354:        }
        !           355: }
        !           356: 
        !           357: 
        !           358: /*
        !           359:  * Read a node written in a more or less internal format.
        !           360:  */
        !           361: 
        !           362: Visible value
        !           363: editqueue(filename)
        !           364:        string filename;
        !           365: {
        !           366:        register FILE *fp = fopen(filename, "r");
        !           367:        auto queue q = Qnil;
        !           368:        register node n;
        !           369: 
        !           370:        if (!fp)
        !           371:                return Vnil;
        !           372:        do {
        !           373:                n = readnode(fp);
        !           374:                if (!n)
        !           375:                        break; /* EOF or error */
        !           376:                addtoqueue(&q, n);
        !           377:                noderelease(n);
        !           378:        } while (skipsp(fp) == '\n');
        !           379:        fclose(fp);
        !           380:        return (value)q;
        !           381: }
        !           382: #endif SAVEBUF

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.