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 <fstream>
 
 using namespace Synopsis;
-
+namespace {
 int usage(const char *command)
 {
-  std::cerr << "Usage: " << command << " <input>" << std::endl;
+  std::cerr << "Usage: " << command << " <input>" << 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 <fstream>
 
 using namespace Synopsis;
-
+namespace {
 int usage(const char *command)
 {
-  std::cerr << "Usage: " << command << " [-c] [-g <filename>] [-d] [-r] [-e] <input>" << std::endl;
+  std::cerr << "Usage: " << command << " [-c] [-g <filename>] [-d] [-r] [-e] <input>" << 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<PTree::CommentedAtom *>(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<PTree::Declarator*>(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<bool> 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<ConstName const *>(*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
 -------
 
