Changeset 7bf7fb9


Ignore:
Timestamp:
Aug 7, 2016, 9:47:37 AM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
04273e9, d1625f8
Parents:
35f9114
Message:

more refactoring of parser code

Location:
src
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/DeclarationNode.cc

    r35f9114 r7bf7fb9  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 20:49:31 2016
    13 // Update Count     : 164
     12// Last Modified On : Sun Aug  7 08:01:55 2016
     13// Update Count     : 165
    1414//
    1515
     
    4949        newnode->name = name;
    5050        newnode->storageClasses = storageClasses;
    51         newnode->bitfieldWidth = maybeClone( bitfieldWidth );
     51//PAB   newnode->bitfieldWidth = maybeClone( bitfieldWidth );
     52        newnode->bitfieldWidth = bitfieldWidth;
    5253        newnode->hasEllipsis = hasEllipsis;
    5354        newnode->initializer = initializer;
  • src/Parser/ExpressionNode.cc

    r35f9114 r7bf7fb9  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 15:07:19 2016
    13 // Update Count     : 409
     12// Last Modified On : Sun Aug  7 09:23:12 2016
     13// Update Count     : 437
    1414//
    1515
    1616#include <cassert>
    1717#include <cctype>
     18#include <climits>
     19#include <cstdio>
    1820#include <algorithm>
    1921#include <sstream>
    20 #include <cstdio>
    2122
    2223#include "ParseNode.h"
     
    3738ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {
    3839        if ( other.argName ) {
     40                std::cout << "ExpressionNode" << std::endl;
    3941                argName = other.argName->clone();
    4042        } else {
     
    8385}
    8486
    85 // CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ) {
    86 //      return new CommaExprNode( this, exp );
    87 // }
    88 
    89 //##############################################################################
    90 
    91 ConstantNode::ConstantNode( ConstantExpr *expr ) : expr( expr ) {
    92 } // ConstantNode::ConstantNode
    93 
    94 ConstantNode *ConstantNode::appendstr( const std::string *newValue ) {
    95         assert( newValue != 0 );
    96 
    97         string value = expr->get_constant()->get_value();
    98 
    99         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
    100         value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) );
    101         expr->get_constant()->set_value( value );
    102 
    103         delete newValue;                                                                        // allocated by lexer
    104         return this;
    105 }
    106 
    107 void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
    108         // os << string( indent, ' ' );
    109         // printDesignation( os );
    110 
    111         // switch ( type ) {
    112         //   case Integer:
    113         //   case Float:
    114         //      os << value ;
    115         //      break;
    116         //   case Character:
    117         //      os << "'" << value << "'";
    118         //      break;
    119         //   case String:
    120         //      os << '"' << value << '"';
    121         //      break;
    122         // } // switch
    123 
    124         // os << ' ';
    125 }
    126 
    127 void ConstantNode::print( std::ostream &os, int indent ) const {
    128         printOneLine( os, indent );
    129         os << endl;
    130 }
    131 
    132 Expression *ConstantNode::build() const {
    133         return expr->clone();
    134 }
    135 
    136 //##############################################################################
    137 
    138 VarRefNode::VarRefNode() : isLabel( false ) {}
    139 
    140 VarRefNode::VarRefNode( const string *name_, bool labelp ) : ExpressionNode( name_ ), isLabel( labelp ) {}
     87//##############################################################################
     88
     89// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
     90//
     91//              prefix action constant action suffix
     92//
     93// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
     94//
     95//              constant BEGIN CONT ...
     96//              <CONT>(...)? BEGIN 0 ... // possible empty suffix
     97//
     98// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
     99// type.
     100
     101static Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
     102
     103static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
     104static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
     105static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
     106static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
     107static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
     108static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
     109
     110ConstantNode *build_constantInteger( std::string & str ) {
     111        static const BasicType::Kind kind[2][3] = {
     112                { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
     113                { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
     114        };
     115        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
     116        int size;                                                                                       // 0 => int, 1 => long, 2 => long long
     117        unsigned long long v;                                                           // converted integral value
     118        size_t last = str.length() - 1;                                         // last character of constant
     119
     120        if ( str[0] == '0' ) {                                                          // octal/hex constant ?
     121                dec = false;
     122                if ( last != 0 && checkX( str[1] ) ) {                  // hex constant ?
     123                        sscanf( (char *)str.c_str(), "%llx", &v );
     124                        //printf( "%llx %llu\n", v, v );
     125                } else {                                                                                // octal constant
     126                        sscanf( (char *)str.c_str(), "%llo", &v );
     127                        //printf( "%llo %llu\n", v, v );
     128                } // if
     129        } else {                                                                                        // decimal constant ?
     130                sscanf( (char *)str.c_str(), "%llu", &v );
     131                //printf( "%llu %llu\n", v, v );
     132        } // if
     133
     134        if ( v <= INT_MAX ) {                                                           // signed int
     135                size = 0;
     136        } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
     137                size = 0;
     138                Unsigned = true;                                                                // unsigned
     139        } else if ( v <= LONG_MAX ) {                                           // signed long int
     140                size = 1;
     141        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
     142                size = 1;
     143                Unsigned = true;                                                                // unsigned long int
     144        } else if ( v <= LLONG_MAX ) {                                          // signed long long int
     145                size = 2;
     146        } else {                                                                                        // unsigned long long int
     147                size = 2;
     148                Unsigned = true;                                                                // unsigned long long int
     149        } // if
     150
     151        if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
     152                Unsigned = true;
     153                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
     154                        size = 1;
     155                        if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
     156                                size = 2;
     157                        } // if
     158                } // if
     159        } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
     160                size = 1;
     161                if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'll' ?
     162                        size = 2;
     163                        if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
     164                                Unsigned = true;
     165                        } // if
     166                } else {
     167                        if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
     168                                Unsigned = true;
     169                        } // if
     170                } // if
     171        } // if
     172
     173        return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ) ) );
     174} // build_constantInteger
     175
     176ConstantNode *build_constantFloat( std::string & str ) {
     177        static const BasicType::Kind kind[2][3] = {
     178                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
     179                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
     180        };
     181
     182        bool complx = false;                                                            // real, complex
     183        int size = 1;                                                                           // 0 => float, 1 => double (default), 2 => long double
     184        // floating-point constant has minimum of 2 characters: 1. or .1
     185        size_t last = str.length() - 1;
     186
     187        if ( checkI( str[last] ) ) {                                            // imaginary ?
     188                complx = true;
     189                last -= 1;                                                                              // backup one character
     190        } // if
     191
     192        if ( checkF( str[last] ) ) {                                            // float ?
     193                size = 0;
     194        } else if ( checkD( str[last] ) ) {                                     // double ?
     195                size = 1;
     196        } else if ( checkL( str[last] ) ) {                                     // long double ?
     197                size = 2;
     198        } // if
     199        if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
     200                complx = true;
     201        } // if
     202
     203        return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ) ) );
     204} // build_constantFloat
     205
     206ConstantNode *build_constantChar( std::string & str ) {
     207        return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) ) );
     208} // build_constantChar
     209
     210ConstantNode *build_constantStr( std::string & str ) {
     211        // string should probably be a primitive type
     212        ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
     213                                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
     214                                                                                        toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
     215                                                                   false, false );
     216        return new ConstantNode( new ConstantExpr( Constant( at, str ) ) );
     217} // build_constantStr
     218
     219//##############################################################################
     220
     221//Expression *build_varref( ExpressionNode expr ) {
     222//      return new NameExpr( get_name(), maybeBuild<Expression>( get_argName() ) );
     223//}
     224
     225VarRefNode::VarRefNode( const string *name, bool labelp ) : ExpressionNode( name ), isLabel( labelp ) {}
    141226
    142227VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
     
    171256                        double value;
    172257                        if ( ss >> value ) {
    173                                 // this is a floating point constant. It MUST be
    174                                 // ".0" or ".1", otherwise the program is invalid
     258                                // this is a floating point constant. It MUST be ".0" or ".1", otherwise the program is invalid
    175259                                if ( ! (var->get_name() == ".0" || var->get_name() == ".1") ) {
    176260                                        throw SemanticError( "invalid designator name: " + var->get_name() );
     
    201285
    202286        if ( isArrayIndex ) {
    203                 // need to traverse entire structure and change any instances of 0 or 1 to
    204                 // ConstantExpr
     287                // need to traverse entire structure and change any instances of 0 or 1 to ConstantExpr
    205288                DesignatorFixer fixer;
    206289                ret = ret->acceptMutator( fixer );
     
    240323static const char *OperName[] = {
    241324        // diadic
    242         "SizeOf", "AlignOf", "OffsetOf", "Attr", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
     325        "SizeOf", "AlignOf", "OffsetOf", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
    243326        "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
    244327        "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
     
    249332
    250333//##############################################################################
    251 
    252 CompositeExprNode::CompositeExprNode( Expression *expr ) : expr( expr ) {}
    253 CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {}
    254 CompositeExprNode::~CompositeExprNode() { delete expr; }
    255 void CompositeExprNode::print( std::ostream &, int indent ) const { assert( false ); }
    256 void CompositeExprNode::printOneLine( std::ostream &, int indent ) const { assert( false ); }
    257334
    258335Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) {
  • src/Parser/ParseNode.cc

    r35f9114 r7bf7fb9  
    1010// Created On       : Sat May 16 13:26:29 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jul 24 02:17:01 2016
    13 // Update Count     : 90
     12// Last Modified On : Sat Aug  6 08:26:11 2016
     13// Update Count     : 93
    1414//
    1515
    16 #include <climits>
    1716#include "ParseNode.h"
    1817using namespace std;
    19 
    20 // Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
    21 //
    22 //              prefix action constant action suffix
    23 //
    24 // Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
    25 //
    26 //              constant BEGIN CONT ...
    27 //              <CONT>(...)? BEGIN 0 ... // possible empty suffix
    28 //
    29 // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
    30 // type.
    31 
    32 static Type::Qualifiers emptyQualifiers;                                // no qualifiers on constants
    33 
    34 static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
    35 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
    36 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
    37 static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
    38 static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
    39 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
    40 
    41 ConstantNode *makeConstantInteger( std::string & str ) {
    42         static const BasicType::Kind kind[2][3] = {
    43                 { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
    44                 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
    45         };
    46         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    47         int size;                                                                                       // 0 => int, 1 => long, 2 => long long
    48         unsigned long long v;                                                           // converted integral value
    49         size_t last = str.length() - 1;                                         // last character of constant
    50 
    51         if ( str[0] == '0' ) {                                                          // octal/hex constant ?
    52                 dec = false;
    53                 if ( last != 0 && checkX( str[1] ) ) {                  // hex constant ?
    54                         sscanf( (char *)str.c_str(), "%llx", &v );
    55                         //printf( "%llx %llu\n", v, v );
    56                 } else {                                                                                // octal constant
    57                         sscanf( (char *)str.c_str(), "%llo", &v );
    58                         //printf( "%llo %llu\n", v, v );
    59                 } // if
    60         } else {                                                                                        // decimal constant ?
    61                 sscanf( (char *)str.c_str(), "%llu", &v );
    62                 //printf( "%llu %llu\n", v, v );
    63         } // if
    64 
    65         if ( v <= INT_MAX ) {                                                           // signed int
    66                 size = 0;
    67         } else if ( v <= UINT_MAX && ! dec ) {                          // unsigned int
    68                 size = 0;
    69                 Unsigned = true;                                                                // unsigned
    70         } else if ( v <= LONG_MAX ) {                                           // signed long int
    71                 size = 1;
    72         } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
    73                 size = 1;
    74                 Unsigned = true;                                                                // unsigned long int
    75         } else if ( v <= LLONG_MAX ) {                                          // signed long long int
    76                 size = 2;
    77         } else {                                                                                        // unsigned long long int
    78                 size = 2;
    79                 Unsigned = true;                                                                // unsigned long long int
    80         } // if
    81 
    82         if ( checkU( str[last] ) ) {                                            // suffix 'u' ?
    83                 Unsigned = true;
    84                 if ( last > 0 && checkL( str[last - 1] ) ) {    // suffix 'l' ?
    85                         size = 1;
    86                         if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ?
    87                                 size = 2;
    88                         } // if
    89                 } // if
    90         } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
    91                 size = 1;
    92                 if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'll' ?
    93                         size = 2;
    94                         if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ?
    95                                 Unsigned = true;
    96                         } // if
    97                 } else {
    98                         if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ?
    99                                 Unsigned = true;
    100                         } // if
    101                 } // if
    102         } // if
    103 
    104         return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ), nullptr ) );
    105 } // makeConstantInteger
    106 
    107 ConstantNode *makeConstantFloat( std::string & str ) {
    108         static const BasicType::Kind kind[2][3] = {
    109                 { BasicType::Float, BasicType::Double, BasicType::LongDouble },
    110                 { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
    111         };
    112 
    113         bool complx = false;                                                            // real, complex
    114         int size = 1;                                                                           // 0 => float, 1 => double (default), 2 => long double
    115         // floating-point constant has minimum of 2 characters: 1. or .1
    116         size_t last = str.length() - 1;
    117 
    118         if ( checkI( str[last] ) ) {                                            // imaginary ?
    119                 complx = true;
    120                 last -= 1;                                                                              // backup one character
    121         } // if
    122 
    123         if ( checkF( str[last] ) ) {                                            // float ?
    124                 size = 0;
    125         } else if ( checkD( str[last] ) ) {                                     // double ?
    126                 size = 1;
    127         } else if ( checkL( str[last] ) ) {                                     // long double ?
    128                 size = 2;
    129         } // if
    130         if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
    131                 complx = true;
    132         } // if
    133 
    134         return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ), nullptr ) );
    135 } // makeConstantFloat
    136 
    137 ConstantNode *makeConstantChar( std::string & str ) {
    138         return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ), nullptr ) );
    139 } // makeConstantChar
    140 
    141 ConstantNode *makeConstantStr( std::string & str ) {
    142         // string should probably be a primitive type
    143         ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
    144                                                                    new ConstantExpr(
    145                                                                            Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
    146                                                                                                  toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
    147                                                                    false, false );
    148         return new ConstantNode( new ConstantExpr( Constant( at, str ), nullptr ) );
    149 } // makeConstantStr
    150 
    15118
    15219// Builder
  • src/Parser/ParseNode.h

    r35f9114 r7bf7fb9  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 13:40:15 2016
    13 // Update Count     : 307
     12// Last Modified On : Sun Aug  7 09:37:16 2016
     13// Update Count     : 333
    1414//
    1515
     
    3030#include "SynTree/Label.h"
    3131
    32 class ExpressionNode;
    33 class CompositeExprNode;
    34 class CommaExprNode;
    3532class StatementNode;
    3633class CompoundStmtNode;
     
    5653        void set_name( const std::string &newValue ) { name = newValue; }
    5754
    58         virtual void print( std::ostream &, int indent = 0 ) const;
    59         virtual void printList( std::ostream &, int indent = 0 ) const;
     55        virtual void print( std::ostream &os, int indent = 0 ) const;
     56        virtual void printList( std::ostream &os, int indent = 0 ) const;
    6057
    6158        ParseNode &operator,( ParseNode &);
     
    6865ParseNode *mkList( ParseNode & );
    6966
     67//##############################################################################
     68
    7069class ExpressionNode : public ParseNode {
    7170  public:
     
    7372        ExpressionNode( const std::string * );
    7473        ExpressionNode( const ExpressionNode &other );
    75         virtual ~ExpressionNode() { delete argName; } // cannot delete argName because it might be referenced elsewhere
     74        virtual ~ExpressionNode() { delete argName; }
    7675
    7776        virtual ExpressionNode *clone() const = 0;
    78 
    79         // virtual CommaExprNode *add_to_list( ExpressionNode * );
    8077
    8178        ExpressionNode *get_argName() const { return argName; }
     
    8582        ExpressionNode *set_extension( bool exten ) { extension = exten; return this; }
    8683
    87         virtual void print( std::ostream &, int indent = 0) const = 0;
    88         virtual void printOneLine( std::ostream &, int indent = 0) const = 0;
     84        virtual void print( std::ostream &os, int indent = 0) const = 0;
     85        virtual void printOneLine( std::ostream &os, int indent = 0) const = 0;
    8986
    9087        virtual Expression *build() const = 0;
    9188  protected:
    92         void printDesignation ( std::ostream &, int indent = 0) const;
     89        void printDesignation ( std::ostream &os, int indent = 0) const;
    9390  private:
    9491        ExpressionNode *argName = 0;
     
    109106};
    110107
     108//##############################################################################
     109
    111110// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
    112111class NullExprNode : public ExpressionNode {
     
    116115        virtual NullExprNode *clone() const;
    117116
    118         virtual void print( std::ostream &, int indent = 0) const;
    119         virtual void printOneLine( std::ostream &, int indent = 0) const;
     117        virtual void print( std::ostream &os, int indent = 0) const;
     118        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    120119
    121120        virtual Expression *build() const;
    122121};
    123122
     123//##############################################################################
     124
    124125class ConstantNode : public ExpressionNode {
    125126  public:
    126         enum Type { Integer, Float, Character, String };
    127 
    128         ConstantNode( ConstantExpr * );
    129         ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {};
    130         ~ConstantNode() { delete expr; }
    131 
    132         virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
    133         virtual void print( std::ostream &, int indent = 0) const;
    134         virtual void printOneLine( std::ostream &, int indent = 0) const;
    135 
    136         ConstantNode *appendstr( const std::string *newValue );
    137 
    138         Expression *build() const;
     127        ConstantNode( ConstantExpr *expr ) : expr( expr ) {}
     128        ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {}
     129        virtual ~ConstantNode() {}
     130
     131        virtual ConstantNode *clone() const { assert( false ); return new ConstantNode( *this ); }
     132
     133        ConstantExpr *get_expr() const { return expr; }
     134
     135        virtual void print( std::ostream &os, int indent = 0 ) const {}
     136        virtual void printOneLine( std::ostream &os, int indent = 0 ) const {}
     137
     138        Expression *build() const { return expr; }
    139139  private:
    140140        ConstantExpr *expr;
    141141};
    142142
    143 ConstantNode *makeConstantInteger( std::string & );
    144 ConstantNode *makeConstantFloat( std::string & );
    145 ConstantNode *makeConstantChar( std::string & );
    146 ConstantNode *makeConstantStr( std::string & );
     143ConstantNode *build_constantInteger( std::string &str );
     144ConstantNode *build_constantFloat( std::string &str );
     145ConstantNode *build_constantChar( std::string &str );
     146ConstantNode *build_constantStr( std::string &str );
     147
     148//##############################################################################
    147149
    148150class VarRefNode : public ExpressionNode {
    149151  public:
    150         VarRefNode();
    151152        VarRefNode( const std::string *, bool isLabel = false );
    152153        VarRefNode( const VarRefNode &other );
     
    156157        virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
    157158
    158         virtual void print( std::ostream &, int indent = 0 ) const;
    159         virtual void printOneLine( std::ostream &, int indent = 0 ) const;
     159        virtual void print( std::ostream &os, int indent = 0 ) const;
     160        virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    160161  private:
    161162        bool isLabel;
    162163};
     164
     165//##############################################################################
    163166
    164167class DesignatorNode : public ExpressionNode {
     
    170173        virtual DesignatorNode *clone() const { return new DesignatorNode( *this ); }
    171174
    172         virtual void print( std::ostream &, int indent = 0 ) const;
    173         virtual void printOneLine( std::ostream &, int indent = 0 ) const;
     175        virtual void print( std::ostream &os, int indent = 0 ) const;
     176        virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    174177  private:
    175178        bool isArrayIndex;
    176179};
     180
     181//##############################################################################
    177182
    178183class TypeValueNode : public ExpressionNode {
     
    187192        virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
    188193
    189         virtual void print( std::ostream &, int indent = 0) const;
    190         virtual void printOneLine( std::ostream &, int indent = 0) const;
     194        virtual void print( std::ostream &os, int indent = 0) const;
     195        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    191196  private:
    192197        DeclarationNode *decl;
     198};
     199
     200//##############################################################################
     201
     202class CompositeExprNode : public ExpressionNode {
     203  public:
     204        CompositeExprNode( Expression *expr ) : expr( expr ) {}
     205        CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {}
     206        virtual ~CompositeExprNode() {}
     207
     208        CompositeExprNode *clone() const { assert( false ); return new CompositeExprNode( *this ); }
     209
     210        Expression *build() const { return expr; }
     211
     212        void print( std::ostream &os, int indent = 0 ) const {}
     213        void printOneLine( std::ostream &os, int indent = 0 ) const {}
     214  private:
     215        Expression *expr;
    193216};
    194217
    195218enum class OperKinds {
    196219        // diadic
    197         SizeOf, AlignOf, OffsetOf, Attr, Plus, Minus, Mul, Div, Mod, Or, And,
     220        SizeOf, AlignOf, OffsetOf, Plus, Minus, Mul, Div, Mod, Or, And,
    198221        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
    199222        Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
     
    224247Expression *build_range( ExpressionNode * low, ExpressionNode *high );
    225248
    226 class CompositeExprNode : public ExpressionNode {
    227   public:
    228         CompositeExprNode( Expression *expr );
    229         CompositeExprNode( const CompositeExprNode &other );
    230         virtual ~CompositeExprNode();
    231 
    232         virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
    233         virtual Expression *build() const { return expr->clone(); }
    234 
    235         virtual void print( std::ostream &, int indent = 0) const;
    236         virtual void printOneLine( std::ostream &, int indent = 0) const;
    237   private:
    238         Expression *expr;
    239 };
     249//##############################################################################
    240250
    241251class AsmExprNode : public ExpressionNode {
     
    248258        virtual Expression *build() const;
    249259
    250         virtual void print( std::ostream &, int indent = 0) const;
    251         virtual void printOneLine( std::ostream &, int indent = 0) const;
     260        virtual void print( std::ostream &os, int indent = 0) const;
     261        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    252262
    253263        ExpressionNode *get_inout() const { return inout; };
     
    265275};
    266276
     277//##############################################################################
     278
    267279class LabelNode : public ExpressionNode {
    268280  public:
     
    270282        virtual LabelNode *clone() const { return new LabelNode( *this ); }
    271283
    272         virtual void print( std::ostream &, int indent = 0) const;
    273         virtual void printOneLine( std::ostream &, int indent = 0) const;
     284        virtual void print( std::ostream &os, int indent = 0) const;
     285        virtual void printOneLine( std::ostream &os, int indent = 0) const;
    274286
    275287        const std::list< Label > &get_labels() const { return labels; };
     
    278290        std::list< Label > labels;
    279291};
     292
     293//##############################################################################
    280294
    281295class ForCtlExprNode : public ExpressionNode {
     
    292306        virtual Expression *build() const;
    293307
    294         virtual void print( std::ostream &, int indent = 0 ) const;
    295         virtual void printOneLine( std::ostream &, int indent = 0 ) const;
     308        virtual void print( std::ostream &os, int indent = 0 ) const;
     309        virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    296310  private:
    297311        StatementNode *init;
     
    299313        ExpressionNode *change;
    300314};
     315
     316//##############################################################################
    301317
    302318class ValofExprNode : public ExpressionNode {
     
    310326
    311327        StatementNode *get_body() const { return body; }
    312         void print( std::ostream &, int indent = 0 ) const;
    313         void printOneLine( std::ostream &, int indent = 0 ) const;
     328        void print( std::ostream &os, int indent = 0 ) const;
     329        void printOneLine( std::ostream &os, int indent = 0 ) const;
    314330        Expression *build() const;
    315331
     
    317333        StatementNode *body;
    318334};
     335
     336//##############################################################################
    319337
    320338class TypeData;
     
    391409
    392410        DeclarationNode *clone() const;
    393         void print( std::ostream &, int indent = 0 ) const;
    394         void printList( std::ostream &, int indent = 0 ) const;
     411        void print( std::ostream &os, int indent = 0 ) const;
     412        void printList( std::ostream &os, int indent = 0 ) const;
    395413
    396414        Declaration *build() const;
     
    426444}; // DeclarationNode
    427445
     446//##############################################################################
     447
    428448class StatementNode : public ParseNode {
    429449  public:
     
    465485        StatementNode *append_last_case( StatementNode * );
    466486
    467         void print( std::ostream &, int indent = 0) const;
     487        void print( std::ostream &os, int indent = 0) const;
    468488        virtual StatementNode *clone() const;
    469489        virtual Statement *build() const;
     
    479499}; // StatementNode
    480500
     501//##############################################################################
     502
    481503class CompoundStmtNode : public StatementNode {
    482504  public:
     
    488510        void add_statement( StatementNode * );
    489511
    490         void print( std::ostream &, int indent = 0 ) const;
     512        void print( std::ostream &os, int indent = 0 ) const;
    491513        virtual Statement *build() const;
    492514  private:
    493515        StatementNode *first, *last;
    494516};
     517
     518//##############################################################################
    495519
    496520class AsmStmtNode : public StatementNode {
     
    499523        ~AsmStmtNode();
    500524
    501         void print( std::ostream &, int indent = 0 ) const;
     525        void print( std::ostream &os, int indent = 0 ) const;
    502526        Statement *build() const;
    503527  private:
     
    509533};
    510534
     535//##############################################################################
     536
    511537class InitializerNode : public ParseNode {
    512538  public:
     
    525551        InitializerNode *next_init() const { return kids; }
    526552
    527         void print( std::ostream &, int indent = 0 ) const;
     553        void print( std::ostream &os, int indent = 0 ) const;
    528554        void printOneLine( std::ostream & ) const;
    529555
     
    537563};
    538564
     565//##############################################################################
     566
    539567class CompoundLiteralNode : public ExpressionNode {
    540568  public:
     
    551579        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
    552580
    553         void print( std::ostream &, int indent = 0 ) const;
    554         void printOneLine( std::ostream &, int indent = 0 ) const;
     581        void print( std::ostream &os, int indent = 0 ) const;
     582        void printOneLine( std::ostream &os, int indent = 0 ) const;
    555583
    556584        virtual Expression *build() const;
  • src/Parser/StatementNode.cc

    r35f9114 r7bf7fb9  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 12 17:21:02 2016
    13 // Update Count     : 133
     12// Last Modified On : Sun Aug  7 06:42:38 2016
     13// Update Count     : 135
    1414//
    1515
     
    106106        return this;
    107107}
    108 
    109 // StatementNode *StatementNode::add_controlexp( ExpressionNode *e ) {
    110 //      if ( control && e )
    111 //              control->add_to_list( e ); // xxx - check this
    112 //      return this;
    113 // }
    114108
    115109StatementNode *StatementNode::append_block( StatementNode *stmt ) {
     
    176170                } // if
    177171                if ( block ) {
    178                         os << string( indent + ParseNode::indent_by, ' ' ) << "Branches of execution: " << endl;
     172                        os << string( indent + ParseNode::indent_by, ' ' ) << "Cases: " << endl;
    179173                        block->printList( os, indent + 2 * ParseNode::indent_by );
    180174                } // if
  • src/Parser/TypeData.cc

    r35f9114 r7bf7fb9  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 13 18:03:29 2016
    13 // Update Count     : 56
     12// Last Modified On : Sun Aug  7 07:51:48 2016
     13// Update Count     : 58
    1414//
    1515
     
    182182                break;
    183183          case Array:
    184                 newtype->array->dimension = maybeClone( array->dimension );
     184//PAB           newtype->array->dimension = maybeClone( array->dimension );
     185                newtype->array->dimension = array->dimension;
    185186                newtype->array->isVarLen = array->isVarLen;
    186187                newtype->array->isStatic = array->isStatic;
  • src/Parser/parser.cc

    r35f9114 r7bf7fb9  
    8989TypedefTable typedefTable;
    9090
     91void appendStr( std::string &to, std::string *from ) {
     92        // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
     93        to.insert( to.length() - 1, from->substr( 1, from->length() - 2 ) );
     94} // appendStr
     95
    9196
    9297/* Line 268 of yacc.c  */
    93 #line 94 "Parser/parser.cc"
     98#line 99 "Parser/parser.cc"
    9499
    95100/* Enabling traces.  */
     
    342347
    343348/* Line 293 of yacc.c  */
    344 #line 110 "parser.yy"
     349#line 115 "parser.yy"
    345350
    346351        Token tok;
     
    360365
    361366/* Line 293 of yacc.c  */
    362 #line 363 "Parser/parser.cc"
     367#line 368 "Parser/parser.cc"
    363368} YYSTYPE;
    364369# define YYSTYPE_IS_TRIVIAL 1
     
    372377
    373378/* Line 343 of yacc.c  */
    374 #line 375 "Parser/parser.cc"
     379#line 380 "Parser/parser.cc"
    375380
    376381#ifdef short
     
    10161021static const yytype_uint16 yyrline[] =
    10171022{
    1018        0,   291,   291,   297,   306,   307,   308,   312,   313,   314,
    1019      318,   319,   323,   324,   328,   329,   333,   334,   340,   342,
    1020      344,   346,   351,   352,   358,   362,   364,   365,   367,   368,
    1021      370,   372,   374,   383,   384,   390,   391,   392,   397,   399,
    1022      404,   405,   409,   413,   415,   417,   419,   424,   427,   429,
    1023      431,   436,   449,   451,   453,   455,   457,   459,   461,   463,
    1024      465,   467,   469,   476,   477,   483,   484,   485,   486,   490,
    1025      491,   493,   498,   499,   501,   503,   508,   509,   511,   516,
    1026      517,   519,   524,   525,   527,   529,   531,   536,   537,   539,
    1027      544,   545,   550,   551,   556,   557,   562,   563,   568,   569,
    1028      574,   575,   578,   580,   585,   590,   591,   593,   599,   600,
    1029      604,   605,   606,   607,   608,   609,   610,   611,   612,   613,
    1030      614,   620,   622,   624,   626,   631,   632,   637,   638,   644,
    1031      645,   651,   652,   653,   654,   655,   656,   657,   658,   659,
    1032      669,   676,   678,   688,   689,   694,   696,   702,   704,   708,
    1033      709,   714,   719,   722,   724,   726,   736,   738,   749,   750,
    1034      752,   756,   758,   762,   763,   768,   769,   773,   778,   779,
    1035      783,   785,   791,   792,   796,   798,   800,   802,   808,   809,
    1036      813,   815,   820,   822,   824,   829,   831,   836,   838,   842,
    1037      845,   849,   852,   856,   858,   862,   864,   871,   873,   875,
    1038      884,   886,   888,   890,   892,   897,   899,   901,   903,   908,
    1039      921,   922,   927,   929,   934,   938,   940,   942,   944,   946,
    1040      952,   953,   959,   960,   964,   965,   970,   972,   978,   979,
    1041      981,   986,   988,   995,   997,  1001,  1002,  1007,  1009,  1013,
    1042     1014,  1018,  1020,  1024,  1025,  1029,  1030,  1034,  1035,  1050,
    1043     1051,  1052,  1053,  1054,  1058,  1063,  1070,  1080,  1085,  1090,
    1044     1098,  1103,  1108,  1113,  1118,  1126,  1148,  1153,  1160,  1162,
    1045     1169,  1174,  1179,  1190,  1195,  1200,  1205,  1210,  1219,  1224,
    1046     1232,  1233,  1234,  1235,  1241,  1246,  1254,  1255,  1256,  1257,
    1047     1261,  1262,  1263,  1264,  1269,  1270,  1279,  1280,  1285,  1286,
    1048     1291,  1293,  1295,  1297,  1299,  1302,  1301,  1313,  1314,  1316,
    1049     1326,  1327,  1332,  1336,  1338,  1340,  1342,  1344,  1346,  1348,
    1050     1350,  1355,  1357,  1359,  1361,  1363,  1365,  1367,  1369,  1371,
    1051     1373,  1375,  1377,  1379,  1385,  1386,  1388,  1390,  1392,  1397,
    1052     1398,  1404,  1405,  1407,  1409,  1414,  1416,  1418,  1420,  1425,
    1053     1426,  1428,  1430,  1435,  1436,  1438,  1443,  1444,  1446,  1448,
    1054     1453,  1455,  1457,  1462,  1463,  1467,  1469,  1475,  1474,  1478,
    1055     1480,  1485,  1487,  1493,  1494,  1499,  1500,  1502,  1503,  1512,
    1056     1513,  1515,  1517,  1522,  1524,  1530,  1531,  1533,  1536,  1539,
    1057     1544,  1545,  1550,  1555,  1559,  1561,  1567,  1566,  1573,  1575,
    1058     1581,  1582,  1590,  1591,  1595,  1596,  1597,  1599,  1601,  1608,
    1059     1609,  1611,  1613,  1618,  1619,  1625,  1626,  1630,  1631,  1636,
    1060     1637,  1638,  1640,  1648,  1649,  1651,  1654,  1656,  1660,  1661,
    1061     1662,  1664,  1666,  1670,  1675,  1683,  1684,  1693,  1695,  1700,
    1062     1701,  1702,  1706,  1707,  1708,  1712,  1713,  1714,  1718,  1719,
    1063     1720,  1725,  1726,  1727,  1728,  1734,  1735,  1737,  1742,  1743,
    1064     1748,  1749,  1750,  1751,  1752,  1767,  1768,  1773,  1774,  1782,
    1065     1784,  1786,  1789,  1791,  1793,  1816,  1817,  1819,  1821,  1826,
    1066     1827,  1829,  1834,  1839,  1840,  1846,  1845,  1849,  1853,  1855,
    1067     1857,  1863,  1864,  1869,  1874,  1876,  1881,  1883,  1884,  1886,
    1068     1891,  1893,  1895,  1900,  1902,  1907,  1912,  1920,  1926,  1925,
    1069     1939,  1940,  1945,  1946,  1950,  1955,  1960,  1968,  1973,  1984,
    1070     1985,  1996,  1997,  2003,  2004,  2008,  2009,  2010,  2013,  2012,
    1071     2023,  2032,  2038,  2044,  2053,  2059,  2065,  2071,  2077,  2085,
    1072     2091,  2099,  2105,  2114,  2115,  2116,  2120,  2124,  2126,  2131,
    1073     2132,  2136,  2137,  2142,  2148,  2149,  2152,  2154,  2155,  2159,
    1074     2160,  2161,  2162,  2196,  2198,  2199,  2201,  2206,  2211,  2216,
    1075     2218,  2220,  2225,  2227,  2229,  2231,  2236,  2238,  2247,  2249,
    1076     2250,  2255,  2257,  2259,  2264,  2266,  2268,  2273,  2275,  2277,
    1077     2286,  2287,  2288,  2292,  2294,  2296,  2301,  2303,  2305,  2310,
    1078     2312,  2314,  2329,  2331,  2332,  2334,  2339,  2340,  2345,  2347,
    1079     2349,  2354,  2356,  2358,  2360,  2365,  2367,  2369,  2379,  2381,
    1080     2382,  2384,  2389,  2391,  2393,  2398,  2400,  2402,  2404,  2409,
    1081     2411,  2413,  2444,  2446,  2447,  2449,  2454,  2459,  2467,  2469,
    1082     2471,  2476,  2478,  2483,  2485,  2499,  2500,  2502,  2507,  2509,
    1083     2511,  2513,  2515,  2520,  2521,  2523,  2525,  2530,  2532,  2534,
    1084     2540,  2542,  2544,  2548,  2550,  2552,  2554,  2568,  2569,  2571,
    1085     2576,  2578,  2580,  2582,  2584,  2589,  2590,  2592,  2594,  2599,
    1086     2601,  2603,  2609,  2610,  2612,  2621,  2624,  2626,  2629,  2631,
    1087     2633,  2646,  2647,  2649,  2654,  2656,  2658,  2660,  2662,  2667,
    1088     2668,  2670,  2672,  2677,  2679,  2687,  2688,  2689,  2694,  2695,
    1089     2699,  2701,  2703,  2705,  2707,  2709,  2716,  2718,  2720,  2722,
    1090     2724,  2726,  2728,  2730,  2732,  2734,  2739,  2741,  2743,  2748,
    1091     2774,  2775,  2777,  2781,  2782,  2786,  2788,  2790,  2792,  2794,
    1092     2796,  2803,  2805,  2807,  2809,  2811,  2813,  2818,  2823,  2825,
    1093     2827,  2845,  2847,  2852,  2853
     1023       0,   296,   296,   302,   311,   312,   313,   317,   318,   319,
     1024     323,   324,   328,   329,   333,   334,   338,   339,   350,   352,
     1025     354,   356,   361,   362,   368,   372,   374,   375,   377,   378,
     1026     380,   382,   384,   393,   394,   400,   401,   402,   407,   409,
     1027     414,   415,   419,   423,   425,   427,   429,   434,   437,   439,
     1028     441,   446,   459,   461,   463,   465,   467,   469,   471,   473,
     1029     475,   477,   479,   486,   487,   493,   494,   495,   496,   500,
     1030     501,   503,   508,   509,   511,   513,   518,   519,   521,   526,
     1031     527,   529,   534,   535,   537,   539,   541,   546,   547,   549,
     1032     554,   555,   560,   561,   566,   567,   572,   573,   578,   579,
     1033     584,   585,   588,   590,   595,   600,   601,   603,   609,   610,
     1034     614,   615,   616,   617,   618,   619,   620,   621,   622,   623,
     1035     624,   630,   632,   634,   636,   641,   642,   647,   648,   654,
     1036     655,   661,   662,   663,   664,   665,   666,   667,   668,   669,
     1037     679,   686,   688,   698,   699,   704,   706,   712,   714,   718,
     1038     719,   724,   729,   732,   734,   736,   746,   748,   759,   760,
     1039     762,   766,   768,   772,   773,   778,   779,   783,   788,   789,
     1040     793,   795,   801,   802,   806,   808,   810,   812,   818,   819,
     1041     823,   825,   830,   832,   834,   839,   841,   846,   848,   852,
     1042     855,   859,   862,   866,   868,   872,   874,   881,   883,   885,
     1043     894,   896,   898,   900,   902,   907,   909,   911,   913,   918,
     1044     931,   932,   937,   939,   944,   948,   950,   952,   954,   956,
     1045     962,   963,   969,   970,   974,   975,   980,   982,   988,   989,
     1046     991,   996,   998,  1005,  1007,  1011,  1012,  1017,  1019,  1023,
     1047    1024,  1028,  1030,  1034,  1035,  1039,  1040,  1044,  1045,  1060,
     1048    1061,  1062,  1063,  1064,  1068,  1073,  1080,  1090,  1095,  1100,
     1049    1108,  1113,  1118,  1123,  1128,  1136,  1158,  1163,  1170,  1172,
     1050    1179,  1184,  1189,  1200,  1205,  1210,  1215,  1220,  1229,  1234,
     1051    1242,  1243,  1244,  1245,  1251,  1256,  1264,  1265,  1266,  1267,
     1052    1271,  1272,  1273,  1274,  1279,  1280,  1289,  1290,  1295,  1296,
     1053    1301,  1303,  1305,  1307,  1309,  1312,  1311,  1323,  1324,  1326,
     1054    1336,  1337,  1342,  1346,  1348,  1350,  1352,  1354,  1356,  1358,
     1055    1360,  1365,  1367,  1369,  1371,  1373,  1375,  1377,  1379,  1381,
     1056    1383,  1385,  1387,  1389,  1395,  1396,  1398,  1400,  1402,  1407,
     1057    1408,  1414,  1415,  1417,  1419,  1424,  1426,  1428,  1430,  1435,
     1058    1436,  1438,  1440,  1445,  1446,  1448,  1453,  1454,  1456,  1458,
     1059    1463,  1465,  1467,  1472,  1473,  1477,  1479,  1485,  1484,  1488,
     1060    1490,  1495,  1497,  1503,  1504,  1509,  1510,  1512,  1513,  1522,
     1061    1523,  1525,  1527,  1532,  1534,  1540,  1541,  1543,  1546,  1549,
     1062    1554,  1555,  1560,  1565,  1569,  1571,  1577,  1576,  1583,  1585,
     1063    1591,  1592,  1600,  1601,  1605,  1606,  1607,  1609,  1611,  1618,
     1064    1619,  1621,  1623,  1628,  1629,  1635,  1636,  1640,  1641,  1646,
     1065    1647,  1648,  1650,  1658,  1659,  1661,  1664,  1666,  1670,  1671,
     1066    1672,  1674,  1676,  1680,  1685,  1693,  1694,  1703,  1705,  1710,
     1067    1711,  1712,  1716,  1717,  1718,  1722,  1723,  1724,  1728,  1729,
     1068    1730,  1735,  1736,  1737,  1738,  1744,  1745,  1747,  1752,  1753,
     1069    1758,  1759,  1760,  1761,  1762,  1777,  1778,  1783,  1784,  1792,
     1070    1794,  1796,  1799,  1801,  1803,  1826,  1827,  1829,  1831,  1836,
     1071    1837,  1839,  1844,  1849,  1850,  1856,  1855,  1859,  1863,  1865,
     1072    1867,  1873,  1874,  1879,  1884,  1886,  1891,  1893,  1894,  1896,
     1073    1901,  1903,  1905,  1910,  1912,  1917,  1922,  1930,  1936,  1935,
     1074    1949,  1950,  1955,  1956,  1960,  1965,  1970,  1978,  1983,  1994,
     1075    1995,  2006,  2007,  2013,  2014,  2018,  2019,  2020,  2023,  2022,
     1076    2033,  2042,  2048,  2054,  2063,  2069,  2075,  2081,  2087,  2095,
     1077    2101,  2109,  2115,  2124,  2125,  2126,  2130,  2134,  2136,  2141,
     1078    2142,  2146,  2147,  2152,  2158,  2159,  2162,  2164,  2165,  2169,
     1079    2170,  2171,  2172,  2206,  2208,  2209,  2211,  2216,  2221,  2226,
     1080    2228,  2230,  2235,  2237,  2239,  2241,  2246,  2248,  2257,  2259,
     1081    2260,  2265,  2267,  2269,  2274,  2276,  2278,  2283,  2285,  2287,
     1082    2296,  2297,  2298,  2302,  2304,  2306,  2311,  2313,  2315,  2320,
     1083    2322,  2324,  2339,  2341,  2342,  2344,  2349,  2350,  2355,  2357,
     1084    2359,  2364,  2366,  2368,  2370,  2375,  2377,  2379,  2389,  2391,
     1085    2392,  2394,  2399,  2401,  2403,  2408,  2410,  2412,  2414,  2419,
     1086    2421,  2423,  2454,  2456,  2457,  2459,  2464,  2469,  2477,  2479,
     1087    2481,  2486,  2488,  2493,  2495,  2509,  2510,  2512,  2517,  2519,
     1088    2521,  2523,  2525,  2530,  2531,  2533,  2535,  2540,  2542,  2544,
     1089    2550,  2552,  2554,  2558,  2560,  2562,  2564,  2578,  2579,  2581,
     1090    2586,  2588,  2590,  2592,  2594,  2599,  2600,  2602,  2604,  2609,
     1091    2611,  2613,  2619,  2620,  2622,  2631,  2634,  2636,  2639,  2641,
     1092    2643,  2656,  2657,  2659,  2664,  2666,  2668,  2670,  2672,  2677,
     1093    2678,  2680,  2682,  2687,  2689,  2697,  2698,  2699,  2704,  2705,
     1094    2709,  2711,  2713,  2715,  2717,  2719,  2726,  2728,  2730,  2732,
     1095    2734,  2736,  2738,  2740,  2742,  2744,  2749,  2751,  2753,  2758,
     1096    2784,  2785,  2787,  2791,  2792,  2796,  2798,  2800,  2802,  2804,
     1097    2806,  2813,  2815,  2817,  2819,  2821,  2823,  2828,  2833,  2835,
     1098    2837,  2855,  2857,  2862,  2863
    10941099};
    10951100#endif
     
    49924997
    49934998/* Line 1806 of yacc.c  */
    4994 #line 291 "parser.yy"
     4999#line 296 "parser.yy"
    49955000    {
    49965001                        typedefTable.enterScope();
     
    50015006
    50025007/* Line 1806 of yacc.c  */
    5003 #line 297 "parser.yy"
     5008#line 302 "parser.yy"
    50045009    {
    50055010                        typedefTable.leaveScope();
     
    50105015
    50115016/* Line 1806 of yacc.c  */
    5012 #line 306 "parser.yy"
    5013     { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); }
     5017#line 311 "parser.yy"
     5018    { (yyval.constant) = build_constantInteger( *(yyvsp[(1) - (1)].tok) ); }
    50145019    break;
    50155020
     
    50175022
    50185023/* Line 1806 of yacc.c  */
    5019 #line 307 "parser.yy"
    5020     { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); }
     5024#line 312 "parser.yy"
     5025    { (yyval.constant) = build_constantFloat( *(yyvsp[(1) - (1)].tok) ); }
    50215026    break;
    50225027
     
    50245029
    50255030/* Line 1806 of yacc.c  */
    5026 #line 308 "parser.yy"
    5027     { (yyval.constant) = makeConstantChar( *(yyvsp[(1) - (1)].tok) ); }
     5031#line 313 "parser.yy"
     5032    { (yyval.constant) = build_constantChar( *(yyvsp[(1) - (1)].tok) ); }
    50285033    break;
    50295034
     
    50315036
    50325037/* Line 1806 of yacc.c  */
    5033 #line 333 "parser.yy"
    5034     { (yyval.constant) = makeConstantStr( *(yyvsp[(1) - (1)].tok) ); }
     5038#line 338 "parser.yy"
     5039    { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].tok) ); }
    50355040    break;
    50365041
     
    50385043
    50395044/* Line 1806 of yacc.c  */
    5040 #line 334 "parser.yy"
    5041     { (yyval.constant) = (yyvsp[(1) - (2)].constant)->appendstr( (yyvsp[(2) - (2)].tok) ); }
     5045#line 340 "parser.yy"
     5046    {
     5047                        appendStr( (yyvsp[(1) - (2)].constant)->get_expr()->get_constant()->get_value(), (yyvsp[(2) - (2)].tok) );
     5048                        delete (yyvsp[(2) - (2)].tok);                                                                  // allocated by lexer
     5049                        (yyval.constant) = (yyvsp[(1) - (2)].constant);
     5050                }
    50425051    break;
    50435052
     
    50455054
    50465055/* Line 1806 of yacc.c  */
    5047 #line 341 "parser.yy"
     5056#line 351 "parser.yy"
    50485057    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    50495058    break;
     
    50525061
    50535062/* Line 1806 of yacc.c  */
    5054 #line 343 "parser.yy"
     5063#line 353 "parser.yy"
    50555064    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    50565065    break;
     
    50595068
    50605069/* Line 1806 of yacc.c  */
    5061 #line 345 "parser.yy"
     5070#line 355 "parser.yy"
    50625071    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    50635072    break;
     
    50665075
    50675076/* Line 1806 of yacc.c  */
    5068 #line 347 "parser.yy"
     5077#line 357 "parser.yy"
    50695078    { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); }
    50705079    break;
     
    50735082
    50745083/* Line 1806 of yacc.c  */
    5075 #line 357 "parser.yy"
     5084#line 367 "parser.yy"
    50765085    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    50775086    break;
     
    50805089
    50815090/* Line 1806 of yacc.c  */
    5082 #line 359 "parser.yy"
     5091#line 369 "parser.yy"
    50835092    { (yyval.en) = new CompositeExprNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
    50845093    break;
     
    50875096
    50885097/* Line 1806 of yacc.c  */
    5089 #line 363 "parser.yy"
     5098#line 373 "parser.yy"
    50905099    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    50915100    break;
     
    50945103
    50955104/* Line 1806 of yacc.c  */
    5096 #line 366 "parser.yy"
     5105#line 376 "parser.yy"
    50975106    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    50985107    break;
     
    51015110
    51025111/* Line 1806 of yacc.c  */
    5103 #line 369 "parser.yy"
     5112#line 379 "parser.yy"
    51045113    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    51055114    break;
     
    51085117
    51095118/* Line 1806 of yacc.c  */
    5110 #line 371 "parser.yy"
     5119#line 381 "parser.yy"
    51115120    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    51125121    break;
     
    51155124
    51165125/* Line 1806 of yacc.c  */
    5117 #line 373 "parser.yy"
     5126#line 383 "parser.yy"
    51185127    { (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); }
    51195128    break;
     
    51225131
    51235132/* Line 1806 of yacc.c  */
    5124 #line 375 "parser.yy"
     5133#line 385 "parser.yy"
    51255134    {
    51265135                        Token fn;
     
    51335142
    51345143/* Line 1806 of yacc.c  */
    5135 #line 385 "parser.yy"
     5144#line 395 "parser.yy"
    51365145    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    51375146    break;
     
    51405149
    51415150/* Line 1806 of yacc.c  */
    5142 #line 390 "parser.yy"
     5151#line 400 "parser.yy"
    51435152    { (yyval.en) = 0; }
    51445153    break;
     
    51475156
    51485157/* Line 1806 of yacc.c  */
    5149 #line 393 "parser.yy"
     5158#line 403 "parser.yy"
    51505159    { (yyval.en) = (yyvsp[(3) - (3)].en)->set_argName( (yyvsp[(1) - (3)].tok) ); }
    51515160    break;
     
    51545163
    51555164/* Line 1806 of yacc.c  */
    5156 #line 398 "parser.yy"
     5165#line 408 "parser.yy"
    51575166    { (yyval.en) = (yyvsp[(7) - (7)].en)->set_argName( (yyvsp[(3) - (7)].en) ); }
    51585167    break;
     
    51615170
    51625171/* Line 1806 of yacc.c  */
    5163 #line 400 "parser.yy"
     5172#line 410 "parser.yy"
    51645173    { (yyval.en) = (yyvsp[(9) - (9)].en)->set_argName( new CompositeExprNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( (yyvsp[(5) - (9)].en) ) ) ) ); }
    51655174    break;
     
    51685177
    51695178/* Line 1806 of yacc.c  */
    5170 #line 405 "parser.yy"
     5179#line 415 "parser.yy"
    51715180    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    51725181    break;
     
    51755184
    51765185/* Line 1806 of yacc.c  */
    5177 #line 410 "parser.yy"
     5186#line 420 "parser.yy"
    51785187    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    51795188    break;
     
    51825191
    51835192/* Line 1806 of yacc.c  */
    5184 #line 414 "parser.yy"
     5193#line 424 "parser.yy"
    51855194    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    51865195    break;
     
    51895198
    51905199/* Line 1806 of yacc.c  */
    5191 #line 416 "parser.yy"
     5200#line 426 "parser.yy"
    51925201    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    51935202    break;
     
    51965205
    51975206/* Line 1806 of yacc.c  */
    5198 #line 418 "parser.yy"
     5207#line 428 "parser.yy"
    51995208    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    52005209    break;
     
    52035212
    52045213/* Line 1806 of yacc.c  */
    5205 #line 420 "parser.yy"
     5214#line 430 "parser.yy"
    52065215    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    52075216    break;
     
    52105219
    52115220/* Line 1806 of yacc.c  */
    5212 #line 428 "parser.yy"
     5221#line 438 "parser.yy"
    52135222    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
    52145223    break;
     
    52175226
    52185227/* Line 1806 of yacc.c  */
    5219 #line 430 "parser.yy"
     5228#line 440 "parser.yy"
    52205229    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
    52215230    break;
     
    52245233
    52255234/* Line 1806 of yacc.c  */
    5226 #line 432 "parser.yy"
     5235#line 442 "parser.yy"
    52275236    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    52285237    break;
     
    52315240
    52325241/* Line 1806 of yacc.c  */
    5233 #line 437 "parser.yy"
     5242#line 447 "parser.yy"
    52345243    {
    52355244                        switch ( (yyvsp[(1) - (2)].op) ) {
     
    52495258
    52505259/* Line 1806 of yacc.c  */
    5251 #line 450 "parser.yy"
     5260#line 460 "parser.yy"
    52525261    { (yyval.en) = new CompositeExprNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    52535262    break;
     
    52565265
    52575266/* Line 1806 of yacc.c  */
    5258 #line 452 "parser.yy"
     5267#line 462 "parser.yy"
    52595268    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    52605269    break;
     
    52635272
    52645273/* Line 1806 of yacc.c  */
    5265 #line 454 "parser.yy"
     5274#line 464 "parser.yy"
    52665275    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    52675276    break;
     
    52705279
    52715280/* Line 1806 of yacc.c  */
    5272 #line 456 "parser.yy"
     5281#line 466 "parser.yy"
    52735282    { (yyval.en) = new CompositeExprNode( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
    52745283    break;
     
    52775286
    52785287/* Line 1806 of yacc.c  */
    5279 #line 458 "parser.yy"
     5288#line 468 "parser.yy"
    52805289    { (yyval.en) = new CompositeExprNode( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    52815290    break;
     
    52845293
    52855294/* Line 1806 of yacc.c  */
    5286 #line 460 "parser.yy"
     5295#line 470 "parser.yy"
    52875296    { (yyval.en) = new CompositeExprNode( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
    52885297    break;
     
    52915300
    52925301/* Line 1806 of yacc.c  */
    5293 #line 462 "parser.yy"
     5302#line 472 "parser.yy"
    52945303    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ) ); }
    52955304    break;
     
    52985307
    52995308/* Line 1806 of yacc.c  */
    5300 #line 464 "parser.yy"
     5309#line 474 "parser.yy"
    53015310    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    53025311    break;
     
    53055314
    53065315/* Line 1806 of yacc.c  */
    5307 #line 466 "parser.yy"
     5316#line 476 "parser.yy"
    53085317    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    53095318    break;
     
    53125321
    53135322/* Line 1806 of yacc.c  */
    5314 #line 468 "parser.yy"
     5323#line 478 "parser.yy"
    53155324    { (yyval.en) = new CompositeExprNode( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
    53165325    break;
     
    53195328
    53205329/* Line 1806 of yacc.c  */
    5321 #line 470 "parser.yy"
     5330#line 480 "parser.yy"
    53225331    { (yyval.en) = new CompositeExprNode( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    53235332    break;
     
    53265335
    53275336/* Line 1806 of yacc.c  */
    5328 #line 476 "parser.yy"
     5337#line 486 "parser.yy"
    53295338    { (yyval.op) = OperKinds::PointTo; }
    53305339    break;
     
    53335342
    53345343/* Line 1806 of yacc.c  */
    5335 #line 477 "parser.yy"
     5344#line 487 "parser.yy"
    53365345    { (yyval.op) = OperKinds::AddressOf; }
    53375346    break;
     
    53405349
    53415350/* Line 1806 of yacc.c  */
    5342 #line 483 "parser.yy"
     5351#line 493 "parser.yy"
    53435352    { (yyval.op) = OperKinds::UnPlus; }
    53445353    break;
     
    53475356
    53485357/* Line 1806 of yacc.c  */
    5349 #line 484 "parser.yy"
     5358#line 494 "parser.yy"
    53505359    { (yyval.op) = OperKinds::UnMinus; }
    53515360    break;
     
    53545363
    53555364/* Line 1806 of yacc.c  */
    5356 #line 485 "parser.yy"
     5365#line 495 "parser.yy"
    53575366    { (yyval.op) = OperKinds::Neg; }
    53585367    break;
     
    53615370
    53625371/* Line 1806 of yacc.c  */
    5363 #line 486 "parser.yy"
     5372#line 496 "parser.yy"
    53645373    { (yyval.op) = OperKinds::BitNeg; }
    53655374    break;
     
    53685377
    53695378/* Line 1806 of yacc.c  */
    5370 #line 492 "parser.yy"
     5379#line 502 "parser.yy"
    53715380    { (yyval.en) = new CompositeExprNode( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    53725381    break;
     
    53755384
    53765385/* Line 1806 of yacc.c  */
    5377 #line 494 "parser.yy"
     5386#line 504 "parser.yy"
    53785387    { (yyval.en) = new CompositeExprNode( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    53795388    break;
     
    53825391
    53835392/* Line 1806 of yacc.c  */
    5384 #line 500 "parser.yy"
     5393#line 510 "parser.yy"
    53855394    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53865395    break;
     
    53895398
    53905399/* Line 1806 of yacc.c  */
    5391 #line 502 "parser.yy"
     5400#line 512 "parser.yy"
    53925401    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53935402    break;
     
    53965405
    53975406/* Line 1806 of yacc.c  */
    5398 #line 504 "parser.yy"
     5407#line 514 "parser.yy"
    53995408    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54005409    break;
     
    54035412
    54045413/* Line 1806 of yacc.c  */
    5405 #line 510 "parser.yy"
     5414#line 520 "parser.yy"
    54065415    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54075416    break;
     
    54105419
    54115420/* Line 1806 of yacc.c  */
    5412 #line 512 "parser.yy"
     5421#line 522 "parser.yy"
    54135422    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54145423    break;
     
    54175426
    54185427/* Line 1806 of yacc.c  */
    5419 #line 518 "parser.yy"
     5428#line 528 "parser.yy"
    54205429    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54215430    break;
     
    54245433
    54255434/* Line 1806 of yacc.c  */
    5426 #line 520 "parser.yy"
     5435#line 530 "parser.yy"
    54275436    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54285437    break;
     
    54315440
    54325441/* Line 1806 of yacc.c  */
    5433 #line 526 "parser.yy"
     5442#line 536 "parser.yy"
    54345443    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54355444    break;
     
    54385447
    54395448/* Line 1806 of yacc.c  */
    5440 #line 528 "parser.yy"
     5449#line 538 "parser.yy"
    54415450    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54425451    break;
     
    54455454
    54465455/* Line 1806 of yacc.c  */
    5447 #line 530 "parser.yy"
     5456#line 540 "parser.yy"
    54485457    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54495458    break;
     
    54525461
    54535462/* Line 1806 of yacc.c  */
    5454 #line 532 "parser.yy"
     5463#line 542 "parser.yy"
    54555464    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54565465    break;
     
    54595468
    54605469/* Line 1806 of yacc.c  */
    5461 #line 538 "parser.yy"
     5470#line 548 "parser.yy"
    54625471    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54635472    break;
     
    54665475
    54675476/* Line 1806 of yacc.c  */
    5468 #line 540 "parser.yy"
     5477#line 550 "parser.yy"
    54695478    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54705479    break;
     
    54735482
    54745483/* Line 1806 of yacc.c  */
    5475 #line 546 "parser.yy"
     5484#line 556 "parser.yy"
    54765485    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54775486    break;
     
    54805489
    54815490/* Line 1806 of yacc.c  */
    5482 #line 552 "parser.yy"
     5491#line 562 "parser.yy"
    54835492    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54845493    break;
     
    54875496
    54885497/* Line 1806 of yacc.c  */
    5489 #line 558 "parser.yy"
     5498#line 568 "parser.yy"
    54905499    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54915500    break;
     
    54945503
    54955504/* Line 1806 of yacc.c  */
    5496 #line 564 "parser.yy"
     5505#line 574 "parser.yy"
    54975506    { (yyval.en) = new CompositeExprNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    54985507    break;
     
    55015510
    55025511/* Line 1806 of yacc.c  */
    5503 #line 570 "parser.yy"
     5512#line 580 "parser.yy"
    55045513    { (yyval.en) = new CompositeExprNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    55055514    break;
     
    55085517
    55095518/* Line 1806 of yacc.c  */
    5510 #line 576 "parser.yy"
     5519#line 586 "parser.yy"
    55115520    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    55125521    break;
     
    55155524
    55165525/* Line 1806 of yacc.c  */
    5517 #line 579 "parser.yy"
     5526#line 589 "parser.yy"
    55185527    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    55195528    break;
     
    55225531
    55235532/* Line 1806 of yacc.c  */
    5524 #line 581 "parser.yy"
     5533#line 591 "parser.yy"
    55255534    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    55265535    break;
     
    55295538
    55305539/* Line 1806 of yacc.c  */
    5531 #line 592 "parser.yy"
     5540#line 602 "parser.yy"
    55325541    { (yyval.en) = new CompositeExprNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    55335542    break;
     
    55365545
    55375546/* Line 1806 of yacc.c  */
    5538 #line 594 "parser.yy"
     5547#line 604 "parser.yy"
    55395548    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
    55405549    break;
     
    55435552
    55445553/* Line 1806 of yacc.c  */
    5545 #line 599 "parser.yy"
     5554#line 609 "parser.yy"
    55465555    { (yyval.en) = new NullExprNode; }
    55475556    break;
     
    55505559
    55515560/* Line 1806 of yacc.c  */
    5552 #line 604 "parser.yy"
     5561#line 614 "parser.yy"
    55535562    { (yyval.op) = OperKinds::Assign; }
    55545563    break;
     
    55575566
    55585567/* Line 1806 of yacc.c  */
    5559 #line 605 "parser.yy"
     5568#line 615 "parser.yy"
    55605569    { (yyval.op) = OperKinds::MulAssn; }
    55615570    break;
     
    55645573
    55655574/* Line 1806 of yacc.c  */
    5566 #line 606 "parser.yy"
     5575#line 616 "parser.yy"
    55675576    { (yyval.op) = OperKinds::DivAssn; }
    55685577    break;
     
    55715580
    55725581/* Line 1806 of yacc.c  */
    5573 #line 607 "parser.yy"
     5582#line 617 "parser.yy"
    55745583    { (yyval.op) = OperKinds::ModAssn; }
    55755584    break;
     
    55785587
    55795588/* Line 1806 of yacc.c  */
    5580 #line 608 "parser.yy"
     5589#line 618 "parser.yy"
    55815590    { (yyval.op) = OperKinds::PlusAssn; }
    55825591    break;
     
    55855594
    55865595/* Line 1806 of yacc.c  */
    5587 #line 609 "parser.yy"
     5596#line 619 "parser.yy"
    55885597    { (yyval.op) = OperKinds::MinusAssn; }
    55895598    break;
     
    55925601
    55935602/* Line 1806 of yacc.c  */
    5594 #line 610 "parser.yy"
     5603#line 620 "parser.yy"
    55955604    { (yyval.op) = OperKinds::LSAssn; }
    55965605    break;
     
    55995608
    56005609/* Line 1806 of yacc.c  */
    5601 #line 611 "parser.yy"
     5610#line 621 "parser.yy"
    56025611    { (yyval.op) = OperKinds::RSAssn; }
    56035612    break;
     
    56065615
    56075616/* Line 1806 of yacc.c  */
    5608 #line 612 "parser.yy"
     5617#line 622 "parser.yy"
    56095618    { (yyval.op) = OperKinds::AndAssn; }
    56105619    break;
     
    56135622
    56145623/* Line 1806 of yacc.c  */
    5615 #line 613 "parser.yy"
     5624#line 623 "parser.yy"
    56165625    { (yyval.op) = OperKinds::ERAssn; }
    56175626    break;
     
    56205629
    56215630/* Line 1806 of yacc.c  */
    5622 #line 614 "parser.yy"
     5631#line 624 "parser.yy"
    56235632    { (yyval.op) = OperKinds::OrAssn; }
    56245633    break;
     
    56275636
    56285637/* Line 1806 of yacc.c  */
    5629 #line 621 "parser.yy"
     5638#line 631 "parser.yy"
    56305639    { (yyval.en) = new CompositeExprNode( build_tuple() ); }
    56315640    break;
     
    56345643
    56355644/* Line 1806 of yacc.c  */
    5636 #line 623 "parser.yy"
     5645#line 633 "parser.yy"
    56375646    { (yyval.en) = new CompositeExprNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
    56385647    break;
     
    56415650
    56425651/* Line 1806 of yacc.c  */
    5643 #line 625 "parser.yy"
     5652#line 635 "parser.yy"
    56445653    { (yyval.en) = new CompositeExprNode( build_tuple( (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ) ); }
    56455654    break;
     
    56485657
    56495658/* Line 1806 of yacc.c  */
    5650 #line 627 "parser.yy"
     5659#line 637 "parser.yy"
    56515660    { (yyval.en) = new CompositeExprNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( (yyvsp[(5) - (7)].en) ) ) ); }
    56525661    break;
     
    56555664
    56565665/* Line 1806 of yacc.c  */
    5657 #line 633 "parser.yy"
     5666#line 643 "parser.yy"
    56585667    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    56595668    break;
     
    56625671
    56635672/* Line 1806 of yacc.c  */
    5664 #line 639 "parser.yy"
     5673#line 649 "parser.yy"
    56655674    { (yyval.en) = new CompositeExprNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56665675    break;
     
    56695678
    56705679/* Line 1806 of yacc.c  */
    5671 #line 644 "parser.yy"
     5680#line 654 "parser.yy"
    56725681    { (yyval.en) = 0; }
    56735682    break;
     
    56765685
    56775686/* Line 1806 of yacc.c  */
    5678 #line 653 "parser.yy"
     5687#line 663 "parser.yy"
    56795688    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    56805689    break;
     
    56835692
    56845693/* Line 1806 of yacc.c  */
    5685 #line 660 "parser.yy"
     5694#line 670 "parser.yy"
    56865695    {
    56875696                        Token fn;
     
    56945703
    56955704/* Line 1806 of yacc.c  */
    5696 #line 670 "parser.yy"
     5705#line 680 "parser.yy"
    56975706    {
    56985707                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
     
    57035712
    57045713/* Line 1806 of yacc.c  */
    5705 #line 677 "parser.yy"
     5714#line 687 "parser.yy"
    57065715    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
    57075716    break;
     
    57105719
    57115720/* Line 1806 of yacc.c  */
    5712 #line 684 "parser.yy"
     5721#line 694 "parser.yy"
    57135722    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
    57145723    break;
     
    57175726
    57185727/* Line 1806 of yacc.c  */
    5719 #line 690 "parser.yy"
     5728#line 700 "parser.yy"
    57205729    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    57215730    break;
     
    57245733
    57255734/* Line 1806 of yacc.c  */
    5726 #line 695 "parser.yy"
     5735#line 705 "parser.yy"
    57275736    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57285737    break;
     
    57315740
    57325741/* Line 1806 of yacc.c  */
    5733 #line 697 "parser.yy"
     5742#line 707 "parser.yy"
    57345743    {   // mark all fields in list
    57355744                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    57425751
    57435752/* Line 1806 of yacc.c  */
    5744 #line 703 "parser.yy"
     5753#line 713 "parser.yy"
    57455754    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57465755    break;
     
    57495758
    57505759/* Line 1806 of yacc.c  */
    5751 #line 710 "parser.yy"
     5760#line 720 "parser.yy"
    57525761    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    57535762    break;
     
    57565765
    57575766/* Line 1806 of yacc.c  */
    5758 #line 715 "parser.yy"
     5767#line 725 "parser.yy"
    57595768    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
    57605769    break;
     
    57635772
    57645773/* Line 1806 of yacc.c  */
    5765 #line 721 "parser.yy"
     5774#line 731 "parser.yy"
    57665775    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    57675776    break;
     
    57705779
    57715780/* Line 1806 of yacc.c  */
    5772 #line 723 "parser.yy"
     5781#line 733 "parser.yy"
    57735782    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
    57745783    break;
     
    57775786
    57785787/* Line 1806 of yacc.c  */
    5779 #line 725 "parser.yy"
     5788#line 735 "parser.yy"
    57805789    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    57815790    break;
     
    57845793
    57855794/* Line 1806 of yacc.c  */
    5786 #line 727 "parser.yy"
     5795#line 737 "parser.yy"
    57875796    {
    57885797                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    57995808
    58005809/* Line 1806 of yacc.c  */
    5801 #line 737 "parser.yy"
     5810#line 747 "parser.yy"
    58025811    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    58035812    break;
     
    58065815
    58075816/* Line 1806 of yacc.c  */
    5808 #line 739 "parser.yy"
     5817#line 749 "parser.yy"
    58095818    {
    58105819                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    58165825
    58175826/* Line 1806 of yacc.c  */
    5818 #line 749 "parser.yy"
     5827#line 759 "parser.yy"
    58195828    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    58205829    break;
     
    58235832
    58245833/* Line 1806 of yacc.c  */
    5825 #line 751 "parser.yy"
     5834#line 761 "parser.yy"
    58265835    { (yyval.en) = new CompositeExprNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    58275836    break;
     
    58305839
    58315840/* Line 1806 of yacc.c  */
    5832 #line 756 "parser.yy"
     5841#line 766 "parser.yy"
    58335842    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
    58345843    break;
     
    58375846
    58385847/* Line 1806 of yacc.c  */
    5839 #line 758 "parser.yy"
     5848#line 768 "parser.yy"
    58405849    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
    58415850    break;
     
    58445853
    58455854/* Line 1806 of yacc.c  */
    5846 #line 762 "parser.yy"
     5855#line 772 "parser.yy"
    58475856    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    58485857    break;
     
    58515860
    58525861/* Line 1806 of yacc.c  */
    5853 #line 763 "parser.yy"
     5862#line 773 "parser.yy"
    58545863    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
    58555864    break;
     
    58585867
    58595868/* Line 1806 of yacc.c  */
    5860 #line 769 "parser.yy"
     5869#line 779 "parser.yy"
    58615870    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
    58625871    break;
     
    58655874
    58665875/* Line 1806 of yacc.c  */
    5867 #line 773 "parser.yy"
     5876#line 783 "parser.yy"
    58685877    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58695878    break;
     
    58725881
    58735882/* Line 1806 of yacc.c  */
    5874 #line 778 "parser.yy"
     5883#line 788 "parser.yy"
    58755884    { (yyval.sn) = 0; }
    58765885    break;
     
    58795888
    58805889/* Line 1806 of yacc.c  */
    5881 #line 784 "parser.yy"
     5890#line 794 "parser.yy"
    58825891    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58835892    break;
     
    58865895
    58875896/* Line 1806 of yacc.c  */
    5888 #line 786 "parser.yy"
     5897#line 796 "parser.yy"
    58895898    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    58905899    break;
     
    58935902
    58945903/* Line 1806 of yacc.c  */
    5895 #line 791 "parser.yy"
     5904#line 801 "parser.yy"
    58965905    { (yyval.sn) = 0; }
    58975906    break;
     
    59005909
    59015910/* Line 1806 of yacc.c  */
    5902 #line 797 "parser.yy"
     5911#line 807 "parser.yy"
    59035912    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    59045913    break;
     
    59075916
    59085917/* Line 1806 of yacc.c  */
    5909 #line 799 "parser.yy"
     5918#line 809 "parser.yy"
    59105919    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    59115920    break;
     
    59145923
    59155924/* Line 1806 of yacc.c  */
    5916 #line 801 "parser.yy"
     5925#line 811 "parser.yy"
    59175926    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    59185927    break;
     
    59215930
    59225931/* Line 1806 of yacc.c  */
    5923 #line 803 "parser.yy"
     5932#line 813 "parser.yy"
    59245933    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
    59255934    break;
     
    59285937
    59295938/* Line 1806 of yacc.c  */
    5930 #line 808 "parser.yy"
     5939#line 818 "parser.yy"
    59315940    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    59325941    break;
     
    59355944
    59365945/* Line 1806 of yacc.c  */
    5937 #line 814 "parser.yy"
     5946#line 824 "parser.yy"
    59385947    { (yyval.sn) = 0; }
    59395948    break;
     
    59425951
    59435952/* Line 1806 of yacc.c  */
    5944 #line 816 "parser.yy"
     5953#line 826 "parser.yy"
    59455954    { (yyval.sn) = 0; }
    59465955    break;
     
    59495958
    59505959/* Line 1806 of yacc.c  */
    5951 #line 821 "parser.yy"
     5960#line 831 "parser.yy"
    59525961    { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    59535962    break;
     
    59565965
    59575966/* Line 1806 of yacc.c  */
    5958 #line 823 "parser.yy"
     5967#line 833 "parser.yy"
    59595968    { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
    59605969    break;
     
    59635972
    59645973/* Line 1806 of yacc.c  */
    5965 #line 825 "parser.yy"
     5974#line 835 "parser.yy"
    59665975    { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
    59675976    break;
     
    59705979
    59715980/* Line 1806 of yacc.c  */
    5972 #line 830 "parser.yy"
     5981#line 840 "parser.yy"
    59735982    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    59745983    break;
     
    59775986
    59785987/* Line 1806 of yacc.c  */
    5979 #line 832 "parser.yy"
     5988#line 842 "parser.yy"
    59805989    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    59815990    break;
     
    59845993
    59855994/* Line 1806 of yacc.c  */
    5986 #line 837 "parser.yy"
     5995#line 847 "parser.yy"
    59875996    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
    59885997    break;
     
    59916000
    59926001/* Line 1806 of yacc.c  */
    5993 #line 841 "parser.yy"
     6002#line 851 "parser.yy"
    59946003    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
    59956004    break;
     
    59986007
    59996008/* Line 1806 of yacc.c  */
    6000 #line 844 "parser.yy"
     6009#line 854 "parser.yy"
    60016010    { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
    60026011    break;
     
    60056014
    60066015/* Line 1806 of yacc.c  */
    6007 #line 848 "parser.yy"
     6016#line 858 "parser.yy"
    60086017    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
    60096018    break;
     
    60126021
    60136022/* Line 1806 of yacc.c  */
    6014 #line 851 "parser.yy"
     6023#line 861 "parser.yy"
    60156024    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    60166025    break;
     
    60196028
    60206029/* Line 1806 of yacc.c  */
    6021 #line 855 "parser.yy"
     6030#line 865 "parser.yy"
    60226031    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
    60236032    break;
     
    60266035
    60276036/* Line 1806 of yacc.c  */
    6028 #line 857 "parser.yy"
     6037#line 867 "parser.yy"
    60296038    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
    60306039    break;
     
    60336042
    60346043/* Line 1806 of yacc.c  */
    6035 #line 859 "parser.yy"
     6044#line 869 "parser.yy"
    60366045    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    60376046    break;
     
    60406049
    60416050/* Line 1806 of yacc.c  */
    6042 #line 863 "parser.yy"
     6051#line 873 "parser.yy"
    60436052    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    60446053    break;
     
    60476056
    60486057/* Line 1806 of yacc.c  */
    6049 #line 865 "parser.yy"
     6058#line 875 "parser.yy"
    60506059    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
    60516060    break;
     
    60546063
    60556064/* Line 1806 of yacc.c  */
    6056 #line 872 "parser.yy"
     6065#line 882 "parser.yy"
    60576066    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    60586067    break;
     
    60616070
    60626071/* Line 1806 of yacc.c  */
    6063 #line 874 "parser.yy"
     6072#line 884 "parser.yy"
    60646073    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    60656074    break;
     
    60686077
    60696078/* Line 1806 of yacc.c  */
    6070 #line 876 "parser.yy"
     6079#line 886 "parser.yy"
    60716080    {
    60726081                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
     
    60786087
    60796088/* Line 1806 of yacc.c  */
    6080 #line 887 "parser.yy"
     6089#line 897 "parser.yy"
    60816090    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    60826091    break;
     
    60856094
    60866095/* Line 1806 of yacc.c  */
    6087 #line 889 "parser.yy"
     6096#line 899 "parser.yy"
    60886097    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    60896098    break;
     
    60926101
    60936102/* Line 1806 of yacc.c  */
    6094 #line 891 "parser.yy"
     6103#line 901 "parser.yy"
    60956104    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    60966105    break;
     
    60996108
    61006109/* Line 1806 of yacc.c  */
    6101 #line 893 "parser.yy"
     6110#line 903 "parser.yy"
    61026111    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    61036112    break;
     
    61066115
    61076116/* Line 1806 of yacc.c  */
    6108 #line 898 "parser.yy"
     6117#line 908 "parser.yy"
    61096118    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    61106119    break;
     
    61136122
    61146123/* Line 1806 of yacc.c  */
    6115 #line 900 "parser.yy"
     6124#line 910 "parser.yy"
    61166125    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    61176126    break;
     
    61206129
    61216130/* Line 1806 of yacc.c  */
    6122 #line 902 "parser.yy"
     6131#line 912 "parser.yy"
    61236132    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    61246133    break;
     
    61276136
    61286137/* Line 1806 of yacc.c  */
    6129 #line 904 "parser.yy"
     6138#line 914 "parser.yy"
    61306139    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    61316140    break;
     
    61346143
    61356144/* Line 1806 of yacc.c  */
    6136 #line 909 "parser.yy"
     6145#line 919 "parser.yy"
    61376146    {
    61386147                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
     
    61446153
    61456154/* Line 1806 of yacc.c  */
    6146 #line 923 "parser.yy"
     6155#line 933 "parser.yy"
    61476156    {
    61486157                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61546163
    61556164/* Line 1806 of yacc.c  */
    6156 #line 928 "parser.yy"
     6165#line 938 "parser.yy"
    61576166    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    61586167    break;
     
    61616170
    61626171/* Line 1806 of yacc.c  */
    6163 #line 930 "parser.yy"
     6172#line 940 "parser.yy"
    61646173    {
    61656174                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61716180
    61726181/* Line 1806 of yacc.c  */
    6173 #line 939 "parser.yy"
     6182#line 949 "parser.yy"
    61746183    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
    61756184    break;
     
    61786187
    61796188/* Line 1806 of yacc.c  */
    6180 #line 941 "parser.yy"
     6189#line 951 "parser.yy"
    61816190    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    61826191    break;
     
    61856194
    61866195/* Line 1806 of yacc.c  */
    6187 #line 943 "parser.yy"
     6196#line 953 "parser.yy"
    61886197    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    61896198    break;
     
    61926201
    61936202/* Line 1806 of yacc.c  */
    6194 #line 945 "parser.yy"
     6203#line 955 "parser.yy"
    61956204    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].constant) ); }
    61966205    break;
     
    61996208
    62006209/* Line 1806 of yacc.c  */
    6201 #line 947 "parser.yy"
     6210#line 957 "parser.yy"
    62026211    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].constant), (yyvsp[(12) - (14)].label) ); }
    62036212    break;
     
    62066215
    62076216/* Line 1806 of yacc.c  */
    6208 #line 952 "parser.yy"
     6217#line 962 "parser.yy"
    62096218    { (yyval.flag) = false; }
    62106219    break;
     
    62136222
    62146223/* Line 1806 of yacc.c  */
    6215 #line 954 "parser.yy"
     6224#line 964 "parser.yy"
    62166225    { (yyval.flag) = true; }
    62176226    break;
     
    62206229
    62216230/* Line 1806 of yacc.c  */
    6222 #line 959 "parser.yy"
     6231#line 969 "parser.yy"
    62236232    { (yyval.en) = 0; }
    62246233    break;
     
    62276236
    62286237/* Line 1806 of yacc.c  */
    6229 #line 966 "parser.yy"
     6238#line 976 "parser.yy"
    62306239    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    62316240    break;
     
    62346243
    62356244/* Line 1806 of yacc.c  */
    6236 #line 971 "parser.yy"
     6245#line 981 "parser.yy"
    62376246    { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); }
    62386247    break;
     
    62416250
    62426251/* Line 1806 of yacc.c  */
    6243 #line 973 "parser.yy"
     6252#line 983 "parser.yy"
    62446253    { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); }
    62456254    break;
     
    62486257
    62496258/* Line 1806 of yacc.c  */
    6250 #line 978 "parser.yy"
     6259#line 988 "parser.yy"
    62516260    { (yyval.constant) = 0; }
    62526261    break;
     
    62556264
    62566265/* Line 1806 of yacc.c  */
    6257 #line 980 "parser.yy"
     6266#line 990 "parser.yy"
    62586267    { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
    62596268    break;
     
    62626271
    62636272/* Line 1806 of yacc.c  */
    6264 #line 982 "parser.yy"
     6273#line 992 "parser.yy"
    62656274    { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); }
    62666275    break;
     
    62696278
    62706279/* Line 1806 of yacc.c  */
    6271 #line 987 "parser.yy"
     6280#line 997 "parser.yy"
    62726281    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    62736282    break;
     
    62766285
    62776286/* Line 1806 of yacc.c  */
    6278 #line 989 "parser.yy"
     6287#line 999 "parser.yy"
    62796288    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    62806289    break;
     
    62836292
    62846293/* Line 1806 of yacc.c  */
    6285 #line 996 "parser.yy"
     6294#line 1006 "parser.yy"
    62866295    { (yyval.decl) = 0; }
    62876296    break;
     
    62906299
    62916300/* Line 1806 of yacc.c  */
    6292 #line 1003 "parser.yy"
     6301#line 1013 "parser.yy"
    62936302    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    62946303    break;
     
    62976306
    62986307/* Line 1806 of yacc.c  */
    6299 #line 1008 "parser.yy"
     6308#line 1018 "parser.yy"
    63006309    { (yyval.decl) = 0; }
    63016310    break;
     
    63046313
    63056314/* Line 1806 of yacc.c  */
    6306 #line 1015 "parser.yy"
     6315#line 1025 "parser.yy"
    63076316    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    63086317    break;
     
    63116320
    63126321/* Line 1806 of yacc.c  */
    6313 #line 1029 "parser.yy"
     6322#line 1039 "parser.yy"
    63146323    {}
    63156324    break;
     
    63186327
    63196328/* Line 1806 of yacc.c  */
    6320 #line 1030 "parser.yy"
     6329#line 1040 "parser.yy"
    63216330    {}
    63226331    break;
     
    63256334
    63266335/* Line 1806 of yacc.c  */
    6327 #line 1059 "parser.yy"
     6336#line 1069 "parser.yy"
    63286337    {
    63296338                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63356344
    63366345/* Line 1806 of yacc.c  */
    6337 #line 1066 "parser.yy"
     6346#line 1076 "parser.yy"
    63386347    {
    63396348                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63456354
    63466355/* Line 1806 of yacc.c  */
    6347 #line 1071 "parser.yy"
     6356#line 1081 "parser.yy"
    63486357    {
    63496358                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    63556364
    63566365/* Line 1806 of yacc.c  */
    6357 #line 1081 "parser.yy"
     6366#line 1091 "parser.yy"
    63586367    {
    63596368                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63656374
    63666375/* Line 1806 of yacc.c  */
    6367 #line 1086 "parser.yy"
     6376#line 1096 "parser.yy"
    63686377    {
    63696378                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63756384
    63766385/* Line 1806 of yacc.c  */
    6377 #line 1091 "parser.yy"
     6386#line 1101 "parser.yy"
    63786387    {
    63796388                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    63856394
    63866395/* Line 1806 of yacc.c  */
    6387 #line 1099 "parser.yy"
     6396#line 1109 "parser.yy"
    63886397    {
    63896398                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63956404
    63966405/* Line 1806 of yacc.c  */
    6397 #line 1104 "parser.yy"
     6406#line 1114 "parser.yy"
    63986407    {
    63996408                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64056414
    64066415/* Line 1806 of yacc.c  */
    6407 #line 1109 "parser.yy"
     6416#line 1119 "parser.yy"
    64086417    {
    64096418                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64156424
    64166425/* Line 1806 of yacc.c  */
    6417 #line 1114 "parser.yy"
     6426#line 1124 "parser.yy"
    64186427    {
    64196428                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64256434
    64266435/* Line 1806 of yacc.c  */
    6427 #line 1119 "parser.yy"
     6436#line 1129 "parser.yy"
    64286437    {
    64296438                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    64356444
    64366445/* Line 1806 of yacc.c  */
    6437 #line 1127 "parser.yy"
     6446#line 1137 "parser.yy"
    64386447    {
    64396448                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    64446453
    64456454/* Line 1806 of yacc.c  */
    6446 #line 1150 "parser.yy"
     6455#line 1160 "parser.yy"
    64476456    {
    64486457                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64536462
    64546463/* Line 1806 of yacc.c  */
    6455 #line 1154 "parser.yy"
     6464#line 1164 "parser.yy"
    64566465    {
    64576466                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64626471
    64636472/* Line 1806 of yacc.c  */
    6464 #line 1161 "parser.yy"
     6473#line 1171 "parser.yy"
    64656474    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64666475    break;
     
    64696478
    64706479/* Line 1806 of yacc.c  */
    6471 #line 1165 "parser.yy"
     6480#line 1175 "parser.yy"
    64726481    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    64736482    break;
     
    64766485
    64776486/* Line 1806 of yacc.c  */
    6478 #line 1170 "parser.yy"
     6487#line 1180 "parser.yy"
    64796488    {
    64806489                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64866495
    64876496/* Line 1806 of yacc.c  */
    6488 #line 1175 "parser.yy"
     6497#line 1185 "parser.yy"
    64896498    {
    64906499                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64966505
    64976506/* Line 1806 of yacc.c  */
    6498 #line 1180 "parser.yy"
     6507#line 1190 "parser.yy"
    64996508    {
    65006509                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    65066515
    65076516/* Line 1806 of yacc.c  */
    6508 #line 1191 "parser.yy"
     6517#line 1201 "parser.yy"
    65096518    {
    65106519                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65166525
    65176526/* Line 1806 of yacc.c  */
    6518 #line 1196 "parser.yy"
     6527#line 1206 "parser.yy"
    65196528    {
    65206529                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65266535
    65276536/* Line 1806 of yacc.c  */
    6528 #line 1201 "parser.yy"
     6537#line 1211 "parser.yy"
    65296538    {
    65306539                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65366545
    65376546/* Line 1806 of yacc.c  */
    6538 #line 1206 "parser.yy"
     6547#line 1216 "parser.yy"
    65396548    {
    65406549                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65466555
    65476556/* Line 1806 of yacc.c  */
    6548 #line 1211 "parser.yy"
     6557#line 1221 "parser.yy"
    65496558    {
    65506559                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65566565
    65576566/* Line 1806 of yacc.c  */
    6558 #line 1220 "parser.yy"
     6567#line 1230 "parser.yy"
    65596568    {
    65606569                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    65666575
    65676576/* Line 1806 of yacc.c  */
    6568 #line 1225 "parser.yy"
     6577#line 1235 "parser.yy"
    65696578    {
    65706579                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    65766585
    65776586/* Line 1806 of yacc.c  */
    6578 #line 1242 "parser.yy"
     6587#line 1252 "parser.yy"
    65796588    {
    65806589                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65866595
    65876596/* Line 1806 of yacc.c  */
    6588 #line 1247 "parser.yy"
     6597#line 1257 "parser.yy"
    65896598    {
    65906599                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65966605
    65976606/* Line 1806 of yacc.c  */
    6598 #line 1269 "parser.yy"
     6607#line 1279 "parser.yy"
    65996608    { (yyval.decl) = 0; }
    66006609    break;
     
    66036612
    66046613/* Line 1806 of yacc.c  */
    6605 #line 1281 "parser.yy"
     6614#line 1291 "parser.yy"
    66066615    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66076616    break;
     
    66106619
    66116620/* Line 1806 of yacc.c  */
    6612 #line 1292 "parser.yy"
     6621#line 1302 "parser.yy"
    66136622    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    66146623    break;
     
    66176626
    66186627/* Line 1806 of yacc.c  */
    6619 #line 1294 "parser.yy"
     6628#line 1304 "parser.yy"
    66206629    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    66216630    break;
     
    66246633
    66256634/* Line 1806 of yacc.c  */
    6626 #line 1296 "parser.yy"
     6635#line 1306 "parser.yy"
    66276636    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    66286637    break;
     
    66316640
    66326641/* Line 1806 of yacc.c  */
    6633 #line 1298 "parser.yy"
     6642#line 1308 "parser.yy"
    66346643    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    66356644    break;
     
    66386647
    66396648/* Line 1806 of yacc.c  */
    6640 #line 1300 "parser.yy"
     6649#line 1310 "parser.yy"
    66416650    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    66426651    break;
     
    66456654
    66466655/* Line 1806 of yacc.c  */
    6647 #line 1302 "parser.yy"
     6656#line 1312 "parser.yy"
    66486657    {
    66496658                        typedefTable.enterScope();
     
    66546663
    66556664/* Line 1806 of yacc.c  */
    6656 #line 1306 "parser.yy"
     6665#line 1316 "parser.yy"
    66576666    {
    66586667                        typedefTable.leaveScope();
     
    66646673
    66656674/* Line 1806 of yacc.c  */
    6666 #line 1315 "parser.yy"
     6675#line 1325 "parser.yy"
    66676676    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66686677    break;
     
    66716680
    66726681/* Line 1806 of yacc.c  */
    6673 #line 1317 "parser.yy"
     6682#line 1327 "parser.yy"
    66746683    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    66756684    break;
     
    66786687
    66796688/* Line 1806 of yacc.c  */
    6680 #line 1328 "parser.yy"
     6689#line 1338 "parser.yy"
    66816690    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66826691    break;
     
    66856694
    66866695/* Line 1806 of yacc.c  */
    6687 #line 1337 "parser.yy"
     6696#line 1347 "parser.yy"
    66886697    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    66896698    break;
     
    66926701
    66936702/* Line 1806 of yacc.c  */
    6694 #line 1339 "parser.yy"
     6703#line 1349 "parser.yy"
    66956704    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    66966705    break;
     
    66996708
    67006709/* Line 1806 of yacc.c  */
    6701 #line 1341 "parser.yy"
     6710#line 1351 "parser.yy"
    67026711    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    67036712    break;
     
    67066715
    67076716/* Line 1806 of yacc.c  */
    6708 #line 1343 "parser.yy"
     6717#line 1353 "parser.yy"
    67096718    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    67106719    break;
     
    67136722
    67146723/* Line 1806 of yacc.c  */
    6715 #line 1345 "parser.yy"
     6724#line 1355 "parser.yy"
    67166725    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    67176726    break;
     
    67206729
    67216730/* Line 1806 of yacc.c  */
    6722 #line 1347 "parser.yy"
     6731#line 1357 "parser.yy"
    67236732    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    67246733    break;
     
    67276736
    67286737/* Line 1806 of yacc.c  */
    6729 #line 1349 "parser.yy"
     6738#line 1359 "parser.yy"
    67306739    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    67316740    break;
     
    67346743
    67356744/* Line 1806 of yacc.c  */
    6736 #line 1351 "parser.yy"
     6745#line 1361 "parser.yy"
    67376746    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    67386747    break;
     
    67416750
    67426751/* Line 1806 of yacc.c  */
    6743 #line 1356 "parser.yy"
     6752#line 1366 "parser.yy"
    67446753    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    67456754    break;
     
    67486757
    67496758/* Line 1806 of yacc.c  */
    6750 #line 1358 "parser.yy"
     6759#line 1368 "parser.yy"
    67516760    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    67526761    break;
     
    67556764
    67566765/* Line 1806 of yacc.c  */
    6757 #line 1360 "parser.yy"
     6766#line 1370 "parser.yy"
    67586767    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    67596768    break;
     
    67626771
    67636772/* Line 1806 of yacc.c  */
    6764 #line 1362 "parser.yy"
     6773#line 1372 "parser.yy"
    67656774    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    67666775    break;
     
    67696778
    67706779/* Line 1806 of yacc.c  */
    6771 #line 1364 "parser.yy"
     6780#line 1374 "parser.yy"
    67726781    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    67736782    break;
     
    67766785
    67776786/* Line 1806 of yacc.c  */
    6778 #line 1366 "parser.yy"
     6787#line 1376 "parser.yy"
    67796788    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    67806789    break;
     
    67836792
    67846793/* Line 1806 of yacc.c  */
    6785 #line 1368 "parser.yy"
     6794#line 1378 "parser.yy"
    67866795    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    67876796    break;
     
    67906799
    67916800/* Line 1806 of yacc.c  */
    6792 #line 1370 "parser.yy"
     6801#line 1380 "parser.yy"
    67936802    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    67946803    break;
     
    67976806
    67986807/* Line 1806 of yacc.c  */
    6799 #line 1372 "parser.yy"
     6808#line 1382 "parser.yy"
    68006809    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    68016810    break;
     
    68046813
    68056814/* Line 1806 of yacc.c  */
    6806 #line 1374 "parser.yy"
     6815#line 1384 "parser.yy"
    68076816    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    68086817    break;
     
    68116820
    68126821/* Line 1806 of yacc.c  */
    6813 #line 1376 "parser.yy"
     6822#line 1386 "parser.yy"
    68146823    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    68156824    break;
     
    68186827
    68196828/* Line 1806 of yacc.c  */
    6820 #line 1378 "parser.yy"
     6829#line 1388 "parser.yy"
    68216830    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    68226831    break;
     
    68256834
    68266835/* Line 1806 of yacc.c  */
    6827 #line 1380 "parser.yy"
     6836#line 1390 "parser.yy"
    68286837    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    68296838    break;
     
    68326841
    68336842/* Line 1806 of yacc.c  */
    6834 #line 1387 "parser.yy"
     6843#line 1397 "parser.yy"
    68356844    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68366845    break;
     
    68396848
    68406849/* Line 1806 of yacc.c  */
    6841 #line 1389 "parser.yy"
     6850#line 1399 "parser.yy"
    68426851    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68436852    break;
     
    68466855
    68476856/* Line 1806 of yacc.c  */
    6848 #line 1391 "parser.yy"
     6857#line 1401 "parser.yy"
    68496858    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68506859    break;
     
    68536862
    68546863/* Line 1806 of yacc.c  */
    6855 #line 1393 "parser.yy"
     6864#line 1403 "parser.yy"
    68566865    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    68576866    break;
     
    68606869
    68616870/* Line 1806 of yacc.c  */
    6862 #line 1399 "parser.yy"
     6871#line 1409 "parser.yy"
    68636872    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68646873    break;
     
    68676876
    68686877/* Line 1806 of yacc.c  */
    6869 #line 1406 "parser.yy"
     6878#line 1416 "parser.yy"
    68706879    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68716880    break;
     
    68746883
    68756884/* Line 1806 of yacc.c  */
    6876 #line 1408 "parser.yy"
     6885#line 1418 "parser.yy"
    68776886    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68786887    break;
     
    68816890
    68826891/* Line 1806 of yacc.c  */
    6883 #line 1410 "parser.yy"
     6892#line 1420 "parser.yy"
    68846893    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    68856894    break;
     
    68886897
    68896898/* Line 1806 of yacc.c  */
    6890 #line 1415 "parser.yy"
     6899#line 1425 "parser.yy"
    68916900    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    68926901    break;
     
    68956904
    68966905/* Line 1806 of yacc.c  */
    6897 #line 1417 "parser.yy"
     6906#line 1427 "parser.yy"
    68986907    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    68996908    break;
     
    69026911
    69036912/* Line 1806 of yacc.c  */
    6904 #line 1419 "parser.yy"
     6913#line 1429 "parser.yy"
    69056914    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    69066915    break;
     
    69096918
    69106919/* Line 1806 of yacc.c  */
    6911 #line 1421 "parser.yy"
     6920#line 1431 "parser.yy"
    69126921    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    69136922    break;
    69146923
    69156924  case 350:
    6916 
    6917 /* Line 1806 of yacc.c  */
    6918 #line 1427 "parser.yy"
    6919     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6920     break;
    6921 
    6922   case 351:
    6923 
    6924 /* Line 1806 of yacc.c  */
    6925 #line 1429 "parser.yy"
    6926     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6927     break;
    6928 
    6929   case 352:
    6930 
    6931 /* Line 1806 of yacc.c  */
    6932 #line 1431 "parser.yy"
    6933     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    6934     break;
    6935 
    6936   case 354:
    69376925
    69386926/* Line 1806 of yacc.c  */
     
    69416929    break;
    69426930
    6943   case 355:
     6931  case 351:
    69446932
    69456933/* Line 1806 of yacc.c  */
     
    69486936    break;
    69496937
     6938  case 352:
     6939
     6940/* Line 1806 of yacc.c  */
     6941#line 1441 "parser.yy"
     6942    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6943    break;
     6944
     6945  case 354:
     6946
     6947/* Line 1806 of yacc.c  */
     6948#line 1447 "parser.yy"
     6949    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6950    break;
     6951
     6952  case 355:
     6953
     6954/* Line 1806 of yacc.c  */
     6955#line 1449 "parser.yy"
     6956    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6957    break;
     6958
    69506959  case 357:
    69516960
    69526961/* Line 1806 of yacc.c  */
    6953 #line 1445 "parser.yy"
     6962#line 1455 "parser.yy"
    69546963    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69556964    break;
     
    69586967
    69596968/* Line 1806 of yacc.c  */
    6960 #line 1447 "parser.yy"
     6969#line 1457 "parser.yy"
    69616970    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69626971    break;
     
    69656974
    69666975/* Line 1806 of yacc.c  */
    6967 #line 1449 "parser.yy"
     6976#line 1459 "parser.yy"
    69686977    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69696978    break;
     
    69726981
    69736982/* Line 1806 of yacc.c  */
    6974 #line 1454 "parser.yy"
     6983#line 1464 "parser.yy"
    69756984    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    69766985    break;
     
    69796988
    69806989/* Line 1806 of yacc.c  */
    6981 #line 1456 "parser.yy"
     6990#line 1466 "parser.yy"
    69826991    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69836992    break;
     
    69866995
    69876996/* Line 1806 of yacc.c  */
    6988 #line 1458 "parser.yy"
     6997#line 1468 "parser.yy"
    69896998    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69906999    break;
     
    69937002
    69947003/* Line 1806 of yacc.c  */
    6995 #line 1468 "parser.yy"
     7004#line 1478 "parser.yy"
    69967005    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    69977006    break;
     
    70007009
    70017010/* Line 1806 of yacc.c  */
    7002 #line 1470 "parser.yy"
     7011#line 1480 "parser.yy"
    70037012    {
    70047013                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    70107019
    70117020/* Line 1806 of yacc.c  */
    7012 #line 1475 "parser.yy"
     7021#line 1485 "parser.yy"
    70137022    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    70147023    break;
     
    70177026
    70187027/* Line 1806 of yacc.c  */
    7019 #line 1477 "parser.yy"
     7028#line 1487 "parser.yy"
    70207029    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    70217030    break;
     
    70247033
    70257034/* Line 1806 of yacc.c  */
    7026 #line 1479 "parser.yy"
     7035#line 1489 "parser.yy"
    70277036    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    70287037    break;
     
    70317040
    70327041/* Line 1806 of yacc.c  */
    7033 #line 1481 "parser.yy"
     7042#line 1491 "parser.yy"
    70347043    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    70357044    break;
     
    70387047
    70397048/* Line 1806 of yacc.c  */
    7040 #line 1486 "parser.yy"
     7049#line 1496 "parser.yy"
    70417050    { (yyval.aggKey) = DeclarationNode::Struct; }
    70427051    break;
     
    70457054
    70467055/* Line 1806 of yacc.c  */
    7047 #line 1488 "parser.yy"
     7056#line 1498 "parser.yy"
    70487057    { (yyval.aggKey) = DeclarationNode::Union; }
    70497058    break;
     
    70527061
    70537062/* Line 1806 of yacc.c  */
    7054 #line 1493 "parser.yy"
     7063#line 1503 "parser.yy"
    70557064    { (yyval.decl) = 0; }
    70567065    break;
     
    70597068
    70607069/* Line 1806 of yacc.c  */
    7061 #line 1495 "parser.yy"
     7070#line 1505 "parser.yy"
    70627071    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    70637072    break;
     
    70667075
    70677076/* Line 1806 of yacc.c  */
    7068 #line 1501 "parser.yy"
     7077#line 1511 "parser.yy"
    70697078    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    70707079    break;
     
    70737082
    70747083/* Line 1806 of yacc.c  */
    7075 #line 1504 "parser.yy"
     7084#line 1514 "parser.yy"
    70767085    {   // mark all fields in list
    70777086                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    70847093
    70857094/* Line 1806 of yacc.c  */
    7086 #line 1514 "parser.yy"
     7095#line 1524 "parser.yy"
    70877096    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    70887097    break;
     
    70917100
    70927101/* Line 1806 of yacc.c  */
    7093 #line 1516 "parser.yy"
     7102#line 1526 "parser.yy"
    70947103    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    70957104    break;
     
    70987107
    70997108/* Line 1806 of yacc.c  */
    7100 #line 1518 "parser.yy"
     7109#line 1528 "parser.yy"
    71017110    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    71027111    break;
     
    71057114
    71067115/* Line 1806 of yacc.c  */
    7107 #line 1523 "parser.yy"
     7116#line 1533 "parser.yy"
    71087117    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    71097118    break;
     
    71127121
    71137122/* Line 1806 of yacc.c  */
    7114 #line 1525 "parser.yy"
     7123#line 1535 "parser.yy"
    71157124    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    71167125    break;
     
    71197128
    71207129/* Line 1806 of yacc.c  */
    7121 #line 1530 "parser.yy"
     7130#line 1540 "parser.yy"
    71227131    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    71237132    break;
     
    71267135
    71277136/* Line 1806 of yacc.c  */
    7128 #line 1532 "parser.yy"
     7137#line 1542 "parser.yy"
    71297138    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    71307139    break;
     
    71337142
    71347143/* Line 1806 of yacc.c  */
    7135 #line 1535 "parser.yy"
     7144#line 1545 "parser.yy"
    71367145    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    71377146    break;
     
    71407149
    71417150/* Line 1806 of yacc.c  */
    7142 #line 1538 "parser.yy"
     7151#line 1548 "parser.yy"
    71437152    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    71447153    break;
     
    71477156
    71487157/* Line 1806 of yacc.c  */
    7149 #line 1544 "parser.yy"
     7158#line 1554 "parser.yy"
    71507159    { (yyval.en) = 0; }
    71517160    break;
     
    71547163
    71557164/* Line 1806 of yacc.c  */
    7156 #line 1546 "parser.yy"
     7165#line 1556 "parser.yy"
    71577166    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    71587167    break;
     
    71617170
    71627171/* Line 1806 of yacc.c  */
    7163 #line 1551 "parser.yy"
     7172#line 1561 "parser.yy"
    71647173    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71657174    break;
     
    71687177
    71697178/* Line 1806 of yacc.c  */
    7170 #line 1560 "parser.yy"
     7179#line 1570 "parser.yy"
    71717180    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    71727181    break;
     
    71757184
    71767185/* Line 1806 of yacc.c  */
    7177 #line 1562 "parser.yy"
     7186#line 1572 "parser.yy"
    71787187    {
    71797188                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    71857194
    71867195/* Line 1806 of yacc.c  */
    7187 #line 1567 "parser.yy"
     7196#line 1577 "parser.yy"
    71887197    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71897198    break;
     
    71927201
    71937202/* Line 1806 of yacc.c  */
    7194 #line 1569 "parser.yy"
     7203#line 1579 "parser.yy"
    71957204    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    71967205    break;
     
    71997208
    72007209/* Line 1806 of yacc.c  */
    7201 #line 1574 "parser.yy"
     7210#line 1584 "parser.yy"
    72027211    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    72037212    break;
     
    72067215
    72077216/* Line 1806 of yacc.c  */
    7208 #line 1576 "parser.yy"
     7217#line 1586 "parser.yy"
    72097218    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    72107219    break;
     
    72137222
    72147223/* Line 1806 of yacc.c  */
    7215 #line 1581 "parser.yy"
     7224#line 1591 "parser.yy"
    72167225    { (yyval.en) = 0; }
    72177226    break;
     
    72207229
    72217230/* Line 1806 of yacc.c  */
    7222 #line 1583 "parser.yy"
     7231#line 1593 "parser.yy"
    72237232    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    72247233    break;
     
    72277236
    72287237/* Line 1806 of yacc.c  */
    7229 #line 1590 "parser.yy"
     7238#line 1600 "parser.yy"
    72307239    { (yyval.decl) = 0; }
    72317240    break;
     
    72347243
    72357244/* Line 1806 of yacc.c  */
    7236 #line 1598 "parser.yy"
     7245#line 1608 "parser.yy"
    72377246    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72387247    break;
     
    72417250
    72427251/* Line 1806 of yacc.c  */
    7243 #line 1600 "parser.yy"
     7252#line 1610 "parser.yy"
    72447253    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72457254    break;
     
    72487257
    72497258/* Line 1806 of yacc.c  */
    7250 #line 1602 "parser.yy"
     7259#line 1612 "parser.yy"
    72517260    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72527261    break;
    72537262
    72547263  case 410:
    7255 
    7256 /* Line 1806 of yacc.c  */
    7257 #line 1610 "parser.yy"
    7258     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7259     break;
    7260 
    7261   case 411:
    7262 
    7263 /* Line 1806 of yacc.c  */
    7264 #line 1612 "parser.yy"
    7265     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7266     break;
    7267 
    7268   case 412:
    7269 
    7270 /* Line 1806 of yacc.c  */
    7271 #line 1614 "parser.yy"
    7272     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    7273     break;
    7274 
    7275   case 414:
    72767264
    72777265/* Line 1806 of yacc.c  */
     
    72807268    break;
    72817269
     7270  case 411:
     7271
     7272/* Line 1806 of yacc.c  */
     7273#line 1622 "parser.yy"
     7274    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7275    break;
     7276
     7277  case 412:
     7278
     7279/* Line 1806 of yacc.c  */
     7280#line 1624 "parser.yy"
     7281    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     7282    break;
     7283
     7284  case 414:
     7285
     7286/* Line 1806 of yacc.c  */
     7287#line 1630 "parser.yy"
     7288    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7289    break;
     7290
    72827291  case 415:
    72837292
    72847293/* Line 1806 of yacc.c  */
    7285 #line 1625 "parser.yy"
     7294#line 1635 "parser.yy"
    72867295    { (yyval.decl) = 0; }
    72877296    break;
     
    72907299
    72917300/* Line 1806 of yacc.c  */
    7292 #line 1632 "parser.yy"
     7301#line 1642 "parser.yy"
    72937302    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72947303    break;
     
    72977306
    72987307/* Line 1806 of yacc.c  */
    7299 #line 1639 "parser.yy"
     7308#line 1649 "parser.yy"
    73007309    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    73017310    break;
     
    73047313
    73057314/* Line 1806 of yacc.c  */
    7306 #line 1641 "parser.yy"
     7315#line 1651 "parser.yy"
    73077316    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    73087317    break;
     
    73117320
    73127321/* Line 1806 of yacc.c  */
    7313 #line 1650 "parser.yy"
     7322#line 1660 "parser.yy"
    73147323    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    73157324    break;
     
    73187327
    73197328/* Line 1806 of yacc.c  */
    7320 #line 1653 "parser.yy"
     7329#line 1663 "parser.yy"
    73217330    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    73227331    break;
     
    73257334
    73267335/* Line 1806 of yacc.c  */
    7327 #line 1655 "parser.yy"
     7336#line 1665 "parser.yy"
    73287337    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    73297338    break;
     
    73327341
    73337342/* Line 1806 of yacc.c  */
    7334 #line 1665 "parser.yy"
     7343#line 1675 "parser.yy"
    73357344    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    73367345    break;
     
    73397348
    73407349/* Line 1806 of yacc.c  */
    7341 #line 1671 "parser.yy"
     7350#line 1681 "parser.yy"
    73427351    {
    73437352                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73497358
    73507359/* Line 1806 of yacc.c  */
    7351 #line 1676 "parser.yy"
     7360#line 1686 "parser.yy"
    73527361    {
    73537362                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73597368
    73607369/* Line 1806 of yacc.c  */
    7361 #line 1685 "parser.yy"
     7370#line 1695 "parser.yy"
    73627371    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73637372    break;
     
    73667375
    73677376/* Line 1806 of yacc.c  */
    7368 #line 1694 "parser.yy"
     7377#line 1704 "parser.yy"
    73697378    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73707379    break;
     
    73737382
    73747383/* Line 1806 of yacc.c  */
    7375 #line 1696 "parser.yy"
     7384#line 1706 "parser.yy"
    73767385    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    73777386    break;
     
    73807389
    73817390/* Line 1806 of yacc.c  */
    7382 #line 1721 "parser.yy"
     7391#line 1731 "parser.yy"
    73837392    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73847393    break;
     
    73877396
    73887397/* Line 1806 of yacc.c  */
    7389 #line 1729 "parser.yy"
     7398#line 1739 "parser.yy"
    73907399    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73917400    break;
     
    73947403
    73957404/* Line 1806 of yacc.c  */
    7396 #line 1734 "parser.yy"
     7405#line 1744 "parser.yy"
    73977406    { (yyval.in) = 0; }
    73987407    break;
     
    74017410
    74027411/* Line 1806 of yacc.c  */
    7403 #line 1736 "parser.yy"
     7412#line 1746 "parser.yy"
    74047413    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    74057414    break;
     
    74087417
    74097418/* Line 1806 of yacc.c  */
    7410 #line 1738 "parser.yy"
     7419#line 1748 "parser.yy"
    74117420    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    74127421    break;
     
    74157424
    74167425/* Line 1806 of yacc.c  */
    7417 #line 1742 "parser.yy"
     7426#line 1752 "parser.yy"
    74187427    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    74197428    break;
     
    74227431
    74237432/* Line 1806 of yacc.c  */
    7424 #line 1743 "parser.yy"
     7433#line 1753 "parser.yy"
    74257434    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    74267435    break;
     
    74297438
    74307439/* Line 1806 of yacc.c  */
    7431 #line 1748 "parser.yy"
     7440#line 1758 "parser.yy"
    74327441    { (yyval.in) = 0; }
    74337442    break;
     
    74367445
    74377446/* Line 1806 of yacc.c  */
    7438 #line 1750 "parser.yy"
     7447#line 1760 "parser.yy"
    74397448    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    74407449    break;
     
    74437452
    74447453/* Line 1806 of yacc.c  */
    7445 #line 1751 "parser.yy"
     7454#line 1761 "parser.yy"
    74467455    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    74477456    break;
     
    74507459
    74517460/* Line 1806 of yacc.c  */
    7452 #line 1753 "parser.yy"
     7461#line 1763 "parser.yy"
    74537462    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    74547463    break;
     
    74577466
    74587467/* Line 1806 of yacc.c  */
    7459 #line 1769 "parser.yy"
     7468#line 1779 "parser.yy"
    74607469    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
    74617470    break;
     
    74647473
    74657474/* Line 1806 of yacc.c  */
    7466 #line 1775 "parser.yy"
     7475#line 1785 "parser.yy"
    74677476    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
    74687477    break;
     
    74717480
    74727481/* Line 1806 of yacc.c  */
    7473 #line 1783 "parser.yy"
     7482#line 1793 "parser.yy"
    74747483    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
    74757484    break;
     
    74787487
    74797488/* Line 1806 of yacc.c  */
    7480 #line 1785 "parser.yy"
     7489#line 1795 "parser.yy"
    74817490    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); }
    74827491    break;
     
    74857494
    74867495/* Line 1806 of yacc.c  */
    7487 #line 1788 "parser.yy"
     7496#line 1798 "parser.yy"
    74887497    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    74897498    break;
     
    74927501
    74937502/* Line 1806 of yacc.c  */
    7494 #line 1790 "parser.yy"
     7503#line 1800 "parser.yy"
    74957504    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    74967505    break;
     
    74997508
    75007509/* Line 1806 of yacc.c  */
    7501 #line 1792 "parser.yy"
     7510#line 1802 "parser.yy"
    75027511    { (yyval.en) = new DesignatorNode( new CompositeExprNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ), true ); }
    75037512    break;
     
    75067515
    75077516/* Line 1806 of yacc.c  */
    7508 #line 1794 "parser.yy"
     7517#line 1804 "parser.yy"
    75097518    { (yyval.en) = new DesignatorNode( (yyvsp[(4) - (6)].en) ); }
    75107519    break;
    75117520
    75127521  case 476:
    7513 
    7514 /* Line 1806 of yacc.c  */
    7515 #line 1818 "parser.yy"
    7516     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7517     break;
    7518 
    7519   case 477:
    7520 
    7521 /* Line 1806 of yacc.c  */
    7522 #line 1820 "parser.yy"
    7523     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    7524     break;
    7525 
    7526   case 478:
    7527 
    7528 /* Line 1806 of yacc.c  */
    7529 #line 1822 "parser.yy"
    7530     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7531     break;
    7532 
    7533   case 480:
    75347522
    75357523/* Line 1806 of yacc.c  */
     
    75387526    break;
    75397527
    7540   case 481:
     7528  case 477:
    75417529
    75427530/* Line 1806 of yacc.c  */
     
    75457533    break;
    75467534
     7535  case 478:
     7536
     7537/* Line 1806 of yacc.c  */
     7538#line 1832 "parser.yy"
     7539    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     7540    break;
     7541
     7542  case 480:
     7543
     7544/* Line 1806 of yacc.c  */
     7545#line 1838 "parser.yy"
     7546    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7547    break;
     7548
     7549  case 481:
     7550
     7551/* Line 1806 of yacc.c  */
     7552#line 1840 "parser.yy"
     7553    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     7554    break;
     7555
    75477556  case 482:
    75487557
    75497558/* Line 1806 of yacc.c  */
    7550 #line 1835 "parser.yy"
     7559#line 1845 "parser.yy"
    75517560    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    75527561    break;
     
    75557564
    75567565/* Line 1806 of yacc.c  */
    7557 #line 1841 "parser.yy"
     7566#line 1851 "parser.yy"
    75587567    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    75597568    break;
     
    75627571
    75637572/* Line 1806 of yacc.c  */
    7564 #line 1846 "parser.yy"
     7573#line 1856 "parser.yy"
    75657574    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75667575    break;
     
    75697578
    75707579/* Line 1806 of yacc.c  */
    7571 #line 1848 "parser.yy"
     7580#line 1858 "parser.yy"
    75727581    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    75737582    break;
     
    75767585
    75777586/* Line 1806 of yacc.c  */
    7578 #line 1854 "parser.yy"
     7587#line 1864 "parser.yy"
    75797588    { (yyval.tclass) = DeclarationNode::Type; }
    75807589    break;
     
    75837592
    75847593/* Line 1806 of yacc.c  */
    7585 #line 1856 "parser.yy"
     7594#line 1866 "parser.yy"
    75867595    { (yyval.tclass) = DeclarationNode::Ftype; }
    75877596    break;
     
    75907599
    75917600/* Line 1806 of yacc.c  */
    7592 #line 1858 "parser.yy"
     7601#line 1868 "parser.yy"
    75937602    { (yyval.tclass) = DeclarationNode::Dtype; }
    75947603    break;
     
    75977606
    75987607/* Line 1806 of yacc.c  */
    7599 #line 1863 "parser.yy"
     7608#line 1873 "parser.yy"
    76007609    { (yyval.decl) = 0; }
    76017610    break;
     
    76047613
    76057614/* Line 1806 of yacc.c  */
    7606 #line 1865 "parser.yy"
     7615#line 1875 "parser.yy"
    76077616    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    76087617    break;
     
    76117620
    76127621/* Line 1806 of yacc.c  */
    7613 #line 1870 "parser.yy"
     7622#line 1880 "parser.yy"
    76147623    {
    76157624                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    76217630
    76227631/* Line 1806 of yacc.c  */
    7623 #line 1875 "parser.yy"
     7632#line 1885 "parser.yy"
    76247633    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    76257634    break;
     
    76287637
    76297638/* Line 1806 of yacc.c  */
    7630 #line 1877 "parser.yy"
     7639#line 1887 "parser.yy"
    76317640    { (yyval.decl) = 0; }
    76327641    break;
     
    76357644
    76367645/* Line 1806 of yacc.c  */
    7637 #line 1882 "parser.yy"
     7646#line 1892 "parser.yy"
    76387647    { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); }
    76397648    break;
     
    76427651
    76437652/* Line 1806 of yacc.c  */
    7644 #line 1885 "parser.yy"
     7653#line 1895 "parser.yy"
    76457654    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
    76467655    break;
     
    76497658
    76507659/* Line 1806 of yacc.c  */
    7651 #line 1887 "parser.yy"
     7660#line 1897 "parser.yy"
    76527661    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    76537662    break;
     
    76567665
    76577666/* Line 1806 of yacc.c  */
    7658 #line 1892 "parser.yy"
     7667#line 1902 "parser.yy"
    76597668    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    76607669    break;
     
    76637672
    76647673/* Line 1806 of yacc.c  */
    7665 #line 1894 "parser.yy"
     7674#line 1904 "parser.yy"
    76667675    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    76677676    break;
     
    76707679
    76717680/* Line 1806 of yacc.c  */
    7672 #line 1896 "parser.yy"
     7681#line 1906 "parser.yy"
    76737682    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    76747683    break;
     
    76777686
    76787687/* Line 1806 of yacc.c  */
    7679 #line 1901 "parser.yy"
     7688#line 1911 "parser.yy"
    76807689    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    76817690    break;
     
    76847693
    76857694/* Line 1806 of yacc.c  */
    7686 #line 1903 "parser.yy"
     7695#line 1913 "parser.yy"
    76877696    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    76887697    break;
     
    76917700
    76927701/* Line 1806 of yacc.c  */
    7693 #line 1908 "parser.yy"
     7702#line 1918 "parser.yy"
    76947703    {
    76957704                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    77017710
    77027711/* Line 1806 of yacc.c  */
    7703 #line 1913 "parser.yy"
     7712#line 1923 "parser.yy"
    77047713    {
    77057714                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    77117720
    77127721/* Line 1806 of yacc.c  */
    7713 #line 1921 "parser.yy"
     7722#line 1931 "parser.yy"
    77147723    {
    77157724                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    77217730
    77227731/* Line 1806 of yacc.c  */
    7723 #line 1926 "parser.yy"
     7732#line 1936 "parser.yy"
    77247733    {
    77257734                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    77317740
    77327741/* Line 1806 of yacc.c  */
    7733 #line 1931 "parser.yy"
     7742#line 1941 "parser.yy"
    77347743    {
    77357744                        typedefTable.leaveTrait();
     
    77427751
    77437752/* Line 1806 of yacc.c  */
    7744 #line 1941 "parser.yy"
     7753#line 1951 "parser.yy"
    77457754    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    77467755    break;
     
    77497758
    77507759/* Line 1806 of yacc.c  */
    7751 #line 1951 "parser.yy"
     7760#line 1961 "parser.yy"
    77527761    {
    77537762                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77597768
    77607769/* Line 1806 of yacc.c  */
    7761 #line 1956 "parser.yy"
     7770#line 1966 "parser.yy"
    77627771    {
    77637772                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77697778
    77707779/* Line 1806 of yacc.c  */
    7771 #line 1961 "parser.yy"
     7780#line 1971 "parser.yy"
    77727781    {
    77737782                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    77797788
    77807789/* Line 1806 of yacc.c  */
    7781 #line 1969 "parser.yy"
     7790#line 1979 "parser.yy"
    77827791    {
    77837792                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77897798
    77907799/* Line 1806 of yacc.c  */
    7791 #line 1974 "parser.yy"
     7800#line 1984 "parser.yy"
    77927801    {
    77937802                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77997808
    78007809/* Line 1806 of yacc.c  */
    7801 #line 1984 "parser.yy"
     7810#line 1994 "parser.yy"
    78027811    {}
    78037812    break;
     
    78067815
    78077816/* Line 1806 of yacc.c  */
    7808 #line 1986 "parser.yy"
     7817#line 1996 "parser.yy"
    78097818    {
    78107819                        if ( theTree ) {
     
    78197828
    78207829/* Line 1806 of yacc.c  */
    7821 #line 1998 "parser.yy"
     7830#line 2008 "parser.yy"
    78227831    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    78237832    break;
     
    78267835
    78277836/* Line 1806 of yacc.c  */
    7828 #line 2003 "parser.yy"
     7837#line 2013 "parser.yy"
    78297838    { (yyval.decl) = 0; }
    78307839    break;
     
    78337842
    78347843/* Line 1806 of yacc.c  */
    7835 #line 2011 "parser.yy"
     7844#line 2021 "parser.yy"
    78367845    {}
    78377846    break;
     
    78407849
    78417850/* Line 1806 of yacc.c  */
    7842 #line 2013 "parser.yy"
     7851#line 2023 "parser.yy"
    78437852    {
    78447853                        linkageStack.push( linkage );
     
    78507859
    78517860/* Line 1806 of yacc.c  */
    7852 #line 2018 "parser.yy"
     7861#line 2028 "parser.yy"
    78537862    {
    78547863                        linkage = linkageStack.top();
     
    78617870
    78627871/* Line 1806 of yacc.c  */
    7863 #line 2024 "parser.yy"
     7872#line 2034 "parser.yy"
    78647873    {   // mark all fields in list
    78657874                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    78727881
    78737882/* Line 1806 of yacc.c  */
    7874 #line 2039 "parser.yy"
     7883#line 2049 "parser.yy"
    78757884    {
    78767885                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78837892
    78847893/* Line 1806 of yacc.c  */
    7885 #line 2045 "parser.yy"
     7894#line 2055 "parser.yy"
    78867895    {
    78877896                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78947903
    78957904/* Line 1806 of yacc.c  */
    7896 #line 2054 "parser.yy"
     7905#line 2064 "parser.yy"
    78977906    {
    78987907                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79057914
    79067915/* Line 1806 of yacc.c  */
    7907 #line 2060 "parser.yy"
     7916#line 2070 "parser.yy"
    79087917    {
    79097918                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79167925
    79177926/* Line 1806 of yacc.c  */
    7918 #line 2066 "parser.yy"
     7927#line 2076 "parser.yy"
    79197928    {
    79207929                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79277936
    79287937/* Line 1806 of yacc.c  */
    7929 #line 2072 "parser.yy"
     7938#line 2082 "parser.yy"
    79307939    {
    79317940                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79387947
    79397948/* Line 1806 of yacc.c  */
    7940 #line 2078 "parser.yy"
     7949#line 2088 "parser.yy"
    79417950    {
    79427951                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79497958
    79507959/* Line 1806 of yacc.c  */
    7951 #line 2086 "parser.yy"
     7960#line 2096 "parser.yy"
    79527961    {
    79537962                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79607969
    79617970/* Line 1806 of yacc.c  */
    7962 #line 2092 "parser.yy"
     7971#line 2102 "parser.yy"
    79637972    {
    79647973                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79717980
    79727981/* Line 1806 of yacc.c  */
    7973 #line 2100 "parser.yy"
     7982#line 2110 "parser.yy"
    79747983    {
    79757984                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79827991
    79837992/* Line 1806 of yacc.c  */
    7984 #line 2106 "parser.yy"
     7993#line 2116 "parser.yy"
    79857994    {
    79867995                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79938002
    79948003/* Line 1806 of yacc.c  */
    7995 #line 2121 "parser.yy"
     8004#line 2131 "parser.yy"
    79968005    { (yyval.en) = new CompositeExprNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    79978006    break;
     
    80008009
    80018010/* Line 1806 of yacc.c  */
    8002 #line 2131 "parser.yy"
     8011#line 2141 "parser.yy"
    80038012    { (yyval.decl) = 0; }
    80048013    break;
     
    80078016
    80088017/* Line 1806 of yacc.c  */
    8009 #line 2138 "parser.yy"
     8018#line 2148 "parser.yy"
    80108019    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    80118020    break;
     
    80148023
    80158024/* Line 1806 of yacc.c  */
    8016 #line 2144 "parser.yy"
     8025#line 2154 "parser.yy"
    80178026    { (yyval.decl) = 0; }
    80188027    break;
     
    80218030
    80228031/* Line 1806 of yacc.c  */
    8023 #line 2159 "parser.yy"
     8032#line 2169 "parser.yy"
    80248033    {}
    80258034    break;
     
    80288037
    80298038/* Line 1806 of yacc.c  */
    8030 #line 2160 "parser.yy"
     8039#line 2170 "parser.yy"
    80318040    {}
    80328041    break;
     
    80358044
    80368045/* Line 1806 of yacc.c  */
    8037 #line 2161 "parser.yy"
     8046#line 2171 "parser.yy"
    80388047    {}
    80398048    break;
     
    80428051
    80438052/* Line 1806 of yacc.c  */
    8044 #line 2162 "parser.yy"
     8053#line 2172 "parser.yy"
    80458054    {}
    80468055    break;
     
    80498058
    80508059/* Line 1806 of yacc.c  */
    8051 #line 2197 "parser.yy"
     8060#line 2207 "parser.yy"
    80528061    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80538062    break;
     
    80568065
    80578066/* Line 1806 of yacc.c  */
    8058 #line 2200 "parser.yy"
     8067#line 2210 "parser.yy"
    80598068    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80608069    break;
     
    80638072
    80648073/* Line 1806 of yacc.c  */
    8065 #line 2202 "parser.yy"
     8074#line 2212 "parser.yy"
    80668075    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80678076    break;
     
    80708079
    80718080/* Line 1806 of yacc.c  */
    8072 #line 2207 "parser.yy"
     8081#line 2217 "parser.yy"
    80738082    {
    80748083                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    80808089
    80818090/* Line 1806 of yacc.c  */
    8082 #line 2212 "parser.yy"
     8091#line 2222 "parser.yy"
    80838092    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80848093    break;
     
    80878096
    80888097/* Line 1806 of yacc.c  */
    8089 #line 2217 "parser.yy"
     8098#line 2227 "parser.yy"
    80908099    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    80918100    break;
     
    80948103
    80958104/* Line 1806 of yacc.c  */
    8096 #line 2219 "parser.yy"
     8105#line 2229 "parser.yy"
    80978106    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    80988107    break;
     
    81018110
    81028111/* Line 1806 of yacc.c  */
    8103 #line 2221 "parser.yy"
     8112#line 2231 "parser.yy"
    81048113    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81058114    break;
     
    81088117
    81098118/* Line 1806 of yacc.c  */
    8110 #line 2226 "parser.yy"
     8119#line 2236 "parser.yy"
    81118120    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    81128121    break;
     
    81158124
    81168125/* Line 1806 of yacc.c  */
    8117 #line 2228 "parser.yy"
     8126#line 2238 "parser.yy"
    81188127    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81198128    break;
     
    81228131
    81238132/* Line 1806 of yacc.c  */
    8124 #line 2230 "parser.yy"
     8133#line 2240 "parser.yy"
    81258134    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81268135    break;
     
    81298138
    81308139/* Line 1806 of yacc.c  */
    8131 #line 2232 "parser.yy"
     8140#line 2242 "parser.yy"
    81328141    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81338142    break;
     
    81368145
    81378146/* Line 1806 of yacc.c  */
    8138 #line 2237 "parser.yy"
     8147#line 2247 "parser.yy"
    81398148    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81408149    break;
     
    81438152
    81448153/* Line 1806 of yacc.c  */
    8145 #line 2239 "parser.yy"
     8154#line 2249 "parser.yy"
    81468155    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81478156    break;
     
    81508159
    81518160/* Line 1806 of yacc.c  */
    8152 #line 2248 "parser.yy"
     8161#line 2258 "parser.yy"
    81538162    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81548163    break;
     
    81578166
    81588167/* Line 1806 of yacc.c  */
    8159 #line 2251 "parser.yy"
     8168#line 2261 "parser.yy"
    81608169    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81618170    break;
     
    81648173
    81658174/* Line 1806 of yacc.c  */
    8166 #line 2256 "parser.yy"
     8175#line 2266 "parser.yy"
    81678176    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    81688177    break;
     
    81718180
    81728181/* Line 1806 of yacc.c  */
    8173 #line 2258 "parser.yy"
     8182#line 2268 "parser.yy"
    81748183    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81758184    break;
     
    81788187
    81798188/* Line 1806 of yacc.c  */
    8180 #line 2260 "parser.yy"
     8189#line 2270 "parser.yy"
    81818190    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81828191    break;
     
    81858194
    81868195/* Line 1806 of yacc.c  */
    8187 #line 2265 "parser.yy"
     8196#line 2275 "parser.yy"
    81888197    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81898198    break;
     
    81928201
    81938202/* Line 1806 of yacc.c  */
    8194 #line 2267 "parser.yy"
     8203#line 2277 "parser.yy"
    81958204    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    81968205    break;
     
    81998208
    82008209/* Line 1806 of yacc.c  */
    8201 #line 2269 "parser.yy"
     8210#line 2279 "parser.yy"
    82028211    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82038212    break;
     
    82068215
    82078216/* Line 1806 of yacc.c  */
    8208 #line 2274 "parser.yy"
     8217#line 2284 "parser.yy"
    82098218    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82108219    break;
     
    82138222
    82148223/* Line 1806 of yacc.c  */
    8215 #line 2276 "parser.yy"
     8224#line 2286 "parser.yy"
    82168225    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82178226    break;
     
    82208229
    82218230/* Line 1806 of yacc.c  */
    8222 #line 2278 "parser.yy"
     8231#line 2288 "parser.yy"
    82238232    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82248233    break;
     
    82278236
    82288237/* Line 1806 of yacc.c  */
    8229 #line 2293 "parser.yy"
     8238#line 2303 "parser.yy"
    82308239    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    82318240    break;
     
    82348243
    82358244/* Line 1806 of yacc.c  */
    8236 #line 2295 "parser.yy"
     8245#line 2305 "parser.yy"
    82378246    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    82388247    break;
     
    82418250
    82428251/* Line 1806 of yacc.c  */
    8243 #line 2297 "parser.yy"
     8252#line 2307 "parser.yy"
    82448253    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82458254    break;
     
    82488257
    82498258/* Line 1806 of yacc.c  */
    8250 #line 2302 "parser.yy"
     8259#line 2312 "parser.yy"
    82518260    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    82528261    break;
     
    82558264
    82568265/* Line 1806 of yacc.c  */
    8257 #line 2304 "parser.yy"
     8266#line 2314 "parser.yy"
    82588267    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82598268    break;
     
    82628271
    82638272/* Line 1806 of yacc.c  */
    8264 #line 2306 "parser.yy"
     8273#line 2316 "parser.yy"
    82658274    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82668275    break;
     
    82698278
    82708279/* Line 1806 of yacc.c  */
    8271 #line 2311 "parser.yy"
     8280#line 2321 "parser.yy"
    82728281    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82738282    break;
     
    82768285
    82778286/* Line 1806 of yacc.c  */
    8278 #line 2313 "parser.yy"
     8287#line 2323 "parser.yy"
    82798288    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82808289    break;
     
    82838292
    82848293/* Line 1806 of yacc.c  */
    8285 #line 2315 "parser.yy"
     8294#line 2325 "parser.yy"
    82868295    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82878296    break;
     
    82908299
    82918300/* Line 1806 of yacc.c  */
    8292 #line 2330 "parser.yy"
     8301#line 2340 "parser.yy"
    82938302    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82948303    break;
     
    82978306
    82988307/* Line 1806 of yacc.c  */
    8299 #line 2333 "parser.yy"
     8308#line 2343 "parser.yy"
    83008309    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83018310    break;
     
    83048313
    83058314/* Line 1806 of yacc.c  */
    8306 #line 2335 "parser.yy"
     8315#line 2345 "parser.yy"
    83078316    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83088317    break;
     
    83118320
    83128321/* Line 1806 of yacc.c  */
    8313 #line 2341 "parser.yy"
     8322#line 2351 "parser.yy"
    83148323    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83158324    break;
     
    83188327
    83198328/* Line 1806 of yacc.c  */
    8320 #line 2346 "parser.yy"
     8329#line 2356 "parser.yy"
    83218330    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83228331    break;
     
    83258334
    83268335/* Line 1806 of yacc.c  */
    8327 #line 2348 "parser.yy"
     8336#line 2358 "parser.yy"
    83288337    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83298338    break;
     
    83328341
    83338342/* Line 1806 of yacc.c  */
    8334 #line 2350 "parser.yy"
     8343#line 2360 "parser.yy"
    83358344    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83368345    break;
     
    83398348
    83408349/* Line 1806 of yacc.c  */
    8341 #line 2355 "parser.yy"
     8350#line 2365 "parser.yy"
    83428351    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83438352    break;
     
    83468355
    83478356/* Line 1806 of yacc.c  */
    8348 #line 2357 "parser.yy"
     8357#line 2367 "parser.yy"
    83498358    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83508359    break;
     
    83538362
    83548363/* Line 1806 of yacc.c  */
    8355 #line 2359 "parser.yy"
     8364#line 2369 "parser.yy"
    83568365    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83578366    break;
     
    83608369
    83618370/* Line 1806 of yacc.c  */
    8362 #line 2361 "parser.yy"
     8371#line 2371 "parser.yy"
    83638372    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83648373    break;
     
    83678376
    83688377/* Line 1806 of yacc.c  */
    8369 #line 2366 "parser.yy"
     8378#line 2376 "parser.yy"
    83708379    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83718380    break;
     
    83748383
    83758384/* Line 1806 of yacc.c  */
    8376 #line 2368 "parser.yy"
     8385#line 2378 "parser.yy"
    83778386    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83788387    break;
     
    83818390
    83828391/* Line 1806 of yacc.c  */
    8383 #line 2370 "parser.yy"
     8392#line 2380 "parser.yy"
    83848393    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83858394    break;
     
    83888397
    83898398/* Line 1806 of yacc.c  */
    8390 #line 2380 "parser.yy"
     8399#line 2390 "parser.yy"
    83918400    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83928401    break;
     
    83958404
    83968405/* Line 1806 of yacc.c  */
    8397 #line 2383 "parser.yy"
     8406#line 2393 "parser.yy"
    83988407    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83998408    break;
     
    84028411
    84038412/* Line 1806 of yacc.c  */
    8404 #line 2385 "parser.yy"
     8413#line 2395 "parser.yy"
    84058414    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84068415    break;
     
    84098418
    84108419/* Line 1806 of yacc.c  */
    8411 #line 2390 "parser.yy"
     8420#line 2400 "parser.yy"
    84128421    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84138422    break;
     
    84168425
    84178426/* Line 1806 of yacc.c  */
    8418 #line 2392 "parser.yy"
     8427#line 2402 "parser.yy"
    84198428    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84208429    break;
     
    84238432
    84248433/* Line 1806 of yacc.c  */
    8425 #line 2394 "parser.yy"
     8434#line 2404 "parser.yy"
    84268435    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84278436    break;
     
    84308439
    84318440/* Line 1806 of yacc.c  */
    8432 #line 2399 "parser.yy"
     8441#line 2409 "parser.yy"
    84338442    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    84348443    break;
     
    84378446
    84388447/* Line 1806 of yacc.c  */
    8439 #line 2401 "parser.yy"
     8448#line 2411 "parser.yy"
    84408449    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84418450    break;
     
    84448453
    84458454/* Line 1806 of yacc.c  */
    8446 #line 2403 "parser.yy"
     8455#line 2413 "parser.yy"
    84478456    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84488457    break;
     
    84518460
    84528461/* Line 1806 of yacc.c  */
    8453 #line 2405 "parser.yy"
     8462#line 2415 "parser.yy"
    84548463    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84558464    break;
     
    84588467
    84598468/* Line 1806 of yacc.c  */
    8460 #line 2410 "parser.yy"
     8469#line 2420 "parser.yy"
    84618470    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    84628471    break;
     
    84658474
    84668475/* Line 1806 of yacc.c  */
    8467 #line 2412 "parser.yy"
     8476#line 2422 "parser.yy"
    84688477    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    84698478    break;
     
    84728481
    84738482/* Line 1806 of yacc.c  */
    8474 #line 2414 "parser.yy"
     8483#line 2424 "parser.yy"
    84758484    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84768485    break;
     
    84798488
    84808489/* Line 1806 of yacc.c  */
    8481 #line 2445 "parser.yy"
     8490#line 2455 "parser.yy"
    84828491    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84838492    break;
     
    84868495
    84878496/* Line 1806 of yacc.c  */
    8488 #line 2448 "parser.yy"
     8497#line 2458 "parser.yy"
    84898498    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84908499    break;
     
    84938502
    84948503/* Line 1806 of yacc.c  */
    8495 #line 2450 "parser.yy"
     8504#line 2460 "parser.yy"
    84968505    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84978506    break;
     
    85008509
    85018510/* Line 1806 of yacc.c  */
    8502 #line 2455 "parser.yy"
     8511#line 2465 "parser.yy"
    85038512    {
    85048513                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    85108519
    85118520/* Line 1806 of yacc.c  */
    8512 #line 2460 "parser.yy"
     8521#line 2470 "parser.yy"
    85138522    {
    85148523                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    85208529
    85218530/* Line 1806 of yacc.c  */
    8522 #line 2468 "parser.yy"
     8531#line 2478 "parser.yy"
    85238532    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85248533    break;
     
    85278536
    85288537/* Line 1806 of yacc.c  */
    8529 #line 2470 "parser.yy"
     8538#line 2480 "parser.yy"
    85308539    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85318540    break;
     
    85348543
    85358544/* Line 1806 of yacc.c  */
    8536 #line 2472 "parser.yy"
     8545#line 2482 "parser.yy"
    85378546    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85388547    break;
     
    85418550
    85428551/* Line 1806 of yacc.c  */
    8543 #line 2477 "parser.yy"
     8552#line 2487 "parser.yy"
    85448553    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    85458554    break;
     
    85488557
    85498558/* Line 1806 of yacc.c  */
    8550 #line 2479 "parser.yy"
     8559#line 2489 "parser.yy"
    85518560    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85528561    break;
     
    85558564
    85568565/* Line 1806 of yacc.c  */
    8557 #line 2484 "parser.yy"
     8566#line 2494 "parser.yy"
    85588567    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85598568    break;
     
    85628571
    85638572/* Line 1806 of yacc.c  */
    8564 #line 2486 "parser.yy"
     8573#line 2496 "parser.yy"
    85658574    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85668575    break;
     
    85698578
    85708579/* Line 1806 of yacc.c  */
    8571 #line 2501 "parser.yy"
     8580#line 2511 "parser.yy"
    85728581    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85738582    break;
     
    85768585
    85778586/* Line 1806 of yacc.c  */
    8578 #line 2503 "parser.yy"
     8587#line 2513 "parser.yy"
    85798588    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85808589    break;
     
    85838592
    85848593/* Line 1806 of yacc.c  */
    8585 #line 2508 "parser.yy"
     8594#line 2518 "parser.yy"
    85868595    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85878596    break;
     
    85908599
    85918600/* Line 1806 of yacc.c  */
    8592 #line 2510 "parser.yy"
     8601#line 2520 "parser.yy"
    85938602    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    85948603    break;
     
    85978606
    85988607/* Line 1806 of yacc.c  */
    8599 #line 2512 "parser.yy"
     8608#line 2522 "parser.yy"
    86008609    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86018610    break;
     
    86048613
    86058614/* Line 1806 of yacc.c  */
    8606 #line 2514 "parser.yy"
     8615#line 2524 "parser.yy"
    86078616    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86088617    break;
    86098618
    86108619  case 652:
    8611 
    8612 /* Line 1806 of yacc.c  */
    8613 #line 2516 "parser.yy"
    8614     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8615     break;
    8616 
    8617   case 654:
    8618 
    8619 /* Line 1806 of yacc.c  */
    8620 #line 2522 "parser.yy"
    8621     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8622     break;
    8623 
    8624   case 655:
    8625 
    8626 /* Line 1806 of yacc.c  */
    8627 #line 2524 "parser.yy"
    8628     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8629     break;
    8630 
    8631   case 656:
    86328620
    86338621/* Line 1806 of yacc.c  */
     
    86368624    break;
    86378625
     8626  case 654:
     8627
     8628/* Line 1806 of yacc.c  */
     8629#line 2532 "parser.yy"
     8630    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8631    break;
     8632
     8633  case 655:
     8634
     8635/* Line 1806 of yacc.c  */
     8636#line 2534 "parser.yy"
     8637    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8638    break;
     8639
     8640  case 656:
     8641
     8642/* Line 1806 of yacc.c  */
     8643#line 2536 "parser.yy"
     8644    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8645    break;
     8646
    86388647  case 657:
    86398648
    86408649/* Line 1806 of yacc.c  */
    8641 #line 2531 "parser.yy"
     8650#line 2541 "parser.yy"
    86428651    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    86438652    break;
     
    86468655
    86478656/* Line 1806 of yacc.c  */
    8648 #line 2533 "parser.yy"
     8657#line 2543 "parser.yy"
    86498658    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    86508659    break;
     
    86538662
    86548663/* Line 1806 of yacc.c  */
    8655 #line 2535 "parser.yy"
     8664#line 2545 "parser.yy"
    86568665    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86578666    break;
     
    86608669
    86618670/* Line 1806 of yacc.c  */
    8662 #line 2541 "parser.yy"
     8671#line 2551 "parser.yy"
    86638672    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    86648673    break;
     
    86678676
    86688677/* Line 1806 of yacc.c  */
    8669 #line 2543 "parser.yy"
     8678#line 2553 "parser.yy"
    86708679    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    86718680    break;
     
    86748683
    86758684/* Line 1806 of yacc.c  */
    8676 #line 2549 "parser.yy"
     8685#line 2559 "parser.yy"
    86778686    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    86788687    break;
     
    86818690
    86828691/* Line 1806 of yacc.c  */
    8683 #line 2551 "parser.yy"
     8692#line 2561 "parser.yy"
    86848693    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    86858694    break;
     
    86888697
    86898698/* Line 1806 of yacc.c  */
    8690 #line 2553 "parser.yy"
     8699#line 2563 "parser.yy"
    86918700    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    86928701    break;
     
    86958704
    86968705/* Line 1806 of yacc.c  */
    8697 #line 2555 "parser.yy"
     8706#line 2565 "parser.yy"
    86988707    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    86998708    break;
     
    87028711
    87038712/* Line 1806 of yacc.c  */
    8704 #line 2570 "parser.yy"
     8713#line 2580 "parser.yy"
    87058714    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87068715    break;
     
    87098718
    87108719/* Line 1806 of yacc.c  */
    8711 #line 2572 "parser.yy"
     8720#line 2582 "parser.yy"
    87128721    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87138722    break;
     
    87168725
    87178726/* Line 1806 of yacc.c  */
    8718 #line 2577 "parser.yy"
     8727#line 2587 "parser.yy"
    87198728    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    87208729    break;
     
    87238732
    87248733/* Line 1806 of yacc.c  */
    8725 #line 2579 "parser.yy"
     8734#line 2589 "parser.yy"
    87268735    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    87278736    break;
     
    87308739
    87318740/* Line 1806 of yacc.c  */
    8732 #line 2581 "parser.yy"
     8741#line 2591 "parser.yy"
    87338742    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87348743    break;
     
    87378746
    87388747/* Line 1806 of yacc.c  */
    8739 #line 2583 "parser.yy"
     8748#line 2593 "parser.yy"
    87408749    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87418750    break;
    87428751
    87438752  case 674:
    8744 
    8745 /* Line 1806 of yacc.c  */
    8746 #line 2585 "parser.yy"
    8747     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8748     break;
    8749 
    8750   case 676:
    8751 
    8752 /* Line 1806 of yacc.c  */
    8753 #line 2591 "parser.yy"
    8754     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8755     break;
    8756 
    8757   case 677:
    8758 
    8759 /* Line 1806 of yacc.c  */
    8760 #line 2593 "parser.yy"
    8761     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8762     break;
    8763 
    8764   case 678:
    87658753
    87668754/* Line 1806 of yacc.c  */
     
    87698757    break;
    87708758
     8759  case 676:
     8760
     8761/* Line 1806 of yacc.c  */
     8762#line 2601 "parser.yy"
     8763    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8764    break;
     8765
     8766  case 677:
     8767
     8768/* Line 1806 of yacc.c  */
     8769#line 2603 "parser.yy"
     8770    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8771    break;
     8772
     8773  case 678:
     8774
     8775/* Line 1806 of yacc.c  */
     8776#line 2605 "parser.yy"
     8777    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8778    break;
     8779
    87718780  case 679:
    87728781
    87738782/* Line 1806 of yacc.c  */
    8774 #line 2600 "parser.yy"
     8783#line 2610 "parser.yy"
    87758784    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    87768785    break;
     
    87798788
    87808789/* Line 1806 of yacc.c  */
    8781 #line 2602 "parser.yy"
     8790#line 2612 "parser.yy"
    87828791    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87838792    break;
     
    87868795
    87878796/* Line 1806 of yacc.c  */
    8788 #line 2604 "parser.yy"
     8797#line 2614 "parser.yy"
    87898798    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87908799    break;
     
    87938802
    87948803/* Line 1806 of yacc.c  */
    8795 #line 2611 "parser.yy"
     8804#line 2621 "parser.yy"
    87968805    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    87978806    break;
     
    88008809
    88018810/* Line 1806 of yacc.c  */
    8802 #line 2622 "parser.yy"
     8811#line 2632 "parser.yy"
    88038812    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    88048813    break;
     
    88078816
    88088817/* Line 1806 of yacc.c  */
    8809 #line 2625 "parser.yy"
     8818#line 2635 "parser.yy"
    88108819    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    88118820    break;
     
    88148823
    88158824/* Line 1806 of yacc.c  */
    8816 #line 2627 "parser.yy"
     8825#line 2637 "parser.yy"
    88178826    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    88188827    break;
     
    88218830
    88228831/* Line 1806 of yacc.c  */
    8823 #line 2630 "parser.yy"
     8832#line 2640 "parser.yy"
    88248833    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    88258834    break;
     
    88288837
    88298838/* Line 1806 of yacc.c  */
    8830 #line 2632 "parser.yy"
     8839#line 2642 "parser.yy"
    88318840    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    88328841    break;
     
    88358844
    88368845/* Line 1806 of yacc.c  */
    8837 #line 2634 "parser.yy"
     8846#line 2644 "parser.yy"
    88388847    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    88398848    break;
     
    88428851
    88438852/* Line 1806 of yacc.c  */
    8844 #line 2648 "parser.yy"
     8853#line 2658 "parser.yy"
    88458854    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88468855    break;
     
    88498858
    88508859/* Line 1806 of yacc.c  */
    8851 #line 2650 "parser.yy"
     8860#line 2660 "parser.yy"
    88528861    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88538862    break;
     
    88568865
    88578866/* Line 1806 of yacc.c  */
    8858 #line 2655 "parser.yy"
     8867#line 2665 "parser.yy"
    88598868    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88608869    break;
     
    88638872
    88648873/* Line 1806 of yacc.c  */
    8865 #line 2657 "parser.yy"
     8874#line 2667 "parser.yy"
    88668875    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88678876    break;
     
    88708879
    88718880/* Line 1806 of yacc.c  */
    8872 #line 2659 "parser.yy"
     8881