Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 59db6897195376150fdc27245cae3d51cc615cd4) +++ src/Parser/ExpressionNode.cc (revision cd623a4e93c2eeb566858071f03b3e141d60d50c) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 6 23:18:19 2015 -// Update Count : 128 +// Last Modified On : Sun Jun 7 07:58:00 2015 +// Update Count : 135 // @@ -60,4 +60,6 @@ } +//############################################################################## + NullExprNode::NullExprNode() {} @@ -84,24 +86,27 @@ } -static inline bool checku( char c ) { return c == 'u' || c == 'U'; } -static inline bool checkl( char c ) { return c == 'l' || c == 'L'; } -static inline bool checkf( char c ) { return c == 'f' || c == 'F'; } -static inline bool checkx( char c ) { return c == 'x' || c == 'X'; } +//############################################################################## + +static inline bool checkU( char c ) { return c == 'u' || c == 'U'; } +static inline bool checkL( char c ) { return c == 'l' || c == 'L'; } +static inline bool checkF( char c ) { return c == 'f' || c == 'F'; } +static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } + +// Very difficult to separate extra parts of constants during lexing because actions are not allow in the middle of +// patterns: +// +// prefix action constant action suffix +// +// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty: +// +// constant BEGIN CONT ... +// (...)? BEGIN 0 ... // possible empty suffix +// +// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their +// type. ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), value( *inVal ) { + // lexing divides constants into 4 kinds switch ( type ) { - case Float: - { - size_t len = value.length() - 1; - - btype = BasicType::Double; // default - if ( checkf( value[len] ) ) { - btype = BasicType::Float; - } // if - if ( checkl( value[len] ) ) { - btype = BasicType::LongDouble; - } // if - break; - } case Integer: { @@ -115,7 +120,7 @@ int size; // 0 => int, 1 => long, 2 => long long - if ( value[0] == '0' ) { // octal ? + if ( value[0] == '0' ) { // octal constant ? dec = false; - if ( last != 0 && checkx( value[1] ) ) { // hex ? + if ( last != 0 && checkX( value[1] ) ) { // hex constant ? sscanf( (char *)value.c_str(), "%llx", &v ); //printf( "%llx %llu\n", v, v ); @@ -124,5 +129,5 @@ //printf( "%llo %llu\n", v, v ); } // if - } else { // decimal ? + } else { // decimal constant ? sscanf( (char *)value.c_str(), "%lld", &v ); //printf( "%llu %llu\n", v, v ); @@ -146,22 +151,35 @@ } // if - if ( checku( value[last] ) ) { // suffix 'u' ? + if ( checkU( value[last] ) ) { // suffix 'u' ? Unsigned = true; - if ( checkl( value[ last - 1 ] ) ) { // suffix 'l' ? + if ( checkL( value[ last - 1 ] ) ) { // suffix 'l' ? size = 1; - if ( checkl( value[ last - 1 ] ) ) { // suffix 'll' ? + if ( checkL( value[ last - 1 ] ) ) { // suffix 'll' ? size = 2; } // if } // if - } else if ( checkl( value[ last ] ) ) { // suffix 'l' ? + } else if ( checkL( value[ last ] ) ) { // suffix 'l' ? size = 1; - if ( checkl( value[ last - 1 ] ) ) { // suffix 'll' ? + if ( checkL( value[ last - 1 ] ) ) { // suffix 'll' ? size = 2; } // if - if ( checku( value[ last - 1 ] ) ) { // suffix 'u' ? + if ( checkU( value[ last - 1 ] ) ) { // suffix 'u' ? Unsigned = true; } // if } // if - btype = kind[Unsigned][size]; // loopup type of constant + btype = kind[Unsigned][size]; // lookup constant type + break; + } + case Float: + { + size_t len = value.length() - 1; + + btype = BasicType::Double; // default + if ( checkF( value[len] ) ) { // float ? + btype = BasicType::Float; + } // if + if ( checkL( value[len] ) ) { // long double ? + btype = BasicType::LongDouble; + } // if break; } @@ -185,16 +203,12 @@ } // ConstantNode::ConstantNode -ConstantNode::Type ConstantNode::get_type( void ) const { - return type; -} - ConstantNode *ConstantNode::appendstr( const std::string *newValue ) { assert( newValue != 0 ); assert( type == String ); - //printf( "%lu \"%s\" \"%s\"\n", value.length() - 1, value.c_str(), newValue->substr( 1, newValue->length() - 2 ).c_str() ); + // "abc" "def" "ghi" => "abcdefghi", so remove new text from quotes and insert before last quote in old string. value.insert( value.length() - 1, newValue->substr( 1, newValue->length() - 2 ) ); - delete newValue; // allocated by yacc + delete newValue; // allocated by lexer return this; } @@ -226,6 +240,5 @@ Expression *ConstantNode::build() const { - ::Type::Qualifiers q; - BasicType *bt; + ::Type::Qualifiers q; // no qualifiers on constants switch ( get_type() ) { @@ -241,8 +254,9 @@ } default: - bt = new BasicType( q, btype ); - return new ConstantExpr( Constant( bt, get_value() ), maybeBuild< Expression >( get_argName() ) ); + return new ConstantExpr( Constant( new BasicType( q, btype ), get_value() ), maybeBuild< Expression >( get_argName() ) ); } } + +//############################################################################## VarRefNode::VarRefNode() : isLabel( false ) {} @@ -268,4 +282,6 @@ os << endl; } + +//############################################################################## OperatorNode::OperatorNode( Type t ) : type( t ) {} @@ -300,5 +316,5 @@ "Cond", "NCond", // diadic - "SizeOf", "AlignOf", "Attr", "CompLit", "Plus", "Minus", "Mul", "Div", "Mod", "Or", + "SizeOf", "AlignOf", "Attr", "CompLit", "Plus", "Minus", "Mul", "Div", "Mod", "Or", "And", "BitOr", "BitAnd", "Xor", "Cast", "LShift", "RShift", "LThan", "GThan", "LEThan", "GEThan", "Eq", "Neq", "Assign", "MulAssn", "DivAssn", "ModAssn", "PlusAssn", @@ -308,4 +324,6 @@ "UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress" }; + +//############################################################################## CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) { @@ -362,192 +380,191 @@ buildList( get_args(), args ); - if ( ! ( op = dynamic_cast( function )) ) { - // a function as opposed to an operator + if ( ! ( op = dynamic_cast( function ) ) ) { // function as opposed to operator return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() )); - } else { - switch ( op->get_type()) { - case OperatorNode::Incr: - case OperatorNode::Decr: - case OperatorNode::IncrPost: - case OperatorNode::DecrPost: - case OperatorNode::Assign: - case OperatorNode::MulAssn: - case OperatorNode::DivAssn: - case OperatorNode::ModAssn: - case OperatorNode::PlusAssn: - case OperatorNode::MinusAssn: - case OperatorNode::LSAssn: - case OperatorNode::RSAssn: - case OperatorNode::AndAssn: - case OperatorNode::ERAssn: - case OperatorNode::OrAssn: - // the rewrite rules for these expressions specify that the first argument has its address taken - assert( ! args.empty() ); - args.front() = new AddressExpr( args.front() ); - break; - default: - /* do nothing */ - ; - } - - switch ( op->get_type() ) { - case OperatorNode::Incr: - case OperatorNode::Decr: - case OperatorNode::IncrPost: - case OperatorNode::DecrPost: - case OperatorNode::Assign: - case OperatorNode::MulAssn: - case OperatorNode::DivAssn: - case OperatorNode::ModAssn: - case OperatorNode::PlusAssn: - case OperatorNode::MinusAssn: - case OperatorNode::LSAssn: - case OperatorNode::RSAssn: - case OperatorNode::AndAssn: - case OperatorNode::ERAssn: - case OperatorNode::OrAssn: - case OperatorNode::Plus: - case OperatorNode::Minus: - case OperatorNode::Mul: - case OperatorNode::Div: - case OperatorNode::Mod: - case OperatorNode::BitOr: - case OperatorNode::BitAnd: - case OperatorNode::Xor: - case OperatorNode::LShift: - case OperatorNode::RShift: - case OperatorNode::LThan: - case OperatorNode::GThan: - case OperatorNode::LEThan: - case OperatorNode::GEThan: - case OperatorNode::Eq: - case OperatorNode::Neq: - case OperatorNode::Index: - case OperatorNode::Range: - case OperatorNode::UnPlus: - case OperatorNode::UnMinus: - case OperatorNode::PointTo: - case OperatorNode::Neg: - case OperatorNode::BitNeg: - case OperatorNode::LabelAddress: - return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args ); - case OperatorNode::AddressOf: - assert( args.size() == 1 ); - assert( args.front() ); - - return new AddressExpr( args.front() ); - case OperatorNode::Cast: - { - TypeValueNode * arg = dynamic_cast( get_args()); - assert( arg ); - - DeclarationNode *decl_node = arg->get_decl(); - ExpressionNode *expr_node = dynamic_cast( arg->get_link()); - - Type *targetType = decl_node->buildType(); - if ( dynamic_cast< VoidType* >( targetType ) ) { - delete targetType; - return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) ); - } else { - return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) ); - } // if - } - case OperatorNode::FieldSel: - { - assert( args.size() == 2 ); - - NameExpr *member = dynamic_cast( args.back()); - // TupleExpr *memberTup = dynamic_cast( args.back()); - - if ( member != 0 ) { - UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front()); - delete member; - return ret; - /* else if ( memberTup != 0 ) - { - UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front()); - delete member; - return ret; - } */ - } else - assert( false ); - } - case OperatorNode::PFieldSel: - { - assert( args.size() == 2 ); - - NameExpr *member = dynamic_cast( args.back()); // modify for Tuples xxx - assert( member != 0 ); - - UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); - deref->get_args().push_back( args.front() ); - - UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref ); + } // if + + switch ( op->get_type()) { + case OperatorNode::Incr: + case OperatorNode::Decr: + case OperatorNode::IncrPost: + case OperatorNode::DecrPost: + case OperatorNode::Assign: + case OperatorNode::MulAssn: + case OperatorNode::DivAssn: + case OperatorNode::ModAssn: + case OperatorNode::PlusAssn: + case OperatorNode::MinusAssn: + case OperatorNode::LSAssn: + case OperatorNode::RSAssn: + case OperatorNode::AndAssn: + case OperatorNode::ERAssn: + case OperatorNode::OrAssn: + // the rewrite rules for these expressions specify that the first argument has its address taken + assert( ! args.empty() ); + args.front() = new AddressExpr( args.front() ); + break; + default: + /* do nothing */ + ; + } + + switch ( op->get_type() ) { + case OperatorNode::Incr: + case OperatorNode::Decr: + case OperatorNode::IncrPost: + case OperatorNode::DecrPost: + case OperatorNode::Assign: + case OperatorNode::MulAssn: + case OperatorNode::DivAssn: + case OperatorNode::ModAssn: + case OperatorNode::PlusAssn: + case OperatorNode::MinusAssn: + case OperatorNode::LSAssn: + case OperatorNode::RSAssn: + case OperatorNode::AndAssn: + case OperatorNode::ERAssn: + case OperatorNode::OrAssn: + case OperatorNode::Plus: + case OperatorNode::Minus: + case OperatorNode::Mul: + case OperatorNode::Div: + case OperatorNode::Mod: + case OperatorNode::BitOr: + case OperatorNode::BitAnd: + case OperatorNode::Xor: + case OperatorNode::LShift: + case OperatorNode::RShift: + case OperatorNode::LThan: + case OperatorNode::GThan: + case OperatorNode::LEThan: + case OperatorNode::GEThan: + case OperatorNode::Eq: + case OperatorNode::Neq: + case OperatorNode::Index: + case OperatorNode::Range: + case OperatorNode::UnPlus: + case OperatorNode::UnMinus: + case OperatorNode::PointTo: + case OperatorNode::Neg: + case OperatorNode::BitNeg: + case OperatorNode::LabelAddress: + return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args ); + case OperatorNode::AddressOf: + assert( args.size() == 1 ); + assert( args.front() ); + + return new AddressExpr( args.front() ); + case OperatorNode::Cast: + { + TypeValueNode * arg = dynamic_cast( get_args()); + assert( arg ); + + DeclarationNode *decl_node = arg->get_decl(); + ExpressionNode *expr_node = dynamic_cast( arg->get_link()); + + Type *targetType = decl_node->buildType(); + if ( dynamic_cast< VoidType* >( targetType ) ) { + delete targetType; + return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) ); + } else { + return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) ); + } // if + } + case OperatorNode::FieldSel: + { + assert( args.size() == 2 ); + + NameExpr *member = dynamic_cast( args.back()); + // TupleExpr *memberTup = dynamic_cast( args.back()); + + if ( member != 0 ) { + UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front()); delete member; return ret; + /* else if ( memberTup != 0 ) + { + UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front()); + delete member; + return ret; + } */ + } else + assert( false ); + } + case OperatorNode::PFieldSel: + { + assert( args.size() == 2 ); + + NameExpr *member = dynamic_cast( args.back()); // modify for Tuples xxx + assert( member != 0 ); + + UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); + deref->get_args().push_back( args.front() ); + + UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref ); + delete member; + return ret; + } + case OperatorNode::AlignOf: + case OperatorNode::SizeOf: + { +/// bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf ); + + if ( TypeValueNode * arg = dynamic_cast( get_args()) ) { + return new SizeofExpr( arg->get_decl()->buildType()); + } else { + return new SizeofExpr( args.front()); + } // if + } + case OperatorNode::Attr: + { + VarRefNode *var = dynamic_cast( get_args()); + assert( var ); + if ( ! get_args()->get_link() ) { + return new AttrExpr( var->build(), ( Expression*)0); + } else if ( TypeValueNode * arg = dynamic_cast( get_args()->get_link()) ) { + return new AttrExpr( var->build(), arg->get_decl()->buildType()); + } else { + return new AttrExpr( var->build(), args.back()); + } // if + } + case OperatorNode::CompLit: + throw UnimplementedError( "C99 compound literals" ); + // the short-circuited operators + case OperatorNode::Or: + case OperatorNode::And: + assert( args.size() == 2); + return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) ); + case OperatorNode::Cond: + { + assert( args.size() == 3); + std::list< Expression* >::const_iterator i = args.begin(); + Expression *arg1 = notZeroExpr( *i++ ); + Expression *arg2 = *i++; + Expression *arg3 = *i++; + return new ConditionalExpr( arg1, arg2, arg3 ); + } + case OperatorNode::NCond: + throw UnimplementedError( "GNU 2-argument conditional expression" ); + case OperatorNode::Comma: + { + assert( args.size() == 2); + std::list< Expression* >::const_iterator i = args.begin(); + Expression *ret = *i++; + while ( i != args.end() ) { + ret = new CommaExpr( ret, *i++ ); } - case OperatorNode::AlignOf: - case OperatorNode::SizeOf: - { -/// bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf ); - - if ( TypeValueNode * arg = dynamic_cast( get_args()) ) { - return new SizeofExpr( arg->get_decl()->buildType()); - } else { - return new SizeofExpr( args.front()); - } // if - } - case OperatorNode::Attr: - { - VarRefNode *var = dynamic_cast( get_args()); - assert( var ); - if ( ! get_args()->get_link() ) { - return new AttrExpr( var->build(), ( Expression*)0); - } else if ( TypeValueNode * arg = dynamic_cast( get_args()->get_link()) ) { - return new AttrExpr( var->build(), arg->get_decl()->buildType()); - } else { - return new AttrExpr( var->build(), args.back()); - } // if - } - case OperatorNode::CompLit: - throw UnimplementedError( "C99 compound literals" ); - // the short-circuited operators - case OperatorNode::Or: - case OperatorNode::And: - assert( args.size() == 2); - return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) ); - case OperatorNode::Cond: - { - assert( args.size() == 3); - std::list< Expression* >::const_iterator i = args.begin(); - Expression *arg1 = notZeroExpr( *i++ ); - Expression *arg2 = *i++; - Expression *arg3 = *i++; - return new ConditionalExpr( arg1, arg2, arg3 ); - } - case OperatorNode::NCond: - throw UnimplementedError( "GNU 2-argument conditional expression" ); - case OperatorNode::Comma: - { - assert( args.size() == 2); - std::list< Expression* >::const_iterator i = args.begin(); - Expression *ret = *i++; - while ( i != args.end() ) { - ret = new CommaExpr( ret, *i++ ); - } - return ret; - } - // Tuples - case OperatorNode::TupleC: - { - TupleExpr *ret = new TupleExpr(); - std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) ); - return ret; - } - default: - // shouldn't happen - return 0; - } - } + return ret; + } + // Tuples + case OperatorNode::TupleC: + { + TupleExpr *ret = new TupleExpr(); + std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) ); + return ret; + } + default: + // shouldn't happen + return 0; + } // switch } @@ -598,4 +615,6 @@ } +//############################################################################## + CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {} @@ -615,4 +634,6 @@ } +//############################################################################## + ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {} @@ -637,4 +658,6 @@ return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) ); } + +//############################################################################## ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) { @@ -689,10 +712,10 @@ } -TypeValueNode::TypeValueNode( DeclarationNode *decl ) - : decl( decl ) { -} - -TypeValueNode::TypeValueNode( const TypeValueNode &other ) - : ExpressionNode( other ), decl( maybeClone( other.decl ) ) { +//############################################################################## + +TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) { +} + +TypeValueNode::TypeValueNode( const TypeValueNode &other ) : ExpressionNode( other ), decl( maybeClone( other.decl ) ) { } @@ -712,14 +735,12 @@ ExpressionNode *flattenCommas( ExpressionNode *list ) { - if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) - { - OperatorNode *op; - if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) - { - if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) ) - composite->add_arg( next ); - return flattenCommas( composite->get_args() ); - } - } + if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) { + OperatorNode *op; + if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) { + if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) ) + composite->add_arg( next ); + return flattenCommas( composite->get_args() ); + } // if + } // if if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) ) @@ -734,5 +755,5 @@ if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) ) return composite->get_args(); - } + } // if return tuple; } Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 59db6897195376150fdc27245cae3d51cc615cd4) +++ src/Parser/ParseNode.h (revision cd623a4e93c2eeb566858071f03b3e141d60d50c) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 6 23:35:33 2015 -// Update Count : 60 +// Last Modified On : Sun Jun 7 07:42:50 2015 +// Update Count : 64 // @@ -101,13 +101,10 @@ class ConstantNode : public ExpressionNode { public: - enum Type { - Integer, Float, Character, String /* , Range, EnumConstant */ - }; + enum Type { Integer, Float, Character, String }; ConstantNode( Type, std::string * ); virtual ConstantNode *clone() const { return new ConstantNode( *this ); } - - Type get_type() const ; + Type get_type( void ) const { return type; } virtual void print( std::ostream &, int indent = 0) const; virtual void printOneLine( std::ostream &, int indent = 0) const; Index: src/Parser/lex.cc =================================================================== --- src/Parser/lex.cc (revision 59db6897195376150fdc27245cae3d51cc615cd4) +++ src/Parser/lex.cc (revision cd623a4e93c2eeb566858071f03b3e141d60d50c) @@ -1390,6 +1390,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Fri Jun 5 17:50:17 2015 - * Update Count : 373 + * Last Modified On : Sun Jun 7 07:14:16 2015 + * Update Count : 374 */ #line 19 "lex.ll" @@ -1779,5 +1779,5 @@ ; YY_BREAK -/* ignore C style comments */ +/* ignore C style comments (ALSO HANDLED BY CPP) */ case 3: YY_RULE_SETUP @@ -1796,5 +1796,5 @@ { BEGIN 0; } YY_BREAK -/* ignore C++ style comments */ +/* ignore C++ style comments (ALSO HANDLED BY CPP) */ case 6: /* rule 6 can match eol */ @@ -2354,5 +2354,5 @@ YY_RULE_SETUP #line 299 "lex.ll" -{} // continuation +{} // continuation (ALSO HANDLED BY CPP) YY_BREAK case 115: Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 59db6897195376150fdc27245cae3d51cc615cd4) +++ src/Parser/lex.ll (revision cd623a4e93c2eeb566858071f03b3e141d60d50c) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Fri Jun 5 17:50:17 2015 - * Update Count : 373 + * Last Modified On : Sun Jun 7 07:14:16 2015 + * Update Count : 374 */ @@ -167,11 +167,11 @@ ^{h_white}*"#"[^\n]*"\n" ; - /* ignore C style comments */ + /* ignore C style comments (ALSO HANDLED BY CPP) */ "/*" { BEGIN COMMENT; } -.|\n ; -"*/" { BEGIN 0; } - - /* ignore C++ style comments */ -"//"[^\n]*"\n" ; +.|\n ; +"*/" { BEGIN 0; } + + /* ignore C++ style comments (ALSO HANDLED BY CPP) */ +"//"[^\n]*"\n" ; /* ignore whitespace */ @@ -297,5 +297,5 @@ /* common character/string constant */ {escape_seq} { rm_underscore(); *strtext += std::string( yytext ); } -"\\"{h_white}*"\n" {} // continuation +"\\"{h_white}*"\n" {} // continuation (ALSO HANDLED BY CPP) "\\" { *strtext += std::string( yytext ); } // unknown escape character Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 59db6897195376150fdc27245cae3d51cc615cd4) +++ src/SynTree/Expression.cc (revision cd623a4e93c2eeb566858071f03b3e141d60d50c) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jun 6 14:13:39 2015 -// Update Count : 14 +// Last Modified On : Sat Jun 6 23:43:22 2015 +// Update Count : 15 // @@ -72,5 +72,5 @@ void ConstantExpr::print( std::ostream &os, int indent ) const { - os << std::string( indent, ' ' ) << "constant expression: " ; + os << "constant expression: " ; constant.print( os ); Expression::print( os, indent );