preparse.y

开放源码的编译器open watcom 1.6.0版的源代码

comma-and-enumerator
    : Y_COMMA enumerator
        { $$ = addEnumElemBegPunct($2); zapToken($1); }
    ;

enumerator
    : identifier
        { $$ = createEnumElem($1, NULL, NULL); }
    | identifier Y_EQUAL constant-expression
        { $$ = createEnumElem($1, $2, $3); }
    ;

cv-qualifier
    : Y_CONST
        { reportError(CERR_CANT_CONVERT_QUALIFIER);
          $$ = createQualifierDeclInfo(STY_CONST,  $1->pos);
          $1->pos = NULL; zapToken($1); }
    | Y_VOLATILE
        { reportError(CERR_CANT_CONVERT_QUALIFIER);
          $$ = createQualifierDeclInfo(STY_VOLATILE,  $1->pos);
          $1->pos = NULL; zapToken($1); }
    ;

type-name
    : decl-specs
        { $$ = createCTreeRoot(createDeclInfoLabel($1)); }
    | decl-specs declarator-no-id
        { $$ = createCTreeRoot(createDeclInfoLabel(addDeclDclr($1, $2))); }
    ;

literal
    : strings
    | Y_NUMBER
        { $$ = createCTreeRoot(createTokenLabel($1)); }
    ;

strings
    : strings single-string
        {
            $$ = createCTree2(createConstr0Label(LABCT_STRINGS), $1, $2);
        }
    | single-string
        { $$ = $1; }
    ;

single-string
    : Y_STRING
        { $$ = createCTreeRoot(createTokenLabel($1)); }
    ;

declarator-id
    : identifier
    | Y_TYPEDEF_NAME
    ;

declarator
    : pragma-modifier declarator
        { $$ = addDclrPragmaModifier($2, $1); }
    | mem-modifier declarator
        { $$ = addDclrMemModifier($2, $1); }
    | ptr-modifier declarator
        { $$ = addDclrPtrModifier($2, $1); }
    | actual-declarator
        { $$ = $1; }
    ;

actual-declarator
    : declarator-id
        { $$ = createDclr($1); }
    | Y_LEFT_PAREN declarator Y_RIGHT_PAREN
        { $$ = $2; zapTokens2($1, $3); }
    | actual-declarator Y_LEFT_BRACKET constant-expression Y_RIGHT_BRACKET
        { $$ = addDclrArray($1, $2, $3, $4); }
    | actual-declarator Y_LEFT_BRACKET                     Y_RIGHT_BRACKET
        { $$ = addDclrArray($1, $2, NULL, $3); }
    | actual-declarator Y_LEFT_PAREN abstract-args Y_RIGHT_PAREN
        { $$ = addDclrFuncArgs($1, $2, $3, $4); }
    ;

declarator-no-id
    : pragma-modifier declarator-no-id
        { $$ = addDclrPragmaModifier($2, $1); }
    | pragma-modifier
        { $$ = addDclrPragmaModifier(createDclr(NULL), $1); }
    | mem-modifier declarator-no-id
        { $$ = addDclrMemModifier($2, $1); }
    | mem-modifier
        { $$ = addDclrMemModifier(createDclr(NULL), $1); }
    | ptr-modifier declarator-no-id
        { $$ = addDclrPtrModifier($2, $1); }
    | ptr-modifier
        { $$ = addDclrPtrModifier(createDclr(NULL), $1); }
    | actual-declarator-no-id
        { $$ = $1; }
    ;

actual-declarator-no-id
    : Y_LEFT_PAREN declarator-no-id Y_RIGHT_PAREN
        { $$ = $2; zapTokens2($1, $3); }
    | actual-declarator-no-id Y_LEFT_BRACKET                     Y_RIGHT_BRACKET
        { $$ = addDclrArray($1, $2, NULL, $3); }
    | actual-declarator-no-id Y_LEFT_BRACKET constant-expression Y_RIGHT_BRACKET
        { $$ = addDclrArray($1, $2, $3, $4); }
    |                         Y_LEFT_BRACKET                     Y_RIGHT_BRACKET
        { $$ = addDclrArray(createDclr(NULL), $1, NULL, $2); }
    |                         Y_LEFT_BRACKET constant-expression Y_RIGHT_BRACKET
        { $$ = addDclrArray(createDclr(NULL), $1, $2, $3); }
    | actual-declarator-no-id Y_LEFT_PAREN abstract-args Y_RIGHT_PAREN
        { $$ = addDclrFuncArgs($1, $2, $3, $4); }
    |                         Y_LEFT_PAREN abstract-args Y_RIGHT_PAREN
        { $$ = addDclrFuncArgs(createDclr(NULL), $1, $2, $3); }
    ;

ptr-modifier
    : Y_TIMES cv-qualifiers-opt
        { $$ = createDclrPtr($1, $2); }
    ;

mem-modifier
    : Y___NEAR
    | Y___FAR
    | Y___FAR16
    | Y___HUGE
    ;

pragma-modifier
    : Y___CDECL
    | Y___PASCAL
    | Y___FORTRAN
    | Y__SYSCALL
    | Y___STDCALL
    ;

cv-qualifiers-opt
    : /* nothing */
        { $$ = STY_NULL; }
    | Y_CONST
        { reportError(CERR_CANT_CONVERT_QUALIFIER);
        $$ = STY_CONST; zapToken($1); }
    | Y_CONST Y_VOLATILE
        { reportError(CERR_CANT_CONVERT_QUALIFIER);
        $$ = STY_CONST | STY_VOLATILE; zapTokens2($1, $2); }
    | Y_VOLATILE
        { reportError(CERR_CANT_CONVERT_QUALIFIER);
        $$ = STY_VOLATILE; zapToken($1); }
    | Y_VOLATILE Y_CONST
        { reportError(CERR_CANT_CONVERT_QUALIFIER);
        $$ = STY_CONST | STY_VOLATILE; zapTokens2($1, $2); }
    ;

abstract-args
    : /* nothing */
        { $$ = createSLList(); }
    | arg-decl-list
    | arg-decl-list Y_COMMA dot-dot-dot-decl
        { addDeclPunct($3, $2); $$ = addDeclList($1, $3 ); }
    | dot-dot-dot-decl
        { $$ = createDeclList($1); }
    ;

arg-decl-list
    : arg-decl-elem
        { $$ = createDeclList($1); }
    | arg-decl-list Y_COMMA arg-decl-elem
        { addDeclPunct($3, $2); $$ = addDeclList($1, $3 ); }
    ;

arg-decl-elem
    : decl-specs
        { $$ = $1; }
    | decl-specs declarator
        { $$ = addDeclDclr($1, $2); }
    | decl-specs declarator-no-id
        { $$ = addDeclDclr($1, $2); }
    ;

dot-dot-dot-decl
    : Y_DOT_DOT_DOT
        { $$ = createDeclInfoSCALAR(STM_DOT_DOT_DOT, $1->pos);
          $1->pos = NULL; zapToken($1); }
    ;

identifier
    : Y_ID
        { $$ = $1; }
    ;

/* NOTE: There is an ambiguity in C:
   typedef int F, INT;         static F(INT);
   This is resolved by redefining F as a function, not by redefining INT
   to be of type "static F"
*/

/*==========================================================================*/

%%

static pToken firstToken;
static int expandNextToken;
static int expandThisLine;
int expandThisLineHideErrors;
int successfulExpand;

int preerror(char *str) {
    str = str;
    return 0;
}

void preparseInterface(pToken t) {
    firstToken = t;
    expandNextToken = 1;
    expandThisLine = 1;
    expandThisLineHideErrors = 0;
    successfulExpand = 1;
    preparse();
}

static int prelex(void) {
    int retval;

    successfulExpand = 1;
    if (firstToken != NULL) {
        prelval.token = firstToken;
        firstToken = NULL;
    } else {
        prelval.token = getExpandToken(
                ((expandNextToken && expandThisLine) ? EXP_OP_EXPAND : 0)  |
                EXP_OP_EMIT_EOL |
                (expandThisLineHideErrors ? EXP_OP_HIDE_ERRORS : 0),
                &successfulExpand);

    }
    if (!successfulExpand) {
        expandThisLineHideErrors = 0;
        retval = 0;
    } else {
        retval = prelval.token->data->code;
    }
    expandNextToken = 1;
    if (retval == Y_PRE_NEWLINE) {
        expandThisLine = 1;
        expandThisLineHideErrors = 0;
        zapToken(prelval.token);
    }
    return retval;
}

static pToken _dupTokenKeepPos(void * _tok) {
    pToken tok = _tok;
    return dupToken(tok, NULL);
}

pCTree createDefineMacroCTree(void) {
    pCTree tree;
    pSLList list;
    pToken tempTok;
    pToken idToken;
    pSymTabEntry newSymbol;
    int assertVal;

    /* Read tokens until end-of-line */
    expandThisLine = 0;
    if (prechar != Y_PRE_NEWLINE) {
        while (prelex() != Y_PRE_NEWLINE);
        if (g_opt.targetLang == TLT_FORTRAN) {
            reportError(CERR_PREDIR_NOT_SUPPORTED, "#define");
        }
    }

    rewindCurrSLListPos(g_currLineCode);
    incCurrSLListPos(g_currLineCode);  /* Skip #define */
    assertVal = getCurrSLListPosElem(g_currLineCode, &idToken);
    assert(assertVal);
    incCurrSLListPos(g_currLineCode);  /* Skip id */

    list = createSLList();
    for (;;) {
        if (!getCurrSLListPosElem(g_currLineCode, &tempTok)) {
            break;
        }
        addSLListElem(list, tempTok);
        incCurrSLListPos(g_currLineCode);
    }

    tree = createCTree2(
            createConstr1Label(LABCT_PRE_DEFINE_MACRO, _lastDefineTok),
            createCTreeRoot(createTokenLabel(idToken)),
            createCTreeRoot(createListLabel(list))
         );

    newSymbol = createTabEntry(getTokenIdName(idToken), SYMT_MACRO,
                               dupSLList(list, _dupTokenKeepPos));
    addSymbol(newSymbol);

    return tree;
}

pCTree eatPreDirList(pToken tok) {
    pSLList list;

    list = createSLList();
    prechar = prelex();
    while (prechar != Y_PRE_NEWLINE) {
        addSLListElem(list, prelval.token);
        prechar = prelex();
    }

    return  createCTree1(
            createConstr1Label(LABCT_PRE_DIR_LIST, tok),
            createCTreeRoot(createListLabel(list))
         );
}

#define preclearin      prechar = -1
                        // We have to copy yacc def'n of preclearin since
                        // yacc puts recoverError() function before it declares
                        // 'preclearin'.  If yacc's def'n ever changes,
                        // we will get a redefinition error.
#define CLEARIN preclearin
static void recoverError(void) {
    pToken tok;
    pSLList context = createSLList();
    int recordMaxTok = 15;
    char *s1;

    for (tok = prelval.token;
                prechar == Y_PRE_NEWLINE ? 0 : (tok->data->code != Y_EOF)  ;
                prechar = prelex(), tok = prelval.token)
    {
        if (recordMaxTok-- > 0) {
            addSLListElem(context, tok);
        }
    }

    s1 = getTokListString(context);
    reportError(RERR_CPARSE_WITH_CONTEXT, s1, "");
    zapSLList(context, zapToken);
    CLEARIN;
    firstToken = tok;
}