Changeset 8c17ab0 for translator


Ignore:
Timestamp:
Nov 13, 2014, 3:09:54 PM (10 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc
Children:
c8ffe20b
Parents:
134b86a
Message:

add quoted identifiers, add compilation include directory, reformatted some files

Location:
translator
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • translator/ControlStruct/MLEMutator.cc

    r134b86a r8c17ab0  
    8080      return branchStmt;
    8181
     82    // test if continue target is a loop
    8283    if ( branchStmt->get_type() == BranchStmt::Continue && enclosingLoops.empty() )
    8384      throw SemanticError( "'continue' outside a loop" );
  • translator/Parser/DeclarationNode.cc

    r134b86a r8c17ab0  
    112112}
    113113
    114 /* static class method */
    115114DeclarationNode *
    116115DeclarationNode::newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle )
     
    136135}
    137136
    138 /* static class method */
    139137DeclarationNode *
    140138DeclarationNode::newQualifier( Qualifier q )
     
    146144}
    147145
    148 /* static class method */
    149146DeclarationNode *
    150147DeclarationNode::newStorageClass( StorageClass sc )
     
    155152}
    156153
    157 /* static class method */
    158154DeclarationNode *
    159155DeclarationNode::newBasicType( BasicType bt )
     
    165161}
    166162
    167 /* static class method */
    168163DeclarationNode *
    169164DeclarationNode::newModifier( Modifier mod )
     
    175170}
    176171
    177 /* static class method */
    178172DeclarationNode *
    179173DeclarationNode::newForall( DeclarationNode* forall )
     
    185179}
    186180
    187 /* static class method */
    188181DeclarationNode *
    189182DeclarationNode::newFromTypedef( std::string* name )
     
    197190}
    198191
    199 /* static class method */
    200192DeclarationNode *
    201193DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields )
     
    214206}
    215207
    216 /* static class method */
    217208DeclarationNode *
    218209DeclarationNode::newEnum( std::string *name, DeclarationNode *constants )
     
    229220}
    230221
    231 /* static class method */
    232222DeclarationNode *
    233223DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant )
     
    239229}
    240230
    241 /* static class method */
    242231DeclarationNode *
    243232DeclarationNode::newName( std::string* name )
     
    248237}
    249238
    250 /* static class method */
    251239DeclarationNode *
    252240DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params )
     
    260248}
    261249
    262 /* static class method */
    263250DeclarationNode *
    264251DeclarationNode::newTypeParam( TypeClass tc, std::string* name )
     
    272259}
    273260
    274 /* static class method */
    275261DeclarationNode *
    276262DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts )
     
    285271}
    286272
    287 /* static class method */
    288273DeclarationNode *
    289274DeclarationNode::newContextUse( std::string *name, ExpressionNode *params )
     
    298283}
    299284
    300 /* static class method */
    301285DeclarationNode *
    302286DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams )
     
    311295}
    312296
    313 /* static class method */
    314297DeclarationNode *
    315298DeclarationNode::newPointer( DeclarationNode *qualifiers )
     
    320303}
    321304
    322 /* static class method */
    323305DeclarationNode *
    324306DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic )
     
    332314}
    333315
    334 /* static class method */
    335316DeclarationNode *
    336317DeclarationNode::newVarArray( DeclarationNode *qualifiers )
     
    344325}
    345326
    346 /* static class method */
    347327DeclarationNode *
    348328DeclarationNode::newBitfield( ExpressionNode *size )
     
    353333}
    354334
    355 /* static class method */
    356335DeclarationNode *
    357336DeclarationNode::newTuple( DeclarationNode *members )
     
    363342}
    364343
    365 /* static class method */
    366344DeclarationNode *
    367345DeclarationNode::newTypeof( ExpressionNode *expr )
     
    373351}
    374352
    375 /* static class method */
    376353DeclarationNode *
    377354DeclarationNode::newAttr( std::string *name, ExpressionNode *expr )
     
    384361}
    385362
    386 /* static class method */
    387363DeclarationNode *
    388364DeclarationNode::newAttr( std::string *name, DeclarationNode *type )
  • translator/Parser/TypedefTable.cc

    r134b86a r8c17ab0  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: TypedefTable.cc,v 1.7 2004/09/14 17:21:12 rcbilson Exp $
    5  *
    6  */
    7 
    81#include <map>
    92#include <list>
     
    1912#endif
    2013
    21 TypedefTable::TypedefTable()
    22     : currentScope(0)
    23 {
    24 }
     14TypedefTable::TypedefTable() : currentScope(0) {}
    2515
    26 bool
    27 TypedefTable::isKind(string identifier, kind_t kind) const
    28 {
     16bool TypedefTable::isKind(string identifier, kind_t kind) const {
    2917    tableType::const_iterator id_pos = table.find(identifier);
    3018    if (id_pos == table.end()) {
     
    3523}
    3624
    37 bool
    38 TypedefTable::isIdentifier(string identifier) const
    39 {
     25bool TypedefTable::isIdentifier(string identifier) const {
    4026    return isKind(identifier, ID);
    4127}
    4228
    43 bool
    44 TypedefTable::isTypedef(string identifier) const
    45 {
     29bool TypedefTable::isTypedef(string identifier) const {
    4630    return isKind(identifier, TD);
    4731}
    4832
    49 bool
    50 TypedefTable::isTypegen(string identifier) const
    51 {
     33bool TypedefTable::isTypegen(string identifier) const {
    5234    return isKind(identifier, TG);
    5335}
    5436
    55 void
    56 TypedefTable::addToScope(const std::string &identifier, kind_t kind, int scope)
    57 {
    58   if( currentContext != "" && scope == contextScope ) {
    59     DeferredEntry entry = { identifier, kind };
    60     contexts[currentContext].push_back( entry );
    61   } else {
    62     debugPrint( "Adding " << identifier << " as type " << kind << " scope " << scope << " from scope " << currentScope << endl );
    63     Entry newEntry = { scope, kind };
    64     tableType::iterator curPos = table.find(identifier);
    65     if (curPos == table.end()) {
    66       list<Entry> newList;
    67       newList.push_front(newEntry);
    68       table[identifier] = newList;
     37void TypedefTable::addToScope(const std::string &identifier, kind_t kind, int scope) {
     38    if ( currentContext != "" && scope == contextScope ) {
     39        DeferredEntry entry = { identifier, kind };
     40        contexts[currentContext].push_back( entry );
    6941    } else {
    70       list<Entry>::iterator listPos = (*curPos).second.begin();
    71       while( listPos != (*curPos).second.end() && listPos->scope > scope ) {
    72         listPos++;
    73       }
    74       (*curPos).second.insert(listPos, newEntry);
     42        debugPrint( "Adding " << identifier << " as type " << kind << " scope " << scope << " from scope " << currentScope << endl );
     43        Entry newEntry = { scope, kind };
     44        tableType::iterator curPos = table.find(identifier);
     45        if (curPos == table.end()) {
     46            list<Entry> newList;
     47            newList.push_front(newEntry);
     48            table[identifier] = newList;
     49        } else {
     50            list<Entry>::iterator listPos = (*curPos).second.begin();
     51            while( listPos != (*curPos).second.end() && listPos->scope > scope ) {
     52                listPos++;
     53            }
     54            (*curPos).second.insert(listPos, newEntry);
     55        }
    7556    }
    76   }
    7757}
    7858
    79 void
    80 TypedefTable::addToCurrentScope(const std::string &identifier, kind_t kind)
    81 {
    82   addToScope( identifier, kind, currentScope );
     59void TypedefTable::addToCurrentScope(const std::string &identifier, kind_t kind) {
     60    addToScope( identifier, kind, currentScope );
    8361}
    8462
    85 void
    86 TypedefTable::addToCurrentScope(kind_t kind)
    87 {
    88   addToCurrentScope( nextIdentifiers.top(), kind );
     63void TypedefTable::addToCurrentScope(kind_t kind) {
     64    addToCurrentScope( nextIdentifiers.top(), kind );
    8965}
    9066
    91 void
    92 TypedefTable::addToEnclosingScope(const std::string &identifier, kind_t kind)
    93 {
    94   assert( currentScope >= 1 );
    95   addToScope( identifier, kind, currentScope - 1 );
     67void TypedefTable::addToEnclosingScope(const std::string &identifier, kind_t kind) {
     68    assert( currentScope >= 1 );
     69    addToScope( identifier, kind, currentScope - 1 );
    9670}
    9771
    98 void
    99 TypedefTable::addToEnclosingScope(kind_t kind)
    100 {
    101   addToEnclosingScope( nextIdentifiers.top(), kind );
     72void TypedefTable::addToEnclosingScope(kind_t kind) {
     73    addToEnclosingScope( nextIdentifiers.top(), kind );
    10274}
    10375
    104 void
    105 TypedefTable::addToEnclosingScope2(const std::string &identifier, kind_t kind)
    106 {
    107   assert( currentScope >= 2 );
    108   addToScope( identifier, kind, currentScope - 2 );
     76void TypedefTable::addToEnclosingScope2(const std::string &identifier, kind_t kind) {
     77    assert( currentScope >= 2 );
     78    addToScope( identifier, kind, currentScope - 2 );
    10979}
    11080
    111 void
    112 TypedefTable::addToEnclosingScope2(kind_t kind)
    113 {
    114   addToEnclosingScope2( nextIdentifiers.top(), kind );
     81void TypedefTable::addToEnclosingScope2(kind_t kind) {
     82    addToEnclosingScope2( nextIdentifiers.top(), kind );
    11583}
    11684
    117 void
    118 TypedefTable::setNextIdentifier( const std::string &identifier )
    119 {
    120   nextIdentifiers.top() = identifier;
     85void TypedefTable::setNextIdentifier( const std::string &identifier ) {
     86    nextIdentifiers.top() = identifier;
    12187}
    12288
    123 void
    124 TypedefTable::openContext( std::string contextName )
    125 {
    126   map< string, deferListType >::iterator i = contexts.find( contextName );
    127   if( i != contexts.end() ) {
    128     deferListType &entries = i->second;
    129     for (deferListType::iterator i = entries.begin(); i != entries.end(); i++) {
    130       addToEnclosingScope( i->identifier, i->kind );
     89void TypedefTable::openContext( std::string contextName ) {
     90    map< string, deferListType >::iterator i = contexts.find( contextName );
     91    if ( i != contexts.end() ) {
     92        deferListType &entries = i->second;
     93        for (deferListType::iterator i = entries.begin(); i != entries.end(); i++) {
     94            addToEnclosingScope( i->identifier, i->kind );
     95        }
    13196    }
    132   }
    13397}
    13498
    135 void
    136 TypedefTable::enterScope(void)
    137 {
     99void TypedefTable::enterScope(void) {
    138100    currentScope += 1;
    139101    deferListStack.push( deferListType() );
     
    142104}
    143105
    144 void
    145 TypedefTable::leaveScope(void)
    146 {
     106void TypedefTable::leaveScope(void) {
    147107    debugPrint( "Leaving scope " << currentScope << endl );
    148108    for (tableType::iterator i = table.begin(); i != table.end(); i++) {
     
    151111            declList.pop_front();
    152112        }
    153         if( declList.empty() ) {
    154           table.erase( i );
     113        if ( declList.empty() ) {
     114            table.erase( i );
    155115        }
    156116    }
    157117    currentScope -= 1;
    158118    for (deferListType::iterator i = deferListStack.top().begin(); i != deferListStack.top().end(); i++) {
    159       addToCurrentScope( i->identifier, i->kind );
     119        addToCurrentScope( i->identifier, i->kind );
    160120    }
    161121    deferListStack.pop();
     
    164124}
    165125
    166 void
    167 TypedefTable::enterContext( std::string contextName )
    168 {
    169   currentContext = contextName;
    170   contextScope = currentScope;
     126void TypedefTable::enterContext( std::string contextName ) {
     127    currentContext = contextName;
     128    contextScope = currentScope;
    171129}
    172130
    173 void
    174 TypedefTable::leaveContext(void)
    175 {
    176   currentContext = "";
     131void TypedefTable::leaveContext(void) {
     132    currentContext = "";
    177133}
    178134
    179 void
    180 TypedefTable::print(void) const
    181 {
     135void TypedefTable::print(void) const {
    182136    for (tableType::const_iterator i = table.begin(); i != table.end(); i++) {
    183137        debugPrint( (*i).first << ": " );
  • translator/Parser/cfa.y

    r134b86a r8c17ab0  
    1010 * Created On       : Sat Sep  1 20:22:55 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Mon Nov  3 16:24:24 2014
    13  * Update Count     : 880
     12 * Last Modified On : Sun Nov  9 22:45:42 2014
     13 * Update Count     : 881
    1414 */
    1515
     
    8484
    8585/* names and constants: lexer differentiates between identifier and typedef names */
    86 %token<tok> IDENTIFIER          TYPEDEFname             TYPEGENname
     86%token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDEFname             TYPEGENname
    8787%token<tok> ATTR_IDENTIFIER     ATTR_TYPEDEFname        ATTR_TYPEGENname
    8888%token<tok> INTEGERconstant     FLOATINGconstant        CHARACTERconstant       STRINGliteral
  • translator/Parser/lex.l

    r134b86a r8c17ab0  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Sat Nov  1 18:09:47 2003
    13  * Update Count     : 197
     12 * Last Modified On : Tue Nov 11 08:10:05 2014
     13 * Update Count     : 215
    1414 */
    1515
     
    1717
    1818%{
    19 /* This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor
    20   directive have been performed and removed from the source. The only exceptions are preprocessor
    21   directives passed to the compiler (e.g., line-number directives) and C/C++ style comments, which
    22    are ignored. */
    23 
    24 /*************** Includes and Defines *****************************/
     19// This lexer assumes the program has been preprocessed by cpp. Hence, all user level preprocessor
     20// directive have been performed and removed from the source. The only exceptions are preprocessor
     21// directives passed to the compiler (e.g., line-number directives) and C/C++ style comments, which
     22// are ignored.
     23
     24//**************************** Includes and Defines ****************************
    2525
    2626#include <string>
     
    2828#include "lex.h"
    2929#include "ParseNode.h"
    30 #include "cfa.tab.h" /* YACC generated definitions based on C++ grammar */
     30#include "cfa.tab.h" // YACC generated definitions based on C++ grammar
    3131
    3232char *yyfilename;
    3333
    34 #define WHITE_RETURN(x)         /* do nothing */
     34#define WHITE_RETURN(x)                                 // do nothing
    3535#define NEWLINE_RETURN()        WHITE_RETURN('\n')
    3636#define RETURN_VAL(x)           yylval.tok.str = new std::string(yytext); \
     
    3939                                return(x)
    4040
    41 #define KEYWORD_RETURN(x)       RETURN_VAL(x)           /* keyword */
     41#define KEYWORD_RETURN(x)       RETURN_VAL(x)           // keyword
    4242#define IDENTIFIER_RETURN()     RETURN_VAL((typedefTable.isIdentifier(yytext) ? IDENTIFIER : typedefTable.isTypedef(yytext) ? TYPEDEFname : TYPEGENname))
    43 #define ATTRIBUTE_RETURN()      RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname))
    44 
    45 #define ASCIIOP_RETURN()        RETURN_VAL((int)yytext[0]) /* single character operator */
    46 #define NAMEDOP_RETURN(x)       RETURN_VAL(x)           /* multichar operator, with a name */
    47 
    48 #define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL(x) /* numeric constant */
    49 
    50 void rm_underscore() {                                  /* remove underscores in constant or escape sequence */
     43//#define ATTRIBUTE_RETURN()    RETURN_VAL((typedefTable.isIdentifier(yytext) ? ATTR_IDENTIFIER : typedefTable.isTypedef(yytext) ? ATTR_TYPEDEFname : ATTR_TYPEGENname))
     44#define ATTRIBUTE_RETURN()      RETURN_VAL(ATTR_IDENTIFIER)
     45
     46#define ASCIIOP_RETURN()        RETURN_VAL((int)yytext[0]) // single character operator
     47#define NAMEDOP_RETURN(x)       RETURN_VAL(x)           // multichar operator, with a name
     48
     49#define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL(x) // numeric constant
     50
     51void rm_underscore() {                                  // remove underscores in constant or escape sequence
    5152    int j = 0;
    5253    for ( int i = 0; i < yyleng; i += 1 ) {
     
    6869universal_char "\\"((u{hex_quad})|(U{hex_quad}{2}))
    6970
    70         /* identifier, GCC: $ in identifier */
     71        // identifier, GCC: $ in identifier
    7172identifier ([a-zA-Z_$]|{universal_char})([0-9a-zA-Z_$]|{universal_char})*
    7273
    73         /* attribute identifier, GCC: $ in identifier */
     74        // quoted identifier
     75quoted_identifier "`"{identifier}"`"
     76
     77        // attribute identifier, GCC: $ in identifier
    7478attr_identifier "@"{identifier}
    7579
    76         /*  numeric constants, CFA: '_' in constant */
     80        // numeric constants, CFA: '_' in constant
    7781hex_quad {hex}{4}
    7882integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
     
    99103hex_floating_constant {hex_prefix}(({hex_fractional_constant}{binary_exponent})|({hex_digits}{binary_exponent})){floating_suffix}?
    100104
    101         /* character escape sequence, GCC: \e => esc character */
     105        // character escape sequence, GCC: \e => esc character
    102106simple_escape "\\"[abefnrtv'"?\\]
     107        // ' stop highlighting
    103108octal_escape "\\"{octal}{1,3}
    104109hex_escape "\\""x"{hex}+
    105110escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char}
    106111
    107         /* display/white-space characters */
     112        // display/white-space characters
    108113h_tab [\011]
    109114form_feed [\014]
     
    112117h_white [ ]|{h_tab}
    113118
    114         /* operators */
     119        // operators
    115120op_unary_only "~"|"!"
    116121op_unary_binary "+"|"-"|"*"
     
    124129
    125130%x COMMENT
     131%x QUOTED
    126132
    127133%%
    128134        /* line directives */
    129135^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["][^\n]*"\n" {
     136        /* " stop highlighting */
    130137        char *end_num;
    131138        char *begin_string, *end_string;
     
    178185catch                   {KEYWORD_RETURN(CATCH);}        /* CFA */
    179186char                    {KEYWORD_RETURN(CHAR);}
    180 choose                  {KEYWORD_RETURN(CHOOSE);}
     187choose                  {KEYWORD_RETURN(CHOOSE);}       /* CFA */
    181188_Complex                {KEYWORD_RETURN(COMPLEX);}      /* ANSI99 */
    182189__complex               {KEYWORD_RETURN(COMPLEX);}      /* GCC */
     
    185192__const                 {KEYWORD_RETURN(CONST);}        /* GCC */
    186193__const__               {KEYWORD_RETURN(CONST);}        /* GCC */
    187 context                 {KEYWORD_RETURN(CONTEXT);}
     194context                 {KEYWORD_RETURN(CONTEXT);}      /* CFA */
    188195continue                {KEYWORD_RETURN(CONTINUE);}
    189196default                 {KEYWORD_RETURN(DEFAULT);}
    190197do                      {KEYWORD_RETURN(DO);}
    191198double                  {KEYWORD_RETURN(DOUBLE);}
    192 dtype                   {KEYWORD_RETURN(DTYPE);}
     199dtype                   {KEYWORD_RETURN(DTYPE);}        /* CFA */
    193200else                    {KEYWORD_RETURN(ELSE);}
    194201enum                    {KEYWORD_RETURN(ENUM);}
    195202__extension__           {KEYWORD_RETURN(EXTENSION);}    /* GCC */
    196203extern                  {KEYWORD_RETURN(EXTERN);}
    197 fallthru                {KEYWORD_RETURN(FALLTHRU);}
     204fallthru                {KEYWORD_RETURN(FALLTHRU);}     /* CFA */
    198205finally                 {KEYWORD_RETURN(FINALLY);}      /* CFA */
    199206float                   {KEYWORD_RETURN(FLOAT);}
    200207for                     {KEYWORD_RETURN(FOR);}
    201 forall                  {KEYWORD_RETURN(FORALL);}
     208forall                  {KEYWORD_RETURN(FORALL);}       /* CFA */
    202209fortran                 {KEYWORD_RETURN(FORTRAN);}
    203 ftype                   {KEYWORD_RETURN(FTYPE);}
     210ftype                   {KEYWORD_RETURN(FTYPE);}        /* CFA */
    204211goto                    {KEYWORD_RETURN(GOTO);}
    205212if                      {KEYWORD_RETURN(IF);}
     
    213220__label__               {KEYWORD_RETURN(LABEL);}        /* GCC */
    214221long                    {KEYWORD_RETURN(LONG);}
    215 lvalue                  {KEYWORD_RETURN(LVALUE);}
     222lvalue                  {KEYWORD_RETURN(LVALUE);}       /* CFA */
    216223register                {KEYWORD_RETURN(REGISTER);}
    217224restrict                {KEYWORD_RETURN(RESTRICT);}     /* ANSI99 */
     
    229236throw                   {KEYWORD_RETURN(THROW);}        /* CFA */
    230237try                     {KEYWORD_RETURN(TRY);}          /* CFA */
    231 type                    {KEYWORD_RETURN(TYPE);}
     238type                    {KEYWORD_RETURN(TYPE);}         /* CFA */
    232239typedef                 {KEYWORD_RETURN(TYPEDEF);}
    233240typeof                  {KEYWORD_RETURN(TYPEOF);}       /* GCC */
     
    245252{identifier}            {IDENTIFIER_RETURN();}
    246253{attr_identifier}       {ATTRIBUTE_RETURN();}
     254"`"                     {BEGIN QUOTED;}
     255<QUOTED>{identifier}    {IDENTIFIER_RETURN();}
     256<QUOTED>"`"             {BEGIN 0;}
    247257
    248258        /* numeric constants */
     
    257267        /* character constant, allows empty value */
    258268"L"?[']([^'\\\n]|{escape_seq})*['] {RETURN_VAL(CHARACTERconstant);}
     269        /* ' stop highlighting */
    259270
    260271        /* string constant */
    261272"L"?["]([^"\\\n]|{escape_seq})*["] {RETURN_VAL(STRINGliteral);}
     273        /* " stop highlighting */
    262274
    263275        /* punctuation */
     
    367379
    368380
    369 /* Local Variables: */
    370 /* fill-column: 100 */
    371 /* compile-command: "gmake" */
    372 /* End: */
     381// Local Variables:
     382// fill-column: 100
     383// compile-command: "make"
     384// End:
  • translator/main.cc

    r134b86a r8c17ab0  
    3838extern "C"{
    3939#include <unistd.h>
    40   extern int  getopt(int, char *const *, const char *);
    41   extern char *optarg;
    42   extern int opterr, optind, optopt;
     40extern int  getopt( int, char *const *, const char * );
     41extern char *optarg;
     42extern int opterr, optind, optopt;
    4343}
    4444
     
    4747bool beVerbose = false;
    4848
    49 int main(int argc, char *argv[]){
    50   bool debugp = false, treep = false, astp = false, manglep = false, symtabp = false, validp = false;
    51   bool preludep = true, protop = false, libp = false;
    52   bool exprp = false;
    53   int c;
    54   FILE *input, *prelude, *builtins;
    55   std::ostream *output = &std::cout;
    56 
    57   opterr = 0;
    58 
    59   while((c = getopt(argc, argv, "dtsgmvxcenplD:")) != -1) {
    60     switch(c){
    61     case 'd':
    62       /* bison debugging info */
    63       debugp = true;
    64       break;
    65     case 't':
    66       /* dump parse tree */
    67       treep = true;
    68       break;
    69     case 's':
    70       /* dump AST */
    71       astp = true;
    72       break;
    73      case 'g':
    74        /* print alternatives for expressions */
    75        manglep = true;
    76        break;
    77      case 'm':
    78        /* print symbol table events */
    79        symtabp = true;
    80        break;
    81     case 'x':
    82       /* dump AST after decl validation pass */
    83       validp = true;
    84       break;
    85     case 'e':
    86       /* dump AST after expression analysis */
    87       exprp = true;
    88       break;
    89     case 'n':
    90       /* don't read preamble */
    91       preludep = false;
    92       break;
    93     case 'p':
    94       /* generate prototypes for preamble functions */
    95       protop = true;
    96       break;
    97     case 'l':
    98       /* generate libcfa.c */
    99       libp = true;
    100       break;
    101     case 'v':
    102       /* verbose */
    103       beVerbose = true;
    104       break;
    105     case 'D':
    106       /* ignore -Dxxx */
    107       break;
    108     case '?':
    109       cout << "Unknown option: '" << (char)optopt << "'" << endl;
    110       exit(1);
    111     default:
    112       abort();
     49int main( int argc, char *argv[] ) {
     50    bool debugp = false, treep = false, astp = false, manglep = false, symtabp = false, validp = false;
     51    bool preludep = true, protop = false, libp = false;
     52    bool exprp = false;
     53    int c;
     54    FILE *input, *prelude, *builtins;
     55    std::ostream *output = &std::cout;
     56
     57    opterr = 0;
     58
     59    while ( (c = getopt( argc, argv, "dtsgmvxcenplD:" )) != -1 ) {
     60        switch (c) {
     61          case 'd':
     62            /* bison debugging info */
     63            debugp = true;
     64            break;
     65          case 't':
     66            /* dump parse tree */
     67            treep = true;
     68            break;
     69          case 's':
     70            /* dump AST */
     71            astp = true;
     72            break;
     73          case 'g':
     74            /* print alternatives for expressions */
     75            manglep = true;
     76            break;
     77          case 'm':
     78            /* print symbol table events */
     79            symtabp = true;
     80            break;
     81          case 'x':
     82            /* dump AST after decl validation pass */
     83            validp = true;
     84            break;
     85          case 'e':
     86            /* dump AST after expression analysis */
     87            exprp = true;
     88            break;
     89          case 'n':
     90            /* don't read preamble */
     91            preludep = false;
     92            break;
     93          case 'p':
     94            /* generate prototypes for preamble functions */
     95            protop = true;
     96            break;
     97          case 'l':
     98            /* generate libcfa.c */
     99            libp = true;
     100            break;
     101          case 'v':
     102            /* verbose */
     103            beVerbose = true;
     104            break;
     105          case 'D':
     106            /* ignore -Dxxx */
     107            break;
     108          case '?':
     109            cout << "Unknown option: '" << (char)optopt << "'" << endl;
     110            exit(1);
     111          default:
     112            abort();
     113        }
    113114    }
    114   }
    115 
    116   try {
    117     if( optind < argc ) {
    118       input = fopen( argv[ optind ], "r" );
    119       if( !input ) {
    120         std::cout << "Error: can't open " << argv[optind] << std::endl;
    121         exit( 1 );
    122       }
    123       optind++;
    124     } else {
    125       input = stdin;
     115
     116    try {
     117        if ( optind < argc ) {
     118            input = fopen( argv[ optind ], "r" );
     119            if ( !input ) {
     120                std::cout << "Error: can't open " << argv[optind] << std::endl;
     121                exit( 1 );
     122            }
     123            optind++;
     124        } else {
     125            input = stdin;
     126        }
     127
     128        if ( optind < argc ) {
     129            output = new ofstream( argv[ optind ] );
     130        }
     131   
     132        Parser::get_parser().set_debug( debugp );
     133   
     134        if ( preludep ) {
     135            // include gcc builtins
     136            builtins = open_builtins();
     137            if ( !builtins ) {
     138                std::cout << "Error: can't open builtins" << std::endl;
     139                exit( 1 );
     140            }
     141     
     142            Parser::get_parser().set_linkage( LinkageSpec::Compiler );
     143            Parser::get_parser().parse( builtins );
     144   
     145            if ( Parser::get_parser().get_parseStatus() != 0 ) {
     146                return Parser::get_parser().get_parseStatus();
     147            }
     148            fclose( builtins );
     149
     150            // include cfa prelude
     151            if ( libp ) {
     152                prelude = input;
     153            } else {
     154                prelude = open_prelude();
     155            }
     156            if ( !prelude ) {
     157                std::cout << "Error: can't open prelude" << std::endl;
     158                exit( 1 );
     159            }
     160     
     161            Parser::get_parser().set_linkage( LinkageSpec::Intrinsic );
     162            Parser::get_parser().parse( prelude );
     163   
     164            if ( Parser::get_parser().get_parseStatus() != 0 ) {
     165                return Parser::get_parser().get_parseStatus();
     166            }
     167            fclose( prelude );
     168        }
     169   
     170        if ( libp ) {
     171            std::list< Declaration* > translationUnit;
     172            buildList( Parser::get_parser().get_parseTree(), translationUnit );
     173            Parser::get_parser().freeTree();
     174            SymTab::validate( translationUnit, false );
     175            CodeGen::fixNames( translationUnit );
     176            LibCfa::makeLibCfa( translationUnit );
     177            ResolvExpr::resolve( translationUnit );
     178            GenPoly::convertLvalue( translationUnit );
     179            GenPoly::box( translationUnit );
     180            CodeGen::generate( translationUnit, *output, true );
     181            if ( output != &std::cout ) {
     182                delete output;
     183            }
     184            return 0;
     185        }
     186   
     187        Parser::get_parser().set_linkage( LinkageSpec::Cforall );
     188 
     189        Parser::get_parser().parse( input );
     190        if ( debugp || Parser::get_parser().get_parseStatus() != 0 ) {
     191            return Parser::get_parser().get_parseStatus();
     192        }
     193        fclose( input );
     194 
     195        if ( treep ) {
     196            Parser::get_parser().get_parseTree()->printList( std::cout );
     197            Parser::get_parser().freeTree();
     198            return 0;
     199        }
     200
     201        std::list< Declaration* > translationUnit;
     202        buildList( Parser::get_parser().get_parseTree(), translationUnit );
     203
     204        Parser::get_parser().freeTree();
     205        if ( astp ) {
     206            printAll( translationUnit, std::cout );
     207            return 0;
     208        }
     209
     210        if ( manglep ) {
     211            SymTab::validate( translationUnit, false );
     212            ResolvExpr::AlternativePrinter printer( std::cout );
     213            acceptAll( translationUnit, printer );
     214            return 0;
     215        }
     216
     217        if ( symtabp ) {
     218            SymTab::validate( translationUnit, true );
     219            return 0;
     220        }
     221
     222        if ( validp ) {
     223            SymTab::validate( translationUnit, false );
     224            printAll( translationUnit, std::cout );
     225            return 0;
     226        }
     227        if ( exprp ) {
     228            SymTab::validate( translationUnit, false );
     229            ResolvExpr::resolve( translationUnit );
     230            printAll( translationUnit, std::cout );
     231            return 0;
     232        }
     233
     234        SymTab::validate( translationUnit, false );
     235        //Try::visit( translationUnit );
     236        //Tuples::mutate( translationUnit );
     237        //InitTweak::mutate( translationUnit );
     238        ControlStruct::mutate( translationUnit );
     239        CodeGen::fixNames( translationUnit );
     240        ResolvExpr::resolve( translationUnit );
     241        //Tuples::checkFunctions( translationUnit );
     242        //      std::cerr << "Finished tuple checkfunctions" << std::endl;
     243        //printAll( translationUnit, std::cerr );
     244        GenPoly::copyParams( translationUnit );
     245        GenPoly::convertSpecializations( translationUnit );
     246        GenPoly::convertLvalue( translationUnit );
     247        GenPoly::box( translationUnit );
     248        //Tuples::mutate( translationUnit );
     249
     250        CodeGen::generate( translationUnit, *output, protop );
     251
     252        if ( output != &std::cout ) {
     253            delete output;
     254        }
     255
     256    } catch ( SemanticError &e ) {
     257        e.print( cout );
     258        if ( output != &std::cout ) {
     259            delete output;
     260        }
     261        return 1;
     262    } catch ( UnimplementedError &e ) {
     263        std::cout << "Sorry, " << e.get_what() << " is not currently implemented" << std::endl;
     264        if ( output != &std::cout ) {
     265            delete output;
     266        }
     267        return 1;
     268    } catch ( CompilerError &e ) {
     269        std::cerr << "Compiler Error: " << e.get_what() << std::endl;
     270        std::cerr << "(please report bugs to " << std::endl;
     271        if ( output != &std::cout ) {
     272            delete output;
     273        }
     274        return 1;
    126275    }
    127276
    128     if( optind < argc ) {
    129       output = new ofstream( argv[ optind ] );
     277    return 0;
     278}
     279
     280FILE *open_prelude() {
     281    FILE *ret;
     282
     283    const string name("prelude.cf"),
     284        full_name = string(CFA_LIBDIR) + "/" + name;
     285
     286    if ( beVerbose ) {
     287        cout << "Reading from " << full_name << endl;
    130288    }
    131    
    132     Parser::get_parser().set_debug( debugp );
    133    
    134     if( preludep ) {
    135       // include gcc builtins
    136       builtins = open_builtins();
    137       if( !builtins ) {
    138         std::cout << "Error: can't open builtins" << std::endl;
    139         exit( 1 );
    140       }
    141      
    142       Parser::get_parser().set_linkage( LinkageSpec::Compiler );
    143       Parser::get_parser().parse( builtins );
    144    
    145       if( Parser::get_parser().get_parseStatus() != 0 ) {
    146         return Parser::get_parser().get_parseStatus();
    147       }
    148       fclose( builtins );
    149 
    150       // include cfa prelude
    151       if( libp ) {
    152         prelude = input;
    153       } else {
    154         prelude = open_prelude();
    155       }
    156       if( !prelude ) {
    157         std::cout << "Error: can't open prelude" << std::endl;
    158         exit( 1 );
    159       }
    160      
    161       Parser::get_parser().set_linkage( LinkageSpec::Intrinsic );
    162       Parser::get_parser().parse( prelude );
    163    
    164       if( Parser::get_parser().get_parseStatus() != 0 ) {
    165         return Parser::get_parser().get_parseStatus();
    166       }
    167       fclose( prelude );
     289
     290    if (! (ret = fopen(full_name.c_str(), "r" ) ) )
     291        return fopen(name.c_str(), "r" );             // trying current directory
     292    else
     293        return ret;
     294}
     295
     296FILE *open_builtins() {
     297    FILE *ret;
     298
     299    const char *name = "builtins.cf";
     300    const char *full_name = CFA_LIBDIR "/builtins.cf";
     301
     302    if ( beVerbose ) {
     303        cout << "Reading from " << full_name << endl;
    168304    }
    169    
    170     if( libp ) {
    171       std::list< Declaration* > translationUnit;
    172       buildList( Parser::get_parser().get_parseTree(), translationUnit );
    173       Parser::get_parser().freeTree();
    174       SymTab::validate( translationUnit, false );
    175       CodeGen::fixNames( translationUnit );
    176       LibCfa::makeLibCfa( translationUnit );
    177       ResolvExpr::resolve( translationUnit );
    178       GenPoly::convertLvalue( translationUnit );
    179       GenPoly::box( translationUnit );
    180       CodeGen::generate( translationUnit, *output, true );
    181       if( output != &std::cout ) {
    182         delete output;
    183       }
    184       return 0;
    185     }
    186    
    187     Parser::get_parser().set_linkage( LinkageSpec::Cforall );
    188  
    189     Parser::get_parser().parse( input );
    190     if( debugp || Parser::get_parser().get_parseStatus() != 0 ) {
    191       return Parser::get_parser().get_parseStatus();
    192     }
    193     fclose( input );
    194  
    195     if( treep ) {
    196       Parser::get_parser().get_parseTree()->printList( std::cout );
    197       Parser::get_parser().freeTree();
    198       return 0;
    199     }
    200 
    201     std::list< Declaration* > translationUnit;
    202     buildList( Parser::get_parser().get_parseTree(), translationUnit );
    203 
    204     Parser::get_parser().freeTree();
    205     if( astp ) {
    206       printAll( translationUnit, std::cout );
    207       return 0;
    208     }
    209 
    210     if( manglep ) {
    211       SymTab::validate( translationUnit, false );
    212       ResolvExpr::AlternativePrinter printer( std::cout );
    213       acceptAll( translationUnit, printer );
    214       return 0;
    215     }
    216 
    217     if( symtabp ) {
    218       SymTab::validate( translationUnit, true );
    219       return 0;
    220     }
    221 
    222     if( validp ) {
    223       SymTab::validate( translationUnit, false );
    224       printAll( translationUnit, std::cout );
    225       return 0;
    226     }
    227     if( exprp ) {
    228       SymTab::validate( translationUnit, false );
    229       ResolvExpr::resolve( translationUnit );
    230       printAll( translationUnit, std::cout );
    231       return 0;
    232     }
    233 
    234     SymTab::validate( translationUnit, false );
    235     //Try::visit( translationUnit );
    236     //Tuples::mutate( translationUnit );
    237     //InitTweak::mutate( translationUnit );
    238     ControlStruct::mutate( translationUnit );
    239     CodeGen::fixNames( translationUnit );
    240     ResolvExpr::resolve( translationUnit );
    241     //Tuples::checkFunctions( translationUnit );
    242     //      std::cerr << "Finished tuple checkfunctions" << std::endl;
    243     //printAll( translationUnit, std::cerr );
    244     GenPoly::copyParams( translationUnit );
    245     GenPoly::convertSpecializations( translationUnit );
    246     GenPoly::convertLvalue( translationUnit );
    247     GenPoly::box( translationUnit );
    248     //Tuples::mutate( translationUnit );
    249 
    250     CodeGen::generate( translationUnit, *output, protop );
    251 
    252     if( output != &std::cout ) {
    253         delete output;
    254     }
    255 
    256   } catch ( SemanticError &e ) {
    257     e.print( cout );
    258     if( output != &std::cout ) {
    259       delete output;
    260     }
    261     return 1;
    262   } catch ( UnimplementedError &e ) {
    263     std::cout << "Sorry, " << e.get_what() << " is not currently implemented" << std::endl;
    264     if( output != &std::cout ) {
    265       delete output;
    266     }
    267     return 1;
    268   } catch ( CompilerError &e ) {
    269     std::cerr << "Compiler Error: " << e.get_what() << std::endl;
    270     std::cerr << "(please report bugs to " << std::endl;
    271     if( output != &std::cout ) {
    272       delete output;
    273     }
    274     return 1;
    275   }
    276 
    277   return 0;
    278 }
    279 
    280 FILE *open_prelude(){
    281   FILE *ret;
    282 
    283   const string name("prelude.cf"),
    284                full_name = string(CFA_LIBDIR) + "/" + name;
    285 
    286   if( beVerbose ) {
    287     cout << "Reading from " << full_name << endl;
    288   }
    289 
    290   if (! (ret = fopen(full_name.c_str(), "r" ) ) )
    291     return fopen(name.c_str(), "r" );             // trying current directory
    292   else
    293     return ret;
    294 }
    295 
    296 FILE *open_builtins(){
    297   FILE *ret;
    298 
    299   const char *name = "builtins.cf";
    300   const char *full_name = CFA_LIBDIR "/builtins.cf";
    301 
    302   if( beVerbose ) {
    303     cout << "Reading from " << full_name << endl;
    304   }
    305 
    306   if (! (ret = fopen(full_name, "r" ) ) )
    307     return fopen(name, "r" );             // trying current directory
    308   else
    309     return ret;
     305
     306    if (! (ret = fopen(full_name, "r" ) ) )
     307        return fopen(name, "r" );                       // trying current directory
     308    else
     309        return ret;
    310310}
    311311
Note: See TracChangeset for help on using the changeset viewer.