[phc-internals] [phc commit] r782 - in trunk/src: codegen generated generated_src

[codesite-noreply at google.com]

Author: edskodevries
Date: Sun Oct  7 03:11:32 2007
New Revision: 782

Modified:
   trunk/src/codegen/AST_to_HIR.h
   trunk/src/generated/HIR-contexts
   trunk/src/generated/HIR.cpp
   trunk/src/generated/HIR.h
   trunk/src/generated/HIR_factory.cpp
   trunk/src/generated/HIR_fold.h
   trunk/src/generated/HIR_transform.cpp
   trunk/src/generated/HIR_transform.h
   trunk/src/generated/HIR_visitor.cpp
   trunk/src/generated/HIR_visitor.h
   trunk/src/generated_src/hir.tea

Log:
Started work on the HIR definition. Removed all obviously redundant constructs
(control flow statements, special forms of assignment). There is one construct
that we may still be able to remove (post_op) -- not yet sure. After 
this, we
should start removing references to 'expr' and replace them by 'VAR_NAME'.


Modified: trunk/src/codegen/AST_to_HIR.h
==============================================================================
--- trunk/src/codegen/AST_to_HIR.h	(original)
+++ trunk/src/codegen/AST_to_HIR.h	Sun Oct  7 03:11:32 2007
@@ -11,86 +11,95 @@
 #include "AST_fold.h"
 #include "HIR.h"

+/*
+ * Those AST nodes that should no longer appear in the HIR do not have an
+ * implementation in this translation, so that we inherit the default assert(0)
+ * implementation from AST_fold. However, to satisfy the typechecker, 
we must
+ * still provide a reasonble type for these nodes. For example, the 
type we
+ * specify for AST_for (which does not have a corresponding HIR 
construct) is
+ * simplify HIR::HIR_statement*. For some constructs, specifying HIR::HIR_node*
+ * suffices.
+ */
 class AST_to_HIR : public AST::AST_fold
-<HIR::HIR_node*,
- HIR::HIR_php_script*,
- HIR::HIR_statement*,
- HIR::HIR_class_def*,
- HIR::HIR_class_mod*,
- HIR::HIR_interface_def*,
- HIR::HIR_member*,
- HIR::HIR_method*,
- HIR::HIR_signature*,
- HIR::HIR_method_mod*,
- HIR::HIR_formal_parameter*,
- HIR::HIR_type*,
- HIR::HIR_attribute*,
- HIR::HIR_attr_mod*,
- HIR::HIR_if*,
- HIR::HIR_while*,
- HIR::HIR_do*,
- HIR::HIR_for*,
- HIR::HIR_foreach*,
- HIR::HIR_switch*,
- HIR::HIR_switch_case*,
- HIR::HIR_break*,
- HIR::HIR_continue*,
- HIR::HIR_return*,
- HIR::HIR_static_declaration*,
- HIR::HIR_global*,
- HIR::HIR_declare*,
- HIR::HIR_directive*,
- HIR::HIR_try*,
- HIR::HIR_catch*,
- HIR::HIR_throw*,
- HIR::HIR_eval_expr*,
- HIR::HIR_nop*,
- HIR::HIR_branch*,
- HIR::HIR_goto*,
- HIR::HIR_label*,
- HIR::HIR_expr*,
- HIR::HIR_literal*,
- HIR::HIR_assignment*,
- HIR::HIR_op_assignment*,
- HIR::HIR_list_assignment*,
- HIR::HIR_list_element*,
- HIR::HIR_nested_list_elements*,
- HIR::HIR_cast*,
- HIR::HIR_unary_op*,
- HIR::HIR_bin_op*,
- HIR::HIR_conditional_expr*,
- HIR::HIR_ignore_errors*,
- HIR::HIR_constant*,
- HIR::HIR_instanceof*,
- HIR::HIR_variable*,
- HIR::HIR_variable_name*,
- HIR::HIR_reflection*,
- HIR::HIR_target*,
- HIR::HIR_pre_op*,
- HIR::HIR_post_op*,
- HIR::HIR_array*,
- HIR::HIR_array_elem*,
- HIR::HIR_method_invocation*,
- HIR::HIR_method_name*,
- HIR::HIR_actual_parameter*,
- HIR::HIR_new*,
- HIR::HIR_class_name*,
- HIR::HIR_commented_node*,
- HIR::HIR_identifier*,
- HIR::Token_class_name*,
- HIR::Token_interface_name*,
- HIR::Token_method_name*,
- HIR::Token_variable_name*,
- HIR::Token_directive_name*,
- HIR::Token_label_name*,
- HIR::Token_int*,
- HIR::Token_real*,
- HIR::Token_string*,
- HIR::Token_bool*,
- HIR::Token_null*,
- HIR::Token_op*,
- HIR::Token_cast*,
- HIR::Token_constant_name*>
+<HIR::HIR_node*,				// AST_node*
+ HIR::HIR_php_script*,			// AST_php_script*
+ HIR::HIR_statement*,			// AST_statement*
+ HIR::HIR_class_def*,			// AST_class_def*
+ HIR::HIR_class_mod*,			// AST_class_mod*
+ HIR::HIR_interface_def*,		// AST_interface_def*
+ HIR::HIR_member*,				// AST_member*
+ HIR::HIR_method*,				// AST_method*
+ HIR::HIR_signature*,			// AST_signature*
+ HIR::HIR_method_mod*,			// AST_method_mod*
+ HIR::HIR_formal_parameter*,	// AST_formal_parameter*
+ HIR::HIR_type*,				// AST_type*
+ HIR::HIR_attribute*,			// AST_attribute*
+ HIR::HIR_attr_mod*,			// AST_attr_mod*
+ HIR::HIR_statement*,			// AST_if*
+ HIR::HIR_statement*,			// AST_while*
+ HIR::HIR_statement*,			// AST_do*
+ HIR::HIR_statement*,			// AST_for*
+ HIR::HIR_statement*,			// AST_foreach*
+ HIR::HIR_statement*,			// AST_switch*
+ HIR::HIR_node*,				// AST_switch_case*
+ HIR::HIR_statement*,			// AST_break*
+ HIR::HIR_statement*,			// AST_continue*
+ HIR::HIR_return*,				// AST_return*
+ HIR::HIR_static_declaration*,	// AST_static_declaration*
+ HIR::HIR_global*,				// AST_global*
+ HIR::HIR_statement*,			// AST_declare*
+ HIR::HIR_node*,				// AST_directive*
+ HIR::HIR_try*,					// AST_try*
+ HIR::HIR_catch*,				// AST_catch*
+ HIR::HIR_throw*,				// AST_throw*
+ HIR::HIR_eval_expr*,			// AST_eval_expr*
+ HIR::HIR_statement*,			// AST_nop*
+ HIR::HIR_branch*,				// AST_branch*
+ HIR::HIR_goto*,				// AST_goto*
+ HIR::HIR_label*,				// AST_label*
+ HIR::HIR_expr*,				// AST_expr*
+ HIR::HIR_literal*,				// AST_literal*
+ HIR::HIR_assignment*,			// AST_assignment*
+ HIR::HIR_expr*,				// AST_op_assignment*
+ HIR::HIR_expr*,				// AST_list_assignment*
+ HIR::HIR_node*,				// AST_list_element*
+ HIR::HIR_node*,				// AST_nested_list_elements*
+ HIR::HIR_cast*,				// AST_cast*
+ HIR::HIR_unary_op*,			// AST_unary_op*
+ HIR::HIR_bin_op*,				// AST_bin_op*
+ HIR::HIR_expr*,				// AST_conditional_expr*
+ HIR::HIR_expr*,				// AST_ignore_errors*
+ HIR::HIR_constant*,			// AST_constant*
+ HIR::HIR_instanceof*,			// AST_instanceof*
+ HIR::HIR_variable*,			// AST_variable*
+ HIR::HIR_variable_name*,		// AST_variable_name*
+ HIR::HIR_reflection*,			// AST_reflection*
+ HIR::HIR_target*,				// AST_target*
+ HIR::HIR_pre_op*,				// AST_pre_op*
+ HIR::HIR_post_op*,				// AST_post_op*
+ HIR::HIR_array*,				// AST_array*
+ HIR::HIR_array_elem*,			// AST_array_elem*
+ HIR::HIR_method_invocation*,	// AST_method_invocation*
+ HIR::HIR_method_name*,			// AST_method_name*
+ HIR::HIR_actual_parameter*,	// AST_actual_parameter*
+ HIR::HIR_new*,					// AST_new*
+ HIR::HIR_class_name*,			// AST_class_name*
+ HIR::HIR_node*,				// AST_commented_node*
+ HIR::HIR_identifier*,			// AST_identifier*
+ HIR::Token_class_name*,		// Token_class_name*
+ HIR::Token_interface_name*,	// Token_interface_name*
+ HIR::Token_method_name*,		// Token_method_name*
+ HIR::Token_variable_name*,		// Token_variable_name*
+ HIR::HIR_identifier*,			// Token_directive_name*
+ HIR::Token_label_name*,		// Token_label_name*
+ HIR::Token_int*,				// Token_int*
+ HIR::Token_real*,				// Token_real*
+ HIR::Token_string*,			// Token_string*
+ HIR::Token_bool*,				// Token_bool*
+ HIR::Token_null*,				// Token_null*
+ HIR::Token_op*,				// Token_op*
+ HIR::Token_cast*,				// Token_cast*
+ HIR::Token_constant_name*>		// Token_constant_name*
 {
  	HIR::HIR_php_script* fold_impl_php_script(AST::AST_php_script* orig, 
List<HIR::HIR_statement*>* statements)
 	{
@@ -180,78 +189,6 @@
 		return result;
 	}

-	HIR::HIR_if* fold_impl_if(AST::AST_if* orig, HIR::HIR_expr* expr, 
List<HIR::HIR_statement*>* iftrue, List<HIR::HIR_statement*>* iffalse)
-	{
-		HIR::HIR_if* result;
-		result = new HIR::HIR_if(expr, iftrue, iffalse);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_while* fold_impl_while(AST::AST_while* orig, HIR::HIR_expr* 
expr, List<HIR::HIR_statement*>* statements)
-	{
-		HIR::HIR_while* result;
-		result = new HIR::HIR_while(expr, statements);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_do* fold_impl_do(AST::AST_do* orig, 
List<HIR::HIR_statement*>* statements, HIR::HIR_expr* expr)
-	{
-		HIR::HIR_do* result;
-		result = new HIR::HIR_do(statements, expr);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_for* fold_impl_for(AST::AST_for* orig, HIR::HIR_expr* init, 
HIR::HIR_expr* cond, HIR::HIR_expr* incr, List<HIR::HIR_statement*>* statements)
-	{
-		HIR::HIR_for* result;
-		result = new HIR::HIR_for(init, cond, incr, statements);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_foreach* fold_impl_foreach(AST::AST_foreach* orig, 
HIR::HIR_expr* expr, HIR::HIR_variable* key, bool is_ref, 
HIR::HIR_variable* val, List<HIR::HIR_statement*>* statements)
-	{
-		HIR::HIR_foreach* result;
-		result = new HIR::HIR_foreach(expr, key, is_ref, val, statements);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_switch* fold_impl_switch(AST::AST_switch* orig, 
HIR::HIR_expr* expr, List<HIR::HIR_switch_case*>* switch_cases)
-	{
-		HIR::HIR_switch* result;
-		result = new HIR::HIR_switch(expr, switch_cases);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_switch_case* fold_impl_switch_case(AST::AST_switch_case* 
orig, HIR::HIR_expr* expr, List<HIR::HIR_statement*>* statements)
-	{
-		HIR::HIR_switch_case* result;
-		result = new HIR::HIR_switch_case(expr, statements);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_break* fold_impl_break(AST::AST_break* orig, HIR::HIR_expr* expr)
-	{
-		HIR::HIR_break* result;
-		result = new HIR::HIR_break(expr);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_continue* fold_impl_continue(AST::AST_continue* orig, 
HIR::HIR_expr* expr)
-	{
-		HIR::HIR_continue* result;
-		result = new HIR::HIR_continue(expr);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
  	HIR::HIR_return* fold_impl_return(AST::AST_return* orig, 
HIR::HIR_expr* expr)
 	{
 		HIR::HIR_return* result;
@@ -276,22 +213,6 @@
 		return result;
 	}

-	HIR::HIR_declare* fold_impl_declare(AST::AST_declare* orig, 
List<HIR::HIR_directive*>* directives, List<HIR::HIR_statement*>* statements)
-	{
-		HIR::HIR_declare* result;
-		result = new HIR::HIR_declare(directives, statements);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_directive* fold_impl_directive(AST::AST_directive* orig, 
HIR::Token_directive_name* directive_name, HIR::HIR_expr* expr)
-	{
-		HIR::HIR_directive* result;
-		result = new HIR::HIR_directive(directive_name, expr);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
  	HIR::HIR_try* fold_impl_try(AST::AST_try* orig, 
List<HIR::HIR_statement*>* statements, List<HIR::HIR_catch*>* catches)
 	{
 		HIR::HIR_try* result;
@@ -324,14 +245,6 @@
 		return result;
 	}

-	HIR::HIR_nop* fold_impl_nop(AST::AST_nop* orig)
-	{
-		HIR::HIR_nop* result;
-		result = new HIR::HIR_nop();
-		result->attrs = orig->attrs;
-		return result;
-	}
-
  	HIR::HIR_branch* fold_impl_branch(AST::AST_branch* orig, 
HIR::HIR_expr* expr, HIR::Token_label_name* iftrue, 
HIR::Token_label_name* iffalse)
 	{
 		HIR::HIR_branch* result;
@@ -364,30 +277,6 @@
 		return result;
 	}

-	HIR::HIR_op_assignment* 
fold_impl_op_assignment(AST::AST_op_assignment* orig, 
HIR::HIR_variable* variable, HIR::Token_op* op, HIR::HIR_expr* expr)
-	{
-		HIR::HIR_op_assignment* result;
-		result = new HIR::HIR_op_assignment(variable, op, expr);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_list_assignment* 
fold_impl_list_assignment(AST::AST_list_assignment* orig, 
List<HIR::HIR_list_element*>* list_elements, HIR::HIR_expr* expr)
-	{
-		HIR::HIR_list_assignment* result;
-		result = new HIR::HIR_list_assignment(list_elements, expr);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_nested_list_elements* 
fold_impl_nested_list_elements(AST::AST_nested_list_elements* orig, 
List<HIR::HIR_list_element*>* list_elements)
-	{
-		HIR::HIR_nested_list_elements* result;
-		result = new HIR::HIR_nested_list_elements(list_elements);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
  	HIR::HIR_cast* fold_impl_cast(AST::AST_cast* orig, HIR::Token_cast* 
cast, HIR::HIR_expr* expr)
 	{
 		HIR::HIR_cast* result;
@@ -412,22 +301,6 @@
 		return result;
 	}

-	HIR::HIR_conditional_expr* 
fold_impl_conditional_expr(AST::AST_conditional_expr* orig, 
HIR::HIR_expr* cond, HIR::HIR_expr* iftrue, HIR::HIR_expr* iffalse)
-	{
-		HIR::HIR_conditional_expr* result;
-		result = new HIR::HIR_conditional_expr(cond, iftrue, iffalse);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::HIR_ignore_errors* 
fold_impl_ignore_errors(AST::AST_ignore_errors* orig, HIR::HIR_expr* expr)
-	{
-		HIR::HIR_ignore_errors* result;
-		result = new HIR::HIR_ignore_errors(expr);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
  	HIR::HIR_constant* fold_impl_constant(AST::AST_constant* orig, 
HIR::Token_class_name* class_name, HIR::Token_constant_name* constant_name)
 	{
 		HIR::HIR_constant* result;
@@ -544,14 +417,6 @@
 	{
 		HIR::Token_variable_name* result;
 		result = new HIR::Token_variable_name(orig->value);
-		result->attrs = orig->attrs;
-		return result;
-	}
-
-	HIR::Token_directive_name* 
fold_directive_name(AST::Token_directive_name* orig)
-	{
-		HIR::Token_directive_name* result;
-		result = new HIR::Token_directive_name(orig->value);
 		result->attrs = orig->attrs;
 		return result;
 	}

Modified: trunk/src/generated/HIR-contexts
==============================================================================
--- trunk/src/generated/HIR-contexts	(original)
+++ trunk/src/generated/HIR-contexts	Sun Oct  7 03:11:32 2007
@@ -6,42 +6,27 @@
 (attribute,member,*)
 (bin_op,expr,)
 (branch,statement,*)
-(break,statement,*)
 (cast,expr,)
 (catch,catch,*)
 (class_def,statement,*)
 (class_mod,class_mod,)
 (class_name,class_name,)
-(conditional_expr,expr,)
 (constant,expr,)
-(continue,statement,*)
-(declare,statement,*)
-(directive,directive,*)
-(do,statement,*)
 (eval_expr,statement,*)
 (expr,expr,)
-(for,statement,*)
-(foreach,statement,*)
 (formal_parameter,formal_parameter,*)
 (global,statement,*)
 (goto,statement,*)
-(if,statement,*)
-(ignore_errors,expr,)
 (instanceof,expr,)
 (interface_def,statement,*)
 (label,statement,*)
-(list_assignment,expr,)
-(list_element,list_element,?*)
 (literal,expr,)
 (member,member,*)
 (method,method,*)
 (method_invocation,expr,)
 (method_mod,method_mod,)
 (method_name,method_name,)
-(nested_list_elements,list_element,?*)
 (new,expr,)
-(nop,statement,*)
-(op_assignment,expr,)
 (post_op,expr,)
 (pre_op,expr,)
 (reflection,reflection,)
@@ -49,8 +34,6 @@
 (signature,signature,)
 (statement,statement,*)
 (static_declaration,statement,*)
-(switch,statement,*)
-(switch_case,switch_case,*)
 (target,target,?)
 (throw,statement,*)
 (try,statement,*)
@@ -58,12 +41,10 @@
 (unary_op,expr,)
 (variable,variable,)
 (variable_name,variable_name,)
-(while,statement,*)
 (BOOL<bool>,expr,)
 (CAST,CAST,)
 (CLASS_NAME,CLASS_NAME,)
 (CONSTANT_NAME,CONSTANT_NAME,)
-(DIRECTIVE_NAME,DIRECTIVE_NAME,)
 (INT<long>,expr,)
 (INTERFACE_NAME,INTERFACE_NAME,)
 (LABEL_NAME,LABEL_NAME,)

Modified: trunk/src/generated/HIR.cpp
==============================================================================
--- trunk/src/generated/HIR.cpp	(original)
+++ trunk/src/generated/HIR.cpp	Sun Oct  7 03:11:32 2007
@@ -203,6 +203,10 @@
     HIR_node::assert_mixin_valid();
 }

+HIR_statement::HIR_statement()
+{
+}
+
 HIR_class_mod::HIR_class_mod(bool is_abstract, bool is_final)
 {
     this->is_abstract = is_abstract;
@@ -274,6 +278,10 @@
     HIR_node::assert_mixin_valid();
 }

+HIR_member::HIR_member()
+{
+}
+
  HIR_signature::HIR_signature(HIR_method_mod* method_mod, bool is_ref, 
Token_method_name* method_name, List<HIR_formal_parameter*>* formal_parameters)
 {
     this->method_mod = method_mod;
@@ -975,109 +983,169 @@
 	}
 }

-HIR_directive::HIR_directive(Token_directive_name* directive_name, 
HIR_expr* expr)
+HIR_catch::HIR_catch(Token_class_name* class_name, 
Token_variable_name* variable_name, List<HIR_statement*>* statements)
 {
-    this->directive_name = directive_name;
-    this->expr = expr;
+    this->class_name = class_name;
+    this->variable_name = variable_name;
+    this->statements = statements;
 }

-HIR_directive::HIR_directive()
+HIR_catch::HIR_catch()
 {
-    this->directive_name = 0;
-    this->expr = 0;
+    this->class_name = 0;
+    this->variable_name = 0;
+    this->statements = 0;
 }

-void HIR_directive::visit(HIR_visitor* visitor)
+void HIR_catch::visit(HIR_visitor* visitor)
 {
-    visitor->visit_directive(this);
+    visitor->visit_catch(this);
 }

-void HIR_directive::transform_children(HIR_transform* transform)
+void HIR_catch::transform_children(HIR_transform* transform)
 {
-    transform->children_directive(this);
+    transform->children_catch(this);
 }

-int HIR_directive::classid()
+int HIR_catch::classid()
 {
     return ID;
 }

-bool HIR_directive::match(HIR_node* in)
+bool HIR_catch::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_directive* that = dynamic_cast<HIR_directive*>(in);
+    HIR_catch* that = dynamic_cast<HIR_catch*>(in);
     if(that == NULL) return false;

-    if(this->directive_name == NULL)
+    if(this->class_name == NULL)
     {
-    	if(that->directive_name != NULL && !that->directive_name->match(this->directive_name))
+    	if(that->class_name != NULL && !that->class_name->match(this->class_name))
     		return false;
     }
-    else if(!this->directive_name->match(that->directive_name))
+    else if(!this->class_name->match(that->class_name))
     	return false;

-    if(this->expr == NULL)
+    if(this->variable_name == NULL)
     {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
+    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
     		return false;
     }
-    else if(!this->expr->match(that->expr))
+    else if(!this->variable_name->match(that->variable_name))
     	return false;

+    if(this->statements != NULL && that->statements != NULL)
+    {
+    	List<HIR_statement*>::const_iterator i, j;
+    	for(
+    		i = this->statements->begin(), j = that->statements->begin();
+    		i != this->statements->end() && j != that->statements->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL)
+    		{
+    			if(*j != NULL && !(*j)->match(*i))
+    				return false;
+    		}
+    		else if(!(*i)->match(*j))
+    			return false;
+    	}
+    	if(i != this->statements->end() || j != that->statements->end())
+    		return false;
+    }
+
     return true;
 }

-bool HIR_directive::equals(HIR_node* in)
+bool HIR_catch::equals(HIR_node* in)
 {
-    HIR_directive* that = dynamic_cast<HIR_directive*>(in);
+    HIR_catch* that = dynamic_cast<HIR_catch*>(in);
     if(that == NULL) return false;

-    if(this->directive_name == NULL || that->directive_name == NULL)
+    if(this->class_name == NULL || that->class_name == NULL)
     {
-    	if(this->directive_name != NULL || that->directive_name != NULL)
+    	if(this->class_name != NULL || that->class_name != NULL)
     		return false;
     }
-    else if(!this->directive_name->equals(that->directive_name))
+    else if(!this->class_name->equals(that->class_name))
     	return false;

-    if(this->expr == NULL || that->expr == NULL)
+    if(this->variable_name == NULL || that->variable_name == NULL)
     {
-    	if(this->expr != NULL || that->expr != NULL)
+    	if(this->variable_name != NULL || that->variable_name != NULL)
     		return false;
     }
-    else if(!this->expr->equals(that->expr))
+    else if(!this->variable_name->equals(that->variable_name))
     	return false;

+    if(this->statements == NULL || that->statements == NULL)
+    {
+    	if(this->statements != NULL || that->statements != NULL)
+    		return false;
+    }
+    else
+    {
+    	List<HIR_statement*>::const_iterator i, j;
+    	for(
+    		i = this->statements->begin(), j = that->statements->begin();
+    		i != this->statements->end() && j != that->statements->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL || *j == NULL)
+    		{
+    			if(*i != NULL || *j != NULL)
+    				return false;
+    		}
+    		else if(!(*i)->equals(*j))
+    			return false;
+    	}
+    	if(i != this->statements->end() || j != that->statements->end())
+    		return false;
+    }
+
     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_directive* HIR_directive::clone()
+HIR_catch* HIR_catch::clone()
 {
-    Token_directive_name* directive_name = this->directive_name ? 
this->directive_name->clone() : NULL;
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_directive* clone = new HIR_directive(directive_name, expr);
+    Token_class_name* class_name = this->class_name ? 
this->class_name->clone() : NULL;
+    Token_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
+    List<HIR_statement*>* statements = NULL;
+    if(this->statements != NULL)
+    {
+    	List<HIR_statement*>::const_iterator i;
+    	statements = new List<HIR_statement*>;
+    	for(i = this->statements->begin(); i != this->statements->end(); i++)
+    		statements->push_back(*i ? (*i)->clone() : NULL);
+    }
+    HIR_catch* clone = new HIR_catch(class_name, variable_name, statements);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_directive::assert_valid()
+void HIR_catch::assert_valid()
 {
-    assert(directive_name != NULL);
-    directive_name->assert_valid();
-    assert(expr != NULL);
-    expr->assert_valid();
+    assert(class_name != NULL);
+    class_name->assert_valid();
+    assert(variable_name != NULL);
+    variable_name->assert_valid();
+    assert(statements != NULL);
+    {
+    	List<HIR_statement*>::const_iterator i;
+    	for(i = this->statements->begin(); i != this->statements->end(); i++)
+    	{
+    		assert(*i != NULL);
+    		(*i)->assert_valid();
+    	}
+    }
     HIR_node::assert_mixin_valid();
 }

-HIR_list_element::HIR_list_element()
-{
-}
-
 HIR_variable_name::HIR_variable_name()
 {
 }
@@ -1284,86 +1352,83 @@
 {
 }

-HIR_commented_node::HIR_commented_node()
-{
-    {
-		attrs->set("phc.comments", new List<String*>);
-	}
-}
-
-//  Return the comments associated with the node
-List<String*>* HIR_commented_node::get_comments()
-{
-    {
-		List<String*>* comments = dynamic_cast<List<String*>*>(attrs->get("phc.comments"));
-		assert(comments);
-		return comments;
-	}
-}
-
 HIR_identifier::HIR_identifier()
 {
 }

-HIR_statement::HIR_statement()
-{
-}
-
-HIR_member::HIR_member()
-{
-}
-
-HIR_switch_case::HIR_switch_case(HIR_expr* expr, List<HIR_statement*>* statements)
+HIR_class_def::HIR_class_def(HIR_class_mod* class_mod, 
Token_class_name* class_name, Token_class_name* extends, 
List<Token_interface_name*>* implements, List<HIR_member*>* members)
 {
-    this->expr = expr;
-    this->statements = statements;
+    this->class_mod = class_mod;
+    this->class_name = class_name;
+    this->extends = extends;
+    this->implements = implements;
+    this->members = members;
 }

-HIR_switch_case::HIR_switch_case()
+HIR_class_def::HIR_class_def()
 {
-    this->expr = 0;
-    this->statements = 0;
+    this->class_mod = 0;
+    this->class_name = 0;
+    this->extends = 0;
+    this->implements = 0;
+    this->members = 0;
 }

-void HIR_switch_case::visit(HIR_visitor* visitor)
+void HIR_class_def::visit(HIR_visitor* visitor)
 {
-    visitor->visit_switch_case(this);
+    visitor->visit_statement(this);
 }

-void HIR_switch_case::transform_children(HIR_transform* transform)
+void HIR_class_def::transform_children(HIR_transform* transform)
 {
-    transform->children_switch_case(this);
+    transform->children_statement(this);
 }

-int HIR_switch_case::classid()
+int HIR_class_def::classid()
 {
     return ID;
 }

-bool HIR_switch_case::match(HIR_node* in)
+bool HIR_class_def::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_switch_case* that = dynamic_cast<HIR_switch_case*>(in);
+    HIR_class_def* that = dynamic_cast<HIR_class_def*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL)
+    if(this->class_mod == NULL)
     {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
+    	if(that->class_mod != NULL && !that->class_mod->match(this->class_mod))
     		return false;
     }
-    else if(!this->expr->match(that->expr))
+    else if(!this->class_mod->match(that->class_mod))
     	return false;

-    if(this->statements != NULL && that->statements != NULL)
+    if(this->class_name == NULL)
     {
-    	List<HIR_statement*>::const_iterator i, j;
+    	if(that->class_name != NULL && !that->class_name->match(this->class_name))
+    		return false;
+    }
+    else if(!this->class_name->match(that->class_name))
+    	return false;
+
+    if(this->extends == NULL)
+    {
+    	if(that->extends != NULL && !that->extends->match(this->extends))
+    		return false;
+    }
+    else if(!this->extends->match(that->extends))
+    	return false;
+
+    if(this->implements != NULL && that->implements != NULL)
+    {
+    	List<Token_interface_name*>::const_iterator i, j;
     	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
+    		i = this->implements->begin(), j = that->implements->begin();
+    		i != this->implements->end() && j != that->implements->end();
     		i++, j++)
     	{
     		if(*i == NULL)
@@ -1374,37 +1439,73 @@
     		else if(!(*i)->match(*j))
     			return false;
     	}
-    	if(i != this->statements->end() || j != that->statements->end())
+    	if(i != this->implements->end() || j != that->implements->end())
+    		return false;
+    }
+
+    if(this->members != NULL && that->members != NULL)
+    {
+    	List<HIR_member*>::const_iterator i, j;
+    	for(
+    		i = this->members->begin(), j = that->members->begin();
+    		i != this->members->end() && j != that->members->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL)
+    		{
+    			if(*j != NULL && !(*j)->match(*i))
+    				return false;
+    		}
+    		else if(!(*i)->match(*j))
+    			return false;
+    	}
+    	if(i != this->members->end() || j != that->members->end())
     		return false;
     }

     return true;
 }

-bool HIR_switch_case::equals(HIR_node* in)
+bool HIR_class_def::equals(HIR_node* in)
 {
-    HIR_switch_case* that = dynamic_cast<HIR_switch_case*>(in);
+    HIR_class_def* that = dynamic_cast<HIR_class_def*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL || that->expr == NULL)
+    if(this->class_mod == NULL || that->class_mod == NULL)
     {
-    	if(this->expr != NULL || that->expr != NULL)
+    	if(this->class_mod != NULL || that->class_mod != NULL)
     		return false;
     }
-    else if(!this->expr->equals(that->expr))
+    else if(!this->class_mod->equals(that->class_mod))
     	return false;

-    if(this->statements == NULL || that->statements == NULL)
+    if(this->class_name == NULL || that->class_name == NULL)
     {
-    	if(this->statements != NULL || that->statements != NULL)
+    	if(this->class_name != NULL || that->class_name != NULL)
+    		return false;
+    }
+    else if(!this->class_name->equals(that->class_name))
+    	return false;
+
+    if(this->extends == NULL || that->extends == NULL)
+    {
+    	if(this->extends != NULL || that->extends != NULL)
+    		return false;
+    }
+    else if(!this->extends->equals(that->extends))
+    	return false;
+
+    if(this->implements == NULL || that->implements == NULL)
+    {
+    	if(this->implements != NULL || that->implements != NULL)
     		return false;
     }
     else
     {
-    	List<HIR_statement*>::const_iterator i, j;
+    	List<Token_interface_name*>::const_iterator i, j;
     	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
+    		i = this->implements->begin(), j = that->implements->begin();
+    		i != this->implements->end() && j != that->implements->end();
     		i++, j++)
     	{
     		if(*i == NULL || *j == NULL)
@@ -1415,37 +1516,85 @@
     		else if(!(*i)->equals(*j))
     			return false;
     	}
-    	if(i != this->statements->end() || j != that->statements->end())
+    	if(i != this->implements->end() || j != that->implements->end())
     		return false;
     }

-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_switch_case* HIR_switch_case::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
+    if(this->members == NULL || that->members == NULL)
     {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
+    	if(this->members != NULL || that->members != NULL)
+    		return false;
+    }
+    else
+    {
+    	List<HIR_member*>::const_iterator i, j;
+    	for(
+    		i = this->members->begin(), j = that->members->begin();
+    		i != this->members->end() && j != that->members->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL || *j == NULL)
+    		{
+    			if(*i != NULL || *j != NULL)
+    				return false;
+    		}
+    		else if(!(*i)->equals(*j))
+    			return false;
+    	}
+    	if(i != this->members->end() || j != that->members->end())
+    		return false;
+    }
+
+    if(!HIR_node::is_mixin_equal(that)) return false;
+    return true;
+}
+
+HIR_class_def* HIR_class_def::clone()
+{
+    HIR_class_mod* class_mod = this->class_mod ? 
this->class_mod->clone() : NULL;
+    Token_class_name* class_name = this->class_name ? 
this->class_name->clone() : NULL;
+    Token_class_name* extends = this->extends ? 
this->extends->clone() : NULL;
+    List<Token_interface_name*>* implements = NULL;
+    if(this->implements != NULL)
+    {
+    	List<Token_interface_name*>::const_iterator i;
+    	implements = new List<Token_interface_name*>;
+    	for(i = this->implements->begin(); i != this->implements->end(); i++)
+    		implements->push_back(*i ? (*i)->clone() : NULL);
+    }
+    List<HIR_member*>* members = NULL;
+    if(this->members != NULL)
+    {
+    	List<HIR_member*>::const_iterator i;
+    	members = new List<HIR_member*>;
+    	for(i = this->members->begin(); i != this->members->end(); i++)
+    		members->push_back(*i ? (*i)->clone() : NULL);
     }
-    HIR_switch_case* clone = new HIR_switch_case(expr, statements);
+    HIR_class_def* clone = new HIR_class_def(class_mod, class_name, 
extends, implements, members);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_switch_case::assert_valid()
+void HIR_class_def::assert_valid()
 {
-    if(expr != NULL) expr->assert_valid();
-    assert(statements != NULL);
+    assert(class_mod != NULL);
+    class_mod->assert_valid();
+    assert(class_name != NULL);
+    class_name->assert_valid();
+    if(extends != NULL) extends->assert_valid();
+    assert(implements != NULL);
     {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
+    	List<Token_interface_name*>::const_iterator i;
+    	for(i = this->implements->begin(); i != this->implements->end(); i++)
+    	{
+    		assert(*i != NULL);
+    		(*i)->assert_valid();
+    	}
+    }
+    assert(members != NULL);
+    {
+    	List<HIR_member*>::const_iterator i;
+    	for(i = this->members->begin(); i != this->members->end(); i++)
     	{
     		assert(*i != NULL);
     		(*i)->assert_valid();
@@ -1454,67 +1603,124 @@
     HIR_node::assert_mixin_valid();
 }

-HIR_catch::HIR_catch(Token_class_name* class_name, 
Token_variable_name* variable_name, List<HIR_statement*>* statements)
+HIR_class_def::HIR_class_def(HIR_class_mod* mod)
 {
-    this->class_name = class_name;
-    this->variable_name = variable_name;
-    this->statements = statements;
+    {
+		this->class_mod = mod;
+		this->class_name = NULL;
+		this->extends = NULL;
+		this->implements = new List<Token_interface_name*>;
+		this->members = new List<HIR_member*>;
+	}
 }

-HIR_catch::HIR_catch()
+HIR_class_def::HIR_class_def(const char* name)
 {
-    this->class_name = 0;
-    this->variable_name = 0;
-    this->statements = 0;
+    {
+		this->class_mod = new HIR_class_mod(false, false);
+		this->class_name = new Token_class_name(new String(name));
+		this->extends = NULL;
+		this->implements = new List<Token_interface_name*>;
+		this->members = new List<HIR_member*>;
+	}
 }

-void HIR_catch::visit(HIR_visitor* visitor)
+void HIR_class_def::add_member(HIR_member* member)
 {
-    visitor->visit_catch(this);
+    {
+		this->members->push_back(member);
+	}
 }

-void HIR_catch::transform_children(HIR_transform* transform)
+//  Returns NULL if the method could not be found
+HIR_method* HIR_class_def::get_method(const char* name)
 {
-    transform->children_catch(this);
+    {
+		List<HIR_member*>::const_iterator i;
+		for(i = members->begin(); i != members->end(); i++)
+		{
+			HIR_method* method = dynamic_cast<HIR_method*>(*i);
+			if(method && *method->signature->method_name->value == name)
+				return method;
+		}
+
+		return NULL;
+	}
 }

-int HIR_catch::classid()
+HIR_interface_def::HIR_interface_def(Token_interface_name* 
interface_name, List<Token_interface_name*>* extends, 
List<HIR_member*>* members)
+{
+    this->interface_name = interface_name;
+    this->extends = extends;
+    this->members = members;
+}
+
+HIR_interface_def::HIR_interface_def()
+{
+    this->interface_name = 0;
+    this->extends = 0;
+    this->members = 0;
+}
+
+void HIR_interface_def::visit(HIR_visitor* visitor)
+{
+    visitor->visit_statement(this);
+}
+
+void HIR_interface_def::transform_children(HIR_transform* transform)
+{
+    transform->children_statement(this);
+}
+
+int HIR_interface_def::classid()
 {
     return ID;
 }

-bool HIR_catch::match(HIR_node* in)
+bool HIR_interface_def::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_catch* that = dynamic_cast<HIR_catch*>(in);
+    HIR_interface_def* that = dynamic_cast<HIR_interface_def*>(in);
     if(that == NULL) return false;

-    if(this->class_name == NULL)
+    if(this->interface_name == NULL)
     {
-    	if(that->class_name != NULL && !that->class_name->match(this->class_name))
+    	if(that->interface_name != NULL && !that->interface_name->match(this->interface_name))
     		return false;
     }
-    else if(!this->class_name->match(that->class_name))
+    else if(!this->interface_name->match(that->interface_name))
     	return false;

-    if(this->variable_name == NULL)
+    if(this->extends != NULL && that->extends != NULL)
     {
-    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
+    	List<Token_interface_name*>::const_iterator i, j;
+    	for(
+    		i = this->extends->begin(), j = that->extends->begin();
+    		i != this->extends->end() && j != that->extends->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL)
+    		{
+    			if(*j != NULL && !(*j)->match(*i))
+    				return false;
+    		}
+    		else if(!(*i)->match(*j))
+    			return false;
+    	}
+    	if(i != this->extends->end() || j != that->extends->end())
     		return false;
     }
-    else if(!this->variable_name->match(that->variable_name))
-    	return false;

-    if(this->statements != NULL && that->statements != NULL)
+    if(this->members != NULL && that->members != NULL)
     {
-    	List<HIR_statement*>::const_iterator i, j;
+    	List<HIR_member*>::const_iterator i, j;
     	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
+    		i = this->members->begin(), j = that->members->begin();
+    		i != this->members->end() && j != that->members->end();
     		i++, j++)
     	{
     		if(*i == NULL)
@@ -1525,45 +1731,62 @@
     		else if(!(*i)->match(*j))
     			return false;
     	}
-    	if(i != this->statements->end() || j != that->statements->end())
+    	if(i != this->members->end() || j != that->members->end())
     		return false;
     }

     return true;
 }

-bool HIR_catch::equals(HIR_node* in)
+bool HIR_interface_def::equals(HIR_node* in)
 {
-    HIR_catch* that = dynamic_cast<HIR_catch*>(in);
+    HIR_interface_def* that = dynamic_cast<HIR_interface_def*>(in);
     if(that == NULL) return false;

-    if(this->class_name == NULL || that->class_name == NULL)
+    if(this->interface_name == NULL || that->interface_name == NULL)
     {
-    	if(this->class_name != NULL || that->class_name != NULL)
+    	if(this->interface_name != NULL || that->interface_name != NULL)
     		return false;
     }
-    else if(!this->class_name->equals(that->class_name))
+    else if(!this->interface_name->equals(that->interface_name))
     	return false;

-    if(this->variable_name == NULL || that->variable_name == NULL)
+    if(this->extends == NULL || that->extends == NULL)
     {
-    	if(this->variable_name != NULL || that->variable_name != NULL)
+    	if(this->extends != NULL || that->extends != NULL)
+    		return false;
+    }
+    else
+    {
+    	List<Token_interface_name*>::const_iterator i, j;
+    	for(
+    		i = this->extends->begin(), j = that->extends->begin();
+    		i != this->extends->end() && j != that->extends->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL || *j == NULL)
+    		{
+    			if(*i != NULL || *j != NULL)
+    				return false;
+    		}
+    		else if(!(*i)->equals(*j))
+    			return false;
+    	}
+    	if(i != this->extends->end() || j != that->extends->end())
     		return false;
     }
-    else if(!this->variable_name->equals(that->variable_name))
-    	return false;

-    if(this->statements == NULL || that->statements == NULL)
+    if(this->members == NULL || that->members == NULL)
     {
-    	if(this->statements != NULL || that->statements != NULL)
+    	if(this->members != NULL || that->members != NULL)
     		return false;
     }
     else
     {
-    	List<HIR_statement*>::const_iterator i, j;
+    	List<HIR_member*>::const_iterator i, j;
     	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
+    		i = this->members->begin(), j = that->members->begin();
+    		i != this->members->end() && j != that->members->end();
     		i++, j++)
     	{
     		if(*i == NULL || *j == NULL)
@@ -1574,7 +1797,7 @@
     		else if(!(*i)->equals(*j))
     			return false;
     	}
-    	if(i != this->statements->end() || j != that->statements->end())
+    	if(i != this->members->end() || j != that->members->end())
     		return false;
     }

@@ -1582,33 +1805,47 @@
     return true;
 }

-HIR_catch* HIR_catch::clone()
+HIR_interface_def* HIR_interface_def::clone()
 {
-    Token_class_name* class_name = this->class_name ? 
this->class_name->clone() : NULL;
-    Token_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
+    Token_interface_name* interface_name = this->interface_name ? 
this->interface_name->clone() : NULL;
+    List<Token_interface_name*>* extends = NULL;
+    if(this->extends != NULL)
     {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
+    	List<Token_interface_name*>::const_iterator i;
+    	extends = new List<Token_interface_name*>;
+    	for(i = this->extends->begin(); i != this->extends->end(); i++)
+    		extends->push_back(*i ? (*i)->clone() : NULL);
     }
-    HIR_catch* clone = new HIR_catch(class_name, variable_name, statements);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
+    List<HIR_member*>* members = NULL;
+    if(this->members != NULL)
+    {
+    	List<HIR_member*>::const_iterator i;
+    	members = new List<HIR_member*>;
+    	for(i = this->members->begin(); i != this->members->end(); i++)
+    		members->push_back(*i ? (*i)->clone() : NULL);
+    }
+    HIR_interface_def* clone = new HIR_interface_def(interface_name, 
extends, members);
+    clone->HIR_node::clone_mixin_from(this);
+    return clone;
 }

-void HIR_catch::assert_valid()
+void HIR_interface_def::assert_valid()
 {
-    assert(class_name != NULL);
-    class_name->assert_valid();
-    assert(variable_name != NULL);
-    variable_name->assert_valid();
-    assert(statements != NULL);
+    assert(interface_name != NULL);
+    interface_name->assert_valid();
+    assert(extends != NULL);
     {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
+    	List<Token_interface_name*>::const_iterator i;
+    	for(i = this->extends->begin(); i != this->extends->end(); i++)
+    	{
+    		assert(*i != NULL);
+    		(*i)->assert_valid();
+    	}
+    }
+    assert(members != NULL);
+    {
+    	List<HIR_member*>::const_iterator i;
+    	for(i = this->members->begin(); i != this->members->end(); i++)
     	{
     		assert(*i != NULL);
     		(*i)->assert_valid();
@@ -1617,51 +1854,57 @@
     HIR_node::assert_mixin_valid();
 }

-HIR_expr::HIR_expr()
-{
-}
-
-HIR_nested_list_elements::HIR_nested_list_elements(List<HIR_list_element*>* 
list_elements)
+HIR_method::HIR_method(HIR_signature* signature, List<HIR_statement*>* statements)
 {
-    this->list_elements = list_elements;
+    this->signature = signature;
+    this->statements = statements;
 }

-HIR_nested_list_elements::HIR_nested_list_elements()
+HIR_method::HIR_method()
 {
-    this->list_elements = 0;
+    this->signature = 0;
+    this->statements = 0;
 }

-void HIR_nested_list_elements::visit(HIR_visitor* visitor)
+void HIR_method::visit(HIR_visitor* visitor)
 {
-    visitor->visit_list_element(this);
+    visitor->visit_member(this);
 }

-void HIR_nested_list_elements::transform_children(HIR_transform* transform)
+void HIR_method::transform_children(HIR_transform* transform)
 {
-    transform->children_list_element(this);
+    transform->children_member(this);
 }

-int HIR_nested_list_elements::classid()
+int HIR_method::classid()
 {
     return ID;
 }

-bool HIR_nested_list_elements::match(HIR_node* in)
+bool HIR_method::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_nested_list_elements* that = dynamic_cast<HIR_nested_list_elements*>(in);
+    HIR_method* that = dynamic_cast<HIR_method*>(in);
     if(that == NULL) return false;

-    if(this->list_elements != NULL && that->list_elements != NULL)
+    if(this->signature == NULL)
+    {
+    	if(that->signature != NULL && !that->signature->match(this->signature))
+    		return false;
+    }
+    else if(!this->signature->match(that->signature))
+    	return false;
+
+    if(this->statements != NULL && that->statements != NULL)
     {
-    	List<HIR_list_element*>::const_iterator i, j;
+    	List<HIR_statement*>::const_iterator i, j;
     	for(
-    		i = this->list_elements->begin(), j = that->list_elements->begin();
-    		i != this->list_elements->end() && j != that->list_elements->end();
+    		i = this->statements->begin(), j = that->statements->begin();
+    		i != this->statements->end() && j != that->statements->end();
     		i++, j++)
     	{
     		if(*i == NULL)
@@ -1672,29 +1915,37 @@
     		else if(!(*i)->match(*j))
     			return false;
     	}
-    	if(i != this->list_elements->end() || j != that->list_elements->end())
+    	if(i != this->statements->end() || j != that->statements->end())
     		return false;
     }

     return true;
 }

-bool HIR_nested_list_elements::equals(HIR_node* in)
+bool HIR_method::equals(HIR_node* in)
 {
-    HIR_nested_list_elements* that = dynamic_cast<HIR_nested_list_elements*>(in);
+    HIR_method* that = dynamic_cast<HIR_method*>(in);
     if(that == NULL) return false;

-    if(this->list_elements == NULL || that->list_elements == NULL)
+    if(this->signature == NULL || that->signature == NULL)
+    {
+    	if(this->signature != NULL || that->signature != NULL)
+    		return false;
+    }
+    else if(!this->signature->equals(that->signature))
+    	return false;
+
+    if(this->statements == NULL || that->statements == NULL)
     {
-    	if(this->list_elements != NULL || that->list_elements != NULL)
+    	if(this->statements != NULL || that->statements != NULL)
     		return false;
     }
     else
     {
-    	List<HIR_list_element*>::const_iterator i, j;
+    	List<HIR_statement*>::const_iterator i, j;
     	for(
-    		i = this->list_elements->begin(), j = that->list_elements->begin();
-    		i != this->list_elements->end() && j != that->list_elements->end();
+    		i = this->statements->begin(), j = that->statements->begin();
+    		i != this->statements->end() && j != that->statements->end();
     		i++, j++)
     	{
     		if(*i == NULL || *j == NULL)
@@ -1705,7 +1956,7 @@
     		else if(!(*i)->equals(*j))
     			return false;
     	}
-    	if(i != this->list_elements->end() || j != that->list_elements->end())
+    	if(i != this->statements->end() || j != that->statements->end())
     		return false;
     }

@@ -1713,69 +1964,93 @@
     return true;
 }

-HIR_nested_list_elements* HIR_nested_list_elements::clone()
+HIR_method* HIR_method::clone()
 {
-    List<HIR_list_element*>* list_elements = NULL;
-    if(this->list_elements != NULL)
+    HIR_signature* signature = this->signature ? 
this->signature->clone() : NULL;
+    List<HIR_statement*>* statements = NULL;
+    if(this->statements != NULL)
     {
-    	List<HIR_list_element*>::const_iterator i;
-    	list_elements = new List<HIR_list_element*>;
-    	for(i = this->list_elements->begin(); i != 
this->list_elements->end(); i++)
-    		list_elements->push_back(*i ? (*i)->clone() : NULL);
+    	List<HIR_statement*>::const_iterator i;
+    	statements = new List<HIR_statement*>;
+    	for(i = this->statements->begin(); i != this->statements->end(); i++)
+    		statements->push_back(*i ? (*i)->clone() : NULL);
     }
-    HIR_nested_list_elements* clone = new HIR_nested_list_elements(list_elements);
+    HIR_method* clone = new HIR_method(signature, statements);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_nested_list_elements::assert_valid()
+void HIR_method::assert_valid()
 {
-    assert(list_elements != NULL);
+    assert(signature != NULL);
+    signature->assert_valid();
+    if(statements != NULL)
     {
-    	List<HIR_list_element*>::const_iterator i;
-    	for(i = this->list_elements->begin(); i != 
this->list_elements->end(); i++)
+    	List<HIR_statement*>::const_iterator i;
+    	for(i = this->statements->begin(); i != this->statements->end(); i++)
     	{
-    		if(*i != NULL) (*i)->assert_valid();
+    		assert(*i != NULL);
+    		(*i)->assert_valid();
     	}
     }
     HIR_node::assert_mixin_valid();
 }

-HIR_reflection::HIR_reflection(HIR_expr* expr)
+HIR_attribute::HIR_attribute(HIR_attr_mod* attr_mod, 
Token_variable_name* variable_name, HIR_expr* expr)
 {
+    this->attr_mod = attr_mod;
+    this->variable_name = variable_name;
     this->expr = expr;
 }

-HIR_reflection::HIR_reflection()
+HIR_attribute::HIR_attribute()
 {
+    this->attr_mod = 0;
+    this->variable_name = 0;
     this->expr = 0;
 }

-void HIR_reflection::visit(HIR_visitor* visitor)
+void HIR_attribute::visit(HIR_visitor* visitor)
 {
-    visitor->visit_class_name(this);
+    visitor->visit_member(this);
 }

-void HIR_reflection::transform_children(HIR_transform* transform)
+void HIR_attribute::transform_children(HIR_transform* transform)
 {
-    transform->children_class_name(this);
+    transform->children_member(this);
 }

-int HIR_reflection::classid()
+int HIR_attribute::classid()
 {
     return ID;
 }

-bool HIR_reflection::match(HIR_node* in)
+bool HIR_attribute::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_reflection* that = dynamic_cast<HIR_reflection*>(in);
+    HIR_attribute* that = dynamic_cast<HIR_attribute*>(in);
     if(that == NULL) return false;

+    if(this->attr_mod == NULL)
+    {
+    	if(that->attr_mod != NULL && !that->attr_mod->match(this->attr_mod))
+    		return false;
+    }
+    else if(!this->attr_mod->match(that->attr_mod))
+    	return false;
+
+    if(this->variable_name == NULL)
+    {
+    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
+    		return false;
+    }
+    else if(!this->variable_name->match(that->variable_name))
+    	return false;
+
     if(this->expr == NULL)
     {
     	if(that->expr != NULL && !that->expr->match(this->expr))
@@ -1787,11 +2062,27 @@
     return true;
 }

-bool HIR_reflection::equals(HIR_node* in)
+bool HIR_attribute::equals(HIR_node* in)
 {
-    HIR_reflection* that = dynamic_cast<HIR_reflection*>(in);
+    HIR_attribute* that = dynamic_cast<HIR_attribute*>(in);
     if(that == NULL) return false;

+    if(this->attr_mod == NULL || that->attr_mod == NULL)
+    {
+    	if(this->attr_mod != NULL || that->attr_mod != NULL)
+    		return false;
+    }
+    else if(!this->attr_mod->equals(that->attr_mod))
+    	return false;
+
+    if(this->variable_name == NULL || that->variable_name == NULL)
+    {
+    	if(this->variable_name != NULL || that->variable_name != NULL)
+    		return false;
+    }
+    else if(!this->variable_name->equals(that->variable_name))
+    	return false;
+
     if(this->expr == NULL || that->expr == NULL)
     {
     	if(this->expr != NULL || that->expr != NULL)
@@ -1804,4050 +2095,1655 @@
     return true;
 }

-HIR_reflection* HIR_reflection::clone()
+HIR_attribute* HIR_attribute::clone()
 {
+    HIR_attr_mod* attr_mod = this->attr_mod ? 
this->attr_mod->clone() : NULL;
+    Token_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
     HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_reflection* clone = new HIR_reflection(expr);
+    HIR_attribute* clone = new HIR_attribute(attr_mod, variable_name, expr);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_reflection::assert_valid()
+void HIR_attribute::assert_valid()
 {
-    assert(expr != NULL);
-    expr->assert_valid();
+    assert(attr_mod != NULL);
+    attr_mod->assert_valid();
+    assert(variable_name != NULL);
+    variable_name->assert_valid();
+    if(expr != NULL) expr->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-Token_class_name::Token_class_name(String* value)
-{
-    this->value = value;
-}
-
-Token_class_name::Token_class_name()
+HIR_return::HIR_return(HIR_expr* expr)
 {
-    this->value = 0;
+    this->expr = expr;
 }

-void Token_class_name::visit(HIR_visitor* visitor)
+HIR_return::HIR_return()
 {
-    visitor->visit_class_name(this);
+    this->expr = 0;
 }

-void Token_class_name::transform_children(HIR_transform* transform)
+void HIR_return::visit(HIR_visitor* visitor)
 {
-    transform->children_class_name(this);
+    visitor->visit_statement(this);
 }

-String* Token_class_name::get_value_as_string()
+void HIR_return::transform_children(HIR_transform* transform)
 {
-    return value;
+    transform->children_statement(this);
 }

-int Token_class_name::classid()
+int HIR_return::classid()
 {
     return ID;
 }

-bool Token_class_name::match(HIR_node* in)
+bool HIR_return::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_class_name* that = dynamic_cast<Token_class_name*>(in);
+    HIR_return* that = dynamic_cast<HIR_return*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
+    if(this->expr == NULL)
+    {
+    	if(that->expr != NULL && !that->expr->match(this->expr))
+    		return false;
+    }
+    else if(!this->expr->match(that->expr))
+    	return false;
+
+    return true;
 }

-bool Token_class_name::equals(HIR_node* in)
+bool HIR_return::equals(HIR_node* in)
 {
-    Token_class_name* that = dynamic_cast<Token_class_name*>(in);
+    HIR_return* that = dynamic_cast<HIR_return*>(in);
     if(that == NULL) return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->expr == NULL || that->expr == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(this->expr != NULL || that->expr != NULL)
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->expr->equals(that->expr))
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_class_name* Token_class_name::clone()
+HIR_return* HIR_return::clone()
 {
-    String* value = new String(*this->value);
-    Token_class_name* clone = new Token_class_name(value);
+    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
+    HIR_return* clone = new HIR_return(expr);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void Token_class_name::assert_valid()
+void HIR_return::assert_valid()
 {
-    assert(value != NULL);
+    if(expr != NULL) expr->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-Token_interface_name::Token_interface_name(String* value)
-{
-    this->value = value;
-}
-
-Token_interface_name::Token_interface_name()
+HIR_static_declaration::HIR_static_declaration(Token_variable_name* 
variable_name, HIR_expr* expr)
 {
-    this->value = 0;
+    this->variable_name = variable_name;
+    this->expr = expr;
 }

-void Token_interface_name::visit(HIR_visitor* visitor)
+HIR_static_declaration::HIR_static_declaration()
 {
-    visitor->visit_interface_name(this);
+    this->variable_name = 0;
+    this->expr = 0;
 }

-void Token_interface_name::transform_children(HIR_transform* transform)
+void HIR_static_declaration::visit(HIR_visitor* visitor)
 {
-    transform->children_interface_name(this);
+    visitor->visit_statement(this);
 }

-String* Token_interface_name::get_value_as_string()
+void HIR_static_declaration::transform_children(HIR_transform* transform)
 {
-    return value;
+    transform->children_statement(this);
 }

-int Token_interface_name::classid()
+int HIR_static_declaration::classid()
 {
     return ID;
 }

-bool Token_interface_name::match(HIR_node* in)
+bool HIR_static_declaration::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_interface_name* that = dynamic_cast<Token_interface_name*>(in);
+    HIR_static_declaration* that = dynamic_cast<HIR_static_declaration*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
-}
-
-bool Token_interface_name::equals(HIR_node* in)
-{
-    Token_interface_name* that = dynamic_cast<Token_interface_name*>(in);
-    if(that == NULL) return false;
+    if(this->variable_name == NULL)
+    {
+    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
+    		return false;
+    }
+    else if(!this->variable_name->match(that->variable_name))
+    	return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->expr == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(that->expr != NULL && !that->expr->match(this->expr))
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->expr->match(that->expr))
     	return false;

-    if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_interface_name* Token_interface_name::clone()
-{
-    String* value = new String(*this->value);
-    Token_interface_name* clone = new Token_interface_name(value);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void Token_interface_name::assert_valid()
-{
-    assert(value != NULL);
-    HIR_node::assert_mixin_valid();
-}
-
-Token_method_name::Token_method_name(String* value)
-{
-    this->value = value;
-}
-
-Token_method_name::Token_method_name()
-{
-    this->value = 0;
-}
-
-void Token_method_name::visit(HIR_visitor* visitor)
-{
-    visitor->visit_method_name(this);
-}
-
-void Token_method_name::transform_children(HIR_transform* transform)
-{
-    transform->children_method_name(this);
-}
-
-String* Token_method_name::get_value_as_string()
-{
-    return value;
-}
-
-int Token_method_name::classid()
-{
-    return ID;
-}
-
-bool Token_method_name::match(HIR_node* in)
+bool HIR_static_declaration::equals(HIR_node* in)
 {
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    Token_method_name* that = dynamic_cast<Token_method_name*>(in);
+    HIR_static_declaration* that = dynamic_cast<HIR_static_declaration*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
-}
-
-bool Token_method_name::equals(HIR_node* in)
-{
-    Token_method_name* that = dynamic_cast<Token_method_name*>(in);
-    if(that == NULL) return false;
+    if(this->variable_name == NULL || that->variable_name == NULL)
+    {
+    	if(this->variable_name != NULL || that->variable_name != NULL)
+    		return false;
+    }
+    else if(!this->variable_name->equals(that->variable_name))
+    	return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->expr == NULL || that->expr == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(this->expr != NULL || that->expr != NULL)
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->expr->equals(that->expr))
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_method_name* Token_method_name::clone()
+HIR_static_declaration* HIR_static_declaration::clone()
 {
-    String* value = new String(*this->value);
-    Token_method_name* clone = new Token_method_name(value);
+    Token_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
+    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
+    HIR_static_declaration* clone = new 
HIR_static_declaration(variable_name, expr);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void Token_method_name::assert_valid()
+void HIR_static_declaration::assert_valid()
 {
-    assert(value != NULL);
+    assert(variable_name != NULL);
+    variable_name->assert_valid();
+    if(expr != NULL) expr->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-Token_variable_name::Token_variable_name(String* value)
-{
-    this->value = value;
-}
-
-Token_variable_name::Token_variable_name()
+HIR_global::HIR_global(HIR_variable_name* variable_name)
 {
-    this->value = 0;
+    this->variable_name = variable_name;
 }

-void Token_variable_name::visit(HIR_visitor* visitor)
+HIR_global::HIR_global()
 {
-    visitor->visit_variable_name(this);
+    this->variable_name = 0;
 }

-void Token_variable_name::transform_children(HIR_transform* transform)
+void HIR_global::visit(HIR_visitor* visitor)
 {
-    transform->children_variable_name(this);
+    visitor->visit_statement(this);
 }

-String* Token_variable_name::get_value_as_string()
+void HIR_global::transform_children(HIR_transform* transform)
 {
-    return value;
+    transform->children_statement(this);
 }

-int Token_variable_name::classid()
+int HIR_global::classid()
 {
     return ID;
 }

-bool Token_variable_name::match(HIR_node* in)
+bool HIR_global::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_variable_name* that = dynamic_cast<Token_variable_name*>(in);
+    HIR_global* that = dynamic_cast<HIR_global*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
+    if(this->variable_name == NULL)
+    {
+    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
+    		return false;
+    }
+    else if(!this->variable_name->match(that->variable_name))
+    	return false;
+
+    return true;
 }

-bool Token_variable_name::equals(HIR_node* in)
+bool HIR_global::equals(HIR_node* in)
 {
-    Token_variable_name* that = dynamic_cast<Token_variable_name*>(in);
+    HIR_global* that = dynamic_cast<HIR_global*>(in);
     if(that == NULL) return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->variable_name == NULL || that->variable_name == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(this->variable_name != NULL || that->variable_name != NULL)
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->variable_name->equals(that->variable_name))
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_variable_name* Token_variable_name::clone()
+HIR_global* HIR_global::clone()
 {
-    String* value = new String(*this->value);
-    Token_variable_name* clone = new Token_variable_name(value);
+    HIR_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
+    HIR_global* clone = new HIR_global(variable_name);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void Token_variable_name::assert_valid()
+void HIR_global::assert_valid()
 {
-    assert(value != NULL);
+    assert(variable_name != NULL);
+    variable_name->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-Token_directive_name::Token_directive_name(String* value)
-{
-    this->value = value;
-}
-
-Token_directive_name::Token_directive_name()
+HIR_try::HIR_try(List<HIR_statement*>* statements, List<HIR_catch*>* catches)
 {
-    this->value = 0;
+    this->statements = statements;
+    this->catches = catches;
 }

-void Token_directive_name::visit(HIR_visitor* visitor)
+HIR_try::HIR_try()
 {
-    visitor->visit_directive_name(this);
+    this->statements = 0;
+    this->catches = 0;
 }

-void Token_directive_name::transform_children(HIR_transform* transform)
+void HIR_try::visit(HIR_visitor* visitor)
 {
-    transform->children_directive_name(this);
+    visitor->visit_statement(this);
 }

-String* Token_directive_name::get_value_as_string()
+void HIR_try::transform_children(HIR_transform* transform)
 {
-    return value;
+    transform->children_statement(this);
 }

-int Token_directive_name::classid()
+int HIR_try::classid()
 {
     return ID;
 }

-bool Token_directive_name::match(HIR_node* in)
+bool HIR_try::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_directive_name* that = dynamic_cast<Token_directive_name*>(in);
+    HIR_try* that = dynamic_cast<HIR_try*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
-}
-
-bool Token_directive_name::equals(HIR_node* in)
-{
-    Token_directive_name* that = dynamic_cast<Token_directive_name*>(in);
-    if(that == NULL) return false;
+    if(this->statements != NULL && that->statements != NULL)
+    {
+    	List<HIR_statement*>::const_iterator i, j;
+    	for(
+    		i = this->statements->begin(), j = that->statements->begin();
+    		i != this->statements->end() && j != that->statements->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL)
+    		{
+    			if(*j != NULL && !(*j)->match(*i))
+    				return false;
+    		}
+    		else if(!(*i)->match(*j))
+    			return false;
+    	}
+    	if(i != this->statements->end() || j != that->statements->end())
+    		return false;
+    }

-    if(this->value == NULL || that->value == NULL)
+    if(this->catches != NULL && that->catches != NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	List<HIR_catch*>::const_iterator i, j;
+    	for(
+    		i = this->catches->begin(), j = that->catches->begin();
+    		i != this->catches->end() && j != that->catches->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL)
+    		{
+    			if(*j != NULL && !(*j)->match(*i))
+    				return false;
+    		}
+    		else if(!(*i)->match(*j))
+    			return false;
+    	}
+    	if(i != this->catches->end() || j != that->catches->end())
     		return false;
     }
-    else if(*this->value != *that->value)
-    	return false;

-    if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_directive_name* Token_directive_name::clone()
-{
-    String* value = new String(*this->value);
-    Token_directive_name* clone = new Token_directive_name(value);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void Token_directive_name::assert_valid()
+bool HIR_try::equals(HIR_node* in)
 {
-    assert(value != NULL);
-    HIR_node::assert_mixin_valid();
-}
-
-Token_label_name::Token_label_name(String* value)
+    HIR_try* that = dynamic_cast<HIR_try*>(in);
+    if(that == NULL) return false;
+
+    if(this->statements == NULL || that->statements == NULL)
+    {
+    	if(this->statements != NULL || that->statements != NULL)
+    		return false;
+    }
+    else
+    {
+    	List<HIR_statement*>::const_iterator i, j;
+    	for(
+    		i = this->statements->begin(), j = that->statements->begin();
+    		i != this->statements->end() && j != that->statements->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL || *j == NULL)
+    		{
+    			if(*i != NULL || *j != NULL)
+    				return false;
+    		}
+    		else if(!(*i)->equals(*j))
+    			return false;
+    	}
+    	if(i != this->statements->end() || j != that->statements->end())
+    		return false;
+    }
+
+    if(this->catches == NULL || that->catches == NULL)
+    {
+    	if(this->catches != NULL || that->catches != NULL)
+    		return false;
+    }
+    else
+    {
+    	List<HIR_catch*>::const_iterator i, j;
+    	for(
+    		i = this->catches->begin(), j = that->catches->begin();
+    		i != this->catches->end() && j != that->catches->end();
+    		i++, j++)
+    	{
+    		if(*i == NULL || *j == NULL)
+    		{
+    			if(*i != NULL || *j != NULL)
+    				return false;
+    		}
+    		else if(!(*i)->equals(*j))
+    			return false;
+    	}
+    	if(i != this->catches->end() || j != that->catches->end())
+    		return false;
+    }
+
+    if(!HIR_node::is_mixin_equal(that)) return false;
+    return true;
+}
+
+HIR_try* HIR_try::clone()
 {
-    this->value = value;
+    List<HIR_statement*>* statements = NULL;
+    if(this->statements != NULL)
+    {
+    	List<HIR_statement*>::const_iterator i;
+    	statements = new List<HIR_statement*>;
+    	for(i = this->statements->begin(); i != this->statements->end(); i++)
+    		statements->push_back(*i ? (*i)->clone() : NULL);
+    }
+    List<HIR_catch*>* catches = NULL;
+    if(this->catches != NULL)
+    {
+    	List<HIR_catch*>::const_iterator i;
+    	catches = new List<HIR_catch*>;
+    	for(i = this->catches->begin(); i != this->catches->end(); i++)
+    		catches->push_back(*i ? (*i)->clone() : NULL);
+    }
+    HIR_try* clone = new HIR_try(statements, catches);
+    clone->HIR_node::clone_mixin_from(this);
+    return clone;
 }

-Token_label_name::Token_label_name()
+void HIR_try::assert_valid()
 {
-    this->value = 0;
+    assert(statements != NULL);
+    {
+    	List<HIR_statement*>::const_iterator i;
+    	for(i = this->statements->begin(); i != this->statements->end(); i++)
+    	{
+    		assert(*i != NULL);
+    		(*i)->assert_valid();
+    	}
+    }
+    assert(catches != NULL);
+    {
+    	List<HIR_catch*>::const_iterator i;
+    	for(i = this->catches->begin(); i != this->catches->end(); i++)
+    	{
+    		assert(*i != NULL);
+    		(*i)->assert_valid();
+    	}
+    }
+    HIR_node::assert_mixin_valid();
 }

-void Token_label_name::visit(HIR_visitor* visitor)
+HIR_throw::HIR_throw(HIR_expr* expr)
 {
-    visitor->visit_label_name(this);
+    this->expr = expr;
 }

-void Token_label_name::transform_children(HIR_transform* transform)
+HIR_throw::HIR_throw()
 {
-    transform->children_label_name(this);
+    this->expr = 0;
 }

-String* Token_label_name::get_value_as_string()
+void HIR_throw::visit(HIR_visitor* visitor)
 {
-    return value;
+    visitor->visit_statement(this);
 }

-int Token_label_name::classid()
+void HIR_throw::transform_children(HIR_transform* transform)
+{
+    transform->children_statement(this);
+}
+
+int HIR_throw::classid()
 {
     return ID;
 }

-bool Token_label_name::match(HIR_node* in)
+bool HIR_throw::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_label_name* that = dynamic_cast<Token_label_name*>(in);
+    HIR_throw* that = dynamic_cast<HIR_throw*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
+    if(this->expr == NULL)
+    {
+    	if(that->expr != NULL && !that->expr->match(this->expr))
+    		return false;
+    }
+    else if(!this->expr->match(that->expr))
+    	return false;
+
+    return true;
 }

-bool Token_label_name::equals(HIR_node* in)
+bool HIR_throw::equals(HIR_node* in)
 {
-    Token_label_name* that = dynamic_cast<Token_label_name*>(in);
+    HIR_throw* that = dynamic_cast<HIR_throw*>(in);
     if(that == NULL) return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->expr == NULL || that->expr == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(this->expr != NULL || that->expr != NULL)
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->expr->equals(that->expr))
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_label_name* Token_label_name::clone()
+HIR_throw* HIR_throw::clone()
 {
-    String* value = new String(*this->value);
-    Token_label_name* clone = new Token_label_name(value);
+    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
+    HIR_throw* clone = new HIR_throw(expr);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void Token_label_name::assert_valid()
+void HIR_throw::assert_valid()
 {
-    assert(value != NULL);
+    assert(expr != NULL);
+    expr->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-Token_op::Token_op(String* value)
-{
-    this->value = value;
-}
-
-Token_op::Token_op()
+HIR_eval_expr::HIR_eval_expr(HIR_expr* expr)
 {
-    this->value = 0;
+    this->expr = expr;
+    _init();
 }

-void Token_op::visit(HIR_visitor* visitor)
+HIR_eval_expr::HIR_eval_expr()
 {
-    visitor->visit_op(this);
+    this->expr = 0;
+    _init();
 }

-void Token_op::transform_children(HIR_transform* transform)
+void HIR_eval_expr::visit(HIR_visitor* visitor)
 {
-    transform->children_op(this);
+    visitor->visit_statement(this);
 }

-String* Token_op::get_value_as_string()
+void HIR_eval_expr::transform_children(HIR_transform* transform)
 {
-    return value;
+    transform->children_statement(this);
 }

-int Token_op::classid()
+int HIR_eval_expr::classid()
 {
     return ID;
 }

-bool Token_op::match(HIR_node* in)
+bool HIR_eval_expr::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_op* that = dynamic_cast<Token_op*>(in);
+    HIR_eval_expr* that = dynamic_cast<HIR_eval_expr*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
+    if(this->expr == NULL)
+    {
+    	if(that->expr != NULL && !that->expr->match(this->expr))
+    		return false;
+    }
+    else if(!this->expr->match(that->expr))
+    	return false;
+
+    return true;
 }

-bool Token_op::equals(HIR_node* in)
+bool HIR_eval_expr::equals(HIR_node* in)
 {
-    Token_op* that = dynamic_cast<Token_op*>(in);
+    HIR_eval_expr* that = dynamic_cast<HIR_eval_expr*>(in);
     if(that == NULL) return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->expr == NULL || that->expr == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(this->expr != NULL || that->expr != NULL)
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->expr->equals(that->expr))
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_op* Token_op::clone()
+HIR_eval_expr* HIR_eval_expr::clone()
 {
-    String* value = new String(*this->value);
-    Token_op* clone = new Token_op(value);
+    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
+    HIR_eval_expr* clone = new HIR_eval_expr(expr);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void Token_op::assert_valid()
+void HIR_eval_expr::assert_valid()
 {
-    assert(value != NULL);
+    assert(expr != NULL);
+    expr->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-Token_cast::Token_cast(String* value)
+void HIR_eval_expr::_init()
 {
-    this->value = value;
+    {
+		assert (expr != NULL);
+	}
 }

-Token_cast::Token_cast()
+HIR_branch::HIR_branch(HIR_expr* expr, Token_label_name* iftrue, 
Token_label_name* iffalse)
 {
-    this->value = 0;
+    this->expr = expr;
+    this->iftrue = iftrue;
+    this->iffalse = iffalse;
 }

-void Token_cast::visit(HIR_visitor* visitor)
+HIR_branch::HIR_branch()
 {
-    visitor->visit_cast(this);
+    this->expr = 0;
+    this->iftrue = 0;
+    this->iffalse = 0;
 }

-void Token_cast::transform_children(HIR_transform* transform)
+void HIR_branch::visit(HIR_visitor* visitor)
 {
-    transform->children_cast(this);
+    visitor->visit_statement(this);
 }

-String* Token_cast::get_value_as_string()
+void HIR_branch::transform_children(HIR_transform* transform)
 {
-    return value;
+    transform->children_statement(this);
 }

-int Token_cast::classid()
+int HIR_branch::classid()
 {
     return ID;
 }

-bool Token_cast::match(HIR_node* in)
+bool HIR_branch::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_cast* that = dynamic_cast<Token_cast*>(in);
+    HIR_branch* that = dynamic_cast<HIR_branch*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
+    if(this->expr == NULL)
+    {
+    	if(that->expr != NULL && !that->expr->match(this->expr))
+    		return false;
+    }
+    else if(!this->expr->match(that->expr))
+    	return false;
+
+    if(this->iftrue == NULL)
+    {
+    	if(that->iftrue != NULL && !that->iftrue->match(this->iftrue))
+    		return false;
+    }
+    else if(!this->iftrue->match(that->iftrue))
+    	return false;
+
+    if(this->iffalse == NULL)
+    {
+    	if(that->iffalse != NULL && !that->iffalse->match(this->iffalse))
+    		return false;
+    }
+    else if(!this->iffalse->match(that->iffalse))
+    	return false;
+
+    return true;
 }

-bool Token_cast::equals(HIR_node* in)
+bool HIR_branch::equals(HIR_node* in)
 {
-    Token_cast* that = dynamic_cast<Token_cast*>(in);
+    HIR_branch* that = dynamic_cast<HIR_branch*>(in);
     if(that == NULL) return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->expr == NULL || that->expr == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(this->expr != NULL || that->expr != NULL)
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->expr->equals(that->expr))
+    	return false;
+
+    if(this->iftrue == NULL || that->iftrue == NULL)
+    {
+    	if(this->iftrue != NULL || that->iftrue != NULL)
+    		return false;
+    }
+    else if(!this->iftrue->equals(that->iftrue))
+    	return false;
+
+    if(this->iffalse == NULL || that->iffalse == NULL)
+    {
+    	if(this->iffalse != NULL || that->iffalse != NULL)
+    		return false;
+    }
+    else if(!this->iffalse->equals(that->iffalse))
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_cast* Token_cast::clone()
+HIR_branch* HIR_branch::clone()
 {
-    String* value = new String(*this->value);
-    Token_cast* clone = new Token_cast(value);
+    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
+    Token_label_name* iftrue = this->iftrue ? this->iftrue->clone() : NULL;
+    Token_label_name* iffalse = this->iffalse ? 
this->iffalse->clone() : NULL;
+    HIR_branch* clone = new HIR_branch(expr, iftrue, iffalse);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void Token_cast::assert_valid()
+void HIR_branch::assert_valid()
 {
-    assert(value != NULL);
+    assert(expr != NULL);
+    expr->assert_valid();
+    assert(iftrue != NULL);
+    iftrue->assert_valid();
+    assert(iffalse != NULL);
+    iffalse->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-Token_constant_name::Token_constant_name(String* value)
-{
-    this->value = value;
-}
-
-Token_constant_name::Token_constant_name()
+HIR_goto::HIR_goto(Token_label_name* label_name)
 {
-    this->value = 0;
+    this->label_name = label_name;
 }

-void Token_constant_name::visit(HIR_visitor* visitor)
+HIR_goto::HIR_goto()
 {
-    visitor->visit_constant_name(this);
+    this->label_name = 0;
 }

-void Token_constant_name::transform_children(HIR_transform* transform)
+void HIR_goto::visit(HIR_visitor* visitor)
 {
-    transform->children_constant_name(this);
+    visitor->visit_statement(this);
 }

-String* Token_constant_name::get_value_as_string()
+void HIR_goto::transform_children(HIR_transform* transform)
 {
-    return value;
+    transform->children_statement(this);
 }

-int Token_constant_name::classid()
+int HIR_goto::classid()
 {
     return ID;
 }

-bool Token_constant_name::match(HIR_node* in)
+bool HIR_goto::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    Token_constant_name* that = dynamic_cast<Token_constant_name*>(in);
+    HIR_goto* that = dynamic_cast<HIR_goto*>(in);
     if(that == NULL) return false;

-    if(this->value != NULL && that->value != NULL)
-    	return (*this->value == *that->value);
-    else
-    	return true;
+    if(this->label_name == NULL)
+    {
+    	if(that->label_name != NULL && !that->label_name->match(this->label_name))
+    		return false;
+    }
+    else if(!this->label_name->match(that->label_name))
+    	return false;
+
+    return true;
 }

-bool Token_constant_name::equals(HIR_node* in)
+bool HIR_goto::equals(HIR_node* in)
 {
-    Token_constant_name* that = dynamic_cast<Token_constant_name*>(in);
+    HIR_goto* that = dynamic_cast<HIR_goto*>(in);
     if(that == NULL) return false;

-    if(this->value == NULL || that->value == NULL)
+    if(this->label_name == NULL || that->label_name == NULL)
     {
-    	if(this->value != NULL || that->value != NULL)
+    	if(this->label_name != NULL || that->label_name != NULL)
     		return false;
     }
-    else if(*this->value != *that->value)
+    else if(!this->label_name->equals(that->label_name))
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-Token_constant_name* Token_constant_name::clone()
+HIR_goto* HIR_goto::clone()
 {
-    String* value = new String(*this->value);
-    Token_constant_name* clone = new Token_constant_name(value);
+    Token_label_name* label_name = this->label_name ? 
this->label_name->clone() : NULL;
+    HIR_goto* clone = new HIR_goto(label_name);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void Token_constant_name::assert_valid()
+void HIR_goto::assert_valid()
 {
-    assert(value != NULL);
+    assert(label_name != NULL);
+    label_name->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-HIR_class_def::HIR_class_def(HIR_class_mod* class_mod, 
Token_class_name* class_name, Token_class_name* extends, 
List<Token_interface_name*>* implements, List<HIR_member*>* members)
+HIR_label::HIR_label(Token_label_name* label_name)
 {
-    this->class_mod = class_mod;
-    this->class_name = class_name;
-    this->extends = extends;
-    this->implements = implements;
-    this->members = members;
+    this->label_name = label_name;
 }

-HIR_class_def::HIR_class_def()
+HIR_label::HIR_label()
 {
-    this->class_mod = 0;
-    this->class_name = 0;
-    this->extends = 0;
-    this->implements = 0;
-    this->members = 0;
+    this->label_name = 0;
 }

-void HIR_class_def::visit(HIR_visitor* visitor)
+void HIR_label::visit(HIR_visitor* visitor)
 {
     visitor->visit_statement(this);
 }

-void HIR_class_def::transform_children(HIR_transform* transform)
+void HIR_label::transform_children(HIR_transform* transform)
 {
     transform->children_statement(this);
 }

-int HIR_class_def::classid()
+int HIR_label::classid()
 {
     return ID;
 }

-bool HIR_class_def::match(HIR_node* in)
+bool HIR_label::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_class_def* that = dynamic_cast<HIR_class_def*>(in);
+    HIR_label* that = dynamic_cast<HIR_label*>(in);
     if(that == NULL) return false;

-    if(this->class_mod == NULL)
-    {
-    	if(that->class_mod != NULL && !that->class_mod->match(this->class_mod))
-    		return false;
-    }
-    else if(!this->class_mod->match(that->class_mod))
-    	return false;
-
-    if(this->class_name == NULL)
-    {
-    	if(that->class_name != NULL && !that->class_name->match(this->class_name))
-    		return false;
-    }
-    else if(!this->class_name->match(that->class_name))
-    	return false;
-
-    if(this->extends == NULL)
+    if(this->label_name == NULL)
     {
-    	if(that->extends != NULL && !that->extends->match(this->extends))
+    	if(that->label_name != NULL && !that->label_name->match(this->label_name))
     		return false;
     }
-    else if(!this->extends->match(that->extends))
+    else if(!this->label_name->match(that->label_name))
     	return false;

-    if(this->implements != NULL && that->implements != NULL)
-    {
-    	List<Token_interface_name*>::const_iterator i, j;
-    	for(
-    		i = this->implements->begin(), j = that->implements->begin();
-    		i != this->implements->end() && j != that->implements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->implements->end() || j != that->implements->end())
-    		return false;
-    }
-
-    if(this->members != NULL && that->members != NULL)
-    {
-    	List<HIR_member*>::const_iterator i, j;
-    	for(
-    		i = this->members->begin(), j = that->members->begin();
-    		i != this->members->end() && j != that->members->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->members->end() || j != that->members->end())
-    		return false;
-    }
-
     return true;
 }

-bool HIR_class_def::equals(HIR_node* in)
+bool HIR_label::equals(HIR_node* in)
 {
-    HIR_class_def* that = dynamic_cast<HIR_class_def*>(in);
+    HIR_label* that = dynamic_cast<HIR_label*>(in);
     if(that == NULL) return false;

-    if(this->class_mod == NULL || that->class_mod == NULL)
-    {
-    	if(this->class_mod != NULL || that->class_mod != NULL)
-    		return false;
-    }
-    else if(!this->class_mod->equals(that->class_mod))
-    	return false;
-
-    if(this->class_name == NULL || that->class_name == NULL)
-    {
-    	if(this->class_name != NULL || that->class_name != NULL)
-    		return false;
-    }
-    else if(!this->class_name->equals(that->class_name))
-    	return false;
-
-    if(this->extends == NULL || that->extends == NULL)
+    if(this->label_name == NULL || that->label_name == NULL)
     {
-    	if(this->extends != NULL || that->extends != NULL)
+    	if(this->label_name != NULL || that->label_name != NULL)
     		return false;
     }
-    else if(!this->extends->equals(that->extends))
+    else if(!this->label_name->equals(that->label_name))
     	return false;

-    if(this->implements == NULL || that->implements == NULL)
-    {
-    	if(this->implements != NULL || that->implements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<Token_interface_name*>::const_iterator i, j;
-    	for(
-    		i = this->implements->begin(), j = that->implements->begin();
-    		i != this->implements->end() && j != that->implements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->implements->end() || j != that->implements->end())
-    		return false;
-    }
-
-    if(this->members == NULL || that->members == NULL)
-    {
-    	if(this->members != NULL || that->members != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_member*>::const_iterator i, j;
-    	for(
-    		i = this->members->begin(), j = that->members->begin();
-    		i != this->members->end() && j != that->members->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->members->end() || j != that->members->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_class_def* HIR_class_def::clone()
-{
-    HIR_class_mod* class_mod = this->class_mod ? 
this->class_mod->clone() : NULL;
-    Token_class_name* class_name = this->class_name ? 
this->class_name->clone() : NULL;
-    Token_class_name* extends = this->extends ? 
this->extends->clone() : NULL;
-    List<Token_interface_name*>* implements = NULL;
-    if(this->implements != NULL)
-    {
-    	List<Token_interface_name*>::const_iterator i;
-    	implements = new List<Token_interface_name*>;
-    	for(i = this->implements->begin(); i != this->implements->end(); i++)
-    		implements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    List<HIR_member*>* members = NULL;
-    if(this->members != NULL)
-    {
-    	List<HIR_member*>::const_iterator i;
-    	members = new List<HIR_member*>;
-    	for(i = this->members->begin(); i != this->members->end(); i++)
-    		members->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_class_def* clone = new HIR_class_def(class_mod, class_name, 
extends, implements, members);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_class_def::assert_valid()
-{
-    assert(class_mod != NULL);
-    class_mod->assert_valid();
-    assert(class_name != NULL);
-    class_name->assert_valid();
-    if(extends != NULL) extends->assert_valid();
-    assert(implements != NULL);
-    {
-    	List<Token_interface_name*>::const_iterator i;
-    	for(i = this->implements->begin(); i != this->implements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    assert(members != NULL);
-    {
-    	List<HIR_member*>::const_iterator i;
-    	for(i = this->members->begin(); i != this->members->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_class_def::HIR_class_def(HIR_class_mod* mod)
-{
-    {
-		this->class_mod = mod;
-		this->class_name = NULL;
-		this->extends = NULL;
-		this->implements = new List<Token_interface_name*>;
-		this->members = new List<HIR_member*>;
-	}
-}
-
-HIR_class_def::HIR_class_def(const char* name)
-{
-    {
-		this->class_mod = new HIR_class_mod(false, false);
-		this->class_name = new Token_class_name(new String(name));
-		this->extends = NULL;
-		this->implements = new List<Token_interface_name*>;
-		this->members = new List<HIR_member*>;
-	}
-}
-
-void HIR_class_def::add_member(HIR_member* member)
-{
-    {
-		this->members->push_back(member);
-	}
-}
-
-//  Returns NULL if the method could not be found
-HIR_method* HIR_class_def::get_method(const char* name)
-{
-    {
-		List<HIR_member*>::const_iterator i;
-		for(i = members->begin(); i != members->end(); i++)
-		{
-			HIR_method* method = dynamic_cast<HIR_method*>(*i);
-			if(method && *method->signature->method_name->value == name)
-				return method;
-		}
-
-		return NULL;
-	}
-}
-
-HIR_interface_def::HIR_interface_def(Token_interface_name* 
interface_name, List<Token_interface_name*>* extends, 
List<HIR_member*>* members)
-{
-    this->interface_name = interface_name;
-    this->extends = extends;
-    this->members = members;
-}
-
-HIR_interface_def::HIR_interface_def()
-{
-    this->interface_name = 0;
-    this->extends = 0;
-    this->members = 0;
-}
-
-void HIR_interface_def::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_interface_def::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_interface_def::classid()
-{
-    return ID;
-}
-
-bool HIR_interface_def::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_interface_def* that = dynamic_cast<HIR_interface_def*>(in);
-    if(that == NULL) return false;
-
-    if(this->interface_name == NULL)
-    {
-    	if(that->interface_name != NULL && !that->interface_name->match(this->interface_name))
-    		return false;
-    }
-    else if(!this->interface_name->match(that->interface_name))
-    	return false;
-
-    if(this->extends != NULL && that->extends != NULL)
-    {
-    	List<Token_interface_name*>::const_iterator i, j;
-    	for(
-    		i = this->extends->begin(), j = that->extends->begin();
-    		i != this->extends->end() && j != that->extends->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->extends->end() || j != that->extends->end())
-    		return false;
-    }
-
-    if(this->members != NULL && that->members != NULL)
-    {
-    	List<HIR_member*>::const_iterator i, j;
-    	for(
-    		i = this->members->begin(), j = that->members->begin();
-    		i != this->members->end() && j != that->members->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->members->end() || j != that->members->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_interface_def::equals(HIR_node* in)
-{
-    HIR_interface_def* that = dynamic_cast<HIR_interface_def*>(in);
-    if(that == NULL) return false;
-
-    if(this->interface_name == NULL || that->interface_name == NULL)
-    {
-    	if(this->interface_name != NULL || that->interface_name != NULL)
-    		return false;
-    }
-    else if(!this->interface_name->equals(that->interface_name))
-    	return false;
-
-    if(this->extends == NULL || that->extends == NULL)
-    {
-    	if(this->extends != NULL || that->extends != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<Token_interface_name*>::const_iterator i, j;
-    	for(
-    		i = this->extends->begin(), j = that->extends->begin();
-    		i != this->extends->end() && j != that->extends->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->extends->end() || j != that->extends->end())
-    		return false;
-    }
-
-    if(this->members == NULL || that->members == NULL)
-    {
-    	if(this->members != NULL || that->members != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_member*>::const_iterator i, j;
-    	for(
-    		i = this->members->begin(), j = that->members->begin();
-    		i != this->members->end() && j != that->members->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->members->end() || j != that->members->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_interface_def* HIR_interface_def::clone()
-{
-    Token_interface_name* interface_name = this->interface_name ? 
this->interface_name->clone() : NULL;
-    List<Token_interface_name*>* extends = NULL;
-    if(this->extends != NULL)
-    {
-    	List<Token_interface_name*>::const_iterator i;
-    	extends = new List<Token_interface_name*>;
-    	for(i = this->extends->begin(); i != this->extends->end(); i++)
-    		extends->push_back(*i ? (*i)->clone() : NULL);
-    }
-    List<HIR_member*>* members = NULL;
-    if(this->members != NULL)
-    {
-    	List<HIR_member*>::const_iterator i;
-    	members = new List<HIR_member*>;
-    	for(i = this->members->begin(); i != this->members->end(); i++)
-    		members->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_interface_def* clone = new HIR_interface_def(interface_name, 
extends, members);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_interface_def::assert_valid()
-{
-    assert(interface_name != NULL);
-    interface_name->assert_valid();
-    assert(extends != NULL);
-    {
-    	List<Token_interface_name*>::const_iterator i;
-    	for(i = this->extends->begin(); i != this->extends->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    assert(members != NULL);
-    {
-    	List<HIR_member*>::const_iterator i;
-    	for(i = this->members->begin(); i != this->members->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_method::HIR_method(HIR_signature* signature, List<HIR_statement*>* statements)
-{
-    this->signature = signature;
-    this->statements = statements;
-}
-
-HIR_method::HIR_method()
-{
-    this->signature = 0;
-    this->statements = 0;
-}
-
-void HIR_method::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_method::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_method::classid()
-{
-    return ID;
-}
-
-bool HIR_method::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_method* that = dynamic_cast<HIR_method*>(in);
-    if(that == NULL) return false;
-
-    if(this->signature == NULL)
-    {
-    	if(that->signature != NULL && !that->signature->match(this->signature))
-    		return false;
-    }
-    else if(!this->signature->match(that->signature))
-    	return false;
-
-    if(this->statements != NULL && that->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_method::equals(HIR_node* in)
-{
-    HIR_method* that = dynamic_cast<HIR_method*>(in);
-    if(that == NULL) return false;
-
-    if(this->signature == NULL || that->signature == NULL)
-    {
-    	if(this->signature != NULL || that->signature != NULL)
-    		return false;
-    }
-    else if(!this->signature->equals(that->signature))
-    	return false;
-
-    if(this->statements == NULL || that->statements == NULL)
-    {
-    	if(this->statements != NULL || that->statements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_method* HIR_method::clone()
-{
-    HIR_signature* signature = this->signature ? 
this->signature->clone() : NULL;
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_method* clone = new HIR_method(signature, statements);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_method::assert_valid()
-{
-    assert(signature != NULL);
-    signature->assert_valid();
-    if(statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_attribute::HIR_attribute(HIR_attr_mod* attr_mod, 
Token_variable_name* variable_name, HIR_expr* expr)
-{
-    this->attr_mod = attr_mod;
-    this->variable_name = variable_name;
-    this->expr = expr;
-}
-
-HIR_attribute::HIR_attribute()
-{
-    this->attr_mod = 0;
-    this->variable_name = 0;
-    this->expr = 0;
-}
-
-void HIR_attribute::visit(HIR_visitor* visitor)
-{
-    visitor->visit_member(this);
-}
-
-void HIR_attribute::transform_children(HIR_transform* transform)
-{
-    transform->children_member(this);
-}
-
-int HIR_attribute::classid()
-{
-    return ID;
-}
-
-bool HIR_attribute::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_attribute* that = dynamic_cast<HIR_attribute*>(in);
-    if(that == NULL) return false;
-
-    if(this->attr_mod == NULL)
-    {
-    	if(that->attr_mod != NULL && !that->attr_mod->match(this->attr_mod))
-    		return false;
-    }
-    else if(!this->attr_mod->match(that->attr_mod))
-    	return false;
-
-    if(this->variable_name == NULL)
-    {
-    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
-    		return false;
-    }
-    else if(!this->variable_name->match(that->variable_name))
-    	return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_attribute::equals(HIR_node* in)
-{
-    HIR_attribute* that = dynamic_cast<HIR_attribute*>(in);
-    if(that == NULL) return false;
-
-    if(this->attr_mod == NULL || that->attr_mod == NULL)
-    {
-    	if(this->attr_mod != NULL || that->attr_mod != NULL)
-    		return false;
-    }
-    else if(!this->attr_mod->equals(that->attr_mod))
-    	return false;
-
-    if(this->variable_name == NULL || that->variable_name == NULL)
-    {
-    	if(this->variable_name != NULL || that->variable_name != NULL)
-    		return false;
-    }
-    else if(!this->variable_name->equals(that->variable_name))
-    	return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_attribute* HIR_attribute::clone()
-{
-    HIR_attr_mod* attr_mod = this->attr_mod ? 
this->attr_mod->clone() : NULL;
-    Token_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_attribute* clone = new HIR_attribute(attr_mod, variable_name, expr);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_attribute::assert_valid()
-{
-    assert(attr_mod != NULL);
-    attr_mod->assert_valid();
-    assert(variable_name != NULL);
-    variable_name->assert_valid();
-    if(expr != NULL) expr->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_if::HIR_if(HIR_expr* expr, List<HIR_statement*>* iftrue, 
List<HIR_statement*>* iffalse)
-{
-    this->expr = expr;
-    this->iftrue = iftrue;
-    this->iffalse = iffalse;
-}
-
-HIR_if::HIR_if()
-{
-    this->expr = 0;
-    this->iftrue = 0;
-    this->iffalse = 0;
-}
-
-void HIR_if::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_if::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_if::classid()
-{
-    return ID;
-}
-
-bool HIR_if::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_if* that = dynamic_cast<HIR_if*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    if(this->iftrue != NULL && that->iftrue != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->iftrue->begin(), j = that->iftrue->begin();
-    		i != this->iftrue->end() && j != that->iftrue->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->iftrue->end() || j != that->iftrue->end())
-    		return false;
-    }
-
-    if(this->iffalse != NULL && that->iffalse != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->iffalse->begin(), j = that->iffalse->begin();
-    		i != this->iffalse->end() && j != that->iffalse->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->iffalse->end() || j != that->iffalse->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_if::equals(HIR_node* in)
-{
-    HIR_if* that = dynamic_cast<HIR_if*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(this->iftrue == NULL || that->iftrue == NULL)
-    {
-    	if(this->iftrue != NULL || that->iftrue != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->iftrue->begin(), j = that->iftrue->begin();
-    		i != this->iftrue->end() && j != that->iftrue->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->iftrue->end() || j != that->iftrue->end())
-    		return false;
-    }
-
-    if(this->iffalse == NULL || that->iffalse == NULL)
-    {
-    	if(this->iffalse != NULL || that->iffalse != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->iffalse->begin(), j = that->iffalse->begin();
-    		i != this->iffalse->end() && j != that->iffalse->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->iffalse->end() || j != that->iffalse->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_if* HIR_if::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    List<HIR_statement*>* iftrue = NULL;
-    if(this->iftrue != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	iftrue = new List<HIR_statement*>;
-    	for(i = this->iftrue->begin(); i != this->iftrue->end(); i++)
-    		iftrue->push_back(*i ? (*i)->clone() : NULL);
-    }
-    List<HIR_statement*>* iffalse = NULL;
-    if(this->iffalse != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	iffalse = new List<HIR_statement*>;
-    	for(i = this->iffalse->begin(); i != this->iffalse->end(); i++)
-    		iffalse->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_if* clone = new HIR_if(expr, iftrue, iffalse);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_if::assert_valid()
-{
-    assert(expr != NULL);
-    expr->assert_valid();
-    assert(iftrue != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->iftrue->begin(); i != this->iftrue->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    assert(iffalse != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->iffalse->begin(); i != this->iffalse->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_if::HIR_if(HIR_expr* expr)
-{
-    {
-		HIR_if (expr, new List<HIR_statement*> (), new List<HIR_statement*>);
-	}
-}
-
-HIR_while::HIR_while(HIR_expr* expr, List<HIR_statement*>* statements)
-{
-    this->expr = expr;
-    this->statements = statements;
-}
-
-HIR_while::HIR_while()
-{
-    this->expr = 0;
-    this->statements = 0;
-}
-
-void HIR_while::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_while::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_while::classid()
-{
-    return ID;
-}
-
-bool HIR_while::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_while* that = dynamic_cast<HIR_while*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    if(this->statements != NULL && that->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_while::equals(HIR_node* in)
-{
-    HIR_while* that = dynamic_cast<HIR_while*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(this->statements == NULL || that->statements == NULL)
-    {
-    	if(this->statements != NULL || that->statements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_while* HIR_while::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_while* clone = new HIR_while(expr, statements);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_while::assert_valid()
-{
-    assert(expr != NULL);
-    expr->assert_valid();
-    assert(statements != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_do::HIR_do(List<HIR_statement*>* statements, HIR_expr* expr)
-{
-    this->statements = statements;
-    this->expr = expr;
-}
-
-HIR_do::HIR_do()
-{
-    this->statements = 0;
-    this->expr = 0;
-}
-
-void HIR_do::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_do::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_do::classid()
-{
-    return ID;
-}
-
-bool HIR_do::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_do* that = dynamic_cast<HIR_do*>(in);
-    if(that == NULL) return false;
-
-    if(this->statements != NULL && that->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_do::equals(HIR_node* in)
-{
-    HIR_do* that = dynamic_cast<HIR_do*>(in);
-    if(that == NULL) return false;
-
-    if(this->statements == NULL || that->statements == NULL)
-    {
-    	if(this->statements != NULL || that->statements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_do* HIR_do::clone()
-{
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_do* clone = new HIR_do(statements, expr);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_do::assert_valid()
-{
-    assert(statements != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    assert(expr != NULL);
-    expr->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_for::HIR_for(HIR_expr* init, HIR_expr* cond, HIR_expr* incr, 
List<HIR_statement*>* statements)
-{
-    this->init = init;
-    this->cond = cond;
-    this->incr = incr;
-    this->statements = statements;
-}
-
-HIR_for::HIR_for()
-{
-    this->init = 0;
-    this->cond = 0;
-    this->incr = 0;
-    this->statements = 0;
-}
-
-void HIR_for::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_for::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_for::classid()
-{
-    return ID;
-}
-
-bool HIR_for::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_for* that = dynamic_cast<HIR_for*>(in);
-    if(that == NULL) return false;
-
-    if(this->init == NULL)
-    {
-    	if(that->init != NULL && !that->init->match(this->init))
-    		return false;
-    }
-    else if(!this->init->match(that->init))
-    	return false;
-
-    if(this->cond == NULL)
-    {
-    	if(that->cond != NULL && !that->cond->match(this->cond))
-    		return false;
-    }
-    else if(!this->cond->match(that->cond))
-    	return false;
-
-    if(this->incr == NULL)
-    {
-    	if(that->incr != NULL && !that->incr->match(this->incr))
-    		return false;
-    }
-    else if(!this->incr->match(that->incr))
-    	return false;
-
-    if(this->statements != NULL && that->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_for::equals(HIR_node* in)
-{
-    HIR_for* that = dynamic_cast<HIR_for*>(in);
-    if(that == NULL) return false;
-
-    if(this->init == NULL || that->init == NULL)
-    {
-    	if(this->init != NULL || that->init != NULL)
-    		return false;
-    }
-    else if(!this->init->equals(that->init))
-    	return false;
-
-    if(this->cond == NULL || that->cond == NULL)
-    {
-    	if(this->cond != NULL || that->cond != NULL)
-    		return false;
-    }
-    else if(!this->cond->equals(that->cond))
-    	return false;
-
-    if(this->incr == NULL || that->incr == NULL)
-    {
-    	if(this->incr != NULL || that->incr != NULL)
-    		return false;
-    }
-    else if(!this->incr->equals(that->incr))
-    	return false;
-
-    if(this->statements == NULL || that->statements == NULL)
-    {
-    	if(this->statements != NULL || that->statements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_for* HIR_for::clone()
-{
-    HIR_expr* init = this->init ? this->init->clone() : NULL;
-    HIR_expr* cond = this->cond ? this->cond->clone() : NULL;
-    HIR_expr* incr = this->incr ? this->incr->clone() : NULL;
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_for* clone = new HIR_for(init, cond, incr, statements);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_for::assert_valid()
-{
-    if(init != NULL) init->assert_valid();
-    if(cond != NULL) cond->assert_valid();
-    if(incr != NULL) incr->assert_valid();
-    assert(statements != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_foreach::HIR_foreach(HIR_expr* expr, HIR_variable* key, bool 
is_ref, HIR_variable* val, List<HIR_statement*>* statements)
-{
-    this->expr = expr;
-    this->key = key;
-    this->is_ref = is_ref;
-    this->val = val;
-    this->statements = statements;
-}
-
-HIR_foreach::HIR_foreach()
-{
-    this->expr = 0;
-    this->key = 0;
-    this->is_ref = 0;
-    this->val = 0;
-    this->statements = 0;
-}
-
-void HIR_foreach::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_foreach::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_foreach::classid()
-{
-    return ID;
-}
-
-bool HIR_foreach::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_foreach* that = dynamic_cast<HIR_foreach*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    if(this->key == NULL)
-    {
-    	if(that->key != NULL && !that->key->match(this->key))
-    		return false;
-    }
-    else if(!this->key->match(that->key))
-    	return false;
-
-    that->is_ref = this->is_ref;
-    if(this->val == NULL)
-    {
-    	if(that->val != NULL && !that->val->match(this->val))
-    		return false;
-    }
-    else if(!this->val->match(that->val))
-    	return false;
-
-    if(this->statements != NULL && that->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_foreach::equals(HIR_node* in)
-{
-    HIR_foreach* that = dynamic_cast<HIR_foreach*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(this->key == NULL || that->key == NULL)
-    {
-    	if(this->key != NULL || that->key != NULL)
-    		return false;
-    }
-    else if(!this->key->equals(that->key))
-    	return false;
-
-    if(this->is_ref != that->is_ref)
-    	return false;
-
-    if(this->val == NULL || that->val == NULL)
-    {
-    	if(this->val != NULL || that->val != NULL)
-    		return false;
-    }
-    else if(!this->val->equals(that->val))
-    	return false;
-
-    if(this->statements == NULL || that->statements == NULL)
-    {
-    	if(this->statements != NULL || that->statements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_foreach* HIR_foreach::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_variable* key = this->key ? this->key->clone() : NULL;
-    bool is_ref = this->is_ref;
-    HIR_variable* val = this->val ? this->val->clone() : NULL;
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_foreach* clone = new HIR_foreach(expr, key, is_ref, val, statements);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_foreach::assert_valid()
-{
-    assert(expr != NULL);
-    expr->assert_valid();
-    if(key != NULL) key->assert_valid();
-    assert(val != NULL);
-    val->assert_valid();
-    assert(statements != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_switch::HIR_switch(HIR_expr* expr, List<HIR_switch_case*>* switch_cases)
-{
-    this->expr = expr;
-    this->switch_cases = switch_cases;
-}
-
-HIR_switch::HIR_switch()
-{
-    this->expr = 0;
-    this->switch_cases = 0;
-}
-
-void HIR_switch::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_switch::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_switch::classid()
-{
-    return ID;
-}
-
-bool HIR_switch::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_switch* that = dynamic_cast<HIR_switch*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    if(this->switch_cases != NULL && that->switch_cases != NULL)
-    {
-    	List<HIR_switch_case*>::const_iterator i, j;
-    	for(
-    		i = this->switch_cases->begin(), j = that->switch_cases->begin();
-    		i != this->switch_cases->end() && j != that->switch_cases->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->switch_cases->end() || j != that->switch_cases->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_switch::equals(HIR_node* in)
-{
-    HIR_switch* that = dynamic_cast<HIR_switch*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(this->switch_cases == NULL || that->switch_cases == NULL)
-    {
-    	if(this->switch_cases != NULL || that->switch_cases != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_switch_case*>::const_iterator i, j;
-    	for(
-    		i = this->switch_cases->begin(), j = that->switch_cases->begin();
-    		i != this->switch_cases->end() && j != that->switch_cases->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->switch_cases->end() || j != that->switch_cases->end())
-    		return false;
-    }
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_switch* HIR_switch::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    List<HIR_switch_case*>* switch_cases = NULL;
-    if(this->switch_cases != NULL)
-    {
-    	List<HIR_switch_case*>::const_iterator i;
-    	switch_cases = new List<HIR_switch_case*>;
-    	for(i = this->switch_cases->begin(); i != 
this->switch_cases->end(); i++)
-    		switch_cases->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_switch* clone = new HIR_switch(expr, switch_cases);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_switch::assert_valid()
-{
-    assert(expr != NULL);
-    expr->assert_valid();
-    assert(switch_cases != NULL);
-    {
-    	List<HIR_switch_case*>::const_iterator i;
-    	for(i = this->switch_cases->begin(); i != 
this->switch_cases->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_break::HIR_break(HIR_expr* expr)
-{
-    this->expr = expr;
-}
-
-HIR_break::HIR_break()
-{
-    this->expr = 0;
-}
-
-void HIR_break::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_break::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_break::classid()
-{
-    return ID;
-}
-
-bool HIR_break::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_break* that = dynamic_cast<HIR_break*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_break::equals(HIR_node* in)
-{
-    HIR_break* that = dynamic_cast<HIR_break*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_break* HIR_break::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_break* clone = new HIR_break(expr);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_break::assert_valid()
-{
-    if(expr != NULL) expr->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_continue::HIR_continue(HIR_expr* expr)
-{
-    this->expr = expr;
-}
-
-HIR_continue::HIR_continue()
-{
-    this->expr = 0;
-}
-
-void HIR_continue::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_continue::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_continue::classid()
-{
-    return ID;
-}
-
-bool HIR_continue::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_continue* that = dynamic_cast<HIR_continue*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_continue::equals(HIR_node* in)
-{
-    HIR_continue* that = dynamic_cast<HIR_continue*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_continue* HIR_continue::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_continue* clone = new HIR_continue(expr);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_continue::assert_valid()
-{
-    if(expr != NULL) expr->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_return::HIR_return(HIR_expr* expr)
-{
-    this->expr = expr;
-}
-
-HIR_return::HIR_return()
-{
-    this->expr = 0;
-}
-
-void HIR_return::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_return::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_return::classid()
-{
-    return ID;
-}
-
-bool HIR_return::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_return* that = dynamic_cast<HIR_return*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_return::equals(HIR_node* in)
-{
-    HIR_return* that = dynamic_cast<HIR_return*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_return* HIR_return::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_return* clone = new HIR_return(expr);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_return::assert_valid()
-{
-    if(expr != NULL) expr->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_static_declaration::HIR_static_declaration(Token_variable_name* 
variable_name, HIR_expr* expr)
-{
-    this->variable_name = variable_name;
-    this->expr = expr;
-}
-
-HIR_static_declaration::HIR_static_declaration()
-{
-    this->variable_name = 0;
-    this->expr = 0;
-}
-
-void HIR_static_declaration::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_static_declaration::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_static_declaration::classid()
-{
-    return ID;
-}
-
-bool HIR_static_declaration::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_static_declaration* that = dynamic_cast<HIR_static_declaration*>(in);
-    if(that == NULL) return false;
-
-    if(this->variable_name == NULL)
-    {
-    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
-    		return false;
-    }
-    else if(!this->variable_name->match(that->variable_name))
-    	return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_static_declaration::equals(HIR_node* in)
-{
-    HIR_static_declaration* that = dynamic_cast<HIR_static_declaration*>(in);
-    if(that == NULL) return false;
-
-    if(this->variable_name == NULL || that->variable_name == NULL)
-    {
-    	if(this->variable_name != NULL || that->variable_name != NULL)
-    		return false;
-    }
-    else if(!this->variable_name->equals(that->variable_name))
-    	return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_static_declaration* HIR_static_declaration::clone()
-{
-    Token_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_static_declaration* clone = new 
HIR_static_declaration(variable_name, expr);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_static_declaration::assert_valid()
-{
-    assert(variable_name != NULL);
-    variable_name->assert_valid();
-    if(expr != NULL) expr->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_global::HIR_global(HIR_variable_name* variable_name)
-{
-    this->variable_name = variable_name;
-}
-
-HIR_global::HIR_global()
-{
-    this->variable_name = 0;
-}
-
-void HIR_global::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_global::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_global::classid()
-{
-    return ID;
-}
-
-bool HIR_global::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_global* that = dynamic_cast<HIR_global*>(in);
-    if(that == NULL) return false;
-
-    if(this->variable_name == NULL)
-    {
-    	if(that->variable_name != NULL && !that->variable_name->match(this->variable_name))
-    		return false;
-    }
-    else if(!this->variable_name->match(that->variable_name))
-    	return false;
-
-    return true;
-}
-
-bool HIR_global::equals(HIR_node* in)
-{
-    HIR_global* that = dynamic_cast<HIR_global*>(in);
-    if(that == NULL) return false;
-
-    if(this->variable_name == NULL || that->variable_name == NULL)
-    {
-    	if(this->variable_name != NULL || that->variable_name != NULL)
-    		return false;
-    }
-    else if(!this->variable_name->equals(that->variable_name))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_global* HIR_global::clone()
-{
-    HIR_variable_name* variable_name = this->variable_name ? 
this->variable_name->clone() : NULL;
-    HIR_global* clone = new HIR_global(variable_name);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_global::assert_valid()
-{
-    assert(variable_name != NULL);
-    variable_name->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_declare::HIR_declare(List<HIR_directive*>* directives, 
List<HIR_statement*>* statements)
-{
-    this->directives = directives;
-    this->statements = statements;
-}
-
-HIR_declare::HIR_declare()
-{
-    this->directives = 0;
-    this->statements = 0;
-}
-
-void HIR_declare::visit(HIR_visitor* visitor)
-{
-    visitor->visit_statement(this);
-}
-
-void HIR_declare::transform_children(HIR_transform* transform)
-{
-    transform->children_statement(this);
-}
-
-int HIR_declare::classid()
-{
-    return ID;
-}
-
-bool HIR_declare::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_declare* that = dynamic_cast<HIR_declare*>(in);
-    if(that == NULL) return false;
-
-    if(this->directives != NULL && that->directives != NULL)
-    {
-    	List<HIR_directive*>::const_iterator i, j;
-    	for(
-    		i = this->directives->begin(), j = that->directives->begin();
-    		i != this->directives->end() && j != that->directives->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->directives->end() || j != that->directives->end())
-    		return false;
-    }
-
-    if(this->statements != NULL && that->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    return true;
-}
-
-bool HIR_declare::equals(HIR_node* in)
-{
-    HIR_declare* that = dynamic_cast<HIR_declare*>(in);
-    if(that == NULL) return false;
-
-    if(this->directives == NULL || that->directives == NULL)
-    {
-    	if(this->directives != NULL || that->directives != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_directive*>::const_iterator i, j;
-    	for(
-    		i = this->directives->begin(), j = that->directives->begin();
-    		i != this->directives->end() && j != that->directives->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->directives->end() || j != that->directives->end())
-    		return false;
-    }
-
-    if(this->statements == NULL || that->statements == NULL)
-    {
-    	if(this->statements != NULL || that->statements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_declare* HIR_declare::clone()
+HIR_label* HIR_label::clone()
 {
-    List<HIR_directive*>* directives = NULL;
-    if(this->directives != NULL)
-    {
-    	List<HIR_directive*>::const_iterator i;
-    	directives = new List<HIR_directive*>;
-    	for(i = this->directives->begin(); i != this->directives->end(); i++)
-    		directives->push_back(*i ? (*i)->clone() : NULL);
-    }
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_declare* clone = new HIR_declare(directives, statements);
+    Token_label_name* label_name = this->label_name ? 
this->label_name->clone() : NULL;
+    HIR_label* clone = new HIR_label(label_name);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_declare::assert_valid()
+void HIR_label::assert_valid()
 {
-    assert(directives != NULL);
-    {
-    	List<HIR_directive*>::const_iterator i;
-    	for(i = this->directives->begin(); i != this->directives->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    assert(statements != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
+    assert(label_name != NULL);
+    label_name->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-HIR_try::HIR_try(List<HIR_statement*>* statements, List<HIR_catch*>* catches)
+HIR_expr::HIR_expr()
 {
-    this->statements = statements;
-    this->catches = catches;
 }

-HIR_try::HIR_try()
+HIR_reflection::HIR_reflection(HIR_expr* expr)
 {
-    this->statements = 0;
-    this->catches = 0;
+    this->expr = expr;
 }

-void HIR_try::visit(HIR_visitor* visitor)
+HIR_reflection::HIR_reflection()
 {
-    visitor->visit_statement(this);
+    this->expr = 0;
 }

-void HIR_try::transform_children(HIR_transform* transform)
+void HIR_reflection::visit(HIR_visitor* visitor)
 {
-    transform->children_statement(this);
+    visitor->visit_class_name(this);
 }

-int HIR_try::classid()
+void HIR_reflection::transform_children(HIR_transform* transform)
+{
+    transform->children_class_name(this);
+}
+
+int HIR_reflection::classid()
 {
     return ID;
 }

-bool HIR_try::match(HIR_node* in)
+bool HIR_reflection::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_try* that = dynamic_cast<HIR_try*>(in);
+    HIR_reflection* that = dynamic_cast<HIR_reflection*>(in);
     if(that == NULL) return false;

-    if(this->statements != NULL && that->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(this->catches != NULL && that->catches != NULL)
+    if(this->expr == NULL)
     {
-    	List<HIR_catch*>::const_iterator i, j;
-    	for(
-    		i = this->catches->begin(), j = that->catches->begin();
-    		i != this->catches->end() && j != that->catches->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->catches->end() || j != that->catches->end())
+    	if(that->expr != NULL && !that->expr->match(this->expr))
     		return false;
     }
+    else if(!this->expr->match(that->expr))
+    	return false;

     return true;
 }

-bool HIR_try::equals(HIR_node* in)
+bool HIR_reflection::equals(HIR_node* in)
 {
-    HIR_try* that = dynamic_cast<HIR_try*>(in);
+    HIR_reflection* that = dynamic_cast<HIR_reflection*>(in);
     if(that == NULL) return false;

-    if(this->statements == NULL || that->statements == NULL)
-    {
-    	if(this->statements != NULL || that->statements != NULL)
-    		return false;
-    }
-    else
-    {
-    	List<HIR_statement*>::const_iterator i, j;
-    	for(
-    		i = this->statements->begin(), j = that->statements->begin();
-    		i != this->statements->end() && j != that->statements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->statements->end() || j != that->statements->end())
-    		return false;
-    }
-
-    if(this->catches == NULL || that->catches == NULL)
-    {
-    	if(this->catches != NULL || that->catches != NULL)
-    		return false;
-    }
-    else
+    if(this->expr == NULL || that->expr == NULL)
     {
-    	List<HIR_catch*>::const_iterator i, j;
-    	for(
-    		i = this->catches->begin(), j = that->catches->begin();
-    		i != this->catches->end() && j != that->catches->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->catches->end() || j != that->catches->end())
+    	if(this->expr != NULL || that->expr != NULL)
     		return false;
     }
+    else if(!this->expr->equals(that->expr))
+    	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_try* HIR_try::clone()
+HIR_reflection* HIR_reflection::clone()
 {
-    List<HIR_statement*>* statements = NULL;
-    if(this->statements != NULL)
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	statements = new List<HIR_statement*>;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    		statements->push_back(*i ? (*i)->clone() : NULL);
-    }
-    List<HIR_catch*>* catches = NULL;
-    if(this->catches != NULL)
-    {
-    	List<HIR_catch*>::const_iterator i;
-    	catches = new List<HIR_catch*>;
-    	for(i = this->catches->begin(); i != this->catches->end(); i++)
-    		catches->push_back(*i ? (*i)->clone() : NULL);
-    }
-    HIR_try* clone = new HIR_try(statements, catches);
+    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
+    HIR_reflection* clone = new HIR_reflection(expr);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_try::assert_valid()
+void HIR_reflection::assert_valid()
 {
-    assert(statements != NULL);
-    {
-    	List<HIR_statement*>::const_iterator i;
-    	for(i = this->statements->begin(); i != this->statements->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
-    assert(catches != NULL);
-    {
-    	List<HIR_catch*>::const_iterator i;
-    	for(i = this->catches->begin(); i != this->catches->end(); i++)
-    	{
-    		assert(*i != NULL);
-    		(*i)->assert_valid();
-    	}
-    }
+    assert(expr != NULL);
+    expr->assert_valid();
     HIR_node::assert_mixin_valid();
 }

-HIR_throw::HIR_throw(HIR_expr* expr)
+Token_class_name::Token_class_name(String* value)
 {
-    this->expr = expr;
+    this->value = value;
 }

-HIR_throw::HIR_throw()
+Token_class_name::Token_class_name()
 {
-    this->expr = 0;
+    this->value = 0;
 }

-void HIR_throw::visit(HIR_visitor* visitor)
+void Token_class_name::visit(HIR_visitor* visitor)
 {
-    visitor->visit_statement(this);
+    visitor->visit_class_name(this);
 }

-void HIR_throw::transform_children(HIR_transform* transform)
+void Token_class_name::transform_children(HIR_transform* transform)
 {
-    transform->children_statement(this);
+    transform->children_class_name(this);
 }

-int HIR_throw::classid()
+String* Token_class_name::get_value_as_string()
+{
+    return value;
+}
+
+int Token_class_name::classid()
 {
     return ID;
 }

-bool HIR_throw::match(HIR_node* in)
+bool Token_class_name::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_throw* that = dynamic_cast<HIR_throw*>(in);
+    Token_class_name* that = dynamic_cast<Token_class_name*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
 }

-bool HIR_throw::equals(HIR_node* in)
+bool Token_class_name::equals(HIR_node* in)
 {
-    HIR_throw* that = dynamic_cast<HIR_throw*>(in);
+    Token_class_name* that = dynamic_cast<Token_class_name*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL || that->expr == NULL)
+    if(this->value == NULL || that->value == NULL)
     {
-    	if(this->expr != NULL || that->expr != NULL)
+    	if(this->value != NULL || that->value != NULL)
     		return false;
     }
-    else if(!this->expr->equals(that->expr))
+    else if(*this->value != *that->value)
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_throw* HIR_throw::clone()
+Token_class_name* Token_class_name::clone()
 {
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_throw* clone = new HIR_throw(expr);
+    String* value = new String(*this->value);
+    Token_class_name* clone = new Token_class_name(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_throw::assert_valid()
+void Token_class_name::assert_valid()
 {
-    assert(expr != NULL);
-    expr->assert_valid();
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-HIR_eval_expr::HIR_eval_expr(HIR_expr* expr)
+Token_interface_name::Token_interface_name(String* value)
 {
-    this->expr = expr;
-    _init();
+    this->value = value;
 }

-HIR_eval_expr::HIR_eval_expr()
+Token_interface_name::Token_interface_name()
 {
-    this->expr = 0;
-    _init();
+    this->value = 0;
 }

-void HIR_eval_expr::visit(HIR_visitor* visitor)
+void Token_interface_name::visit(HIR_visitor* visitor)
 {
-    visitor->visit_statement(this);
+    visitor->visit_interface_name(this);
 }

-void HIR_eval_expr::transform_children(HIR_transform* transform)
+void Token_interface_name::transform_children(HIR_transform* transform)
 {
-    transform->children_statement(this);
+    transform->children_interface_name(this);
 }

-int HIR_eval_expr::classid()
+String* Token_interface_name::get_value_as_string()
+{
+    return value;
+}
+
+int Token_interface_name::classid()
 {
     return ID;
 }

-bool HIR_eval_expr::match(HIR_node* in)
+bool Token_interface_name::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_eval_expr* that = dynamic_cast<HIR_eval_expr*>(in);
+    Token_interface_name* that = dynamic_cast<Token_interface_name*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
 }

-bool HIR_eval_expr::equals(HIR_node* in)
+bool Token_interface_name::equals(HIR_node* in)
 {
-    HIR_eval_expr* that = dynamic_cast<HIR_eval_expr*>(in);
+    Token_interface_name* that = dynamic_cast<Token_interface_name*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL || that->expr == NULL)
+    if(this->value == NULL || that->value == NULL)
     {
-    	if(this->expr != NULL || that->expr != NULL)
+    	if(this->value != NULL || that->value != NULL)
     		return false;
     }
-    else if(!this->expr->equals(that->expr))
+    else if(*this->value != *that->value)
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_eval_expr* HIR_eval_expr::clone()
+Token_interface_name* Token_interface_name::clone()
 {
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_eval_expr* clone = new HIR_eval_expr(expr);
+    String* value = new String(*this->value);
+    Token_interface_name* clone = new Token_interface_name(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_eval_expr::assert_valid()
+void Token_interface_name::assert_valid()
 {
-    assert(expr != NULL);
-    expr->assert_valid();
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-void HIR_eval_expr::_init()
+Token_method_name::Token_method_name(String* value)
 {
-    {
-		assert (expr != NULL);
-	}
+    this->value = value;
+}
+
+Token_method_name::Token_method_name()
+{
+    this->value = 0;
 }

-HIR_nop::HIR_nop()
+void Token_method_name::visit(HIR_visitor* visitor)
 {
+    visitor->visit_method_name(this);
 }

-void HIR_nop::visit(HIR_visitor* visitor)
+void Token_method_name::transform_children(HIR_transform* transform)
 {
-    visitor->visit_statement(this);
+    transform->children_method_name(this);
 }

-void HIR_nop::transform_children(HIR_transform* transform)
+String* Token_method_name::get_value_as_string()
 {
-    transform->children_statement(this);
+    return value;
 }

-int HIR_nop::classid()
+int Token_method_name::classid()
 {
     return ID;
 }

-bool HIR_nop::match(HIR_node* in)
+bool Token_method_name::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_nop* that = dynamic_cast<HIR_nop*>(in);
+    Token_method_name* that = dynamic_cast<Token_method_name*>(in);
     if(that == NULL) return false;

-    return true;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
 }

-bool HIR_nop::equals(HIR_node* in)
+bool Token_method_name::equals(HIR_node* in)
 {
-    HIR_nop* that = dynamic_cast<HIR_nop*>(in);
+    Token_method_name* that = dynamic_cast<Token_method_name*>(in);
     if(that == NULL) return false;

+    if(this->value == NULL || that->value == NULL)
+    {
+    	if(this->value != NULL || that->value != NULL)
+    		return false;
+    }
+    else if(*this->value != *that->value)
+    	return false;
+
     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_nop* HIR_nop::clone()
+Token_method_name* Token_method_name::clone()
 {
-    HIR_nop* clone = new HIR_nop();
+    String* value = new String(*this->value);
+    Token_method_name* clone = new Token_method_name(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_nop::assert_valid()
+void Token_method_name::assert_valid()
 {
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-HIR_branch::HIR_branch(HIR_expr* expr, Token_label_name* iftrue, 
Token_label_name* iffalse)
+Token_variable_name::Token_variable_name(String* value)
 {
-    this->expr = expr;
-    this->iftrue = iftrue;
-    this->iffalse = iffalse;
+    this->value = value;
 }

-HIR_branch::HIR_branch()
+Token_variable_name::Token_variable_name()
 {
-    this->expr = 0;
-    this->iftrue = 0;
-    this->iffalse = 0;
+    this->value = 0;
 }

-void HIR_branch::visit(HIR_visitor* visitor)
+void Token_variable_name::visit(HIR_visitor* visitor)
 {
-    visitor->visit_statement(this);
+    visitor->visit_variable_name(this);
 }

-void HIR_branch::transform_children(HIR_transform* transform)
+void Token_variable_name::transform_children(HIR_transform* transform)
 {
-    transform->children_statement(this);
+    transform->children_variable_name(this);
 }

-int HIR_branch::classid()
+String* Token_variable_name::get_value_as_string()
+{
+    return value;
+}
+
+int Token_variable_name::classid()
 {
     return ID;
 }

-bool HIR_branch::match(HIR_node* in)
+bool Token_variable_name::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_branch* that = dynamic_cast<HIR_branch*>(in);
+    Token_variable_name* that = dynamic_cast<Token_variable_name*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    if(this->iftrue == NULL)
-    {
-    	if(that->iftrue != NULL && !that->iftrue->match(this->iftrue))
-    		return false;
-    }
-    else if(!this->iftrue->match(that->iftrue))
-    	return false;
-
-    if(this->iffalse == NULL)
-    {
-    	if(that->iffalse != NULL && !that->iffalse->match(this->iffalse))
-    		return false;
-    }
-    else if(!this->iffalse->match(that->iffalse))
-    	return false;
-
-    return true;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
 }

-bool HIR_branch::equals(HIR_node* in)
+bool Token_variable_name::equals(HIR_node* in)
 {
-    HIR_branch* that = dynamic_cast<HIR_branch*>(in);
+    Token_variable_name* that = dynamic_cast<Token_variable_name*>(in);
     if(that == NULL) return false;

-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(this->iftrue == NULL || that->iftrue == NULL)
-    {
-    	if(this->iftrue != NULL || that->iftrue != NULL)
-    		return false;
-    }
-    else if(!this->iftrue->equals(that->iftrue))
-    	return false;
-
-    if(this->iffalse == NULL || that->iffalse == NULL)
+    if(this->value == NULL || that->value == NULL)
     {
-    	if(this->iffalse != NULL || that->iffalse != NULL)
+    	if(this->value != NULL || that->value != NULL)
     		return false;
     }
-    else if(!this->iffalse->equals(that->iffalse))
+    else if(*this->value != *that->value)
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_branch* HIR_branch::clone()
+Token_variable_name* Token_variable_name::clone()
 {
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    Token_label_name* iftrue = this->iftrue ? this->iftrue->clone() : NULL;
-    Token_label_name* iffalse = this->iffalse ? 
this->iffalse->clone() : NULL;
-    HIR_branch* clone = new HIR_branch(expr, iftrue, iffalse);
+    String* value = new String(*this->value);
+    Token_variable_name* clone = new Token_variable_name(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_branch::assert_valid()
+void Token_variable_name::assert_valid()
 {
-    assert(expr != NULL);
-    expr->assert_valid();
-    assert(iftrue != NULL);
-    iftrue->assert_valid();
-    assert(iffalse != NULL);
-    iffalse->assert_valid();
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-HIR_goto::HIR_goto(Token_label_name* label_name)
+Token_label_name::Token_label_name(String* value)
 {
-    this->label_name = label_name;
+    this->value = value;
 }

-HIR_goto::HIR_goto()
+Token_label_name::Token_label_name()
 {
-    this->label_name = 0;
+    this->value = 0;
 }

-void HIR_goto::visit(HIR_visitor* visitor)
+void Token_label_name::visit(HIR_visitor* visitor)
 {
-    visitor->visit_statement(this);
+    visitor->visit_label_name(this);
 }

-void HIR_goto::transform_children(HIR_transform* transform)
+void Token_label_name::transform_children(HIR_transform* transform)
 {
-    transform->children_statement(this);
+    transform->children_label_name(this);
 }

-int HIR_goto::classid()
+String* Token_label_name::get_value_as_string()
+{
+    return value;
+}
+
+int Token_label_name::classid()
 {
     return ID;
 }

-bool HIR_goto::match(HIR_node* in)
+bool Token_label_name::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_goto* that = dynamic_cast<HIR_goto*>(in);
+    Token_label_name* that = dynamic_cast<Token_label_name*>(in);
     if(that == NULL) return false;

-    if(this->label_name == NULL)
-    {
-    	if(that->label_name != NULL && !that->label_name->match(this->label_name))
-    		return false;
-    }
-    else if(!this->label_name->match(that->label_name))
-    	return false;
-
-    return true;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
 }

-bool HIR_goto::equals(HIR_node* in)
+bool Token_label_name::equals(HIR_node* in)
 {
-    HIR_goto* that = dynamic_cast<HIR_goto*>(in);
+    Token_label_name* that = dynamic_cast<Token_label_name*>(in);
     if(that == NULL) return false;

-    if(this->label_name == NULL || that->label_name == NULL)
+    if(this->value == NULL || that->value == NULL)
     {
-    	if(this->label_name != NULL || that->label_name != NULL)
+    	if(this->value != NULL || that->value != NULL)
     		return false;
     }
-    else if(!this->label_name->equals(that->label_name))
+    else if(*this->value != *that->value)
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_goto* HIR_goto::clone()
+Token_label_name* Token_label_name::clone()
 {
-    Token_label_name* label_name = this->label_name ? 
this->label_name->clone() : NULL;
-    HIR_goto* clone = new HIR_goto(label_name);
+    String* value = new String(*this->value);
+    Token_label_name* clone = new Token_label_name(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_goto::assert_valid()
+void Token_label_name::assert_valid()
 {
-    assert(label_name != NULL);
-    label_name->assert_valid();
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-HIR_label::HIR_label(Token_label_name* label_name)
+Token_cast::Token_cast(String* value)
 {
-    this->label_name = label_name;
+    this->value = value;
 }

-HIR_label::HIR_label()
+Token_cast::Token_cast()
 {
-    this->label_name = 0;
+    this->value = 0;
 }

-void HIR_label::visit(HIR_visitor* visitor)
+void Token_cast::visit(HIR_visitor* visitor)
 {
-    visitor->visit_statement(this);
+    visitor->visit_cast(this);
 }

-void HIR_label::transform_children(HIR_transform* transform)
+void Token_cast::transform_children(HIR_transform* transform)
 {
-    transform->children_statement(this);
+    transform->children_cast(this);
 }

-int HIR_label::classid()
+String* Token_cast::get_value_as_string()
+{
+    return value;
+}
+
+int Token_cast::classid()
 {
     return ID;
 }

-bool HIR_label::match(HIR_node* in)
+bool Token_cast::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_label* that = dynamic_cast<HIR_label*>(in);
+    Token_cast* that = dynamic_cast<Token_cast*>(in);
     if(that == NULL) return false;

-    if(this->label_name == NULL)
-    {
-    	if(that->label_name != NULL && !that->label_name->match(this->label_name))
-    		return false;
-    }
-    else if(!this->label_name->match(that->label_name))
-    	return false;
-
-    return true;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
 }

-bool HIR_label::equals(HIR_node* in)
+bool Token_cast::equals(HIR_node* in)
 {
-    HIR_label* that = dynamic_cast<HIR_label*>(in);
+    Token_cast* that = dynamic_cast<Token_cast*>(in);
     if(that == NULL) return false;

-    if(this->label_name == NULL || that->label_name == NULL)
+    if(this->value == NULL || that->value == NULL)
     {
-    	if(this->label_name != NULL || that->label_name != NULL)
+    	if(this->value != NULL || that->value != NULL)
     		return false;
     }
-    else if(!this->label_name->equals(that->label_name))
+    else if(*this->value != *that->value)
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_label* HIR_label::clone()
+Token_cast* Token_cast::clone()
 {
-    Token_label_name* label_name = this->label_name ? 
this->label_name->clone() : NULL;
-    HIR_label* clone = new HIR_label(label_name);
+    String* value = new String(*this->value);
+    Token_cast* clone = new Token_cast(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_label::assert_valid()
+void Token_cast::assert_valid()
 {
-    assert(label_name != NULL);
-    label_name->assert_valid();
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-HIR_literal::HIR_literal()
+Token_op::Token_op(String* value)
 {
+    this->value = value;
 }

-HIR_assignment::HIR_assignment(HIR_variable* variable, bool is_ref, 
HIR_expr* expr)
+Token_op::Token_op()
 {
-    this->variable = variable;
-    this->is_ref = is_ref;
-    this->expr = expr;
+    this->value = 0;
 }

-HIR_assignment::HIR_assignment()
+void Token_op::visit(HIR_visitor* visitor)
 {
-    this->variable = 0;
-    this->is_ref = 0;
-    this->expr = 0;
+    visitor->visit_op(this);
 }

-void HIR_assignment::visit(HIR_visitor* visitor)
+void Token_op::transform_children(HIR_transform* transform)
 {
-    visitor->visit_expr(this);
+    transform->children_op(this);
 }

-void HIR_assignment::transform_children(HIR_transform* transform)
+String* Token_op::get_value_as_string()
 {
-    transform->children_expr(this);
+    return value;
 }

-int HIR_assignment::classid()
+int Token_op::classid()
 {
     return ID;
 }

-bool HIR_assignment::match(HIR_node* in)
+bool Token_op::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_assignment* that = dynamic_cast<HIR_assignment*>(in);
+    Token_op* that = dynamic_cast<Token_op*>(in);
     if(that == NULL) return false;

-    if(this->variable == NULL)
-    {
-    	if(that->variable != NULL && !that->variable->match(this->variable))
-    		return false;
-    }
-    else if(!this->variable->match(that->variable))
-    	return false;
-
-    that->is_ref = this->is_ref;
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
 }

-bool HIR_assignment::equals(HIR_node* in)
+bool Token_op::equals(HIR_node* in)
 {
-    HIR_assignment* that = dynamic_cast<HIR_assignment*>(in);
+    Token_op* that = dynamic_cast<Token_op*>(in);
     if(that == NULL) return false;

-    if(this->variable == NULL || that->variable == NULL)
-    {
-    	if(this->variable != NULL || that->variable != NULL)
-    		return false;
-    }
-    else if(!this->variable->equals(that->variable))
-    	return false;
-
-    if(this->is_ref != that->is_ref)
-    	return false;
-
-    if(this->expr == NULL || that->expr == NULL)
+    if(this->value == NULL || that->value == NULL)
     {
-    	if(this->expr != NULL || that->expr != NULL)
+    	if(this->value != NULL || that->value != NULL)
     		return false;
     }
-    else if(!this->expr->equals(that->expr))
+    else if(*this->value != *that->value)
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_assignment* HIR_assignment::clone()
+Token_op* Token_op::clone()
 {
-    HIR_variable* variable = this->variable ? 
this->variable->clone() : NULL;
-    bool is_ref = this->is_ref;
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_assignment* clone = new HIR_assignment(variable, is_ref, expr);
+    String* value = new String(*this->value);
+    Token_op* clone = new Token_op(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_assignment::assert_valid()
+void Token_op::assert_valid()
 {
-    assert(variable != NULL);
-    variable->assert_valid();
-    assert(expr != NULL);
-    expr->assert_valid();
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-HIR_op_assignment::HIR_op_assignment(HIR_variable* variable, Token_op* 
op, HIR_expr* expr)
+Token_constant_name::Token_constant_name(String* value)
 {
-    this->variable = variable;
-    this->op = op;
-    this->expr = expr;
+    this->value = value;
+}
+
+Token_constant_name::Token_constant_name()
+{
+    this->value = 0;
 }

-HIR_op_assignment::HIR_op_assignment()
+void Token_constant_name::visit(HIR_visitor* visitor)
 {
-    this->variable = 0;
-    this->op = 0;
-    this->expr = 0;
+    visitor->visit_constant_name(this);
 }

-void HIR_op_assignment::visit(HIR_visitor* visitor)
+void Token_constant_name::transform_children(HIR_transform* transform)
 {
-    visitor->visit_expr(this);
+    transform->children_constant_name(this);
 }

-void HIR_op_assignment::transform_children(HIR_transform* transform)
+String* Token_constant_name::get_value_as_string()
 {
-    transform->children_expr(this);
+    return value;
 }

-int HIR_op_assignment::classid()
+int Token_constant_name::classid()
 {
     return ID;
 }

-bool HIR_op_assignment::match(HIR_node* in)
+bool Token_constant_name::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_op_assignment* that = dynamic_cast<HIR_op_assignment*>(in);
-    if(that == NULL) return false;
-
-    if(this->variable == NULL)
-    {
-    	if(that->variable != NULL && !that->variable->match(this->variable))
-    		return false;
-    }
-    else if(!this->variable->match(that->variable))
-    	return false;
-
-    if(this->op == NULL)
-    {
-    	if(that->op != NULL && !that->op->match(this->op))
-    		return false;
-    }
-    else if(!this->op->match(that->op))
-    	return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_op_assignment::equals(HIR_node* in)
-{
-    HIR_op_assignment* that = dynamic_cast<HIR_op_assignment*>(in);
+    Token_constant_name* that = dynamic_cast<Token_constant_name*>(in);
     if(that == NULL) return false;

-    if(this->variable == NULL || that->variable == NULL)
-    {
-    	if(this->variable != NULL || that->variable != NULL)
-    		return false;
-    }
-    else if(!this->variable->equals(that->variable))
-    	return false;
-
-    if(this->op == NULL || that->op == NULL)
-    {
-    	if(this->op != NULL || that->op != NULL)
-    		return false;
-    }
-    else if(!this->op->equals(that->op))
-    	return false;
+    if(this->value != NULL && that->value != NULL)
+    	return (*this->value == *that->value);
+    else
+    	return true;
+}
+
+bool Token_constant_name::equals(HIR_node* in)
+{
+    Token_constant_name* that = dynamic_cast<Token_constant_name*>(in);
+    if(that == NULL) return false;

-    if(this->expr == NULL || that->expr == NULL)
+    if(this->value == NULL || that->value == NULL)
     {
-    	if(this->expr != NULL || that->expr != NULL)
+    	if(this->value != NULL || that->value != NULL)
     		return false;
     }
-    else if(!this->expr->equals(that->expr))
+    else if(*this->value != *that->value)
     	return false;

     if(!HIR_node::is_mixin_equal(that)) return false;
     return true;
 }

-HIR_op_assignment* HIR_op_assignment::clone()
+Token_constant_name* Token_constant_name::clone()
 {
-    HIR_variable* variable = this->variable ? 
this->variable->clone() : NULL;
-    Token_op* op = this->op ? this->op->clone() : NULL;
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_op_assignment* clone = new HIR_op_assignment(variable, op, expr);
+    String* value = new String(*this->value);
+    Token_constant_name* clone = new Token_constant_name(value);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_op_assignment::assert_valid()
+void Token_constant_name::assert_valid()
 {
-    assert(variable != NULL);
-    variable->assert_valid();
-    assert(op != NULL);
-    op->assert_valid();
-    assert(expr != NULL);
-    expr->assert_valid();
+    assert(value != NULL);
     HIR_node::assert_mixin_valid();
 }

-HIR_op_assignment::HIR_op_assignment(HIR_variable* variable, const 
char* op, HIR_expr* expr)
+HIR_literal::HIR_literal()
 {
-    {
-      this->variable = variable;
-      this->op = new Token_op(new String(op));
-      this->expr = expr;
-   }
 }

-HIR_list_assignment::HIR_list_assignment(List<HIR_list_element*>* 
list_elements, HIR_expr* expr)
+HIR_assignment::HIR_assignment(HIR_variable* variable, bool is_ref, 
HIR_expr* expr)
 {
-    this->list_elements = list_elements;
+    this->variable = variable;
+    this->is_ref = is_ref;
     this->expr = expr;
 }

-HIR_list_assignment::HIR_list_assignment()
+HIR_assignment::HIR_assignment()
 {
-    this->list_elements = 0;
+    this->variable = 0;
+    this->is_ref = 0;
     this->expr = 0;
 }

-void HIR_list_assignment::visit(HIR_visitor* visitor)
+void HIR_assignment::visit(HIR_visitor* visitor)
 {
     visitor->visit_expr(this);
 }

-void HIR_list_assignment::transform_children(HIR_transform* transform)
+void HIR_assignment::transform_children(HIR_transform* transform)
 {
     transform->children_expr(this);
 }

-int HIR_list_assignment::classid()
+int HIR_assignment::classid()
 {
     return ID;
 }

-bool HIR_list_assignment::match(HIR_node* in)
+bool HIR_assignment::match(HIR_node* in)
 {
     __WILDCARD__* joker;
     joker = dynamic_cast<__WILDCARD__*>(in);
     if(joker != NULL && joker->match(this))
     	return true;

-    HIR_list_assignment* that = dynamic_cast<HIR_list_assignment*>(in);
+    HIR_assignment* that = dynamic_cast<HIR_assignment*>(in);
     if(that == NULL) return false;

-    if(this->list_elements != NULL && that->list_elements != NULL)
+    if(this->variable == NULL)
     {
-    	List<HIR_list_element*>::const_iterator i, j;
-    	for(
-    		i = this->list_elements->begin(), j = that->list_elements->begin();
-    		i != this->list_elements->end() && j != that->list_elements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL)
-    		{
-    			if(*j != NULL && !(*j)->match(*i))
-    				return false;
-    		}
-    		else if(!(*i)->match(*j))
-    			return false;
-    	}
-    	if(i != this->list_elements->end() || j != that->list_elements->end())
+    	if(that->variable != NULL && !that->variable->match(this->variable))
     		return false;
     }
+    else if(!this->variable->match(that->variable))
+    	return false;

+    that->is_ref = this->is_ref;
     if(this->expr == NULL)
     {
     	if(that->expr != NULL && !that->expr->match(this->expr))
@@ -5859,35 +3755,21 @@
     return true;
 }

-bool HIR_list_assignment::equals(HIR_node* in)
+bool HIR_assignment::equals(HIR_node* in)
 {
-    HIR_list_assignment* that = dynamic_cast<HIR_list_assignment*>(in);
+    HIR_assignment* that = dynamic_cast<HIR_assignment*>(in);
     if(that == NULL) return false;

-    if(this->list_elements == NULL || that->list_elements == NULL)
-    {
-    	if(this->list_elements != NULL || that->list_elements != NULL)
-    		return false;
-    }
-    else
+    if(this->variable == NULL || that->variable == NULL)
     {
-    	List<HIR_list_element*>::const_iterator i, j;
-    	for(
-    		i = this->list_elements->begin(), j = that->list_elements->begin();
-    		i != this->list_elements->end() && j != that->list_elements->end();
-    		i++, j++)
-    	{
-    		if(*i == NULL || *j == NULL)
-    		{
-    			if(*i != NULL || *j != NULL)
-    				return false;
-    		}
-    		else if(!(*i)->equals(*j))
-    			return false;
-    	}
-    	if(i != this->list_elements->end() || j != that->list_elements->end())
+    	if(this->variable != NULL || that->variable != NULL)
     		return false;
     }
+    else if(!this->variable->equals(that->variable))
+    	return false;
+
+    if(this->is_ref != that->is_ref)
+    	return false;

     if(this->expr == NULL || that->expr == NULL)
     {
@@ -5901,32 +3783,20 @@
     return true;
 }

-HIR_list_assignment* HIR_list_assignment::clone()
+HIR_assignment* HIR_assignment::clone()
 {
-    List<HIR_list_element*>* list_elements = NULL;
-    if(this->list_elements != NULL)
-    {
-    	List<HIR_list_element*>::const_iterator i;
-    	list_elements = new List<HIR_list_element*>;
-    	for(i = this->list_elements->begin(); i != 
this->list_elements->end(); i++)
-    		list_elements->push_back(*i ? (*i)->clone() : NULL);
-    }
+    HIR_variable* variable = this->variable ? 
this->variable->clone() : NULL;
+    bool is_ref = this->is_ref;
     HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_list_assignment* clone = new 
HIR_list_assignment(list_elements, expr);
+    HIR_assignment* clone = new HIR_assignment(variable, is_ref, expr);
     clone->HIR_node::clone_mixin_from(this);
     return clone;
 }

-void HIR_list_assignment::assert_valid()
+void HIR_assignment::assert_valid()
 {
-    assert(list_elements != NULL);
-    {
-    	List<HIR_list_element*>::const_iterator i;
-    	for(i = this->list_elements->begin(); i != 
this->list_elements->end(); i++)
-    	{
-    		if(*i != NULL) (*i)->assert_valid();
-    	}
-    }
+    assert(variable != NULL);
+    variable->assert_valid();
     assert(expr != NULL);
     expr->assert_valid();
     HIR_node::assert_mixin_valid();
@@ -6273,204 +4143,6 @@
 		this->op = new Token_op(new String(op));
 		this->right = right;
 	}
-}
-
-HIR_conditional_expr::HIR_conditional_expr(HIR_expr* cond, HIR_expr* 
iftrue, HIR_expr* iffalse)
-{
-    this->cond = cond;
-    this->iftrue = iftrue;
-    this->iffalse = iffalse;
-}
-
-HIR_conditional_expr::HIR_conditional_expr()
-{
-    this->cond = 0;
-    this->iftrue = 0;
-    this->iffalse = 0;
-}
-
-void HIR_conditional_expr::visit(HIR_visitor* visitor)
-{
-    visitor->visit_expr(this);
-}
-
-void HIR_conditional_expr::transform_children(HIR_transform* transform)
-{
-    transform->children_expr(this);
-}
-
-int HIR_conditional_expr::classid()
-{
-    return ID;
-}
-
-bool HIR_conditional_expr::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_conditional_expr* that = dynamic_cast<HIR_conditional_expr*>(in);
-    if(that == NULL) return false;
-
-    if(this->cond == NULL)
-    {
-    	if(that->cond != NULL && !that->cond->match(this->cond))
-    		return false;
-    }
-    else if(!this->cond->match(that->cond))
-    	return false;
-
-    if(this->iftrue == NULL)
-    {
-    	if(that->iftrue != NULL && !that->iftrue->match(this->iftrue))
-    		return false;
-    }
-    else if(!this->iftrue->match(that->iftrue))
-    	return false;
-
-    if(this->iffalse == NULL)
-    {
-    	if(that->iffalse != NULL && !that->iffalse->match(this->iffalse))
-    		return false;
-    }
-    else if(!this->iffalse->match(that->iffalse))
-    	return false;
-
-    return true;
-}
-
-bool HIR_conditional_expr::equals(HIR_node* in)
-{
-    HIR_conditional_expr* that = dynamic_cast<HIR_conditional_expr*>(in);
-    if(that == NULL) return false;
-
-    if(this->cond == NULL || that->cond == NULL)
-    {
-    	if(this->cond != NULL || that->cond != NULL)
-    		return false;
-    }
-    else if(!this->cond->equals(that->cond))
-    	return false;
-
-    if(this->iftrue == NULL || that->iftrue == NULL)
-    {
-    	if(this->iftrue != NULL || that->iftrue != NULL)
-    		return false;
-    }
-    else if(!this->iftrue->equals(that->iftrue))
-    	return false;
-
-    if(this->iffalse == NULL || that->iffalse == NULL)
-    {
-    	if(this->iffalse != NULL || that->iffalse != NULL)
-    		return false;
-    }
-    else if(!this->iffalse->equals(that->iffalse))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_conditional_expr* HIR_conditional_expr::clone()
-{
-    HIR_expr* cond = this->cond ? this->cond->clone() : NULL;
-    HIR_expr* iftrue = this->iftrue ? this->iftrue->clone() : NULL;
-    HIR_expr* iffalse = this->iffalse ? this->iffalse->clone() : NULL;
-    HIR_conditional_expr* clone = new HIR_conditional_expr(cond, 
iftrue, iffalse);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_conditional_expr::assert_valid()
-{
-    assert(cond != NULL);
-    cond->assert_valid();
-    assert(iftrue != NULL);
-    iftrue->assert_valid();
-    assert(iffalse != NULL);
-    iffalse->assert_valid();
-    HIR_node::assert_mixin_valid();
-}
-
-HIR_ignore_errors::HIR_ignore_errors(HIR_expr* expr)
-{
-    this->expr = expr;
-}
-
-HIR_ignore_errors::HIR_ignore_errors()
-{
-    this->expr = 0;
-}
-
-void HIR_ignore_errors::visit(HIR_visitor* visitor)
-{
-    visitor->visit_expr(this);
-}
-
-void HIR_ignore_errors::transform_children(HIR_transform* transform)
-{
-    transform->children_expr(this);
-}
-
-int HIR_ignore_errors::classid()
-{
-    return ID;
-}
-
-bool HIR_ignore_errors::match(HIR_node* in)
-{
-    __WILDCARD__* joker;
-    joker = dynamic_cast<__WILDCARD__*>(in);
-    if(joker != NULL && joker->match(this))
-    	return true;
-
-    HIR_ignore_errors* that = dynamic_cast<HIR_ignore_errors*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL)
-    {
-    	if(that->expr != NULL && !that->expr->match(this->expr))
-    		return false;
-    }
-    else if(!this->expr->match(that->expr))
-    	return false;
-
-    return true;
-}
-
-bool HIR_ignore_errors::equals(HIR_node* in)
-{
-    HIR_ignore_errors* that = dynamic_cast<HIR_ignore_errors*>(in);
-    if(that == NULL) return false;
-
-    if(this->expr == NULL || that->expr == NULL)
-    {
-    	if(this->expr != NULL || that->expr != NULL)
-    		return false;
-    }
-    else if(!this->expr->equals(that->expr))
-    	return false;
-
-    if(!HIR_node::is_mixin_equal(that)) return false;
-    return true;
-}
-
-HIR_ignore_errors* HIR_ignore_errors::clone()
-{
-    HIR_expr* expr = this->expr ? this->expr->clone() : NULL;
-    HIR_ignore_errors* clone = new HIR_ignore_errors(expr);
-    clone->HIR_node::clone_mixin_from(this);
-    return clone;
-}
-
-void HIR_ignore_errors::assert_valid()
-{
-    assert(expr != NULL);
-    expr->assert_valid();
-    HIR_node::assert_mixin_valid();
 }

  HIR_constant::HIR_constant(Token_class_name* class_name, 
Token_constant_name* constant_name)

Modified: trunk/src/generated/HIR.h
==============================================================================
--- trunk/src/generated/HIR.h	(original)
+++ trunk/src/generated/HIR.h	Sun Oct  7 03:11:32 2007
@@ -20,70 +20,50 @@
 namespace HIR{
 class HIR_node;
 class HIR_php_script;
+class HIR_statement;
 class HIR_class_mod;
+class HIR_member;
 class HIR_signature;
 class HIR_method_mod;
 class HIR_formal_parameter;
 class HIR_type;
 class HIR_attr_mod;
-class HIR_directive;
-class HIR_list_element;
+class HIR_catch;
 class HIR_variable_name;
 class HIR_target;
 class HIR_array_elem;
 class HIR_method_name;
 class HIR_actual_parameter;
 class HIR_class_name;
-class HIR_commented_node;
 class HIR_identifier;
-class HIR_statement;
-class HIR_member;
-class HIR_switch_case;
-class HIR_catch;
-class HIR_expr;
-class HIR_nested_list_elements;
-class HIR_reflection;
-class Token_class_name;
-class Token_interface_name;
-class Token_method_name;
-class Token_variable_name;
-class Token_directive_name;
-class Token_label_name;
-class Token_op;
-class Token_cast;
-class Token_constant_name;
 class HIR_class_def;
 class HIR_interface_def;
 class HIR_method;
 class HIR_attribute;
-class HIR_if;
-class HIR_while;
-class HIR_do;
-class HIR_for;
-class HIR_foreach;
-class HIR_switch;
-class HIR_break;
-class HIR_continue;
 class HIR_return;
 class HIR_static_declaration;
 class HIR_global;
-class HIR_declare;
 class HIR_try;
 class HIR_throw;
 class HIR_eval_expr;
-class HIR_nop;
 class HIR_branch;
 class HIR_goto;
 class HIR_label;
+class HIR_expr;
+class HIR_reflection;
+class Token_class_name;
+class Token_interface_name;
+class Token_method_name;
+class Token_variable_name;
+class Token_label_name;
+class Token_cast;
+class Token_op;
+class Token_constant_name;
 class HIR_literal;
 class HIR_assignment;
-class HIR_op_assignment;
-class HIR_list_assignment;
 class HIR_cast;
 class HIR_unary_op;
 class HIR_bin_op;
-class HIR_conditional_expr;
-class HIR_ignore_errors;
 class HIR_constant;
 class HIR_instanceof;
 class HIR_variable;
@@ -101,7 +81,7 @@
 class HIR_transform;
 class HIR_visitor;

-// node ::= php_script | class_mod | signature | method_mod | 
formal_parameter | type | attr_mod | directive | list_element | 
variable_name | target | array_elem | method_name | actual_parameter | 
class_name | commented_node | identifier;
+// node ::= php_script | statement | class_mod | member | signature | 
method_mod | formal_parameter | type | attr_mod | catch | variable_name  
| target | array_elem | method_name | actual_parameter | class_name | identifier;
 class HIR_node : virtual public Object
 {
 public:
@@ -154,6 +134,26 @@
     virtual void assert_valid();
 };

+// statement ::= class_def | interface_def | method | return | 
static_declaration | global | try | throw | eval_expr | label | goto | branch;
+class HIR_statement : virtual public HIR_node
+{
+public:
+    HIR_statement();
+public:
+    virtual void visit(HIR_visitor* visitor) = 0;
+    virtual void transform_children(HIR_transform* transform) = 0;
+public:
+    virtual int classid() = 0;
+public:
+    virtual bool match(HIR_node* in) = 0;
+public:
+    virtual bool equals(HIR_node* in) = 0;
+public:
+    virtual HIR_statement* clone() = 0;
+public:
+    virtual void assert_valid() = 0;
+};
+
 // class_mod ::= "abstract"? "final"? ;
 class HIR_class_mod : virtual public HIR_node
 {
@@ -180,6 +180,26 @@
     virtual void assert_valid();
 };

+// member ::= method | attribute;
+class HIR_member : virtual public HIR_node
+{
+public:
+    HIR_member();
+public:
+    virtual void visit(HIR_visitor* visitor) = 0;
+    virtual void transform_children(HIR_transform* transform) = 0;
+public:
+    virtual int classid() = 0;
+public:
+    virtual bool match(HIR_node* in) = 0;
+public:
+    virtual bool equals(HIR_node* in) = 0;
+public:
+    virtual HIR_member* clone() = 0;
+public:
+    virtual void assert_valid() = 0;
+};
+
 // signature ::= method_mod is_ref:"&" METHOD_NAME formal_parameter* ;
 class HIR_signature : virtual public HIR_node
 {
@@ -338,52 +358,33 @@
     static HIR_attr_mod* new_CONST();
 };

-// directive ::= DIRECTIVE_NAME expr ;
-class HIR_directive : virtual public HIR_node
+// catch ::= CLASS_NAME VARIABLE_NAME statement* ;
+class HIR_catch : virtual public HIR_node
 {
 public:
-    HIR_directive(Token_directive_name* directive_name, HIR_expr* expr);
+    HIR_catch(Token_class_name* class_name, Token_variable_name* 
variable_name, List<HIR_statement*>* statements);
 protected:
-    HIR_directive();
+    HIR_catch();
 public:
-    Token_directive_name* directive_name;
-    HIR_expr* expr;
+    Token_class_name* class_name;
+    Token_variable_name* variable_name;
+    List<HIR_statement*>* statements;
 public:
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    static const int ID = 25;
+    static const int ID = 16;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
 public:
     virtual bool equals(HIR_node* in);
 public:
-    virtual HIR_directive* clone();
+    virtual HIR_catch* clone();
 public:
     virtual void assert_valid();
 };

-// list_element ::= variable | nested_list_elements;
-class HIR_list_element : virtual public HIR_node
-{
-public:
-    HIR_list_element();
-public:
-    virtual void visit(HIR_visitor* visitor) = 0;
-    virtual void transform_children(HIR_transform* transform) = 0;
-public:
-    virtual int classid() = 0;
-public:
-    virtual bool match(HIR_node* in) = 0;
-public:
-    virtual bool equals(HIR_node* in) = 0;
-public:
-    virtual HIR_list_element* clone() = 0;
-public:
-    virtual void assert_valid() = 0;
-};
-
 // variable_name ::= VARIABLE_NAME | reflection;
 class HIR_variable_name : virtual public HIR_node
 {
@@ -439,7 +440,7 @@
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    static const int ID = 50;
+    static const int ID = 33;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
@@ -485,7 +486,7 @@
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    static const int ID = 52;
+    static const int ID = 35;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
@@ -517,29 +518,7 @@
     virtual void assert_valid() = 0;
 };

-// commented_node ::= member | statement | interface_def | class_def | 
switch_case | catch;
-class HIR_commented_node : virtual public HIR_node
-{
-public:
-    virtual void visit(HIR_visitor* visitor) = 0;
-    virtual void transform_children(HIR_transform* transform) = 0;
-public:
-    virtual int classid() = 0;
-public:
-    virtual bool match(HIR_node* in) = 0;
-public:
-    virtual bool equals(HIR_node* in) = 0;
-public:
-    virtual HIR_commented_node* clone() = 0;
-public:
-    virtual void assert_valid() = 0;
-public:
-    HIR_commented_node();
-    //  Return the comments associated with the node
-    List<String*>* get_comments();
-};
-
-// identifier ::= INTERFACE_NAME | CLASS_NAME | METHOD_NAME | 
VARIABLE_NAME | DIRECTIVE_NAME | CAST | OP | CONSTANT_NAME | LABEL_NAME;
+// identifier ::= INTERFACE_NAME | CLASS_NAME | METHOD_NAME | 
VARIABLE_NAME | CAST | OP | CONSTANT_NAME | LABEL_NAME;
 class HIR_identifier : virtual public HIR_node
 {
 public:
@@ -561,682 +540,286 @@
     virtual String* get_value_as_string() = 0;
 };

-// statement ::= class_def | interface_def | method | if | while | do |
  for | foreach | switch | break | continue | return | 
static_declaration | global | declare | try | throw | eval_expr | nop | 
label | goto | branch;
-class HIR_statement : virtual public HIR_commented_node
+// class_def ::= class_mod CLASS_NAME extends:CLASS_NAME? 
implements:INTERFACE_NAME* member* ;
+class HIR_class_def : virtual public HIR_statement
 {
 public:
-    HIR_statement();
-public:
-    virtual void visit(HIR_visitor* visitor) = 0;
-    virtual void transform_children(HIR_transform* transform) = 0;
-public:
-    virtual int classid() = 0;
-public:
-    virtual bool match(HIR_node* in) = 0;
-public:
-    virtual bool equals(HIR_node* in) = 0;
-public:
-    virtual HIR_statement* clone() = 0;
+    HIR_class_def(HIR_class_mod* class_mod, Token_class_name* 
class_name, Token_class_name* extends, List<Token_interface_name*>* 
implements, List<HIR_member*>* members);
+protected:
+    HIR_class_def();
 public:
-    virtual void assert_valid() = 0;
-};
-
-// member ::= method | attribute;
-class HIR_member : virtual public HIR_commented_node
-{
+    HIR_class_mod* class_mod;
+    Token_class_name* class_name;
+    Token_class_name* extends;
+    List<Token_interface_name*>* implements;
+    List<HIR_member*>* members;
 public:
-    HIR_member();
+    virtual void visit(HIR_visitor* visitor);
+    virtual void transform_children(HIR_transform* transform);
 public:
-    virtual void visit(HIR_visitor* visitor) = 0;
-    virtual void transform_children(HIR_transform* transform) = 0;
+    static const int ID = 2;
+    virtual int classid();
 public:
-    virtual int classid() = 0;
+    virtual bool match(HIR_node* in);
 public:
-    virtual bool match(HIR_node* in) = 0;
+    virtual bool equals(HIR_node* in);
 public:
-    virtual bool equals(HIR_node* in) = 0;
+    virtual HIR_class_def* clone();
 public:
-    virtual HIR_member* clone() = 0;
+    virtual void assert_valid();
 public:
-    virtual void assert_valid() = 0;
+    HIR_class_def(HIR_class_mod* mod);
+    HIR_class_def(const char* name);
+    void add_member(HIR_member* member);
+    //  Returns NULL if the method could not be found
+    HIR_method* get_method(const char* name);
 };

-// switch_case ::= expr? statement* ;
-class HIR_switch_case : virtual public HIR_commented_node
+// interface_def ::= INTERFACE_NAME extends:INTERFACE_NAME* member* ;
+class HIR_interface_def : virtual public HIR_statement
 {
 public:
-    HIR_switch_case(HIR_expr* expr, List<HIR_statement*>* statements);
+    HIR_interface_def(Token_interface_name* interface_name, 
List<Token_interface_name*>* extends, List<HIR_member*>* members);
 protected:
-    HIR_switch_case();
+    HIR_interface_def();
 public:
-    HIR_expr* expr;
-    List<HIR_statement*>* statements;
+    Token_interface_name* interface_name;
+    List<Token_interface_name*>* extends;
+    List<HIR_member*>* members;
 public:
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    static const int ID = 18;
+    static const int ID = 4;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
 public:
     virtual bool equals(HIR_node* in);
 public:
-    virtual HIR_switch_case* clone();
+    virtual HIR_interface_def* clone();
 public:
     virtual void assert_valid();
 };

-// catch ::= CLASS_NAME VARIABLE_NAME statement* ;
-class HIR_catch : virtual public HIR_commented_node
+// method ::= signature statement*? ;
+class HIR_method : virtual public HIR_statement, virtual public HIR_member
 {
 public:
-    HIR_catch(Token_class_name* class_name, Token_variable_name* 
variable_name, List<HIR_statement*>* statements);
+    HIR_method(HIR_signature* signature, List<HIR_statement*>* statements);
 protected:
-    HIR_catch();
+    HIR_method();
 public:
-    Token_class_name* class_name;
-    Token_variable_name* variable_name;
+    HIR_signature* signature;
     List<HIR_statement*>* statements;
 public:
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    static const int ID = 27;
+    static const int ID = 5;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
 public:
     virtual bool equals(HIR_node* in);
 public:
-    virtual HIR_catch* clone();
+    virtual HIR_method* clone();
 public:
     virtual void assert_valid();
 };

-// expr ::= assignment | op_assignment | list_assignment | cast | 
unary_op | bin_op | conditional_expr | ignore_errors | constant | 
instanceof | variable | pre_op | post_op | array | method_invocation | 
new | literal;
-class HIR_expr : virtual public HIR_target
+// attribute ::= attr_mod VARIABLE_NAME expr? ;
+class HIR_attribute : virtual public HIR_member
 {
 public:
-    HIR_expr();
+    HIR_attribute(HIR_attr_mod* attr_mod, Token_variable_name* 
variable_name, HIR_expr* expr);
+protected:
+    HIR_attribute();
 public:
-    virtual void visit(HIR_visitor* visitor) = 0;
-    virtual void transform_children(HIR_transform* transform) = 0;
+    HIR_attr_mod* attr_mod;
+    Token_variable_name* variable_name;
+    HIR_expr* expr;
 public:
-    virtual int classid() = 0;
+    virtual void visit(HIR_visitor* visitor);
+    virtual void transform_children(HIR_transform* transform);
 public:
-    virtual bool match(HIR_node* in) = 0;
+    static const int ID = 10;
+    virtual int classid();
 public:
-    virtual bool equals(HIR_node* in) = 0;
+    virtual bool match(HIR_node* in);
 public:
-    virtual HIR_expr* clone() = 0;
+    virtual bool equals(HIR_node* in);
 public:
-    virtual void assert_valid() = 0;
+    virtual HIR_attribute* clone();
+public:
+    virtual void assert_valid();
 };

-// nested_list_elements ::= list_element?* ;
-class HIR_nested_list_elements : virtual public HIR_list_element
+// return ::= expr? ;
+class HIR_return : virtual public HIR_statement
 {
 public:
-    HIR_nested_list_elements(List<HIR_list_element*>* list_elements);
+    HIR_return(HIR_expr* expr);
 protected:
-    HIR_nested_list_elements();
+    HIR_return();
 public:
-    List<HIR_list_element*>* list_elements;
+    HIR_expr* expr;
 public:
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    static const int ID = 37;
+    static const int ID = 12;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
 public:
     virtual bool equals(HIR_node* in);
 public:
-    virtual HIR_nested_list_elements* clone();
+    virtual HIR_return* clone();
 public:
     virtual void assert_valid();
 };

-// reflection ::= expr ;
-class HIR_reflection : virtual public HIR_variable_name, virtual 
public HIR_method_name, virtual public HIR_class_name
+// static_declaration ::= VARIABLE_NAME expr? ;
+class HIR_static_declaration : virtual public HIR_statement
 {
 public:
-    HIR_reflection(HIR_expr* expr);
+    HIR_static_declaration(Token_variable_name* variable_name, 
HIR_expr* expr);
 protected:
-    HIR_reflection();
+    HIR_static_declaration();
 public:
+    Token_variable_name* variable_name;
     HIR_expr* expr;
 public:
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    static const int ID = 46;
+    static const int ID = 13;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
 public:
     virtual bool equals(HIR_node* in);
 public:
-    virtual HIR_reflection* clone();
+    virtual HIR_static_declaration* clone();
 public:
     virtual void assert_valid();
 };

-class Token_class_name : virtual public HIR_target, virtual public 
HIR_class_name, virtual public HIR_identifier
+// global ::= variable_name ;
+class HIR_global : virtual public HIR_statement
 {
 public:
-    Token_class_name(String* value);
+    HIR_global(HIR_variable_name* variable_name);
 protected:
-    Token_class_name();
+    HIR_global();
+public:
+    HIR_variable_name* variable_name;
 public:
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    String* value;
-    virtual String* get_value_as_string();
-public:
-    static const int ID = 54;
+    static const int ID = 14;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
 public:
     virtual bool equals(HIR_node* in);
 public:
-    virtual Token_class_name* clone();
+    virtual HIR_global* clone();
 public:
     virtual void assert_valid();
 };

-class Token_interface_name : virtual public HIR_identifier
+// try ::= statement* catches:catch* ;
+class HIR_try : virtual public HIR_statement
 {
 public:
-    Token_interface_name(String* value);
+    HIR_try(List<HIR_statement*>* statements, List<HIR_catch*>* catches);
 protected:
-    Token_interface_name();
+    HIR_try();
+public:
+    List<HIR_statement*>* statements;
+    List<HIR_catch*>* catches;
 public:
     virtual void visit(HIR_visitor* visitor);
     virtual void transform_children(HIR_transform* transform);
 public:
-    String* value;
-    virtual String* get_value_as_string();
-public:
-    static const int ID = 55;
+    static const int ID = 15;
     virtual int classid();
 public:
     virtual bool match(HIR_node* in);
 public:
     virtual bool equals(HIR_node* in);
 public:
-    virtual Token_interface_name* clone();
-public:
-    virtual void assert_valid();
-};
-
-class Token_method_name : virtual public HIR_method_name, virtual 
public HIR_identifier
-{
-public:
-    Token_method_name(String* value);
-protected:
-    Token_method_name();
-public:
-    virtual void visit(HIR_visitor* visitor);
-    virtual void transform_children(HIR_transform* transform);
-public:
-    String* value;
-    virtual String* get_value_as_string();
-public:
-    static const int ID = 56;
-    virtual int classid();
-public:
-    virtual bool match(HIR_node* in);
-public:
-    virtual bool equals(HIR_node* in);
-public:
-    virtual Token_method_name* clone();
-public:
-    virtual void assert_valid();
-};
-
-class Token_variable_name : virtual public HIR_variable_name, virtual 
public HIR_identifier
-{
-public:
-    Token_variable_name(String* value);
-protected:
-    Token_variable_name();
-public:
-    virtual void visit(HIR_visitor* visitor);
-    virtual void transform_children(HIR_transform* transform);
-public:
-    String* value;
-    virtual String* get_value_as_string();
-public:
-    static const int ID = 57;
-    virtual int classid();
-public:
-    virtual bool match(HIR_node* in);
-public:
-    virtual bool equals(HIR_node* in);
-public:
-    virtual Token_variable_name* clone();
-public:
-    virtual void assert_valid();
-};
-
-class Token_directive_name : virtual public HIR_identifier
-{
-public:
-    Token_directive_name(String* value);
-protected:
-    Token_directive_name();
-public:
-    virtual void visit(HIR_visitor* visitor);
-    virtual void transform_children(HIR_transform* transform);
-public:
-    String* value;
-    virtual String* get_value_as_string();
-public:
-    static const int ID = 58;
-    virtual int classid();
-public:
-    virtual bool match(HIR_node* in);
-public:
-    virtual bool equals(HIR_node* in);
-public:
-    virtual Token_directive_name* clone();
-public:
-    virtual void assert_valid();
-};
-
-class Token_label_name : virtual public HIR_identifier
-{
-public:
-    Token_label_name(String* value);
-protected:
-    Token_label_name();
-public:
-    virtual void visit(HIR_visitor* visitor);
-    virtual void transform_children(HIR_transform* transform);
-public:
-    String* value;
-    virtual String* get_value_as_string();
-public:
-    static const int ID = 59;
-    virtual int classid();
-public:
-    virtual bool match(HIR_node* in);
-public:
-    virtual bool equals(HIR_node* in);
-public:
-    virtual Token_label_name* clone();
-public:
-    virtual void assert_valid();
-};
-
-class Token_op : virtual public HIR_identifier
-{
-public:
-    Token_op(String* value);
-protected:
-    Token_op();
-public:
-    virtual void visit(HIR_visitor* visitor);
-    virtual void transform_children(HIR_transform* transform);
-public:
-    String* value;
-    virtual String* get_value_as_string();
-public:
-    static const int ID = 65

==============================================================================
Diff truncated at 200k characters