Return to display.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / equel

Annotation of 43BSD/ingres/source/equel/display.c, revision 1.1

1.1     ! root        1: # include      <stdio.h>
        !             2: # include      "constants.h"
        !             3: # include      "globals.h"
        !             4: # include      <setjmp.h>
        !             5: # include      <sccs.h>
        !             6: 
        !             7: SCCSID(@(#)display.c   8.1     12/31/84)
        !             8: 
        !             9: /*
        !            10: **  DISPLAY.C -- display manipulation routines
        !            11: **
        !            12: **     a display is a list of strings, the symbol
        !            13: **     space Symsp is impemented by means of displays.
        !            14: **
        !            15: **     Required By:
        !            16: **             Lexical analysis routines to add to the symbol space
        !            17: **             semantic productions to manipulate input
        !            18: */
        !            19: 
        !            20: 
        !            21: 
        !            22: 
        !            23:        /* this avoids having to specify &Cv_display in the semantic
        !            24:         * routines, by making Cv_display a pointer to the pertinent
        !            25:         * display structure.
        !            26:         */
        !            27: struct display *Cv_display     = &Displays [0];
        !            28: 
        !            29: /*
        !            30: **  ENTER_DISPLAY -- enter a new string into a display
        !            31: **
        !            32: **     Parameters:
        !            33: **             disp -- display to be added to
        !            34: **             string -- string to add
        !            35: **
        !            36: **     Returns:
        !            37: **             pointer to new disp_node structure.
        !            38: **
        !            39: **     Side Effects:
        !            40: **             allocates a new disp_node structispl
        !            41: **             Expects a dynamic "string", i.e. one that it can 
        !            42: **             dispose of as it wishes, so it is the users responsability
        !            43: **             to allocate space for this string.
        !            44: **             If the string passed is 0, the string
        !            45: **             "ERROR_TOKEN" is substituted, and a message is printed,
        !            46: **             so a caller may call enter_display with the return of an
        !            47: **             salloc() directly.
        !            48: **             If no space is available for the allocation of the
        !            49: **             new node, an error message is given, and a reset(III)
        !            50: **             is performed (this should goto equel()[main.c])
        !            51: **
        !            52: **     Called By:
        !            53: **             add_sym() -- to add a token to the Symsp
        !            54: **             the semantic productions -- for manipulating usages
        !            55: **                     of C variables.
        !            56: */
        !            57: 
        !            58: 
        !            59: struct disp_node *enter_display(disp, string)
        !            60: struct display *disp;
        !            61: char           *string;
        !            62: {
        !            63:        register struct display         *d;
        !            64:        register struct disp_node       *node;
        !            65:        extern  jmp_buf                 Jmpbuf;
        !            66: 
        !            67:        node = (struct disp_node *)nalloc(sizeof *node);
        !            68:        if (node == 0)
        !            69:        {
        !            70:                yysemerr("symbol space overflow", string);
        !            71:                longjmp(Jmpbuf,1);
        !            72:        }
        !            73:        d = disp;
        !            74:        if (!d->disp_first)
        !            75:                d->disp_first = d->disp_last = node;
        !            76:        else
        !            77:        {
        !            78:                d->disp_last->d_next = node;
        !            79:                d->disp_last = node;
        !            80:        }
        !            81:        node->d_next = 0;
        !            82:        if (!(node->d_elm = string))
        !            83:        {
        !            84:                yysemerr("alloc error in display", 0);
        !            85:                node->d_elm = "ERROR_TOKEN";
        !            86:        }
        !            87:        return (node);
        !            88: }
        !            89: 
        !            90: /*
        !            91: **  ADDSYM -- add a token to the symbol space
        !            92: **
        !            93: **     The node's .d_line field is set to the value of yyline,
        !            94: **     which, if this routine is called from a lexical routine
        !            95: **     taking lexemes that can't include newlines (and back them up),
        !            96: **     is the line the lexeme was read from. This fact is used
        !            97: **     be yyserror() [yyerror.c] to report accurate line numbers
        !            98: **     for errors.
        !            99: **
        !           100: **     Parameters:
        !           101: **             s -- string to add
        !           102: **
        !           103: **     Returns:
        !           104: **             pointer to node added
        !           105: */
        !           106: 
        !           107: 
        !           108: 
        !           109: struct disp_node *addsym(s)
        !           110: char           *s;
        !           111: {
        !           112:        register struct disp_node       *d;
        !           113: 
        !           114:        d = enter_display(&Symsp, s);
        !           115:        d->d_line = yyline;
        !           116:        return (d);
        !           117: }
        !           118: 
        !           119: /*
        !           120: **  FREE_DISPLAY -- frees all elements of a display
        !           121: **
        !           122: **     Parameters:
        !           123: **             disp -- the display to free
        !           124: */
        !           125: 
        !           126: 
        !           127: 
        !           128: 
        !           129: 
        !           130: free_display(disp)
        !           131: struct display *disp;
        !           132: {
        !           133:        register struct display         *d;
        !           134:        register struct disp_node       *f, *n;
        !           135: 
        !           136:        d = disp;
        !           137:        for (f = d->disp_first; f; f = n)
        !           138:        {
        !           139:                n = f->d_next;
        !           140:                xfree(f->d_elm);
        !           141:                xfree(f);
        !           142:        }
        !           143:        d->disp_first = d->disp_last = 0;
        !           144: }
        !           145: 
        !           146: /*
        !           147: **  SYSMSPFREE -- Frees symbol space
        !           148: **     Symspfree frees all the symbol table, EXCEPT
        !           149: **     for the last element in it, as this is the lookahead
        !           150: **     element. That is to say, the element which forced reduction
        !           151: **     to the non-terminal program, which called on symspfree()
        !           152: **
        !           153: **     Requires:
        !           154: **             Symsp -- to free it
        !           155: **
        !           156: **     Called By:
        !           157: **             argproc()
        !           158: **             semantic routines (nonterminal "program")
        !           159: */
        !           160: 
        !           161: 
        !           162: 
        !           163: symspfree()
        !           164: {
        !           165:        register struct display         *d;
        !           166:        register struct disp_node       *f, *n;
        !           167: 
        !           168:        d = &Symsp;
        !           169:        for (f = d->disp_first; f && f->d_next; f = n)
        !           170:        {
        !           171:                n = f->d_next;
        !           172:                xfree(f->d_elm);
        !           173:                xfree(f);
        !           174:        }
        !           175:        d->disp_first = d->disp_last;
        !           176: }
        !           177: 
        !           178: /*
        !           179: **  W_DISPLAY -- write out the contents of a display
        !           180: **
        !           181: **     Parameters:
        !           182: **             disp -- display to take write out
        !           183: **
        !           184: **     Side Effects:
        !           185: **             Writes onto Out_file
        !           186: **             the contents of the display,
        !           187: **             each string is comsidered a separate
        !           188: **             word to be written out(so w_raw may
        !           189: **             break a line between words).
        !           190: **             Calls are made to w_op() and w_key() so as 
        !           191: **             to have the minimum number of spaces in the text.
        !           192: **
        !           193: **     Requires:
        !           194: **             w_op() -- to write out operator terminated
        !           195: **                     strings
        !           196: **             w_key() -- to write out KEYCHAR terminated 
        !           197: **                     strings
        !           198: **
        !           199: **     Called By:
        !           200: **             semantic productions dealing with usage of
        !           201: **             C variables.
        !           202: */
        !           203: 
        !           204: 
        !           205: 
        !           206: w_display(disp)
        !           207: struct display         *disp;
        !           208: {
        !           209:        register struct disp_node       *n;
        !           210: 
        !           211:        for (n = disp->disp_first; n; n = n->d_next)
        !           212:        {
        !           213:                switch (Cmap [n->d_elm [length(n->d_elm) - 1]])
        !           214:                {
        !           215: 
        !           216:                  case OPATR :
        !           217:                  case PUNCT :
        !           218:                        w_op(n->d_elm);
        !           219:                        break;
        !           220: 
        !           221:                  default :
        !           222:                        w_key(n->d_elm);
        !           223:                        break;
        !           224:                }
        !           225:        }
        !           226: }
        !           227: /*
        !           228: **  EAT_DISPLAY -- enter text from In_file into a display
        !           229: **     Enters all text gotten through getch() [getch.c]
        !           230: **     lying between one character delimiters, which may
        !           231: **     be nested, into a display or w_op()'s it.
        !           232: **     eat_display() assumes that when it is called a 
        !           233: **     "left_ch" has just been seen. It will "eat" up to 
        !           234: **     MAXSTRING characters.
        !           235: **     Newline is played with because :
        !           236: **             a) a newline may have been read by eat_display
        !           237: **                instead of yylex(), therefore if eat_display
        !           238: **                stops there, yylex() must know that a newline
        !           239: **                has just been seen and it must test for C_CODE.
        !           240: **             b) Newline may have to be set to 0 if an include()
        !           241: **                was done which sets it to 1, and no yylex() was
        !           242: **                done afterwards to reset it.
        !           243: **
        !           244: **             NOTE : This playing with Newline is needed because 
        !           245: **             yylex() and not getch() maintains Newline. If getch()
        !           246: **             maintained Newline then it would be automatically right.
        !           247: **
        !           248: **     Parameters:
        !           249: **             disp -- display to add elements to if != 0 else
        !           250: **                     characters are written out.
        !           251: **             left_ch -- left delimiter character
        !           252: **             right_ch -- right delimiter character
        !           253: **
        !           254: **     Side Effects:
        !           255: **             advances input to after the close of the
        !           256: **             left_ch, right_ch pair.
        !           257: **             may back up 2 characters.
        !           258: **
        !           259: **     Called By:
        !           260: **             semantic routines dealing with array subscription
        !           261: **
        !           262: **     Bugs:
        !           263: **             #include's encountered, are treated wrongly
        !           264: **             because the "#include ...c.h" is put out immediately,
        !           265: **             while the display is put out only later.
        !           266: */
        !           267: 
        !           268: 
        !           269: eat_display(disp, left_ch, right_ch)
        !           270: struct display *disp;
        !           271: char           left_ch;
        !           272: char           right_ch;
        !           273: {
        !           274:        char            buf [MAXSTRING + 1];
        !           275:        register char   *cp;
        !           276:        register        level;
        !           277:        register        i;
        !           278:        char            pk;
        !           279:        char            r_c [2];
        !           280: 
        !           281:        cp = buf;
        !           282:        level = i = 1;
        !           283:        *cp = left_ch;
        !           284:        do
        !           285:        {
        !           286:                i++;
        !           287:                if (i >= sizeof buf)
        !           288:                {
        !           289:                        yysemerr("display too long", 0);
        !           290:                        break;
        !           291:                }
        !           292:                if ((*++cp = getch()) == left_ch)
        !           293:                        level++;
        !           294:                else if (*cp == right_ch)
        !           295:                        level -= 1;
        !           296:                else if (*cp == EOF_TOK)
        !           297:                {
        !           298:                        backup(*cp);
        !           299: missing :
        !           300:                        r_c [1] = '\0';
        !           301:                        r_c [0] = right_ch;
        !           302:                        yysemerr("missing closing character", r_c);
        !           303:                        *cp = right_ch;
        !           304:                        /* make next line be read as possible
        !           305:                         * C_CODE by yylex() [yylex.c]
        !           306:                         */
        !           307:                        Newline = 1;
        !           308:                        break;
        !           309:                }
        !           310:                else if (*cp == '\n')
        !           311:                {
        !           312:                        /* test that next line is valid equel line,
        !           313:                         * and strip "##"
        !           314:                         */
        !           315:                        if ((pk = getch()) != '#')
        !           316:                        {
        !           317:                                backup(pk);
        !           318:                                goto missing;
        !           319:                        }
        !           320:                        if ((pk = getch()) != '#')
        !           321:                        {
        !           322:                                backup(pk);
        !           323:                                backup('#');
        !           324:                                goto missing;
        !           325:                        }
        !           326:                }
        !           327:        }  while (*cp != right_ch || level > 0);
        !           328:        if (level == 0)
        !           329:                Newline = 0;
        !           330:        *++cp = '\0';
        !           331:        if (disp)
        !           332:                enter_display(disp, salloc(buf));
        !           333:        else
        !           334:                w_op(buf);
        !           335: }

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