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
===================================================================
Index: Synopsis_0_8/src/Synopsis/PTree/Node.hh
===================================================================
Index: Synopsis_0_8/src/Synopsis/PTree/Visitor.hh
===================================================================
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)
@@ -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)
@@ -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)
@@ -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)
@@ -534,7 +534,7 @@ 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 
@@ -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;
@@ -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);
@@ -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)
@@ -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();
@@ -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();
@@ -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;
@@ -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_();
@@ -2737,15 +2737,16 @@ 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;
@@ -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);
@@ -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;
 
@@ -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;
@@ -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) != '(')
@@ -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;
@@ -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!
@@ -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);
Index: Synopsis_0_8/src/Synopsis/TypeAnalysis/ConstEvaluator.cc
===================================================================
Index: Synopsis_0_8/src/Synopsis/Parser.hh
===================================================================
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.
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
 -------