Annotation of researchv10no/cmd/lcc/c/keywords.h, revision 1.1.1.1

1.1       root        1: case 'a':
                      2:        if (rcp[0] == 'u'
                      3:        &&  rcp[1] == 't'
                      4:        &&  rcp[2] == 'o'
                      5:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                      6:                cp = rcp + 3;
                      7:                return AUTO;
                      8:        }
                      9:        goto id;
                     10: case 'b':
                     11:        if (rcp[0] == 'r'
                     12:        &&  rcp[1] == 'e'
                     13:        &&  rcp[2] == 'a'
                     14:        &&  rcp[3] == 'k'
                     15:        && !(map[rcp[4]]&(DIGIT|LETTER))) {
                     16:                cp = rcp + 4;
                     17:                return BREAK;
                     18:        }
                     19:        goto id;
                     20: case 'c':
                     21:        if (rcp[0] == 'a'
                     22:        &&  rcp[1] == 's'
                     23:        &&  rcp[2] == 'e'
                     24:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                     25:                cp = rcp + 3;
                     26:                return CASE;
                     27:        }
                     28:        if (rcp[0] == 'h'
                     29:        &&  rcp[1] == 'a'
                     30:        &&  rcp[2] == 'r'
                     31:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                     32:                cp = rcp + 3;
                     33:                tsym = chartype->u.sym;
                     34:                return CHAR;
                     35:        }
                     36:        if (rcp[0] == 'o'
                     37:        &&  rcp[1] == 'n'
                     38:        &&  rcp[2] == 's'
                     39:        &&  rcp[3] == 't'
                     40:        && !(map[rcp[4]]&(DIGIT|LETTER))) {
                     41:                cp = rcp + 4;
                     42:                return CONST;
                     43:        }
                     44:        if (rcp[0] == 'o'
                     45:        &&  rcp[1] == 'n'
                     46:        &&  rcp[2] == 't'
                     47:        &&  rcp[3] == 'i'
                     48:        &&  rcp[4] == 'n'
                     49:        &&  rcp[5] == 'u'
                     50:        &&  rcp[6] == 'e'
                     51:        && !(map[rcp[7]]&(DIGIT|LETTER))) {
                     52:                cp = rcp + 7;
                     53:                return CONTINUE;
                     54:        }
                     55:        goto id;
                     56: case 'd':
                     57:        if (rcp[0] == 'e'
                     58:        &&  rcp[1] == 'f'
                     59:        &&  rcp[2] == 'a'
                     60:        &&  rcp[3] == 'u'
                     61:        &&  rcp[4] == 'l'
                     62:        &&  rcp[5] == 't'
                     63:        && !(map[rcp[6]]&(DIGIT|LETTER))) {
                     64:                cp = rcp + 6;
                     65:                return DEFAULT;
                     66:        }
                     67:        if (rcp[0] == 'o'
                     68:        &&  rcp[1] == 'u'
                     69:        &&  rcp[2] == 'b'
                     70:        &&  rcp[3] == 'l'
                     71:        &&  rcp[4] == 'e'
                     72:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                     73:                cp = rcp + 5;
                     74:                tsym = doubletype->u.sym;
                     75:                return DOUBLE;
                     76:        }
                     77:        if (rcp[0] == 'o'
                     78:        && !(map[rcp[1]]&(DIGIT|LETTER))) {
                     79:                cp = rcp + 1;
                     80:                return DO;
                     81:        }
                     82:        goto id;
                     83: case 'e':
                     84:        if (rcp[0] == 'l'
                     85:        &&  rcp[1] == 's'
                     86:        &&  rcp[2] == 'e'
                     87:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                     88:                cp = rcp + 3;
                     89:                return ELSE;
                     90:        }
                     91:        if (rcp[0] == 'n'
                     92:        &&  rcp[1] == 'u'
                     93:        &&  rcp[2] == 'm'
                     94:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                     95:                cp = rcp + 3;
                     96:                return ENUM;
                     97:        }
                     98:        if (rcp[0] == 'x'
                     99:        &&  rcp[1] == 't'
                    100:        &&  rcp[2] == 'e'
                    101:        &&  rcp[3] == 'r'
                    102:        &&  rcp[4] == 'n'
                    103:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    104:                cp = rcp + 5;
                    105:                return EXTERN;
                    106:        }
                    107:        goto id;
                    108: case 'f':
                    109:        if (rcp[0] == 'l'
                    110:        &&  rcp[1] == 'o'
                    111:        &&  rcp[2] == 'a'
                    112:        &&  rcp[3] == 't'
                    113:        && !(map[rcp[4]]&(DIGIT|LETTER))) {
                    114:                cp = rcp + 4;
                    115:                tsym = floattype->u.sym;
                    116:                return FLOAT;
                    117:        }
                    118:        if (rcp[0] == 'o'
                    119:        &&  rcp[1] == 'r'
                    120:        && !(map[rcp[2]]&(DIGIT|LETTER))) {
                    121:                cp = rcp + 2;
                    122:                return FOR;
                    123:        }
                    124:        goto id;
                    125: case 'g':
                    126:        if (rcp[0] == 'o'
                    127:        &&  rcp[1] == 't'
                    128:        &&  rcp[2] == 'o'
                    129:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                    130:                cp = rcp + 3;
                    131:                return GOTO;
                    132:        }
                    133:        goto id;
                    134: case 'i':
                    135:        if (rcp[0] == 'f'
                    136:        && !(map[rcp[1]]&(DIGIT|LETTER))) {
                    137:                cp = rcp + 1;
                    138:                return IF;
                    139:        }
                    140:        if (rcp[0] == 'n'
                    141:        &&  rcp[1] == 't'
                    142:        && !(map[rcp[2]]&(DIGIT|LETTER))) {
                    143:                cp = rcp + 2;
                    144:                tsym = inttype->u.sym;
                    145:                return INT;
                    146:        }
                    147:        goto id;
                    148: case 'l':
                    149:        if (rcp[0] == 'o'
                    150:        &&  rcp[1] == 'n'
                    151:        &&  rcp[2] == 'g'
                    152:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                    153:                cp = rcp + 3;
                    154:                tsym = longtype->u.sym;
                    155:                return LONG;
                    156:        }
                    157:        goto id;
                    158: case 'r':
                    159:        if (rcp[0] == 'e'
                    160:        &&  rcp[1] == 'g'
                    161:        &&  rcp[2] == 'i'
                    162:        &&  rcp[3] == 's'
                    163:        &&  rcp[4] == 't'
                    164:        &&  rcp[5] == 'e'
                    165:        &&  rcp[6] == 'r'
                    166:        && !(map[rcp[7]]&(DIGIT|LETTER))) {
                    167:                cp = rcp + 7;
                    168:                return REGISTER;
                    169:        }
                    170:        if (rcp[0] == 'e'
                    171:        &&  rcp[1] == 't'
                    172:        &&  rcp[2] == 'u'
                    173:        &&  rcp[3] == 'r'
                    174:        &&  rcp[4] == 'n'
                    175:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    176:                cp = rcp + 5;
                    177:                return RETURN;
                    178:        }
                    179:        goto id;
                    180: case 's':
                    181:        if (rcp[0] == 'h'
                    182:        &&  rcp[1] == 'o'
                    183:        &&  rcp[2] == 'r'
                    184:        &&  rcp[3] == 't'
                    185:        && !(map[rcp[4]]&(DIGIT|LETTER))) {
                    186:                cp = rcp + 4;
                    187:                tsym = shorttype->u.sym;
                    188:                return SHORT;
                    189:        }
                    190:        if (rcp[0] == 'i'
                    191:        &&  rcp[1] == 'g'
                    192:        &&  rcp[2] == 'n'
                    193:        &&  rcp[3] == 'e'
                    194:        &&  rcp[4] == 'd'
                    195:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    196:                cp = rcp + 5;
                    197:                return SIGNED;
                    198:        }
                    199:        if (rcp[0] == 'i'
                    200:        &&  rcp[1] == 'z'
                    201:        &&  rcp[2] == 'e'
                    202:        &&  rcp[3] == 'o'
                    203:        &&  rcp[4] == 'f'
                    204:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    205:                cp = rcp + 5;
                    206:                return SIZEOF;
                    207:        }
                    208:        if (rcp[0] == 't'
                    209:        &&  rcp[1] == 'a'
                    210:        &&  rcp[2] == 't'
                    211:        &&  rcp[3] == 'i'
                    212:        &&  rcp[4] == 'c'
                    213:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    214:                cp = rcp + 5;
                    215:                return STATIC;
                    216:        }
                    217:        if (rcp[0] == 't'
                    218:        &&  rcp[1] == 'r'
                    219:        &&  rcp[2] == 'u'
                    220:        &&  rcp[3] == 'c'
                    221:        &&  rcp[4] == 't'
                    222:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    223:                cp = rcp + 5;
                    224:                return STRUCT;
                    225:        }
                    226:        if (rcp[0] == 'w'
                    227:        &&  rcp[1] == 'i'
                    228:        &&  rcp[2] == 't'
                    229:        &&  rcp[3] == 'c'
                    230:        &&  rcp[4] == 'h'
                    231:        && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    232:                cp = rcp + 5;
                    233:                return SWITCH;
                    234:        }
                    235:        goto id;
                    236: case 't':
                    237:        if (rcp[0] == 'y'
                    238:        &&  rcp[1] == 'p'
                    239:        &&  rcp[2] == 'e'
                    240:        &&  rcp[3] == 'd'
                    241:        &&  rcp[4] == 'e'
                    242:        &&  rcp[5] == 'f'
                    243:        && !(map[rcp[6]]&(DIGIT|LETTER))) {
                    244:                cp = rcp + 6;
                    245:                return TYPEDEF;
                    246:        }
                    247:        goto id;
                    248: case 'u':
                    249:        if (rcp[0] == 'n'
                    250:        &&  rcp[1] == 'i'
                    251:        &&  rcp[2] == 'o'
                    252:        &&  rcp[3] == 'n'
                    253:        && !(map[rcp[4]]&(DIGIT|LETTER))) {
                    254:                cp = rcp + 4;
                    255:                return UNION;
                    256:        }
                    257:        if (rcp[0] == 'n'
                    258:        &&  rcp[1] == 's'
                    259:        &&  rcp[2] == 'i'
                    260:        &&  rcp[3] == 'g'
                    261:        &&  rcp[4] == 'n'
                    262:        &&  rcp[5] == 'e'
                    263:        &&  rcp[6] == 'd'
                    264:        && !(map[rcp[7]]&(DIGIT|LETTER))) {
                    265:                cp = rcp + 7;
                    266:                return UNSIGNED;
                    267:        }
                    268:        goto id;
                    269: case 'v':
                    270:        if (rcp[0] == 'o'
                    271:        &&  rcp[1] == 'i'
                    272:        &&  rcp[2] == 'd'
                    273:        && !(map[rcp[3]]&(DIGIT|LETTER))) {
                    274:                cp = rcp + 3;
                    275:                tsym = voidtype->u.sym;
                    276:                return VOID;
                    277:        }
                    278:        if (rcp[0] == 'o'
                    279:        &&  rcp[1] == 'l'
                    280:        &&  rcp[2] == 'a'
                    281:        &&  rcp[3] == 't'
                    282:        &&  rcp[4] == 'i'
                    283:        &&  rcp[5] == 'l'
                    284:        &&  rcp[6] == 'e'
                    285:        && !(map[rcp[7]]&(DIGIT|LETTER))) {
                    286:                cp = rcp + 7;
                    287:                return VOLATILE;
                    288:        }
                    289:        goto id;
                    290: case 'w':
                    291:        if (rcp[0] == 'h'
                    292:        &&  rcp[1] == 'i'
                    293:        &&  rcp[2] == 'l'
                    294:        &&  rcp[3] == 'e'
                    295:        && !(map[rcp[4]]&(DIGIT|LETTER))) {
                    296:                cp = rcp + 4;
                    297:                return WHILE;
                    298:        }
                    299: case 'h':
                    300: case 'j':
                    301: case 'k':
                    302: case 'm':
                    303: case 'n':
                    304: case 'o':
                    305: case 'p':
                    306: case 'q':
                    307: case 'x':
                    308: case 'y':
                    309: case 'z':
                    310: case 'A':
                    311: case 'B':
                    312: case 'C':
                    313: case 'D':
                    314: case 'E':
                    315: case 'F':
                    316: case 'G':
                    317: case 'H':
                    318: case 'I':
                    319: case 'J':
                    320: case 'K':
                    321: case 'M':
                    322: case 'N':
                    323: case 'O':
                    324: case 'P':
                    325: case 'Q':
                    326: case 'R':
                    327: case 'S':
                    328: case 'T':
                    329: case 'U':
                    330: case 'V':
                    331: case 'W':
                    332: case 'X':
                    333: case 'Y':
                    334: case 'Z':
                    335: case '_':

unix.superglobalmegacorp.com

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