Return to prtout.c CVS log

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

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

1.1     ! root        1: # include      <stdio.h>
        !             2: # include      "constants.h"
        !             3: # include      "globals.h"
        !             4: # include      <sccs.h>
        !             5: 
        !             6: SCCSID(@(#)prtout.c    8.1     12/31/84)
        !             7: 
        !             8: 
        !             9: /*
        !            10: **  PRTOUT.C -- output routines
        !            11: **
        !            12: **     Output routines for non-specific data structures
        !            13: **     (i.e. w_display is in [display.c])
        !            14: */
        !            15: 
        !            16: 
        !            17: 
        !            18: int    Fillcnt         = FILLCNT;
        !            19: /*
        !            20: **  W_CON -- write out a constant
        !            21: **     Writes out a constant of type 'type'
        !            22: **     pointed to by 'string'.
        !            23: */
        !            24: 
        !            25: 
        !            26: w_con(type, string)
        !            27: int    type;
        !            28: char   *string;
        !            29: {
        !            30:        if (type == Tokens.sp_sconst)
        !            31:                w_string(string, 1);
        !            32:        else
        !            33:                w_key(string);
        !            34: }
        !            35: /*
        !            36: **  W_OP -- Writes out a string which doesn't need a blank
        !            37: **         to separate it from a keyword.
        !            38: */
        !            39: 
        !            40: 
        !            41: w_op(string)
        !            42: char           *string;
        !            43: {
        !            44:        w_raw(string);
        !            45:        Lastc = OPCHAR;
        !            46: }
        !            47: /*
        !            48: **  W_VAR -- writes out code to send the
        !            49: **          value of a C variable down to
        !            50: **          the Quel scanner.
        !            51: **
        !            52: **     Conserves the state of In_quote.
        !            53: */
        !            54: 
        !            55: 
        !            56: w_var(disp, type)
        !            57: int            type;
        !            58: struct display *disp;
        !            59: {
        !            60:        register struct disp_node       *d;
        !            61:        register                        savestat;
        !            62: 
        !            63:        savestat = In_quote;
        !            64: 
        !            65:        /* if was In_quote, then will want a space before the
        !            66:         * string written down
        !            67:         */
        !            68:        if (savestat)
        !            69:                w_key("");
        !            70:        if (type != opIDSTRING)
        !            71:        {
        !            72:                w_new("IIcvar(");
        !            73:                if (type != opSTRING)
        !            74:                        w_op("&");
        !            75:        }
        !            76:        else
        !            77:                w_new("IIwrite(");
        !            78:        w_display(disp);
        !            79:        switch (type)
        !            80:        {
        !            81:          case opSHORT:
        !            82:                w_op(",1,2);");
        !            83:                break;
        !            84: 
        !            85:          case opFLOAT :
        !            86:                w_op(",2,4);");
        !            87:                break;
        !            88: 
        !            89:          case opSTRING :
        !            90:                w_op(",3,0);");
        !            91:                break;
        !            92: 
        !            93:          case opDOUBLE :
        !            94:                w_op(",4,8);");
        !            95:                break;
        !            96: 
        !            97:          case opCHAR :
        !            98:                w_op(",5,1);");
        !            99:                break;
        !           100: 
        !           101:          case opLONG :         /* also ints, since this is a VAX */
        !           102:                w_op(",6,4);");
        !           103:                break;
        !           104: 
        !           105:          case opIDSTRING :
        !           106:                w_op(");");
        !           107:                break;
        !           108: 
        !           109:          default :
        !           110:                syserr("invalid type %d in w_var",
        !           111:                type);
        !           112:        }
        !           113:        if (savestat)
        !           114:        {
        !           115:                begin_quote();
        !           116:                /* if was In_quote, then will want a space 
        !           117:                 * before next keyword
        !           118:                 */
        !           119:                w_key("");
        !           120:        }
        !           121: }
        !           122: /*
        !           123: **  W_KEY -- write out a string needing a blank to
        !           124: **          separate it from other keywords.
        !           125: */
        !           126: 
        !           127: 
        !           128: w_key(string)
        !           129: char   *string;
        !           130: {
        !           131:        if (Lastc == KEYCHAR)
        !           132:                w_raw(" ");
        !           133:        w_raw(string);
        !           134:        Lastc = KEYCHAR;
        !           135: }
        !           136: /*
        !           137: **  W_NEW -- write out a string after getting out of
        !           138: **          any pending IIwrite's.
        !           139: */
        !           140: 
        !           141: w_new(string)
        !           142: char   *string;
        !           143: {
        !           144:        end_quote();
        !           145:        w_op(string);
        !           146: }
        !           147: /*
        !           148: **  BEGIN_QUOTE -- Issue an IIwrite("
        !           149: */
        !           150: 
        !           151: 
        !           152: begin_quote()
        !           153: {
        !           154:        In_string = 1;
        !           155:        In_quote = 1;
        !           156:        Fillmode = 1;
        !           157:        w_op("IIwrite(\"");
        !           158: }
        !           159: /*
        !           160: **  END_QUOTE -- End any pending IIwrite("
        !           161: */
        !           162: 
        !           163: 
        !           164: end_quote()
        !           165: {
        !           166:        In_string = 0;
        !           167:        if (In_quote)
        !           168:                w_op("\");");
        !           169:        In_quote = 0;
        !           170: }
        !           171: /*
        !           172: **  EQUATE_LINES -- Make subsequent lines be output on the
        !           173: **                 same line they were read (lines of C_CODE only).
        !           174: **
        !           175: **     Note: Because of the algorithm used, it is possible that
        !           176: **             the correct line in the output has already been passed,
        !           177: **             in which case equate_lines does nothing.
        !           178: */
        !           179: 
        !           180: 
        !           181: equate_lines()
        !           182: {
        !           183:        Fillmode = 0;
        !           184:        while (Lineout < yyline)
        !           185:                w_raw("\n");
        !           186:        Lastc = OPCHAR;
        !           187: }
        !           188: /*
        !           189: **  W_SYNC -- Put out an IIsync() call
        !           190: */
        !           191: 
        !           192: 
        !           193: w_sync()
        !           194: {
        !           195:        w_new("IIsync(");
        !           196:        w_file();
        !           197:        w_op(");");
        !           198: }
        !           199: /*
        !           200: **  W_FLUSH -- Put out an IIflush_tup() call
        !           201: */
        !           202: 
        !           203: 
        !           204: w_flush()
        !           205: {
        !           206:        w_new("IIflushtup(");
        !           207:        w_file();
        !           208:        w_op(");");
        !           209: }
        !           210: /*
        !           211: **  W_FILE -- Writes out the name and line number of the
        !           212: **           input file if Rtdb is specified, else a 0.
        !           213: */
        !           214: 
        !           215: 
        !           216: w_file()
        !           217: {
        !           218:        char            itemp [6];
        !           219: 
        !           220:        if (Rtdb)
        !           221:        {
        !           222:                w_string(Input_file_name, 0);
        !           223:                itoa(yyline, itemp);
        !           224:                w_op(",");
        !           225:                w_key(itemp);
        !           226:        }
        !           227:        else
        !           228:                w_key("0");
        !           229: }
        !           230: /*
        !           231: **  W_STRING -- Writes out a string
        !           232: **
        !           233: **     String is output as a string constant if type == 0
        !           234: **     otherwise writes out string inside an IIwrite(
        !           235: */
        !           236: 
        !           237: 
        !           238: w_string(string, type)
        !           239: char   *string;
        !           240: int    type;
        !           241: {
        !           242:        register char   *t;
        !           243:        register char   *s;
        !           244: 
        !           245:        if (type)
        !           246:        {
        !           247:                if (!In_quote)
        !           248:                        begin_quote();
        !           249:                w_raw("\\\"");
        !           250:        }
        !           251:        else
        !           252:                w_raw("\"");
        !           253: 
        !           254:        s = t = string;
        !           255:        In_string += 1;
        !           256:        for ( ;*t ; )
        !           257:        {
        !           258:                if (*t == '\\')
        !           259:                {
        !           260:                  
        !           261:                        if (t [1] == '\n')
        !           262:                        {
        !           263:                                *t = '\0';
        !           264:                                w_raw(s);
        !           265:                                s = t = &t [2];
        !           266:                                w_raw("\\\n");
        !           267:                        }
        !           268:                        else
        !           269:                        {
        !           270:                                *t++ = '\0';
        !           271:                                w_raw(s);
        !           272:                                s = t;
        !           273:                                /* note that this call must be atomic,
        !           274:                                 * as w_raw would feel free to put newlines
        !           275:                                 * in if not.
        !           276:                                 */
        !           277:                                if (type)
        !           278:                                        w_raw("\\\\");
        !           279:                                else
        !           280:                                        w_raw("\\");
        !           281:                        }
        !           282:                }
        !           283:                else if (*t == '"')
        !           284:                {
        !           285:                        w_raw("\\\"");
        !           286:                        s = ++t;
        !           287:                }
        !           288:                else
        !           289:                        t++;
        !           290:        }
        !           291:        w_raw(s);
        !           292:        In_string -= 1;
        !           293:        if (type)
        !           294:                w_raw("\\\"");
        !           295:        else
        !           296:                w_raw("\"");
        !           297: }
        !           298: /*
        !           299: **  W_RAW -- Lowest level output character routine
        !           300: **
        !           301: **     Outputs string depending on Fillcnt and In_quote
        !           302: **     and In_string and Fillmode.
        !           303: **     When not in Fillmode does straight output.
        !           304: **     When on Fillmode, fills lines to Fillmode.
        !           305: **
        !           306: **     NOTE : w_raw will feel free to output a newline after 
        !           307: **             'string' if the string causes more than Fillcnt
        !           308: **             characters to be output.
        !           309: **             Inside strings (In_string != 0) w_raw will put
        !           310: **             a '\\' before the newline issued.
        !           311: **             When In_quote != 0 when the fillcnt is exceeded,
        !           312: **             the IIwrite( is ended an continued on the next line
        !           313: **             so that the query string won't overflow the C 
        !           314: **             pre-processor's line buffer.
        !           315: */
        !           316: 
        !           317: 
        !           318: w_raw(string)
        !           319: char   *string;
        !           320: {
        !           321:        register char   *s;
        !           322:        register        charcnt;
        !           323: 
        !           324:        charcnt = 0;
        !           325:        for (s = string; *s; s++)
        !           326:        {
        !           327:                if (*s != '\n')
        !           328:                {
        !           329:                        putc(*s, Out_file);
        !           330:                        charcnt++;
        !           331:                }
        !           332:                else
        !           333:                {
        !           334:                        if (Fillmode == 0 ||
        !           335:                           Charcnt + charcnt > Fillcnt ||
        !           336:                           In_string)
        !           337:                        {
        !           338:                                putc(*s, Out_file);
        !           339:                                Lineout++;
        !           340:                                charcnt = 0;
        !           341:                                Charcnt = 0;
        !           342:                        }
        !           343:                        else
        !           344:                        {
        !           345:                                putc(' ', Out_file);
        !           346:                                charcnt++;
        !           347:                        }
        !           348:                }
        !           349:        }
        !           350:        if ((Charcnt += charcnt) > Fillcnt && Fillmode == 1)
        !           351:        {
        !           352:                if (In_string)
        !           353:                {
        !           354:                        if (In_quote)
        !           355:                        {
        !           356:                                puts("\");\nIIwrite(\"", Out_file);
        !           357:                                Charcnt = 9;
        !           358:                        }
        !           359:                        else
        !           360:                        {
        !           361:                                puts("\\\n", Out_file);
        !           362:                                Charcnt = 0;
        !           363:                        }
        !           364:                }
        !           365:                else
        !           366:                {
        !           367:                        putc('\n', Out_file);
        !           368:                        Charcnt = 0;
        !           369:                }
        !           370:                Lineout++;
        !           371:        }
        !           372: }
        !           373: /*
        !           374: **  PUTS -- put a string on an output file using putc()
        !           375: */
        !           376: 
        !           377: puts(s, file)
        !           378: char   *s;
        !           379: FILE   *file;
        !           380: {
        !           381:        register char   *sp;
        !           382:        register FILE   *f;
        !           383: 
        !           384:        f = file;
        !           385:        for (sp = s; *sp; )
        !           386:                putc(*sp++, f);
        !           387: }

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