Return to config.l CVS log

Up to [Research Unix] / researchv9 / sys / conf / src / config

Annotation of researchv9/sys/conf/src/config/config.l, revision 1.1.1.1

1.1       root        1: %{
                      2: /*     config.l        1.8     81/05/18        */
                      3: 
                      4: #include <ctype.h>
                      5: #include "y.tab.h"
                      6: #include "config.h"
                      7: 
                      8: #define tprintf if (do_trace) printf
                      9: 
                     10: YYSTYPE yylval;
                     11: 
                     12: /*
                     13:  * Key word table
                     14:  */
                     15: 
                     16: struct kt {
                     17:        char *kt_name;
                     18:        int kt_val;
                     19: } key_words[] = {
                     20:        "cpu", CPU, "ident", IDENT, "config", CONFIG, "options", OPTIONS,
                     21:        "device", DEVICE, "controller", CONTROLLER, "uba", UBA, "mba", MBA,
                     22:        "csr", CSR, "nexus", NEXUS, "drive", DRIVE, "vector", VECTOR,
                     23:        "pseudo-device", PSEUDO_DEVICE, "flags", FLAGS, "trace", TRACE,
                     24:        "disk", DISK, "tape", DEVICE, "slave", SLAVE, "at", AT,
                     25:        "hz", HZ, "timezone", TIMEZONE, "dst", DST, "maxusers", MAXUSERS,
                     26:        "master", MASTER, "mkfile", MAKEFILE,
                     27:        "machine", MACHINE, "priority", PRIORITY,
                     28:        0,0,
                     29: };
                     30: %}
                     31: WORD   [A-Za-z_][-A-Za-z_]*
                     32: %%
                     33: {WORD}         {
                     34:                        int i;
                     35: 
                     36:                        if ((i = kw_lookup(yytext)) == -1)
                     37:                        {
                     38:                                yylval.cp = yytext;
                     39:                                tprintf("id(%s) ", yytext);
                     40:                                return ID;
                     41:                        }
                     42:                        tprintf("(%s) ", yytext);
                     43:                        return i;
                     44:                }
                     45: \"[^"]+\"      {
                     46:                        yytext[strlen(yytext)-1] = '\0';
                     47:                        yylval.cp = yytext + 1;
                     48:                        return ID;
                     49:                }
                     50: 0[0-7]*                {
                     51:                        yylval.i = octal(yytext);
                     52:                        tprintf("#O:%o ", yylval.i);
                     53:                        return NUMBER;
                     54:                }
                     55: 0x[0-9a-f]+    {
                     56:                        yylval.i = hex(yytext);
                     57:                        tprintf("#X:%x ", yylval.i);
                     58:                        return NUMBER;
                     59:                }
                     60: [1-9][0-9]*    {
                     61:                        yylval.i = atoi(yytext);
                     62:                        tprintf("#D:%d ", yylval.i);
                     63:                        return NUMBER;
                     64:                }
                     65: [0-9]"."[0-9]* {
                     66:                        double atof();
                     67:                        yylval.i = (int) (60 * atof(yytext) + 0.5);
                     68:                        return FPNUMBER;
                     69:                }
                     70: "-"            {
                     71:                        return MINUS;
                     72:                }
                     73: "?"            {
                     74:                        yylval.i = QUES;
                     75:                        tprintf("? ");
                     76:                        return NUMBER;
                     77:                }
                     78: \n/[ \t]       {
                     79:                        yyline++;
                     80:                        tprintf("\n... ");
                     81:                }
                     82: \n             {
                     83:                        yyline++;
                     84:                        tprintf("\n");
                     85:                        return SEMICOLON;
                     86:                }
                     87: #.*            {       /* Ignored (comment) */;        }
                     88: [ \t]*         {       /* Ignored (white space) */;    }
                     89: ";"            {       return SEMICOLON;               }
                     90: ","            {       return COMMA;                   }
                     91: vme16          {       return VME16D16;                }
                     92: vme24          {       return VME24D16;                }
                     93: vme32          {       return VME32D32;                }
                     94: vme16d16       {       return VME16D16;                }
                     95: vme24d16       {       return VME24D16;                }
                     96: vme32d16       {       return VME32D16;                }
                     97: vme16d32       {       return VME16D32;                }
                     98: vme24d32       {       return VME24D32;                }
                     99: vme32d32       {       return VME32D32;                }
                    100: %%
                    101: /*
                    102:  * kw_lookup
                    103:  *     Look up a string in the keyword table.  Returns a -1 if the
                    104:  *     string is not a keyword otherwise it returns the keyword number
                    105:  */
                    106: 
                    107: kw_lookup(word)
                    108: register char *word;
                    109: {
                    110:        register struct kt *kp;
                    111: 
                    112:        for (kp = key_words; kp->kt_name != 0; kp++)
                    113:                if (eq(word, kp->kt_name))
                    114:                        return kp->kt_val;
                    115:        return -1;
                    116: }
                    117: 
                    118: /*
                    119:  * Number conversion routines
                    120:  */
                    121: 
                    122: octal(str)
                    123: char *str;
                    124: {
                    125:        int num;
                    126: 
                    127:        sscanf(str, "%o", &num);
                    128:        return num;
                    129: }
                    130: 
                    131: hex(str)
                    132: char *str;
                    133: {
                    134:        int num;
                    135: 
                    136:        sscanf(str+2, "%x", &num);
                    137:        return num;
                    138: }

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