Index: Synopsis_0_8/Synopsis/Parsers/C/ParserImpl.cc =================================================================== --- Synopsis_0_8/Synopsis/Parsers/C/ParserImpl.cc (revision 1735) +++ Synopsis_0_8/Synopsis/Parsers/C/ParserImpl.cc (working copy) @@ -58,7 +58,7 @@ PyObject *parse(PyObject * /* self */, P ErrorHandler error_handler(); // if (verbose) ::verbose = true; - if (debug) Synopsis::Trace::enable(Trace::TRANSLATION); + if (debug) Synopsis::Trace::enable(debug); if (!src || *src == '\0') { Index: Synopsis_0_8/Synopsis/process.py =================================================================== --- Synopsis_0_8/Synopsis/process.py (revision 1735) +++ Synopsis_0_8/Synopsis/process.py (working copy) @@ -61,6 +61,7 @@ def process(argv = sys.argv, **commands) props = {} # process all option arguments... for o, a in get_options(args): props[o] = a +# sys.stderr.write("""\nXYZZYX .%s. == .%s.\n"""%(props[o],a)) # ...and keep remaining (non-option) arguments as 'input' if args: props['input'] = args Index: Synopsis_0_8/src/tools/display-symbols.cc =================================================================== --- Synopsis_0_8/src/tools/display-symbols.cc (revision 1735) +++ Synopsis_0_8/src/tools/display-symbols.cc (working copy) @@ -1,5 +1,5 @@ // -// Copyright (C) 2005 Stefan Seefeld +// Copyright (C) 2005-2006 Stefan Seefeld // All rights reserved. // Licensed to the public under the terms of the GNU LGPL (>= 2), // see the file COPYING for details. @@ -15,12 +15,14 @@ #include using namespace Synopsis; - +namespace { int usage(const char *command) { - std::cerr << "Usage: " << command << " " << std::endl; + std::cerr << "Usage: " << command << " " << std::endl + << "\t-d\tDebug" << std::endl; return -1; } +} int main(int argc, char **argv) { Index: Synopsis_0_8/src/tools/display-ptree.cc =================================================================== --- Synopsis_0_8/src/tools/display-ptree.cc (revision 1735) +++ Synopsis_0_8/src/tools/display-ptree.cc (working copy) @@ -1,5 +1,5 @@ // -// Copyright (C) 2005 Stefan Seefeld +// Copyright (C) 2005-2006 Stefan Seefeld // All rights reserved. // Licensed to the public under the terms of the GNU LGPL (>= 2), // see the file COPYING for details. @@ -15,13 +15,18 @@ #include using namespace Synopsis; - +namespace { int usage(const char *command) { - std::cerr << "Usage: " << command << " [-c] [-g ] [-d] [-r] [-e] " << std::endl; + std::cerr << "Usage: " << command << " [-c] [-g ] [-d] [-r] [-e] " << std::endl + << "\t-c\tParse as C" << std::endl + << "\t-g\tDotfile" << std::endl + << "\t-e\tEncoding" << std::endl + << "\t-r\tTypeinfo" << std::endl + << "\t-d\tDebug" << std::endl; return -1; } - +} int main(int argc, char **argv) { bool encoding = false; Index: Synopsis_0_8/src/Synopsis/PTree/Atoms.hh =================================================================== --- Synopsis_0_8/src/Synopsis/PTree/Atoms.hh (revision 1735) +++ Synopsis_0_8/src/Synopsis/PTree/Atoms.hh (working copy) @@ -41,7 +41,7 @@ private: // class DupLeaf is used by Ptree::Make() and QuoteClass (qMake()). // The string given to the constructors are duplicated. -class DupAtom : public CommentedAtom +class DupAtom : public CommentedAtom { public: DupAtom(char const *, size_t); Index: Synopsis_0_8/src/Synopsis/PTree/Node.hh =================================================================== --- Synopsis_0_8/src/Synopsis/PTree/Node.hh (revision 1735) +++ Synopsis_0_8/src/Synopsis/PTree/Node.hh (working copy) @@ -21,7 +21,7 @@ namespace Synopsis namespace PTree { -class Node : public LightObject +class Node : public LightObject { public: virtual ~Node() {} @@ -53,14 +53,14 @@ protected: Node(Node *p, Node *q); private: - union + union { - struct + struct { Node *child; Node *next; } nonleaf; - struct + struct { const char* position; int length; @@ -68,7 +68,7 @@ private: } my_data; }; -class Iterator : public LightObject +class Iterator : public LightObject { public: Iterator(Node *p) { ptree = p;} @@ -86,7 +86,7 @@ private: Node *ptree; }; -class Array : public LightObject +class Array : public LightObject { public: Array(size_t = 8); Index: Synopsis_0_8/src/Synopsis/PTree/Visitor.hh =================================================================== --- Synopsis_0_8/src/Synopsis/PTree/Visitor.hh (revision 1735) +++ Synopsis_0_8/src/Synopsis/PTree/Visitor.hh (working copy) @@ -19,7 +19,7 @@ namespace PTree //. The default implementation does nothing, so you //. only need to implement the methods you actually need. //. Any types for which no corresponding 'visit' methods -//. exist will be caught by the 'visit' of the closest parent. +//. exist will be caught by the 'visit' of the closest parent. class Visitor { public: Index: Synopsis_0_8/src/Synopsis/PTree/operations.cc =================================================================== --- Synopsis_0_8/src/Synopsis/PTree/operations.cc (revision 1735) +++ Synopsis_0_8/src/Synopsis/PTree/operations.cc (working copy) @@ -192,7 +192,7 @@ Node *cons(Node *p, Node *q) return new List(p, q); } -List *list() +List *list() { return 0; } @@ -453,7 +453,7 @@ Node *snoc(Node *p, Node *q) return nconc(p, cons(q, 0)); } -/* nconc is desctructive append */ +/* nconc is destructive append */ Node *nconc(Node *p, Node *q) { Index: Synopsis_0_8/src/Synopsis/PTree/Node.cc =================================================================== --- Synopsis_0_8/src/Synopsis/PTree/Node.cc (revision 1735) +++ Synopsis_0_8/src/Synopsis/PTree/Node.cc (working copy) @@ -59,7 +59,7 @@ const char *Node::end() const { const char *e = PTree::nth(this, --n)->end(); if (e) return e; - } + } return 0; } } @@ -70,24 +70,24 @@ namespace Synopsis void MopErrorMessage(const char* where, const char* msg) { - std::cerr << "MOP error: in " << where << ", " << msg << '\n'; + std::cerr << "MOP error: in " << where << ", " << msg << std::endl; exit(1); } void MopErrorMessage2(const char* msg1, const char* msg2) { - std::cerr << "MOP error: " << msg1 << msg2 << '\n'; + std::cerr << "MOP error: " << msg1 << msg2 << std::endl; exit(1); } void MopWarningMessage(const char* where, const char* msg) { - std::cerr << "MOP warning: in " << where << ", " << msg << '\n'; + std::cerr << "MOP warning: in " << where << ", " << msg << std::endl; } void MopWarningMessage2(const char* msg1, const char* msg2) { - std::cerr << "MOP warning: " << msg1 << msg2 << '\n'; + std::cerr << "MOP warning: " << msg1 << msg2 << std::endl; } void MopMoreWarningMessage(const char* msg1, const char* msg2) @@ -96,7 +96,7 @@ void MopMoreWarningMessage(const char* m if(msg2 != 0) std::cerr << msg2; - std::cerr << '\n'; + std::cerr << std::endl; } } Index: Synopsis_0_8/src/Synopsis/Parser.cc =================================================================== --- Synopsis_0_8/src/Synopsis/Parser.cc (revision 1735) +++ Synopsis_0_8/src/Synopsis/Parser.cc (working copy) @@ -23,7 +23,7 @@ public: : my_filename(f), my_line(l), my_context(c) {} virtual void write(std::ostream &) const { - std::cerr << "Syntax error : " << my_filename << ':' << my_line + std::cerr << "Syntax error : " << my_filename << ':' << my_line << ": Error before '" << my_context << '\'' << std::endl; } private: @@ -53,7 +53,7 @@ private: class SymbolAlreadyDefined : public Parser::Error { public: - SymbolAlreadyDefined(PTree::Encoding const &name, + SymbolAlreadyDefined(PTree::Encoding const &name, std::string const & f1, unsigned long l1, std::string const & f2, unsigned long l2) : my_name(name), my_file1(f1), my_line1(l1), my_file2(f2), my_line2(l2) {} @@ -185,7 +185,7 @@ void set_leaf_comments(PTree::Node *node { std::cerr << "Warning: Failed to find leaf when trying to add comments." << std::endl; PTree::display(parent, std::cerr, false); - return; + return; } if (!(cleaf = dynamic_cast(leaf))) @@ -227,7 +227,7 @@ struct Parser::ScopeGuard noop = true; } } - ~ScopeGuard() + ~ScopeGuard() { if (!noop) parser.my_symbols.leave_scope(); parser.my_scope_is_valid = scope_was_valid; @@ -246,7 +246,7 @@ Parser::StatusGuard::StatusGuard(Parser { } -Parser::StatusGuard::~StatusGuard() +Parser::StatusGuard::~StatusGuard() { if (!my_committed) { @@ -384,7 +384,7 @@ bool Parser::definition(PTree::Node *&p) { Trace trace("Parser::definition", Trace::PARSING); bool res; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == ';') res = null_declaration(p); else if(t == Token::TYPEDEF) @@ -437,7 +437,7 @@ bool Parser::definition(PTree::Node *&p) } } } - else + else { PTree::Declaration *decl; if (!declaration(decl)) return false; @@ -500,7 +500,7 @@ bool Parser::type_specifier(PTree::Node // Do we need a new node type ('Typename') ? if(!opt_cv_qualifier(cv_q) || !opt_integral_type_or_class_spec(tspec, encode)) return false; - + if(!tspec) { if(check) @@ -534,10 +534,10 @@ bool Parser::type_specifier(PTree::Node // is_type_specifier() returns true if the next is probably a type specifier. bool Parser::is_type_specifier() { - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == Token::TYPENAME || t == Token::Identifier || t == Token::Scope || t == Token::CONST || t == Token::VOLATILE - || t == Token::CHAR || t == Token::WCHAR + || t == Token::CHAR || t == Token::WCHAR || t == Token::INT || t == Token::SHORT || t == Token::LONG || t == Token::SIGNED || t == Token::UNSIGNED || t == Token::FLOAT || t == Token::DOUBLE || t == Token::VOID || t == Token::BOOLEAN @@ -629,7 +629,7 @@ bool Parser::metaclass_decl(PTree::Node */ bool Parser::meta_arguments(PTree::Node *&args) { - int t; + Token::Type t; Token tk; int n = 1; @@ -751,7 +751,7 @@ bool Parser::namespace_alias(PTree::Name PTree::Node *n = new PTree::Identifier(tk); encode.simple_name(n); ++length; - + if(my_lexer.look_ahead(0) == Token::Scope) { my_lexer.get_token(tk); @@ -770,7 +770,7 @@ bool Parser::namespace_alias(PTree::Name if (my_lexer.get_token(tk) != ';') return false; - exp = new PTree::NamespaceAlias(ns, PTree::list(alias, eq, + exp = new PTree::NamespaceAlias(ns, PTree::list(alias, eq, name, new PTree::Atom(tk))); return true; } @@ -815,7 +815,7 @@ bool Parser::using_declaration(PTree::Us { Trace trace("Parser::user_declaration", Trace::PARSING); Token tk; - + if(my_lexer.get_token(tk) != Token::USING) return false; @@ -944,7 +944,7 @@ bool Parser::template_decl2(PTree::Templ PTree::List *params; if(my_lexer.get_token(tk) != Token::TEMPLATE) return false; - if(my_lexer.look_ahead(0) != '<') + if(my_lexer.look_ahead(0) != '<') { // template instantiation decl = 0; @@ -968,7 +968,7 @@ bool Parser::template_decl2(PTree::Templ decl = PTree::nconc(decl, PTree::list(params, new PTree::Atom(tk))); // FIXME: nested TEMPLATE is ignored - while (my_lexer.look_ahead(0) == Token::TEMPLATE) + while (my_lexer.look_ahead(0) == Token::TEMPLATE) { my_lexer.get_token(tk); if(my_lexer.look_ahead(0) != '<') break; @@ -1089,7 +1089,7 @@ bool Parser::type_parameter(PTree::Node decl = PTree::nconc(decl, PTree::list(new PTree::Atom(tk), default_type)); } } - else if (type == Token::TEMPLATE) + else if (type == Token::TEMPLATE) { TemplateDeclKind kind; PTree::TemplateDecl *tdecl; @@ -1125,21 +1125,21 @@ bool Parser::type_parameter(PTree::Node //. extern-template-decl: //. extern template declaration - bool Parser::extern_template_decl(PTree::Node *&decl) - { - Trace trace("Parser::extern_template_decl", Trace::PARSING); - Token tk1, tk2; - PTree::Declaration *body; - - if(my_lexer.get_token(tk1) != Token::EXTERN) return false; - if(my_lexer.get_token(tk2) != Token::TEMPLATE) return false; - if(!declaration(body)) return false; - - decl = new PTree::ExternTemplate(new PTree::Atom(tk1), - PTree::list(new PTree::Atom(tk2), body)); - return true; - } - + bool Parser::extern_template_decl(PTree::Node *&decl) + { + Trace trace("Parser::extern_template_decl", Trace::PARSING); + Token tk1, tk2; + PTree::Declaration *body; + + if(my_lexer.get_token(tk1) != Token::EXTERN) return false; + if(my_lexer.get_token(tk2) != Token::TEMPLATE) return false; + if(!declaration(body)) return false; + + decl = new PTree::ExternTemplate(new PTree::Atom(tk1), + PTree::list(new PTree::Atom(tk2), body)); + return true; + } + /* declaration : integral.declaration @@ -1205,7 +1205,7 @@ bool Parser::declaration(PTree::Declarat else { type_encode.clear(); - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(cv_q != 0 && ((t == Token::Identifier && my_lexer.look_ahead(1) == '=') || t == '*')) res = const_declaration(statement, type_encode, head, cv_q); @@ -1278,7 +1278,7 @@ bool Parser::integral_declaration(PTree: if(!function_body(body)) return false; if(PTree::length(decl) != 1) return false; - statement = PTree::snoc(def, body); + statement = PTree::snoc(def, body); return true; } } @@ -1396,7 +1396,7 @@ bool Parser::is_constructor_decl() return false; else { - int t = my_lexer.look_ahead(1); + Token::Type t = my_lexer.look_ahead(1); if(t == '*' || t == '&' || t == '(') return false; // declarator else if(t == Token::CONST || t == Token::VOLATILE) @@ -1414,20 +1414,20 @@ bool Parser::is_constructor_decl() */ bool Parser::is_ptr_to_member(int i) { - int t0 = my_lexer.look_ahead(i++); - + Token::Type t0 = my_lexer.look_ahead(i++); + if(t0 == Token::Scope) t0 = my_lexer.look_ahead(i++); while(t0 == Token::Identifier) { - int t = my_lexer.look_ahead(i++); + Token::Type t = my_lexer.look_ahead(i++); if(t == '<') { int n = 1; while(n > 0) { - int u = my_lexer.look_ahead(i++); + Token::Type u = my_lexer.look_ahead(i++); if(u == '<') ++n; else if(u == '>') --n; else if(u == '(') @@ -1435,7 +1435,7 @@ bool Parser::is_ptr_to_member(int i) int m = 1; while(m > 0) { - int v = my_lexer.look_ahead(i++); + Token::Type v = my_lexer.look_ahead(i++); if(v == '(') ++m; else if(v == ')') --m; else if(v == '\0' || v == ';' || v == '}') @@ -1465,7 +1465,7 @@ bool Parser::opt_member_spec(PTree::Node Trace trace("Parser::opt_member_spec", Trace::PARSING); Token tk; PTree::Node *lf; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); p = 0; while(t == Token::FRIEND || t == Token::INLINE || t == Token::VIRTUAL || @@ -1502,7 +1502,7 @@ bool Parser::opt_member_spec(PTree::Node bool Parser::opt_storage_spec(PTree::Node *&p) { Trace trace("Parser::opt_storage_spec", Trace::PARSING); - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == Token::STATIC || t == Token::EXTERN || t == Token::AUTO || t == Token::REGISTER || t == Token::MUTABLE) { @@ -1544,7 +1544,7 @@ bool Parser::opt_cv_qualifier(PTree::Nod PTree::Node *p = 0; while(true) { - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == Token::CONST || t == Token::VOLATILE) { Token tk; @@ -1581,7 +1581,7 @@ bool Parser::opt_integral_type_or_class_ { Trace trace("Parser::opt_integral_type_or_class_spec", Trace::PARSING); bool is_integral; - int t; + Token::Type t; char type = ' ', flag = ' '; is_integral = false; @@ -1755,7 +1755,7 @@ bool Parser::opt_throw_decl(PTree::Node { Trace trace("Parser::opt_throw_decl", Trace::PARSING); Token tk; - int t; + Token::Type t; PTree::Node *p = 0; if(my_lexer.look_ahead(0) == Token::THROW) @@ -1826,7 +1826,7 @@ bool Parser::init_declarator_list(PTree: encode = type_encode; if(!init_declarator(d, encode, should_be_declarator, is_statement)) return false; - + if (d && (PTree::type_of(d) == Token::ntDeclarator)) static_cast(d)->set_comments(comments); @@ -1872,7 +1872,7 @@ bool Parser::init_declarator(PTree::Node should_be_declarator, is_statement)) return false; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == '=') { my_lexer.get_token(tk); @@ -1936,19 +1936,18 @@ bool Parser::declarator2(PTree::Node *&d PTree::Node **declared_name) { Trace trace("Parser::declarator2", Trace::PARSING); - PTree::Encoding recursive_encode; - int t; - bool recursive_decl = false; PTree::Node *declared_name0 = 0; + PTree::Node *d; if(declared_name == 0) declared_name = &declared_name0; - PTree::Node *d; if(!opt_ptr_operator(d, type_encode)) return false; - t = my_lexer.look_ahead(0); + PTree::Encoding recursive_encode; + bool recursive_decl = false; + Token::Type t = my_lexer.look_ahead(0); if(t == '(') { char const * lex_save = my_lexer.save(); @@ -1963,7 +1962,7 @@ bool Parser::declarator2(PTree::Node *&d Token cp; if(my_lexer.get_token(cp) != ')') { - if (kind != kCastDeclarator) + if (kind != kCastDeclarator) return false; my_lexer.restore(lex_save); name_encode.clear(); @@ -2046,13 +2045,13 @@ bool Parser::declarator2(PTree::Node *&d if(!args_encode.empty()) type_encode.function(args_encode); - + opt_throw_decl(throw_decl); // ignore in this version if(my_lexer.look_ahead(0) == ':') if(member_initializers(mi)) d = PTree::snoc(d, mi); else return false; - + break; // "T f(int)(char)" is invalid. } else if(t == '[') @@ -2070,7 +2069,7 @@ bool Parser::declarator2(PTree::Node *&d long size; if (TypeAnalysis::evaluate_const(my_symbols.current_scope(), expr, size)) type_encode.array(size); - else + else type_encode.array(); } d = PTree::nconc(d, PTree::list(new PTree::Atom(ob), expr, @@ -2098,7 +2097,7 @@ bool Parser::opt_ptr_operator(PTree::Nod ptrs = 0; while(true) { - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t != '*' && t != '&' && !is_ptr_to_member(0)) break; else { @@ -2191,10 +2190,10 @@ bool Parser::name(PTree::Node *&id, PTre { Trace trace("Parser::name", Trace::PARSING); Token tk, tk2; - int t; + Token::Type t; int length = 0; - - if(my_lexer.look_ahead(0) == Token::Scope) + t = my_lexer.look_ahead(0); + if(t == Token::Scope) { my_lexer.get_token(tk); id = PTree::list(new PTree::Atom(tk)); @@ -2206,7 +2205,7 @@ bool Parser::name(PTree::Node *&id, PTre id = 0; // gcc keyword typeof(name) means type of the given name - if(my_lexer.look_ahead(0) == Token::TYPEOF) + if(t == Token::TYPEOF) { // TODO: Do proper type analysis. encode.anonymous(); @@ -2272,7 +2271,7 @@ bool Parser::name(PTree::Node *&id, PTre PTree::Node *op; PTree::Node *opf; if(!operator_name(op, encode)) return false; - + t = my_lexer.look_ahead(0); if(t != '<') opf = PTree::list(new PTree::Kwd::Operator(tk), op); else @@ -2310,7 +2309,7 @@ bool Parser::operator_name(PTree::Node * Trace trace("Parser::operator_name", Trace::PARSING); Token tk; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == '+' || t == '-' || t == '*' || t == '/' || t == '%' || t == '^' || t == '&' || t == '|' || t == '~' || t == '!' || t == '=' || t == '<' || t == '>' || t == Token::AssignOp || t == Token::ShiftOp || t == Token::EqualOp @@ -2438,7 +2437,7 @@ bool Parser::ptr_to_member(PTree::Node * else return false; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == '<') { PTree::Node *args; @@ -2504,7 +2503,7 @@ bool Parser::template_args(PTree::Node * type_encode.clear(); // Prefer type name, but if not ',' or '>' then must be expression - if(type_id(a, type_encode) && + if(type_id(a, type_encode) && (my_lexer.look_ahead(0) == ',' || my_lexer.look_ahead(0) == '>')) encode.append(type_encode); else @@ -2512,7 +2511,7 @@ bool Parser::template_args(PTree::Node * // FIXME: find the right place to put this. PGuard guard(*this, &Parser::my_gt_is_operator); my_gt_is_operator = false; - my_lexer.restore(pos); + my_lexer.restore(pos); if(!conditional_expr(a)) return false; encode.value_temp_param(); } @@ -2566,7 +2565,7 @@ bool Parser::parameter_declaration_list_ my_lexer.restore(pos); return(is_args = parameter_declaration_list(arglist, encode)); } - else + else if(is_args = parameter_declaration_list(arglist, encode)) return true; else { @@ -2593,7 +2592,7 @@ bool Parser::parameter_declaration_list( { PTree::ParameterDeclaration *pdecl; arg_encode.clear(); - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == ')') { if(list == 0) encode.void_(); @@ -2670,7 +2669,7 @@ bool Parser::parameter_declaration(PTree { my_lexer.get_token(tk); PTree::Node *init; - if(!initialize_expr(init)) return false; + if(!initialize_expr(init)) return false; decl = PTree::nconc(decl, PTree::list(new PTree::Atom(tk), init)); } return true; @@ -2683,7 +2682,7 @@ bool Parser::parameter_declaration(PTree // designator-list designator // designator: // [ constant-expression ] -// . identifier +// . identifier bool Parser::designation(PTree::Node *&d) { Trace trace("Parser::designation", Trace::PARSING); @@ -2729,6 +2728,7 @@ bool Parser::designation(PTree::Node *&d return true; } + /* initialize.expr : expression @@ -2737,20 +2737,22 @@ bool Parser::designation(PTree::Node *&d bool Parser::initialize_expr(PTree::Node *&exp) { Trace trace("Parser::initialize_expr", Trace::PARSING); - Token tk; + Token::Type t = my_lexer.look_ahead(0); PTree::Node *e, *elist; - if(my_lexer.look_ahead(0) != '{') return assign_expr(exp); + if(t != '{') return assign_expr(exp); else { + Token tk; my_lexer.get_token(tk); PTree::Node *ob = new PTree::Atom(tk); elist = 0; - int t = my_lexer.look_ahead(0); + t = my_lexer.look_ahead(0); while(t != '}') { PTree::Node *d = 0; if (!(my_ruleset & CXX) && (t == '.' || t == '[') && !designation(d)) return false; + t = my_lexer.look_ahead(0); if(!initialize_expr(e)) { @@ -2802,7 +2804,7 @@ bool Parser::function_arguments(PTree::N args = 0; if(my_lexer.look_ahead(0) == ')') return true; - + while(true) { if(!assign_expr(exp)) return false; @@ -2831,7 +2833,7 @@ bool Parser::enum_spec(PTree::EnumSpec * if(my_lexer.get_token(tk) != Token::ENUM) return false; spec = new PTree::EnumSpec(new PTree::Atom(tk)); - int t = my_lexer.get_token(tk); + Token::Type t = my_lexer.get_token(tk); if(t == Token::Identifier) { PTree::Node *name = new PTree::Atom(tk); @@ -2848,13 +2850,13 @@ bool Parser::enum_spec(PTree::EnumSpec * spec = PTree::snoc(spec, 0); } if(t != '{') return false; - + if(my_lexer.look_ahead(0) == '}') body = 0; else if(!enum_body(body)) return false; if(my_lexer.get_token(tk2) != '}') return false; - spec = PTree::snoc(spec, + spec = PTree::snoc(spec, new PTree::Brace(new PTree::Atom(tk), body, new PTree::CommentedAtom(tk2, wrap_comments(my_lexer.get_comments())))); declare(spec); @@ -2878,7 +2880,7 @@ bool Parser::enum_body(PTree::Node *&bod if(my_lexer.get_token(tk) != Token::Identifier) return false; PTree::Node *comments = wrap_comments(my_lexer.get_comments()); - + if(my_lexer.look_ahead(0, tk2) != '=') name = new PTree::CommentedAtom(tk, comments); else @@ -2929,7 +2931,7 @@ bool Parser::class_spec(PTree::ClassSpec if(my_lexer.look_ahead(0) == Token::UserKeyword) if(!userdef_keyword(head)) return false; - int t = my_lexer.get_token(tk); + Token::Type t = my_lexer.get_token(tk); PTree::Keyword *kwd; switch (t) { @@ -2993,7 +2995,7 @@ bool Parser::base_clause(PTree::Node *&b { Trace trace("Parser::base_clause", Trace::PARSING); Token tk; - int t; + Token::Type t; PTree::Node *name; PTree::Encoding encode; @@ -3028,7 +3030,7 @@ bool Parser::base_clause(PTree::Node *&b default : throw std::runtime_error("Parser::base_clause(): fatal"); } - + super = PTree::snoc(super, lf); t = my_lexer.look_ahead(0); } @@ -3086,7 +3088,7 @@ bool Parser::class_body(PTree::ClassBody } my_lexer.get_token(tk); - body = new PTree::ClassBody(ob, mems, + body = new PTree::ClassBody(ob, mems, new PTree::CommentedAtom(tk, wrap_comments(my_lexer.get_comments()))); return true; } @@ -3111,7 +3113,7 @@ bool Parser::class_member(PTree::Node *& Trace trace("Parser::class_member", Trace::PARSING); Token tk1, tk2; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == Token::PUBLIC || t == Token::PROTECTED || t == Token::PRIVATE) { PTree::Node *lf; @@ -3267,10 +3269,10 @@ bool Parser::assign_expr(PTree::Node *&e Trace trace("Parser::assign_expr", Trace::PARSING); Token::Type t = my_lexer.look_ahead(0); - - if (t == Token::THROW) return throw_expr(exp); + if (t == Token::THROW) return throw_expr(exp); PTree::Node *left; + if(!conditional_expr(left)) return false; t = my_lexer.look_ahead(0); if(t != '=' && t != Token::AssignOp) exp = left; @@ -3280,7 +3282,7 @@ bool Parser::assign_expr(PTree::Node *&e my_lexer.get_token(tk); PTree::Node *right; if(!assign_expr(right)) return false; - + exp = new PTree::AssignExpr(left, PTree::list(new PTree::Atom(tk), right)); } return true; @@ -3330,7 +3332,7 @@ bool Parser::logical_or_expr(PTree::Node my_lexer.get_token(tk); PTree::Node *right; if(!logical_and_expr(right)) return false; - + exp = new PTree::InfixExpr(exp, PTree::list(new PTree::Atom(tk), right)); } return true; @@ -3602,7 +3604,7 @@ bool Parser::type_id(PTree::Node *&tname if(!declarator(arg, kCastDeclarator, false, type_encode, name_encode, false)) return false; - tname = PTree::list(type_name, arg); + tname = PTree::list(type_name, arg); return true; } @@ -3653,7 +3655,7 @@ bool Parser::throw_expr(PTree::Node *&ex Token tk; if(my_lexer.get_token(tk) != Token::THROW) return false; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); PTree::Node *e = 0; // FIXME: what is that ?? if(t == ':' || t == ';') e = 0; @@ -3778,7 +3780,7 @@ bool Parser::allocate_expr(PTree::Node * PTree::Node *head = 0; bool ukey = false; - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(t == Token::Scope) { my_lexer.get_token(tk); @@ -3834,7 +3836,7 @@ bool Parser::userdef_keyword(PTree::Node { Token tk; - int t = my_lexer.get_token(tk); + Token::Type t = my_lexer.get_token(tk); if(t != Token::UserKeyword && t != Token::UserKeyword5) return false; if(my_lexer.look_ahead(0) != '(') @@ -3952,7 +3954,7 @@ bool Parser::new_declarator(PTree::Decla long size; if (TypeAnalysis::evaluate_const(my_symbols.current_scope(), expr, size)) encode.array(size); - else + else encode.array(); } decl = PTree::nconc(decl, PTree::list(new PTree::Atom(ob), expr, @@ -4115,7 +4117,6 @@ bool Parser::primary_expr(PTree::Node *& Token tk, tk2; PTree::Node *exp2; PTree::Encoding cast_type_encode; - switch(my_lexer.look_ahead(0)) { case Token::Constant: @@ -4206,7 +4207,7 @@ bool Parser::typeof_expr(PTree::Node *&n if (!assign_expr(node)) return false; #else PTree::Encoding name_encode; - if (!name(node, name_encode)) return false; + if (!name(node, name_encode)) return false; if (!node->is_atom()) node = new PTree::Name(node, name_encode); else @@ -4302,7 +4303,7 @@ bool Parser::var_name_core(PTree::Node * Trace trace("Parser::var_name_core", Trace::PARSING); Token tk; int length = 0; - + if(my_lexer.look_ahead(0) == Token::Scope) { my_lexer.get_token(tk); @@ -4315,7 +4316,7 @@ bool Parser::var_name_core(PTree::Node * while(true) { Token::Type t = my_lexer.get_token(tk); - if(t == Token::TEMPLATE) + if(t == Token::TEMPLATE) { // Skip template token, next will be identifier t = my_lexer.get_token(tk); @@ -4381,9 +4382,10 @@ bool Parser::var_name_core(PTree::Node * bool Parser::more_var_name() { Trace trace("Parser::more_var_name", Trace::PARSING); - if(my_lexer.look_ahead(0) == Token::Scope) + Token::Type t = my_lexer.look_ahead(0); + if(t == Token::Scope) { - int t = my_lexer.look_ahead(1); + t = my_lexer.look_ahead(1); if(t == Token::Identifier || t == '~' || t == Token::OPERATOR || t == Token::TEMPLATE) return true; @@ -4399,13 +4401,13 @@ bool Parser::more_var_name() bool Parser::is_template_args() { int i = 0; - int t = my_lexer.look_ahead(i++); + Token::Type t = my_lexer.look_ahead(i++); if(t == '<') { int n = 1; while(n > 0) { - int u = my_lexer.look_ahead(i++); + Token::Type u = my_lexer.look_ahead(i++); if(u == '<') ++n; else if(u == '>') --n; else if(u == '(') @@ -4413,7 +4415,7 @@ bool Parser::is_template_args() int m = 1; while(m > 0) { - int v = my_lexer.look_ahead(i++); + Token::Type v = my_lexer.look_ahead(i++); if(v == '(') ++m; else if(v == ')') --m; else if(v == '\0' || v == ';' || v == '}') return false; @@ -4438,14 +4440,14 @@ bool Parser::condition(PTree::Node *&exp // Do declarator first, otherwise "T*foo = blah" gets matched as a // multiplication infix expression inside an assignment expression! const char *save = my_lexer.save(); - do + do { PTree::Node *storage_s, *cv_q, *cv_q2, *integral, *head, *decl; if (!opt_storage_spec(storage_s)) break; head = storage_s; - + if (!opt_cv_qualifier(cv_q) || !opt_integral_type_or_class_spec(integral, type_encode)) break; @@ -4569,7 +4571,7 @@ bool Parser::statement(PTree::Node *&st) Trace trace("Parser::statement", Trace::PARSING); Token tk1, tk2, tk3; PTree::Node *st2, *exp, *comments; - int k; + Token::Type k; // Get the comments - if we dont make it past the switch then it is a // parse error anyway! @@ -4646,7 +4648,7 @@ bool Parser::statement(PTree::Node *&st) my_lexer.get_token(tk2); st = new PTree::ReturnStatement(new PTree::Kwd::Return(tk1), PTree::list(new PTree::Atom(tk2))); - } + } else { if(!expression(exp)) return false; @@ -4888,7 +4890,7 @@ bool Parser::expr_statement(PTree::Node { Trace trace("Parser::expr_statement", Trace::PARSING); Token tk; - + Token::Type t = my_lexer.look_ahead(0); if(my_lexer.look_ahead(0) == ';') { my_lexer.get_token(tk); @@ -4982,7 +4984,7 @@ bool Parser::declaration_statement(PTree else { type_encode.clear(); - int t = my_lexer.look_ahead(0); + Token::Type t = my_lexer.look_ahead(0); if(cv_q != 0 && ((t == Token::Identifier && my_lexer.look_ahead(1) == '=') || t == '*')) return const_declaration(statement, type_encode, head, cv_q); @@ -5020,7 +5022,7 @@ bool Parser::integral_decl_statement(PTr { if(!init_declarator_list(decl, type_encode, false, true)) return false; if(my_lexer.get_token(tk) != ';') return false; - + statement = new PTree::Declaration(head, PTree::list(integral, decl, new PTree::Atom(tk))); return true; Index: Synopsis_0_8/src/Synopsis/TypeAnalysis/ConstEvaluator.cc =================================================================== --- Synopsis_0_8/src/Synopsis/TypeAnalysis/ConstEvaluator.cc (revision 1735) +++ Synopsis_0_8/src/Synopsis/TypeAnalysis/ConstEvaluator.cc (working copy) @@ -81,7 +81,7 @@ void ConstEvaluator::visit(Literal *node { case Token::Constant: { - if (*node->position() == '0' && + if (*node->position() == '0' && (node->position()[1] == 'x' || node->position()[1] == 'X')) { iss.setf(std::ios::hex, std::ios::basefield); @@ -112,7 +112,7 @@ void ConstEvaluator::visit(Identifier *n Encoding name(node->position(), node->length()); SymbolSet symbols = my_scope->lookup(name); ConstName const *const_ = 0; - if (symbols.size() == 1) + if (symbols.size() == 1) const_ = dynamic_cast(*symbols.begin()); if (!const_ || !const_->defined()) my_valid = false; else @@ -221,14 +221,14 @@ void ConstEvaluator::visit(UnaryExpr *no if (op->length() == 1) switch (*op->position()) // '*' and '&' do not apply to constant expressions { - case '+': break; + case '+': break; case '-': my_value = -my_value; break; - case '!': + case '!': my_value = !my_value; break; - case '~': + case '~': my_value = ~my_value; break; default: Index: Synopsis_0_8/src/Synopsis/Parser.hh =================================================================== --- Synopsis_0_8/src/Synopsis/Parser.hh (revision 1735) +++ Synopsis_0_8/src/Synopsis/Parser.hh (working copy) @@ -55,7 +55,7 @@ public: private: enum DeclKind { kDeclarator, kArgDeclarator, kCastDeclarator }; - enum TemplateDeclKind { tdk_unknown, tdk_decl, tdk_instantiation, + enum TemplateDeclKind { tdk_unknown, tdk_decl, tdk_instantiation, tdk_specialization, num_tdks }; struct ScopeGuard; @@ -121,7 +121,7 @@ private: //. template < template-parameter-list > class identifier [opt] //. template < template-parameter-list > class identifier [opt] = id-expression bool type_parameter(PTree::Node *&); - + //. GNU extension: //. extern-template-decl: //. extern template declaration @@ -158,7 +158,7 @@ private: bool opt_integral_type_or_class_spec(PTree::Node *&, PTree::Encoding&); bool constructor_decl(PTree::Node *&, PTree::Encoding&); bool opt_throw_decl(PTree::Node *&); - + //. [gram.dcl.decl] bool init_declarator_list(PTree::Node *&, PTree::Encoding&, bool, bool = false); bool init_declarator(PTree::Node *&, PTree::Encoding&, bool, bool); @@ -171,13 +171,13 @@ private: bool opt_ptr_operator(PTree::Node *&, PTree::Encoding&); bool member_initializers(PTree::Node *&); bool member_init(PTree::Node *&); - + bool name(PTree::Node *&, PTree::Encoding&); bool operator_name(PTree::Node *&, PTree::Encoding&); bool cast_operator_name(PTree::Node *&, PTree::Encoding&); bool ptr_to_member(PTree::Node *&, PTree::Encoding&); bool template_args(PTree::Node *&, PTree::Encoding&); - + bool parameter_declaration_list_or_init(PTree::Node *&, bool&, PTree::Encoding&, bool); bool parameter_declaration_list(PTree::Node *&, PTree::Encoding&); @@ -188,11 +188,11 @@ private: //. decl-specifier-seq abstract-declarator [opt] //. decl-specifier-seq abstract-declarator [opt] = assignment-expression bool parameter_declaration(PTree::ParameterDeclaration *&, PTree::Encoding&); - + bool function_arguments(PTree::Node *&); bool designation(PTree::Node *&); bool initialize_expr(PTree::Node *&); - + bool enum_spec(PTree::EnumSpec *&, PTree::Encoding&); bool enum_body(PTree::Node *&); bool class_spec(PTree::ClassSpec *&, PTree::Encoding&); @@ -210,7 +210,7 @@ private: bool class_member(PTree::Node *&); bool access_decl(PTree::Node *&); bool user_access_spec(PTree::Node *&); - + //. expression: //. assignment-expression //. expression , assignment-expression @@ -348,7 +348,7 @@ private: bool var_name(PTree::Node *&); bool var_name_core(PTree::Node *&, PTree::Encoding&); bool is_template_args(); - + //. function-body: //. compound-statement bool function_body(PTree::Block *&); @@ -391,7 +391,7 @@ private: //. type-specifier-seq //. ... bool try_block(PTree::Node *&); - + bool expr_statement(PTree::Node *&); bool declaration_statement(PTree::Declaration *&); bool integral_decl_statement(PTree::Declaration *&, PTree::Encoding&, PTree::Node *, PTree::Node *, PTree::Node *); @@ -399,7 +399,7 @@ private: bool maybe_typename_or_class_template(Token&); void skip_to(Token::Type token); - + private: bool more_var_name(); Index: Synopsis_0_8/src/Synopsis/Lexer.cc =================================================================== --- Synopsis_0_8/src/Synopsis/Lexer.cc (revision 1735) +++ Synopsis_0_8/src/Synopsis/Lexer.cc (working copy) @@ -1,5 +1,5 @@ // -// Copyright (C) 2004 Stefan Seefeld +// Copyright (C) 2004-2006 Stefan Seefeld // All rights reserved. // Licensed to the public under the terms of the GNU LGPL (>= 2), // see the file COPYING for details. @@ -357,7 +357,7 @@ char Lexer::get_next_non_white_char() if(c != '\\') break; c = my_buffer->get(); - if(c != '\n' && c!= '\r') + if(c != '\n' && c!= '\r') { my_buffer->unget(); break; @@ -421,7 +421,7 @@ Token::Type Lexer::read_line() ++my_token.length; return Token::WideCharConst; } - } + } else { if(read_str_const(top+1)) @@ -627,7 +627,7 @@ Token::Type Lexer::read_separator(char c case '!' : return Token::EqualOp; case '<' : case '>' : return Token::RelOp; - default : + default : my_buffer->unget(); my_token.length = 1; return single_char_op(c); @@ -701,7 +701,7 @@ Token::Type Lexer::single_char_op(unsign if('!' <= c && c <= '?' && valid[c - '!'] == 'x') return c; else if(c == '[' || c == ']' || c == '^') return c; else if('{' <= c && c <= '~') return c; - else if(c == '#') + else if(c == '#') { // Skip to end of line do{ c = my_buffer->get();} Index: Synopsis_0_8/README =================================================================== --- Synopsis_0_8/README (revision 1735) +++ Synopsis_0_8/README (working copy) @@ -52,6 +52,9 @@ Building instead of the built in one, run 'python setup.py config --with-gc-prefix=/your/gc/prefix' +* To clean the temporary object files do 'python setup.py clean' + or 'python setup.py clean -a' to clean all object files. + Testing -------