Changeset 0da3e2c for src/main.cc


Ignore:
Timestamp:
Aug 16, 2016, 5:56:37 PM (8 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, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
29917c6
Parents:
7880579
Message:

more refactoring of parser code

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/main.cc

    r7880579 r0da3e2c  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 15 17:58:57 2016
    13 // Update Count     : 220
     12// Last Modified On : Tue Aug 16 17:47:52 2016
     13// Update Count     : 252
    1414//
    1515
    … …  
    1717#include <fstream>
    1818#include <getopt.h>
    19 #include "Parser/Parser.h"
     19#include "Parser/lex.h"
     20#include "Parser/parser.h"
     21#include "Parser/TypedefTable.h"
    2022#include "SynTree/Declaration.h"
    2123#include "SynTree/Visitor.h"
    … …  
    4749using namespace std;
    4850
    49 #define OPTPRINT(x) \
    50         if ( errorp ) std::cerr << x << std::endl;
    51 
    52 static void parse( FILE * input, LinkageSpec::Type t, bool shouldExit = false );
    53 static void dump( std::list< Declaration * > & translationUnit, std::ostream & out = std::cout );
     51#define OPTPRINT(x) if ( errorp ) std::cerr << x << std::endl;
     52
     53extern int yydebug;
     54
     55LinkageSpec::Type linkage = LinkageSpec::Cforall;
     56TypedefTable typedefTable;
     57DeclarationNode *parseTree = nullptr;                                   // program parse tree
    5458
    5559bool
    … …  
    7276        codegenp = false;
    7377
    74 enum { Ast, Bbox, Bresolver, CtorInitFix, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, Validate, };
    75 
    76 static struct option long_opts[] = {
    77         { "ast", no_argument, 0, Ast },
    78         { "before-box", no_argument, 0, Bbox },
    79         { "before-resolver", no_argument, 0, Bresolver },
    80         { "ctorinitfix", no_argument, 0, CtorInitFix },
    81         { "expr", no_argument, 0, Expr },
    82         { "expralt", no_argument, 0, ExprAlt },
    83         { "grammar", no_argument, 0, Grammar },
    84         { "libcfa", no_argument, 0, LibCFA },
    85         { "no-preamble", no_argument, 0, Nopreamble },
    86         { "parse", no_argument, 0, Parse },
    87         { "no-prototypes", no_argument, 0, Prototypes },
    88         { "resolver", no_argument, 0, Resolver },
    89         { "symbol", no_argument, 0, Symbol },
    90         { "tree", no_argument, 0, Tree },
    91         { "validate", no_argument, 0, Validate },
    92         { 0, 0, 0, 0 }
    93 };
     78static void parse( FILE * input, LinkageSpec::Type t, bool shouldExit = false );
     79static void dump( std::list< Declaration * > & translationUnit, std::ostream & out = std::cout );
     80static void parse_cmdline( int argc, char *argv[], const char *&filename );
     81
    9482
    9583int main( int argc, char *argv[] ) {
    9684        FILE *input;
    9785        std::ostream *output = &std::cout;
    98         int long_index;
    9986        std::list< Declaration * > translationUnit;
    10087        const char *filename = NULL;
    10188
    102         opterr = 0;                                                                                     // prevent getopt from printing error messages
    103 
    104         int c;
    105         while ( (c = getopt_long( argc, argv, "abBcefglnpqrstvyzD:F:", long_opts, &long_index )) != -1 ) {
    106                 switch ( c ) {
    107                   case Ast:
    108                   case 'a':                                                                             // dump AST
    109                         astp = true;
    110                         break;
    111                   case Bresolver:
    112                   case 'b':                                                                             // print before resolver steps
    113                         bresolvep = true;
    114                         break;
    115                   case 'B':                                                                             // print before resolver steps
    116                         bboxp = true;
    117                         break;
    118                   case CtorInitFix:
    119                   case 'c':
    120                         ctorinitp = true;
    121                         break;
    122                   case Expr:
    123                   case 'e':                                                                             // dump AST after expression analysis
    124                         exprp = true;
    125                         break;
    126                   case ExprAlt:
    127                   case 'f':                                                                             // print alternatives for expressions
    128                         expraltp = true;
    129                         break;
    130                   case Grammar:
    131                   case 'g':                                                                             // bison debugging info (grammar rules)
    132                         grammarp = true;
    133                         break;
    134                   case LibCFA:
    135                   case 'l':                                                                             // generate libcfa.c
    136                         libcfap = true;
    137                         break;
    138                   case Nopreamble:
    139                   case 'n':                                                                             // do not read preamble
    140                         nopreludep = true;
    141                         break;
    142                   case Prototypes:
    143                   case 'p':                                                                             // generate prototypes for preamble functions
    144                         noprotop = true;
    145                         break;
    146                   case Parse:
    147                   case 'q':                                                                             // dump parse tree
    148                         parsep = true;
    149                         break;
    150                   case Resolver:
    151                   case 'r':                                                                             // print resolver steps
    152                         resolvep = true;
    153                         break;
    154                   case Symbol:
    155                   case 's':                                                                             // print symbol table events
    156                         symtabp = true;
    157                         break;
    158                   case Tree:
    159                   case 't':                                                                             // build in tree
    160                         treep = true;
    161                         break;
    162                   case 'v':                                                                             // dump AST after decl validation pass
    163                         validp = true;
    164                         break;
    165                   case 'y':
    166                         errorp = true;
    167                         break;
    168                   case 'z':
    169                         codegenp = true;
    170                         break;
    171                   case 'D':                                                                             // ignore -Dxxx
    172                         break;
    173                   case 'F':                                                                             // source file-name without suffix
    174                         filename = optarg;
    175                         break;
    176                   case '?':
    177                         cout << "Unknown option: '" << (char)optopt << "'" << endl;
    178                         exit( EXIT_FAILURE );
    179                   default:
    180                         abort();
    181                 } // switch
    182         } // while
     89        parse_cmdline( argc, argv, filename );                          // process command-line arguments
    18390
    18491        try {
    … …  
    206113                } // if
    207114
    208                 Parser::get_parser().set_debug( grammarp );
     115                yydebug = grammarp;
    209116
    210117                // read in the builtins, extras, and the prelude
    … …  
    241148
    242149                if ( parsep ) {
    243                         Parser::get_parser().get_parseTree()->printList( std::cout );
    244                         Parser::get_parser().freeTree();
    245                         return 0;
    246                 } // if
    247 
    248                 buildList( Parser::get_parser().get_parseTree(), translationUnit );
    249 
    250                 Parser::get_parser().freeTree();
     150                        parseTree->printList( std::cout );
     151                        delete parseTree;
     152                        return 0;
     153                } // if
     154
     155                buildList( parseTree, translationUnit );
     156                delete parseTree;
     157
    251158                if ( astp ) {
    252159                        dump( translationUnit );
    … …  
    361268} // main
    362269
    363 static void parse( FILE * input, LinkageSpec::Type linkage, bool shouldExit ) {
    364         Parser::get_parser().set_linkage( linkage );
    365         Parser::get_parser().parse( input );
     270void parse_cmdline( int argc, char *argv[], const char *&filename ) {
     271        enum { Ast, Bbox, Bresolver, CtorInitFix, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, Validate, };
     272
     273        static struct option long_opts[] = {
     274                { "ast", no_argument, 0, Ast },
     275                { "before-box", no_argument, 0, Bbox },
     276                { "before-resolver", no_argument, 0, Bresolver },
     277                { "ctorinitfix", no_argument, 0, CtorInitFix },
     278                { "expr", no_argument, 0, Expr },
     279                { "expralt", no_argument, 0, ExprAlt },
     280                { "grammar", no_argument, 0, Grammar },
     281                { "libcfa", no_argument, 0, LibCFA },
     282                { "no-preamble", no_argument, 0, Nopreamble },
     283                { "parse", no_argument, 0, Parse },
     284                { "no-prototypes", no_argument, 0, Prototypes },
     285                { "resolver", no_argument, 0, Resolver },
     286                { "symbol", no_argument, 0, Symbol },
     287                { "tree", no_argument, 0, Tree },
     288                { "validate", no_argument, 0, Validate },
     289                { 0, 0, 0, 0 }
     290        }; // long_opts
     291        int long_index;
     292
     293        opterr = 0;                                                                                     // (global) prevent getopt from printing error messages
     294
     295        int c;
     296        while ( (c = getopt_long( argc, argv, "abBcefglnpqrstvyzD:F:", long_opts, &long_index )) != -1 ) {
     297                switch ( c ) {
     298                  case Ast:
     299                  case 'a':                                                                             // dump AST
     300                        astp = true;
     301                        break;
     302                  case Bresolver:
     303                  case 'b':                                                                             // print before resolver steps
     304                        bresolvep = true;
     305                        break;
     306                  case 'B':                                                                             // print before resolver steps
     307                        bboxp = true;
     308                        break;
     309                  case CtorInitFix:
     310                  case 'c':
     311                        ctorinitp = true;
     312                        break;
     313                  case Expr:
     314                  case 'e':                                                                             // dump AST after expression analysis
     315                        exprp = true;
     316                        break;
     317                  case ExprAlt:
     318                  case 'f':                                                                             // print alternatives for expressions
     319                        expraltp = true;
     320                        break;
     321                  case Grammar:
     322                  case 'g':                                                                             // bison debugging info (grammar rules)
     323                        grammarp = true;
     324                        break;
     325                  case LibCFA:
     326                  case 'l':                                                                             // generate libcfa.c
     327                        libcfap = true;
     328                        break;
     329                  case Nopreamble:
     330                  case 'n':                                                                             // do not read preamble
     331                        nopreludep = true;
     332                        break;
     333                  case Prototypes:
     334                  case 'p':                                                                             // generate prototypes for preamble functions
     335                        noprotop = true;
     336                        break;
     337                  case Parse:
     338                  case 'q':                                                                             // dump parse tree
     339                        parsep = true;
     340                        break;
     341                  case Resolver:
     342                  case 'r':                                                                             // print resolver steps
     343                        resolvep = true;
     344                        break;
     345                  case Symbol:
     346                  case 's':                                                                             // print symbol table events
     347                        symtabp = true;
     348                        break;
     349                  case Tree:
     350                  case 't':                                                                             // build in tree
     351                        treep = true;
     352                        break;
     353                  case 'v':                                                                             // dump AST after decl validation pass
     354                        validp = true;
     355                        break;
     356                  case 'y':
     357                        errorp = true;
     358                        break;
     359                  case 'z':
     360                        codegenp = true;
     361                        break;
     362                  case 'D':                                                                             // ignore -Dxxx
     363                        break;
     364                  case 'F':                                                                             // source file-name without suffix
     365                        filename = optarg;
     366                        break;
     367                  case '?':
     368                        cout << "Unknown option: '" << (char)optopt << "'" << endl;
     369                        exit( EXIT_FAILURE );
     370                  default:
     371                        abort();
     372                } // switch
     373        } // while
     374} // parse_cmdline
     375
     376static void parse( FILE * input, LinkageSpec::Type link, bool shouldExit ) {
     377        extern int yyparse( void );
     378        extern FILE *yyin;
     379        extern int yylineno;
     380
     381        linkage = link;                                                                         // set globals
     382        yyin = input;
     383        yylineno = 1;
     384        typedefTable.enterScope();
     385        int parseStatus = yyparse();
    366386
    367387        fclose( input );
    368         if ( shouldExit || Parser::get_parser().get_parseStatus() != 0 ) {
    369                 exit( Parser::get_parser().get_parseStatus() );
     388        if ( shouldExit || parseStatus != 0 ) {
     389                exit( parseStatus );
    370390        } // if
    371 }
     391} // parse
    372392
    373393static bool notPrelude( Declaration * decl ) {
    374394        return ! LinkageSpec::isBuiltin( decl->get_linkage() );
    375 }
     395} // notPrelude
    376396
    377397static void dump( std::list< Declaration * > & translationUnit, std::ostream & out ) {
    … …  
    385405        printAll( decls, out );
    386406        deleteAll( translationUnit );
    387 }
    388 
     407} // dump
    389408
    390409// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.