lex.cpp

一个小型C语言编译器

                    cp = rcp + 5;
                    return RETURN;
                }
                goto id;
            case 's':
                if (rcp[0] == 'h'
                &&  rcp[1] == 'o'
                &&  rcp[2] == 'r'
                &&  rcp[3] == 't'
                && !(map[rcp[4]]&(DIGIT|LETTER))) {
                    cp = rcp + 4;
                    //tsym = shorttype->u.sym;
                    return SHORT;
                }
                if (rcp[0] == 'i'
                &&  rcp[1] == 'g'
                &&  rcp[2] == 'n'
                &&  rcp[3] == 'e'
                &&  rcp[4] == 'd'
                && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    cp = rcp + 5;
                    return SIGNED;
                }
                if (rcp[0] == 'i'
                &&  rcp[1] == 'z'
                &&  rcp[2] == 'e'
                &&  rcp[3] == 'o'
                &&  rcp[4] == 'f'
                && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    cp = rcp + 5;
                    return SIZEOF;
                }
                if (rcp[0] == 't'
                &&  rcp[1] == 'a'
                &&  rcp[2] == 't'
                &&  rcp[3] == 'i'
                &&  rcp[4] == 'c'
                && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    cp = rcp + 5;
                    return STATIC;
                }
                if (rcp[0] == 't'
                &&  rcp[1] == 'r'
                &&  rcp[2] == 'u'
                &&  rcp[3] == 'c'
                &&  rcp[4] == 't'
                && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    cp = rcp + 5;
                    return STRUCT;
                }
                if (rcp[0] == 'w'
                &&  rcp[1] == 'i'
                &&  rcp[2] == 't'
                &&  rcp[3] == 'c'
                &&  rcp[4] == 'h'
                && !(map[rcp[5]]&(DIGIT|LETTER))) {
                    cp = rcp + 5;
                    return SWITCH;
                }
                goto id;
            case 't':
                if (rcp[0] == 'y'
                &&  rcp[1] == 'p'
                &&  rcp[2] == 'e'
                &&  rcp[3] == 'd'
                &&  rcp[4] == 'e'
                &&  rcp[5] == 'f'
                && !(map[rcp[6]]&(DIGIT|LETTER))) {
                    cp = rcp + 6;
                    return TYPEDEF;
                }
                goto id;
            case 'u':
                if (rcp[0] == 'n'
                &&  rcp[1] == 'i'
                &&  rcp[2] == 'o'
                &&  rcp[3] == 'n'
                && !(map[rcp[4]]&(DIGIT|LETTER))) {
                    cp = rcp + 4;
                    return UNION;
                }
                if (rcp[0] == 'n'
                &&  rcp[1] == 's'
                &&  rcp[2] == 'i'
                &&  rcp[3] == 'g'
                &&  rcp[4] == 'n'
                &&  rcp[5] == 'e'
                &&  rcp[6] == 'd'
                && !(map[rcp[7]]&(DIGIT|LETTER))) {
                    cp = rcp + 7;
                    return UNSIGNED;
                }
                goto id;
            case 'v':
                if (rcp[0] == 'o'
                &&  rcp[1] == 'i'
                &&  rcp[2] == 'd'
                && !(map[rcp[3]]&(DIGIT|LETTER))) {
                    cp = rcp + 3;
                    //tsym = voidtype->u.sym;
                    return VOID;
                }
                if (rcp[0] == 'o'
                &&  rcp[1] == 'l'
                &&  rcp[2] == 'a'
                &&  rcp[3] == 't'
                &&  rcp[4] == 'i'
                &&  rcp[5] == 'l'
                &&  rcp[6] == 'e'
                && !(map[rcp[7]]&(DIGIT|LETTER))) {
                    cp = rcp + 7;
                    return VOLATILE;
                }
                goto id;
            case 'w':
                if (rcp[0] == 'h'
                &&  rcp[1] == 'i'
                &&  rcp[2] == 'l'
                &&  rcp[3] == 'e'
                && !(map[rcp[4]]&(DIGIT|LETTER))) {
                    cp = rcp + 4;
                    return WHILE;
                }
                goto id;
            default:
                if ((map[cp[-1]]&BLANK) == 0)
                  if (cp[-1] < ' ' || cp[-1] >= 0177)
                      //error("illegal character `\\0%o'\n", cp[-1]);
                      printf("illegal character `\\0%o'\n", cp[-1]);
                  else
                      //error("illegal character `%c'\n", cp[-1]);
                      printf("illegal character `%c'\n", cp[-1]);
        }
    }
}


/*
static Symbol icon(unsigned n, int overflow, int base)
{
    if ((*cp=='u'||*cp=='U') && (cp[1]=='l'||cp[1]=='L')
    ||  (*cp=='l'||*cp=='L') && (cp[1]=='u'||cp[1]=='U')) {
        tval.type = unsignedlong;
        cp += 2;
    } else if (*cp == 'u' || *cp == 'U') {
        tval.type = unsignedtype;
        cp += 1;
    } else if (*cp == 'l' || *cp == 'L') {
        if (n > (unsigned)~(1<<8*longtype->size - 1))
          tval.type = unsignedlong;
        else
          tval.type = longtype;
        cp += 1;
    } else if (base == 10 && n > (unsigned)~(1<<8*longtype->size - 1))
        tval.type = unsignedlong;
    else if (n > (unsigned)~(1<<8*inttype->size - 1))
        tval.type = unsignedtype;
    else
        tval.type = inttype;
    if (overflow) {
        warning("overflow in constant `%S'\n", token,
          (char*)cp - token);
        n = ~(1<<8*longtype->size - 1);
        tval.type = longtype;
    }
    if (isunsigned(tval.type))
        tval.u.c.v.u = n;
    else
        tval.u.c.v.i = n;
    ppnumber("integer");
    return &tval;
}
*/
static void ppnumber(char* which) 
{
    unsigned char *rcp = cp--;
    
    for ( ; (map[*cp]&(DIGIT|LETTER)) || *cp == '.'; cp++)
      if ((cp[0] == 'E' || cp[0] == 'e')
      &&  (cp[1] == '-' || cp[1] == '+'))
        cp++;
    if (cp > rcp)
        //error("`%S' is a preprocessing number but an invalid %s constant\n", token, (char*)cp-token, which);
        printf("`%S' is a preprocessing number but an invalid %s constant\n", token, (char*)cp-token, which);
}



/*
static Symbol fcon() {
    if (*cp == '.')
        do
            cp++;
        while (map[*cp]&DIGIT);
    if (*cp == 'e' || *cp == 'E') {
        if (*++cp == '-' || *cp == '+')
            cp++;
        if (map[*cp]&DIGIT)
            do
                cp++;
            while (map[*cp]&DIGIT);
        else
            error("invalid floating constant `%S'\n", token, (char*)cp - token);
    }
    
    errno = 0;
    tval.u.c.v.d = strtod(token, NULL);
    if (errno == ERANGE)
        warning("overflow in floating constant `%S'\n", token,
          (char*)cp - token);
    if (*cp == 'f' || *cp == 'F') {
        ++cp;
        if (tval.u.c.v.d > FLT_MAX)
            warning("overflow in floating constant `%S'\n", token,
              (char*)cp - token);
        tval.type = floattype;
        tval.u.c.v.f = tval.u.c.v.d;
    } else if (*cp == 'l' || *cp == 'L') {
        cp++;
        tval.type = longdouble;
    } else
        tval.type = doubletype;
    ppnumber("floating");
    return &tval;
}
*/



int getchr() {
    for (;;) {
        while (map[*cp]&BLANK)
            cp++;
        if (!(map[*cp]&NEWLINE))
            return *cp;
        cp++;
        nextline();
        if (cp == limit)
            return EOI;
    }
}
static int backslash(int q) 
{
    int c;
    
    switch (*cp++) {
        case 'a': return 7;
        case 'b': return '\b';
        case 'f': return '\f';
        case 'n': return '\n';
        case 'r': return '\r';
        case 't': return '\t';
        case 'v': return '\v';
        case '\'': case '"': case '\\': case '\?': break;
        case 'x': 
            {
                int overflow = 0;
                if ((map[*cp]&(DIGIT|HEX)) == 0) {
                    if (*cp < ' ' || *cp == 0177)
                        //error("ill-formed hexadecimal escape sequence\n");
                        printf("ill-formed hexadecimal escape sequence\n");
                    else
                        //error("ill-formed hexadecimal escape sequence `\\x%c'\n", *cp);
                        printf("ill-formed hexadecimal escape sequence `\\x%c'\n", *cp);
                    if (*cp != q)
                        cp++;
                    return 0;
                }
                for (c = 0; map[*cp]&(DIGIT|HEX); cp++) {
                    if (c&~((unsigned)-1 >> 4))
                        overflow++;
                    if (map[*cp]&DIGIT)
                        c = (c<<4) + *cp - '0';
                    else
                        c = (c<<4) + (*cp&~040) - 'A' + 10;
                }
                if (c&~0377 || overflow)
                    //warning("overflow in hexadecimal escape sequence\n");
                    printf("overflow in hexadecimal escape sequence\n");
                return c&0377;
            }
        case '0': case '1': case '2': case '3':
        case '4': case '5': case '6': case '7':
            c = *(cp-1) - '0';
            if (*cp >= '0' && *cp <= '7') {
                c = (c<<3) + *cp++ - '0';
                if (*cp >= '0' && *cp <= '7')
                    c = (c<<3) + *cp++ - '0';
            }
            if (c&~0377)
                //warning("overflow in octal escape sequence\n");
                printf("overflow in octal escape sequence\n");
            return c&0377;
        default:
            if (cp[-1] < ' ' || cp[-1] >= 0177)
                //warning("unrecognized character escape sequence\n");
                printf("unrecognized character escape sequence\n");
            else
                //warning("unrecognized character escape sequence `\\%c'\n", cp[-1]);
                printf("unrecognized character escape sequence `\\%c'\n", cp[-1]);
    }
    return cp[-1];
}