Return to par_util.c CVS log

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

Annotation of 43BSD/ingres/source/parser/par_util.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <aux.h>
        !             3: # include      <tree.h>
        !             4: # include      "parser.h"
        !             5: # include      <catalog.h>
        !             6: # include      <pv.h>
        !             7: # include      <symbol.h>
        !             8: # include      <sccs.h>
        !             9: # include      "scanner.h"
        !            10: # include      <errors.h>
        !            11: 
        !            12: SCCSID(@(#)par_util.c  8.2     2/14/85)
        !            13: 
        !            14: /*
        !            15: **  PAR_UTIL -- parser utility functions
        !            16: **
        !            17: **     These functions are generally unrelated except that they are
        !            18: **     needed to operate the parser and are too small to be considered
        !            19: **     seperate modules.
        !            20: **
        !            21: **     Defined Constants:
        !            22: **
        !            23: **     Defines:
        !            24: **             timeofday       -- convert arguments to minutes since midnight
        !            25: **             tlprepend       -- attach two target list components
        !            26: **             header          -- prints the header for a retrieve to terminal
        !            27: **             patmat          -- converts pattern matching characters in a string
        !            28: **             permcom         -- adds a command to the permit command vector
        !            29: **
        !            30: **     Requires:
        !            31: **             nothing
        !            32: **
        !            33: **     Required By:
        !            34: **             y.tab.c         -- the grammar
        !            35: **
        !            36: **     Files:
        !            37: **             none
        !            38: **
        !            39: **     Compilation Flags:
        !            40: **             none
        !            41: **
        !            42: **     Trace Flags:
        !            43: **             PAR_UTIL.C ~~ 62, 63
        !            44: **
        !            45: **     History:
        !            46: **             20 Dec 1978     -- written (rick)
        !            47: */
        !            48: 
        !            49: 
        !            50: 
        !            51: 
        !            52: 
        !            53: 
        !            54: 
        !            55: 
        !            56: /*
        !            57: **  TIMEOFDAY -- convert 2 integers to minutes since midnight
        !            58: **
        !            59: **     Converts the hours and minutes parameters to minutes since midnight
        !            60: **     performing some error (bounds) checking on the time.
        !            61: **
        !            62: **     To answer the question about what is midnight, both 0:00 and 24:00
        !            63: **     are handled, but not the same way.  The former is zero minutes from
        !            64: **     midnight and the latter is 1440 minutes from midnight.  (1440 is
        !            65: **     24 hrs times 60 minutes, or 1 minute past the end of the day.)
        !            66: **
        !            67: **     Parameters:
        !            68: **             hrs             -- an integer pointer to the hour
        !            69: **             mins            -- an integer pointer to the minutes
        !            70: **
        !            71: **     Returns:
        !            72: **             integer time since midnight
        !            73: **
        !            74: **     Side Effects:
        !            75: **             may detect an error and call par_error which never returns.
        !            76: **
        !            77: **     Requires:
        !            78: **             that the pointers be on integer boundaries
        !            79: **
        !            80: **     Called By:
        !            81: **             y.tab.c         -- the grammar
        !            82: **
        !            83: **     Trace Flags:
        !            84: **             none
        !            85: **
        !            86: **     Diagnostics:
        !            87: **             BADHOURS        -- No such hour
        !            88: **             BADMINS         -- No such minute
        !            89: **             BAD24TIME       -- only 24:00 allowed
        !            90: **
        !            91: **     Syserrs:
        !            92: **             none
        !            93: **
        !            94: **     History:
        !            95: **             20 Dec 1978     -- written (rick)
        !            96: */
        !            97: timeofday(hrs, mins)
        !            98: short  *hrs;
        !            99: short  *mins;
        !           100: {
        !           101:        register int    h;
        !           102:        register int    m;
        !           103:        register int    rtval;
        !           104: 
        !           105:        h = *hrs;
        !           106:        m = *mins;
        !           107:        if (h > 24 || h < 0)
        !           108:                /* no such hour */
        !           109:                par_error(BADHOURS, WARN, iocv(h), 0);
        !           110:        if (m > 59 || m < 0)
        !           111:                /* no such minute */
        !           112:                par_error(BADMINS, WARN, iocv(m), 0);
        !           113:        if (h == 24)
        !           114:        {
        !           115:                h = 1440;
        !           116:                if (m != 0)
        !           117:                        /* can only use 24:00 */
        !           118:                        par_error(BAD24TIME, WARN, iocv(m), 0);
        !           119:        }
        !           120:        rtval = (h * 60) + m;
        !           121:        return (rtval);
        !           122: }
        !           123: 
        !           124: 
        !           125: /*
        !           126: **  TLPREPEND -- combine two target list components
        !           127: **
        !           128: **     Attach two target list components to each other.
        !           129: **     Neither component need be a single element.  The
        !           130: **     'a' component will be attached at the extreme left
        !           131: **     of the 'b' component.
        !           132: **
        !           133: **     Parameters:
        !           134: **             a               -- tl component to attach
        !           135: **             b               -- tl base for attaching
        !           136: **
        !           137: **     Returns:
        !           138: **             nothing
        !           139: **
        !           140: **     Side Effects:
        !           141: **             this routine is a side effect.  It attaches a to b
        !           142: **             and when it returns a is attached to b but the pointer
        !           143: **             to b never changes (neither does the pointer to a)
        !           144: **
        !           145: **     Requires:
        !           146: **             nothing
        !           147: **
        !           148: **     Called By:
        !           149: **             y.tab.c         -- the grammar
        !           150: **
        !           151: **     Trace Flags:
        !           152: **             tlprepend ~~ 62.4
        !           153: **
        !           154: **     Diagnostics:
        !           155: **             none
        !           156: **
        !           157: **     Syserrs:
        !           158: **             none
        !           159: **
        !           160: **     History:
        !           161: **             20 Dec 1978     -- written (rick)
        !           162: */
        !           163: 
        !           164: QTREE *
        !           165: tlprepend(a, b)
        !           166: QTREE  *a;
        !           167: QTREE  *b;
        !           168: {
        !           169:        register QTREE  *q;
        !           170: 
        !           171: # ifdef        xPTR1
        !           172:        tTfp(62, 4, "tlprepend\n");
        !           173: # endif
        !           174: 
        !           175:        if (b==NULL)
        !           176:            return(a);
        !           177:        /* scan to the left end of b */
        !           178:        for (q = b; q->left != NULL; q = q->left)
        !           179:                ;       /* no action */
        !           180:        
        !           181:        /* attach a to the end of b */
        !           182:        q->left = a;
        !           183:        return (b);
        !           184: }
        !           185: 
        !           186: 
        !           187: 
        !           188: /*
        !           189: **  HEADER.C -- print header for retrieve to terminal
        !           190: **
        !           191: **     "setp" to reconstruct the field names and types and passing
        !           192: **     them to the normal printhdr etc.
        !           193: **
        !           194: **     Defines:
        !           195: **             header()
        !           196: **
        !           197: **     Requires:
        !           198: **             printhdr        - utility lib
        !           199: **             beginhdr        - utility lib
        !           200: **             printeol        - utility lib
        !           201: **             printeh         - utility lib
        !           202: **             atoi            - utility lib
        !           203: **             Dc              - vble, number of params in list
        !           204: **             Dv              - vble, list of parameters
        !           205: **
        !           206: **     Trace Flags:
        !           207: **             none
        !           208: **
        !           209: **     History:
        !           210: **             written (ancient history) (rick)
        !           211: */
        !           212: header(pv)
        !           213: PARM   *pv;
        !           214: {
        !           215:        int             len;
        !           216:        HDRINFO         *hptr;
        !           217:        HDRINFO         *tptr;
        !           218:        int             start = 1;
        !           219:        extern HDRINFO  *Hdrptr;
        !           220:        extern HDRINFO  *Fieldwidth;
        !           221:        extern int      Hdr;
        !           222: 
        !           223:        Hdr = TRUE;
        !           224:        beginhdr();
        !           225: 
        !           226: 
        !           227:        for (; pv->pv_type != PV_EOF; pv += 2)
        !           228:        {
        !           229:                if ((pv[1].pv_val.pv_str[0] & I1MASK) == 'c')
        !           230:                {
        !           231:                        tptr = (HDRINFO *) malloc(sizeof(HDRINFO));
        !           232:                        if (start)
        !           233:                        {
        !           234:                                Hdrptr = tptr;
        !           235:                                Fieldwidth = Hdrptr;
        !           236:                                start = 0;
        !           237:                        }
        !           238:                        else
        !           239:                                hptr->next = tptr;
        !           240:                        hptr = tptr;
        !           241:                }
        !           242: 
        !           243:                len = atoi(&pv[1].pv_val.pv_str[1]);
        !           244:                printhdr(pv[1].pv_val.pv_str[0] & I1MASK, len, pv->pv_val.pv_str);
        !           245: 
        !           246:                if ((pv[1].pv_val.pv_str[0] & I1MASK) == 'c')
        !           247:                {
        !           248:                        tptr->len = len;
        !           249:                        tptr->len &= 0377;
        !           250:                        tptr->next = NULL;
        !           251:                }
        !           252:        }
        !           253:        printeol();
        !           254:        printeh();
        !           255: }
        !           256: 
        !           257: 
        !           258: 
        !           259: 
        !           260: 
        !           261: 
        !           262: /*
        !           263: **  PATMAT -- converts pattern matching characters in a string
        !           264: **
        !           265: **     Searches a string up to a null byte for one of the pattern
        !           266: **     matching characters '*', '?', '[', and ']'. It then converts
        !           267: **     these characters to their internal control character equivalents.
        !           268: **
        !           269: **     Parameters:
        !           270: **             str             -- the string to search
        !           271: **
        !           272: **     Returns:
        !           273: **             0               -- always
        !           274: **
        !           275: **     Side Effects:
        !           276: **             none
        !           277: **
        !           278: **     Requires:
        !           279: **             symbol.h
        !           280: **
        !           281: **     Called By:
        !           282: **             y.tab.c         -- grammar
        !           283: **
        !           284: **     Trace Flags:
        !           285: **             none
        !           286: **
        !           287: **     Diagnostics:
        !           288: **             none
        !           289: **
        !           290: **     Syserrs:
        !           291: **             none
        !           292: **
        !           293: **     History:
        !           294: **             written (ancient history) (rick)
        !           295: **             amended (Heidi) -- checks for numbers after PAT_SPEC's 
        !           296: **                     and does away with flags making pattern matching
        !           297: **                     characters legal in strings
        !           298: */
        !           299: 
        !           300: 
        !           301: /*
        !           302: ** PATMAT
        !           303: **     hunts through a string and converts the pattern matching
        !           304: **     characters and replaces with the corresponding cntrl chars
        !           305: */
        !           306: patmat(str)
        !           307: char   *str;
        !           308: {
        !           309:        register int    i;              /* index variables */
        !           310:        register char   *p, *q, c;
        !           311:        extern int      Qlflag;
        !           312: 
        !           313:        q = str;
        !           314:        for (p = str; *p; p++)
        !           315:        {       
        !           316:                if (*p == '\\')
        !           317:                {
        !           318:                        *q++ = *++p;
        !           319:                        continue;
        !           320:                }
        !           321:                switch (*p)
        !           322:                {
        !           323:                  case '#':
        !           324:                        if (*(p + 1) == '#') 
        !           325:                        {
        !           326:                                p++;
        !           327:                                if ((c = *(p + 1)) == '0')
        !           328:                                {
        !           329:                                        *q++ = PAT_GLOB;
        !           330:                                        p++;
        !           331:                                }
        !           332:                                else if (c >= '1' && c <= '9')
        !           333:                                {
        !           334:                                        if ( !Qlflag )               /* target*/
        !           335:                                            Patspec_flag[c - '0'] = 1;
        !           336:                                        else                     /* qualifier */
        !           337:                                        {
        !           338:                                            if( Patspec_flag[c - '0'] == (TARGBIT | QUALBIT))
        !           339:                                            {
        !           340:                                                for (i=0; i<PATNUM; i++)
        !           341:                                                        Patspec_flag[i] = 0;
        !           342:                                                par_error(DUPINDEX,WARN,0);
        !           343:                                            }
        !           344:                                            /* allows for repeated indices in
        !           345:                                            ** qualifier as long as index is not
        !           346:                                            ** mentioned in target
        !           347:                                            */
        !           348:                                            else
        !           349:                                                Patspec_flag[c - '0'] = Patspec_flag[c - '0'] | QUALBIT;
        !           350:                                        }
        !           351:                                        *q++ = PAT_SPEC;
        !           352:                                }
        !           353:                                else 
        !           354:                                        par_error(NOINDEX,WARN,0);
        !           355:                                continue;
        !           356:                        }
        !           357:                        else
        !           358:                                *q++ = *p;
        !           359:                        continue;
        !           360:       
        !           361:                  case '*':
        !           362:                        if (!Qlflag)
        !           363:                                par_error(NOPATMAT, WARN, 0);
        !           364:                        *q++ = PAT_ANY;
        !           365:                        continue;
        !           366: 
        !           367:                  case '?':
        !           368:                        if (!Qlflag)
        !           369:                                par_error(NOPATMAT, WARN, 0);
        !           370:                        *q++ = PAT_ONE;
        !           371:                        continue;
        !           372: 
        !           373:                  case '[':
        !           374:                        if (!Qlflag)
        !           375:                                par_error(NOPATMAT, WARN, 0);
        !           376:                        *q++ = PAT_LBRAC;
        !           377:                        continue;
        !           378: 
        !           379:                  case ']':
        !           380:                        if (!Qlflag)
        !           381:                                par_error(NOPATMAT, WARN, 0);
        !           382:                        *q++ = PAT_RBRAC;
        !           383:                        continue;
        !           384: 
        !           385:                  default:
        !           386:                        *q++ = *p;
        !           387:                        continue;
        !           388:                }
        !           389:        }
        !           390:        *q = '\0';
        !           391:        return (0);
        !           392: }
        !           393: /*
        !           394: **  PERMCOM -- map command allowed into protection catalog bits
        !           395: **
        !           396: **     translates the QMODE type symbols into the appropriate counterparts
        !           397: **     for the permit statement allowed command vector.  The manifest
        !           398: **     constants are designed to be inclusive or'd together to form a
        !           399: **     composite bit map of OK actions.
        !           400: **
        !           401: **     Parameters:
        !           402: **             a               -- the QMODE type symbol for the command to add
        !           403: **
        !           404: **     Returns:
        !           405: **             none
        !           406: **
        !           407: **     Side Effects:
        !           408: **             changes the variable Permcomd to reflect the additional permission
        !           409: **
        !           410: **     Requires:
        !           411: **             Permcomd must be define globally
        !           412: **             catalog.h for the proper constants
        !           413: **
        !           414: **     Called By:
        !           415: **             y.tab.c         -- the grammar
        !           416: **
        !           417: **     Trace Flags:
        !           418: **             none
        !           419: **
        !           420: **     Diagnostics:
        !           421: **             none
        !           422: **
        !           423: **     Syserrs:
        !           424: **             bad QMODE(%d)   -- a bad symbol has been passed for mapping
        !           425: **
        !           426: **     History:
        !           427: **             28 Dec 1978     -- written (rick)
        !           428: */
        !           429: 
        !           430: permcom(a)
        !           431: int    a;
        !           432: {
        !           433:        extern int              Permcomd;
        !           434:        switch (a)
        !           435:        {
        !           436:          case mdRETR:
        !           437:                Permcomd |= PRO_RETR;
        !           438:                break;
        !           439: 
        !           440:          case mdAPP:
        !           441:                Permcomd |= PRO_APP;
        !           442:                break;
        !           443:        
        !           444:          case mdREPL:
        !           445:                Permcomd |= PRO_REPL;
        !           446:                break;
        !           447: 
        !           448:          case mdDEL:
        !           449:                Permcomd |= PRO_DEL;
        !           450:                break;
        !           451: 
        !           452:          case -1:
        !           453:                Permcomd |= 0177777;            /* all bits set */
        !           454:                break;
        !           455:        
        !           456:          default:
        !           457:                syserr("permcom: bad QMODE(%d)", a);
        !           458:        }
        !           459: }
        !           460: 
        !           461: char   *
        !           462: makestr(str)
        !           463: register char  *str;
        !           464: {
        !           465:        register char   *result;
        !           466:        register int    len;
        !           467: 
        !           468:        len = length(str) + 1;
        !           469: 
        !           470:        result = (char *) need(Qbuf, len);
        !           471: 
        !           472:        bmove(str, result, len);
        !           473: 
        !           474:        return (result);
        !           475: }
        !           476: 
        !           477: 
        !           478: /*
        !           479: **     QUALINDEX -- 
        !           480: **             check to see if a PAT_SPEC index was used in a target
        !           481: **             list and not in a qualifier list
        !           482: **
        !           483: **             Returns: 0 if ok
        !           484: **                      calls par_error if not ok
        !           485: **
        !           486: **             Called by: y.tab.c   -grammar
        !           487: */
        !           488: 
        !           489: qualindex()
        !           490: {
        !           491:        int i;
        !           492: 
        !           493:        for (i=0; i<PATNUM; i++)
        !           494:        {
        !           495:                if (Patspec_flag[i] == TARGBIT)
        !           496:                {
        !           497:                        /* reset the rest of the flag array */
        !           498:                        while (i++ < PATNUM)
        !           499:                             Patspec_flag[i] = 0;
        !           500:                        par_error(NOQUALINDX, WARN, 0);
        !           501:                }
        !           502:                Patspec_flag[i] = 0;
        !           503:        }
        !           504:        return(0);
        !           505: }

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