Viewing file:  HIR_transform.cpp (61.99 KB) -rw-rw-r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#include "HIR_transform.h"
namespace HIR{
Transform::~Transform()
{
}
/* Invoked before the children are transformed */
PHP_script* Transform::pre_php_script(PHP_script* in)
{
return in;
}
void Transform::pre_class_def(Class_def* in, Statement_list* out)
{
out->push_back(in);
}
Class_mod* Transform::pre_class_mod(Class_mod* in)
{
return in;
}
void Transform::pre_interface_def(Interface_def* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_method(Method* in, Method_list* out)
{
out->push_back(in);
}
Signature* Transform::pre_signature(Signature* in)
{
return in;
}
Method_mod* Transform::pre_method_mod(Method_mod* in)
{
return in;
}
void Transform::pre_formal_parameter(Formal_parameter* in, Formal_parameter_list* out)
{
out->push_back(in);
}
Type* Transform::pre_type(Type* in)
{
return in;
}
void Transform::pre_attribute(Attribute* in, Member_list* out)
{
out->push_back(in);
}
Attr_mod* Transform::pre_attr_mod(Attr_mod* in)
{
return in;
}
Name_with_default* Transform::pre_name_with_default(Name_with_default* in)
{
return in;
}
void Transform::pre_if(If* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_loop(Loop* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_foreach(Foreach* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_break(Break* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_continue(Continue* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_return(Return* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_static_declaration(Static_declaration* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_global(Global* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_try(Try* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_catch(Catch* in, Catch_list* out)
{
out->push_back(in);
}
void Transform::pre_throw(Throw* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_assign_var(Assign_var* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_assign_field(Assign_field* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_assign_array(Assign_array* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_assign_var_var(Assign_var_var* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_assign_next(Assign_next* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_pre_op(Pre_op* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::pre_eval_expr(Eval_expr* in, Statement_list* out)
{
out->push_back(in);
}
Expr* Transform::pre_field_access(Field_access* in)
{
return in;
}
Expr* Transform::pre_array_access(Array_access* in)
{
return in;
}
Expr* Transform::pre_array_next(Array_next* in)
{
return in;
}
Expr* Transform::pre_cast(Cast* in)
{
return in;
}
Expr* Transform::pre_unary_op(Unary_op* in)
{
return in;
}
Expr* Transform::pre_bin_op(Bin_op* in)
{
return in;
}
Constant* Transform::pre_constant(Constant* in)
{
return in;
}
Expr* Transform::pre_instanceof(Instanceof* in)
{
return in;
}
Expr* Transform::pre_method_invocation(Method_invocation* in)
{
return in;
}
Expr* Transform::pre_new(New* in)
{
return in;
}
void Transform::pre_variable_actual_parameter(Variable_actual_parameter* in, Actual_parameter_list* out)
{
out->push_back(in);
}
Method_name* Transform::pre_variable_method(Variable_method* in)
{
return in;
}
Variable_name* Transform::pre_variable_variable(Variable_variable* in)
{
return in;
}
Class_name* Transform::pre_variable_class(Variable_class* in)
{
return in;
}
Field_name* Transform::pre_variable_field(Variable_field* in)
{
return in;
}
Static_value* Transform::pre_static_array(Static_array* in)
{
return in;
}
void Transform::pre_static_array_elem(Static_array_elem* in, Static_array_elem_list* out)
{
out->push_back(in);
}
FOREIGN* Transform::pre_foreign(FOREIGN* in)
{
return in;
}
CLASS_NAME* Transform::pre_class_name(CLASS_NAME* in)
{
return in;
}
INTERFACE_NAME* Transform::pre_interface_name(INTERFACE_NAME* in)
{
return in;
}
METHOD_NAME* Transform::pre_method_name(METHOD_NAME* in)
{
return in;
}
VARIABLE_NAME* Transform::pre_variable_name(VARIABLE_NAME* in)
{
return in;
}
OP* Transform::pre_op(OP* in)
{
return in;
}
Literal* Transform::pre_int(INT* in)
{
return in;
}
Literal* Transform::pre_real(REAL* in)
{
return in;
}
Literal* Transform::pre_string(STRING* in)
{
return in;
}
Literal* Transform::pre_bool(BOOL* in)
{
return in;
}
Literal* Transform::pre_nil(NIL* in)
{
return in;
}
CAST* Transform::pre_cast(CAST* in)
{
return in;
}
CONSTANT_NAME* Transform::pre_constant_name(CONSTANT_NAME* in)
{
return in;
}
Field_name* Transform::pre_field_name(FIELD_NAME* in)
{
return in;
}
/* Invoked after the children have been transformed */
PHP_script* Transform::post_php_script(PHP_script* in)
{
return in;
}
void Transform::post_class_def(Class_def* in, Statement_list* out)
{
out->push_back(in);
}
Class_mod* Transform::post_class_mod(Class_mod* in)
{
return in;
}
void Transform::post_interface_def(Interface_def* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_method(Method* in, Method_list* out)
{
out->push_back(in);
}
Signature* Transform::post_signature(Signature* in)
{
return in;
}
Method_mod* Transform::post_method_mod(Method_mod* in)
{
return in;
}
void Transform::post_formal_parameter(Formal_parameter* in, Formal_parameter_list* out)
{
out->push_back(in);
}
Type* Transform::post_type(Type* in)
{
return in;
}
void Transform::post_attribute(Attribute* in, Member_list* out)
{
out->push_back(in);
}
Attr_mod* Transform::post_attr_mod(Attr_mod* in)
{
return in;
}
Name_with_default* Transform::post_name_with_default(Name_with_default* in)
{
return in;
}
void Transform::post_if(If* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_loop(Loop* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_foreach(Foreach* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_break(Break* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_continue(Continue* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_return(Return* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_static_declaration(Static_declaration* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_global(Global* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_try(Try* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_catch(Catch* in, Catch_list* out)
{
out->push_back(in);
}
void Transform::post_throw(Throw* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_assign_var(Assign_var* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_assign_field(Assign_field* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_assign_array(Assign_array* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_assign_var_var(Assign_var_var* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_assign_next(Assign_next* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_pre_op(Pre_op* in, Statement_list* out)
{
out->push_back(in);
}
void Transform::post_eval_expr(Eval_expr* in, Statement_list* out)
{
out->push_back(in);
}
Expr* Transform::post_field_access(Field_access* in)
{
return in;
}
Expr* Transform::post_array_access(Array_access* in)
{
return in;
}
Expr* Transform::post_array_next(Array_next* in)
{
return in;
}
Expr* Transform::post_cast(Cast* in)
{
return in;
}
Expr* Transform::post_unary_op(Unary_op* in)
{
return in;
}
Expr* Transform::post_bin_op(Bin_op* in)
{
return in;
}
Constant* Transform::post_constant(Constant* in)
{
return in;
}
Expr* Transform::post_instanceof(Instanceof* in)
{
return in;
}
Expr* Transform::post_method_invocation(Method_invocation* in)
{
return in;
}
Expr* Transform::post_new(New* in)
{
return in;
}
void Transform::post_variable_actual_parameter(Variable_actual_parameter* in, Actual_parameter_list* out)
{
out->push_back(in);
}
Method_name* Transform::post_variable_method(Variable_method* in)
{
return in;
}
Variable_name* Transform::post_variable_variable(Variable_variable* in)
{
return in;
}
Class_name* Transform::post_variable_class(Variable_class* in)
{
return in;
}
Field_name* Transform::post_variable_field(Variable_field* in)
{
return in;
}
Static_value* Transform::post_static_array(Static_array* in)
{
return in;
}
void Transform::post_static_array_elem(Static_array_elem* in, Static_array_elem_list* out)
{
out->push_back(in);
}
FOREIGN* Transform::post_foreign(FOREIGN* in)
{
return in;
}
CLASS_NAME* Transform::post_class_name(CLASS_NAME* in)
{
return in;
}
INTERFACE_NAME* Transform::post_interface_name(INTERFACE_NAME* in)
{
return in;
}
METHOD_NAME* Transform::post_method_name(METHOD_NAME* in)
{
return in;
}
VARIABLE_NAME* Transform::post_variable_name(VARIABLE_NAME* in)
{
return in;
}
OP* Transform::post_op(OP* in)
{
return in;
}
Literal* Transform::post_int(INT* in)
{
return in;
}
Literal* Transform::post_real(REAL* in)
{
return in;
}
Literal* Transform::post_string(STRING* in)
{
return in;
}
Literal* Transform::post_bool(BOOL* in)
{
return in;
}
Literal* Transform::post_nil(NIL* in)
{
return in;
}
CAST* Transform::post_cast(CAST* in)
{
return in;
}
CONSTANT_NAME* Transform::post_constant_name(CONSTANT_NAME* in)
{
return in;
}
Field_name* Transform::post_field_name(FIELD_NAME* in)
{
return in;
}
/* Transform the children of the node */
void Transform::children_php_script(PHP_script* in)
{
in->statements = transform_statement_list(in->statements);
}
void Transform::children_class_def(Class_def* in)
{
in->class_mod = transform_class_mod(in->class_mod);
in->class_name = transform_class_name(in->class_name);
in->extends = transform_class_name(in->extends);
in->implements = transform_interface_name_list(in->implements);
in->members = transform_member_list(in->members);
}
void Transform::children_class_mod(Class_mod* in)
{
}
void Transform::children_interface_def(Interface_def* in)
{
in->interface_name = transform_interface_name(in->interface_name);
in->extends = transform_interface_name_list(in->extends);
in->members = transform_member_list(in->members);
}
void Transform::children_method(Method* in)
{
in->signature = transform_signature(in->signature);
in->statements = transform_statement_list(in->statements);
}
void Transform::children_signature(Signature* in)
{
in->method_mod = transform_method_mod(in->method_mod);
in->method_name = transform_method_name(in->method_name);
in->formal_parameters = transform_formal_parameter_list(in->formal_parameters);
}
void Transform::children_method_mod(Method_mod* in)
{
}
void Transform::children_formal_parameter(Formal_parameter* in)
{
in->type = transform_type(in->type);
in->var = transform_name_with_default(in->var);
}
void Transform::children_type(Type* in)
{
in->class_name = transform_class_name(in->class_name);
}
void Transform::children_attribute(Attribute* in)
{
in->attr_mod = transform_attr_mod(in->attr_mod);
in->var = transform_name_with_default(in->var);
}
void Transform::children_attr_mod(Attr_mod* in)
{
}
void Transform::children_name_with_default(Name_with_default* in)
{
in->variable_name = transform_variable_name(in->variable_name);
in->default_value = transform_static_value(in->default_value);
}
void Transform::children_if(If* in)
{
in->variable_name = transform_variable_name(in->variable_name);
in->iftrue = transform_statement_list(in->iftrue);
in->iffalse = transform_statement_list(in->iffalse);
}
void Transform::children_loop(Loop* in)
{
in->statements = transform_statement_list(in->statements);
}
void Transform::children_foreach(Foreach* in)
{
in->arr = transform_variable_name(in->arr);
in->key = transform_variable_name(in->key);
in->val = transform_variable_name(in->val);
in->statements = transform_statement_list(in->statements);
}
void Transform::children_break(Break* in)
{
in->expr = transform_expr(in->expr);
}
void Transform::children_continue(Continue* in)
{
in->expr = transform_expr(in->expr);
}
void Transform::children_return(Return* in)
{
in->rvalue = transform_rvalue(in->rvalue);
}
void Transform::children_static_declaration(Static_declaration* in)
{
in->var = transform_name_with_default(in->var);
}
void Transform::children_global(Global* in)
{
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_try(Try* in)
{
in->statements = transform_statement_list(in->statements);
in->catches = transform_catch_list(in->catches);
}
void Transform::children_catch(Catch* in)
{
in->class_name = transform_class_name(in->class_name);
in->variable_name = transform_variable_name(in->variable_name);
in->statements = transform_statement_list(in->statements);
}
void Transform::children_throw(Throw* in)
{
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_assign_var(Assign_var* in)
{
in->lhs = transform_variable_name(in->lhs);
in->rhs = transform_expr(in->rhs);
}
void Transform::children_assign_field(Assign_field* in)
{
in->target = transform_target(in->target);
in->field_name = transform_field_name(in->field_name);
in->rhs = transform_rvalue(in->rhs);
}
void Transform::children_assign_array(Assign_array* in)
{
in->lhs = transform_variable_name(in->lhs);
in->index = transform_rvalue(in->index);
in->rhs = transform_rvalue(in->rhs);
}
void Transform::children_assign_var_var(Assign_var_var* in)
{
in->lhs = transform_variable_name(in->lhs);
in->rhs = transform_rvalue(in->rhs);
}
void Transform::children_assign_next(Assign_next* in)
{
in->lhs = transform_variable_name(in->lhs);
in->rhs = transform_rvalue(in->rhs);
}
void Transform::children_pre_op(Pre_op* in)
{
in->op = transform_op(in->op);
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_eval_expr(Eval_expr* in)
{
in->expr = transform_expr(in->expr);
}
void Transform::children_field_access(Field_access* in)
{
in->target = transform_target(in->target);
in->field_name = transform_field_name(in->field_name);
}
void Transform::children_array_access(Array_access* in)
{
in->variable_name = transform_variable_name(in->variable_name);
in->index = transform_rvalue(in->index);
}
void Transform::children_array_next(Array_next* in)
{
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_cast(Cast* in)
{
in->cast = transform_cast(in->cast);
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_unary_op(Unary_op* in)
{
in->op = transform_op(in->op);
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_bin_op(Bin_op* in)
{
in->left = transform_rvalue(in->left);
in->op = transform_op(in->op);
in->right = transform_rvalue(in->right);
}
void Transform::children_constant(Constant* in)
{
in->class_name = transform_class_name(in->class_name);
in->constant_name = transform_constant_name(in->constant_name);
}
void Transform::children_instanceof(Instanceof* in)
{
in->variable_name = transform_variable_name(in->variable_name);
in->class_name = transform_class_name(in->class_name);
}
void Transform::children_method_invocation(Method_invocation* in)
{
in->target = transform_target(in->target);
in->method_name = transform_method_name(in->method_name);
in->actual_parameters = transform_actual_parameter_list(in->actual_parameters);
}
void Transform::children_new(New* in)
{
in->class_name = transform_class_name(in->class_name);
in->actual_parameters = transform_actual_parameter_list(in->actual_parameters);
}
void Transform::children_variable_actual_parameter(Variable_actual_parameter* in)
{
in->target = transform_target(in->target);
in->variable_name = transform_variable_name(in->variable_name);
in->array_indices = transform_rvalue_list(in->array_indices);
}
void Transform::children_variable_method(Variable_method* in)
{
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_variable_variable(Variable_variable* in)
{
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_variable_class(Variable_class* in)
{
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_variable_field(Variable_field* in)
{
in->variable_name = transform_variable_name(in->variable_name);
}
void Transform::children_static_array(Static_array* in)
{
in->static_array_elems = transform_static_array_elem_list(in->static_array_elems);
}
void Transform::children_static_array_elem(Static_array_elem* in)
{
in->key = transform_static_array_key(in->key);
in->val = transform_static_value(in->val);
}
/* Tokens don't have children, so these methods do nothing by default */
void Transform::children_foreign(FOREIGN* in)
{
}
void Transform::children_class_name(CLASS_NAME* in)
{
}
void Transform::children_interface_name(INTERFACE_NAME* in)
{
}
void Transform::children_method_name(METHOD_NAME* in)
{
}
void Transform::children_variable_name(VARIABLE_NAME* in)
{
}
void Transform::children_op(OP* in)
{
}
void Transform::children_int(INT* in)
{
}
void Transform::children_real(REAL* in)
{
}
void Transform::children_string(STRING* in)
{
}
void Transform::children_bool(BOOL* in)
{
}
void Transform::children_nil(NIL* in)
{
}
void Transform::children_cast(CAST* in)
{
}
void Transform::children_constant_name(CONSTANT_NAME* in)
{
}
void Transform::children_field_name(FIELD_NAME* in)
{
}
/* Call the pre-transform, transform-children post-transform methods in order */
/* Do not override unless you know what you are doing */
Statement_list* Transform::transform_statement_list(Statement_list* in)
{
Statement_list::const_iterator i;
Statement_list* out = new Statement_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back_all(transform_statement(*i));
}
return out;
}
Statement_list* Transform::transform_statement(Statement* in)
{
Statement_list::const_iterator i;
Statement_list* out1 = new Statement_list;
Statement_list* out2 = new Statement_list;
if(in == NULL) out1->push_back(NULL);
else pre_statement(in, out1);
for(i = out1->begin(); i != out1->end(); i++)
{
if(*i != NULL)
{
children_statement(*i);
post_statement(*i, out2);
}
else out2->push_back(NULL);
}
return out2;
}
Class_mod* Transform::transform_class_mod(Class_mod* in)
{
if(in == NULL) return NULL;
Class_mod* out;
out = pre_class_mod(in);
if(out != NULL)
{
children_class_mod(out);
out = post_class_mod(out);
}
return out;
}
CLASS_NAME* Transform::transform_class_name(CLASS_NAME* in)
{
if(in == NULL) return NULL;
CLASS_NAME* out;
out = pre_class_name(in);
if(out != NULL)
{
children_class_name(out);
out = post_class_name(out);
}
return out;
}
INTERFACE_NAME_list* Transform::transform_interface_name_list(INTERFACE_NAME_list* in)
{
INTERFACE_NAME_list::const_iterator i;
INTERFACE_NAME_list* out = new INTERFACE_NAME_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back(transform_interface_name(*i));
}
return out;
}
Member_list* Transform::transform_member_list(Member_list* in)
{
Member_list::const_iterator i;
Member_list* out = new Member_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back_all(transform_member(*i));
}
return out;
}
Member_list* Transform::transform_member(Member* in)
{
Member_list::const_iterator i;
Member_list* out1 = new Member_list;
Member_list* out2 = new Member_list;
if(in == NULL) out1->push_back(NULL);
else pre_member(in, out1);
for(i = out1->begin(); i != out1->end(); i++)
{
if(*i != NULL)
{
children_member(*i);
post_member(*i, out2);
}
else out2->push_back(NULL);
}
return out2;
}
INTERFACE_NAME* Transform::transform_interface_name(INTERFACE_NAME* in)
{
if(in == NULL) return NULL;
INTERFACE_NAME* out;
out = pre_interface_name(in);
if(out != NULL)
{
children_interface_name(out);
out = post_interface_name(out);
}
return out;
}
Signature* Transform::transform_signature(Signature* in)
{
if(in == NULL) return NULL;
Signature* out;
out = pre_signature(in);
if(out != NULL)
{
children_signature(out);
out = post_signature(out);
}
return out;
}
Method_mod* Transform::transform_method_mod(Method_mod* in)
{
if(in == NULL) return NULL;
Method_mod* out;
out = pre_method_mod(in);
if(out != NULL)
{
children_method_mod(out);
out = post_method_mod(out);
}
return out;
}
METHOD_NAME* Transform::transform_method_name(METHOD_NAME* in)
{
if(in == NULL) return NULL;
METHOD_NAME* out;
out = pre_method_name(in);
if(out != NULL)
{
children_method_name(out);
out = post_method_name(out);
}
return out;
}
Formal_parameter_list* Transform::transform_formal_parameter_list(Formal_parameter_list* in)
{
Formal_parameter_list::const_iterator i;
Formal_parameter_list* out = new Formal_parameter_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back_all(transform_formal_parameter(*i));
}
return out;
}
Formal_parameter_list* Transform::transform_formal_parameter(Formal_parameter* in)
{
Formal_parameter_list::const_iterator i;
Formal_parameter_list* out1 = new Formal_parameter_list;
Formal_parameter_list* out2 = new Formal_parameter_list;
if(in == NULL) out1->push_back(NULL);
else pre_formal_parameter(in, out1);
for(i = out1->begin(); i != out1->end(); i++)
{
if(*i != NULL)
{
children_formal_parameter(*i);
post_formal_parameter(*i, out2);
}
else out2->push_back(NULL);
}
return out2;
}
Type* Transform::transform_type(Type* in)
{
if(in == NULL) return NULL;
Type* out;
out = pre_type(in);
if(out != NULL)
{
children_type(out);
out = post_type(out);
}
return out;
}
Name_with_default* Transform::transform_name_with_default(Name_with_default* in)
{
if(in == NULL) return NULL;
Name_with_default* out;
out = pre_name_with_default(in);
if(out != NULL)
{
children_name_with_default(out);
out = post_name_with_default(out);
}
return out;
}
Attr_mod* Transform::transform_attr_mod(Attr_mod* in)
{
if(in == NULL) return NULL;
Attr_mod* out;
out = pre_attr_mod(in);
if(out != NULL)
{
children_attr_mod(out);
out = post_attr_mod(out);
}
return out;
}
VARIABLE_NAME* Transform::transform_variable_name(VARIABLE_NAME* in)
{
if(in == NULL) return NULL;
VARIABLE_NAME* out;
out = pre_variable_name(in);
if(out != NULL)
{
children_variable_name(out);
out = post_variable_name(out);
}
return out;
}
Static_value* Transform::transform_static_value(Static_value* in)
{
if(in == NULL) return NULL;
Static_value* out;
out = pre_static_value(in);
if(out != NULL)
{
children_static_value(out);
out = post_static_value(out);
}
return out;
}
Expr* Transform::transform_expr(Expr* in)
{
if(in == NULL) return NULL;
Expr* out;
out = pre_expr(in);
if(out != NULL)
{
children_expr(out);
out = post_expr(out);
}
return out;
}
Rvalue* Transform::transform_rvalue(Rvalue* in)
{
if(in == NULL) return NULL;
Rvalue* out;
out = pre_rvalue(in);
if(out != NULL)
{
children_rvalue(out);
out = post_rvalue(out);
}
return out;
}
Variable_name* Transform::transform_variable_name(Variable_name* in)
{
if(in == NULL) return NULL;
Variable_name* out;
out = pre_variable_name(in);
if(out != NULL)
{
children_variable_name(out);
out = post_variable_name(out);
}
return out;
}
Catch_list* Transform::transform_catch_list(Catch_list* in)
{
Catch_list::const_iterator i;
Catch_list* out = new Catch_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back_all(transform_catch(*i));
}
return out;
}
Catch_list* Transform::transform_catch(Catch* in)
{
Catch_list::const_iterator i;
Catch_list* out1 = new Catch_list;
Catch_list* out2 = new Catch_list;
if(in == NULL) out1->push_back(NULL);
else pre_catch(in, out1);
for(i = out1->begin(); i != out1->end(); i++)
{
if(*i != NULL)
{
children_catch(*i);
post_catch(*i, out2);
}
else out2->push_back(NULL);
}
return out2;
}
Target* Transform::transform_target(Target* in)
{
if(in == NULL) return NULL;
Target* out;
out = pre_target(in);
if(out != NULL)
{
children_target(out);
out = post_target(out);
}
return out;
}
Field_name* Transform::transform_field_name(Field_name* in)
{
if(in == NULL) return NULL;
Field_name* out;
out = pre_field_name(in);
if(out != NULL)
{
children_field_name(out);
out = post_field_name(out);
}
return out;
}
OP* Transform::transform_op(OP* in)
{
if(in == NULL) return NULL;
OP* out;
out = pre_op(in);
if(out != NULL)
{
children_op(out);
out = post_op(out);
}
return out;
}
CAST* Transform::transform_cast(CAST* in)
{
if(in == NULL) return NULL;
CAST* out;
out = pre_cast(in);
if(out != NULL)
{
children_cast(out);
out = post_cast(out);
}
return out;
}
CONSTANT_NAME* Transform::transform_constant_name(CONSTANT_NAME* in)
{
if(in == NULL) return NULL;
CONSTANT_NAME* out;
out = pre_constant_name(in);
if(out != NULL)
{
children_constant_name(out);
out = post_constant_name(out);
}
return out;
}
Class_name* Transform::transform_class_name(Class_name* in)
{
if(in == NULL) return NULL;
Class_name* out;
out = pre_class_name(in);
if(out != NULL)
{
children_class_name(out);
out = post_class_name(out);
}
return out;
}
Method_name* Transform::transform_method_name(Method_name* in)
{
if(in == NULL) return NULL;
Method_name* out;
out = pre_method_name(in);
if(out != NULL)
{
children_method_name(out);
out = post_method_name(out);
}
return out;
}
Actual_parameter_list* Transform::transform_actual_parameter_list(Actual_parameter_list* in)
{
Actual_parameter_list::const_iterator i;
Actual_parameter_list* out = new Actual_parameter_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back_all(transform_actual_parameter(*i));
}
return out;
}
Actual_parameter_list* Transform::transform_actual_parameter(Actual_parameter* in)
{
Actual_parameter_list::const_iterator i;
Actual_parameter_list* out1 = new Actual_parameter_list;
Actual_parameter_list* out2 = new Actual_parameter_list;
if(in == NULL) out1->push_back(NULL);
else pre_actual_parameter(in, out1);
for(i = out1->begin(); i != out1->end(); i++)
{
if(*i != NULL)
{
children_actual_parameter(*i);
post_actual_parameter(*i, out2);
}
else out2->push_back(NULL);
}
return out2;
}
Rvalue_list* Transform::transform_rvalue_list(Rvalue_list* in)
{
Rvalue_list::const_iterator i;
Rvalue_list* out = new Rvalue_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back(transform_rvalue(*i));
}
return out;
}
Static_array_elem_list* Transform::transform_static_array_elem_list(Static_array_elem_list* in)
{
Static_array_elem_list::const_iterator i;
Static_array_elem_list* out = new Static_array_elem_list;
if(in == NULL)
return NULL;
for(i = in->begin(); i != in->end(); i++)
{
out->push_back_all(transform_static_array_elem(*i));
}
return out;
}
Static_array_elem_list* Transform::transform_static_array_elem(Static_array_elem* in)
{
Static_array_elem_list::const_iterator i;
Static_array_elem_list* out1 = new Static_array_elem_list;
Static_array_elem_list* out2 = new Static_array_elem_list;
if(in == NULL) out1->push_back(NULL);
else pre_static_array_elem(in, out1);
for(i = out1->begin(); i != out1->end(); i++)
{
if(*i != NULL)
{
children_static_array_elem(*i);
post_static_array_elem(*i, out2);
}
else out2->push_back(NULL);
}
return out2;
}
Static_array_key* Transform::transform_static_array_key(Static_array_key* in)
{
if(in == NULL) return NULL;
Static_array_key* out;
out = pre_static_array_key(in);
if(out != NULL)
{
children_static_array_key(out);
out = post_static_array_key(out);
}
return out;
}
PHP_script* Transform::transform_php_script(PHP_script* in)
{
if(in == NULL) return NULL;
PHP_script* out;
out = pre_php_script(in);
if(out != NULL)
{
children_php_script(out);
out = post_php_script(out);
}
return out;
}
/* Invoke the right pre-transform (manual dispatching) */
/* Do not override unless you know what you are doing */
void Transform::pre_statement(Statement* in, Statement_list* out)
{
switch(in->classid())
{
case Class_def::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_class_def(dynamic_cast<Class_def*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Interface_def::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_interface_def(dynamic_cast<Interface_def*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Method::ID:
{
Method_list* local_out = new Method_list;
Method_list::const_iterator i;
pre_method(dynamic_cast<Method*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Return::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_return(dynamic_cast<Return*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Static_declaration::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_static_declaration(dynamic_cast<Static_declaration*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Global::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_global(dynamic_cast<Global*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Try::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_try(dynamic_cast<Try*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Throw::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_throw(dynamic_cast<Throw*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case If::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_if(dynamic_cast<If*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Loop::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_loop(dynamic_cast<Loop*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Foreach::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_foreach(dynamic_cast<Foreach*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Break::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_break(dynamic_cast<Break*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Continue::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_continue(dynamic_cast<Continue*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_var::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_assign_var(dynamic_cast<Assign_var*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_var_var::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_assign_var_var(dynamic_cast<Assign_var_var*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_array::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_assign_array(dynamic_cast<Assign_array*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_next::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_assign_next(dynamic_cast<Assign_next*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_field::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_assign_field(dynamic_cast<Assign_field*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Eval_expr::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_eval_expr(dynamic_cast<Eval_expr*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Pre_op::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
pre_pre_op(dynamic_cast<Pre_op*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case FOREIGN::ID:
out->push_back(pre_foreign(dynamic_cast<FOREIGN*>(in)));
return;
}
assert(0);
}
void Transform::pre_member(Member* in, Member_list* out)
{
switch(in->classid())
{
case Method::ID:
{
Method_list* local_out = new Method_list;
Method_list::const_iterator i;
pre_method(dynamic_cast<Method*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Attribute::ID:
{
Member_list* local_out = new Member_list;
Member_list::const_iterator i;
pre_attribute(dynamic_cast<Attribute*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
}
assert(0);
}
Static_value* Transform::pre_static_value(Static_value* in)
{
switch(in->classid())
{
case INT::ID: return pre_int(dynamic_cast<INT*>(in));
case REAL::ID: return pre_real(dynamic_cast<REAL*>(in));
case STRING::ID: return pre_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return pre_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return pre_nil(dynamic_cast<NIL*>(in));
case Static_array::ID: return pre_static_array(dynamic_cast<Static_array*>(in));
case Constant::ID: return pre_constant(dynamic_cast<Constant*>(in));
}
assert(0);
}
Expr* Transform::pre_expr(Expr* in)
{
switch(in->classid())
{
case Cast::ID: return pre_cast(dynamic_cast<Cast*>(in));
case Unary_op::ID: return pre_unary_op(dynamic_cast<Unary_op*>(in));
case Bin_op::ID: return pre_bin_op(dynamic_cast<Bin_op*>(in));
case Constant::ID: return pre_constant(dynamic_cast<Constant*>(in));
case Instanceof::ID: return pre_instanceof(dynamic_cast<Instanceof*>(in));
case Method_invocation::ID: return pre_method_invocation(dynamic_cast<Method_invocation*>(in));
case New::ID: return pre_new(dynamic_cast<New*>(in));
case INT::ID: return pre_int(dynamic_cast<INT*>(in));
case REAL::ID: return pre_real(dynamic_cast<REAL*>(in));
case STRING::ID: return pre_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return pre_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return pre_nil(dynamic_cast<NIL*>(in));
case VARIABLE_NAME::ID: return pre_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
case Variable_variable::ID: return pre_variable_variable(dynamic_cast<Variable_variable*>(in));
case Array_access::ID: return pre_array_access(dynamic_cast<Array_access*>(in));
case Field_access::ID: return pre_field_access(dynamic_cast<Field_access*>(in));
case Array_next::ID: return pre_array_next(dynamic_cast<Array_next*>(in));
case FOREIGN::ID: return pre_foreign(dynamic_cast<FOREIGN*>(in));
}
assert(0);
}
Rvalue* Transform::pre_rvalue(Rvalue* in)
{
switch(in->classid())
{
case INT::ID: return pre_int(dynamic_cast<INT*>(in));
case REAL::ID: return pre_real(dynamic_cast<REAL*>(in));
case STRING::ID: return pre_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return pre_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return pre_nil(dynamic_cast<NIL*>(in));
case VARIABLE_NAME::ID: return pre_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
}
assert(0);
}
Variable_name* Transform::pre_variable_name(Variable_name* in)
{
switch(in->classid())
{
case VARIABLE_NAME::ID: return pre_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
case Variable_variable::ID: return pre_variable_variable(dynamic_cast<Variable_variable*>(in));
}
assert(0);
}
Target* Transform::pre_target(Target* in)
{
switch(in->classid())
{
case VARIABLE_NAME::ID: return pre_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
case CLASS_NAME::ID: return pre_class_name(dynamic_cast<CLASS_NAME*>(in));
}
assert(0);
}
Field_name* Transform::pre_field_name(Field_name* in)
{
switch(in->classid())
{
case FIELD_NAME::ID: return pre_field_name(dynamic_cast<FIELD_NAME*>(in));
case Variable_field::ID: return pre_variable_field(dynamic_cast<Variable_field*>(in));
}
assert(0);
}
Class_name* Transform::pre_class_name(Class_name* in)
{
switch(in->classid())
{
case CLASS_NAME::ID: return pre_class_name(dynamic_cast<CLASS_NAME*>(in));
case Variable_class::ID: return pre_variable_class(dynamic_cast<Variable_class*>(in));
}
assert(0);
}
Method_name* Transform::pre_method_name(Method_name* in)
{
switch(in->classid())
{
case METHOD_NAME::ID: return pre_method_name(dynamic_cast<METHOD_NAME*>(in));
case Variable_method::ID: return pre_variable_method(dynamic_cast<Variable_method*>(in));
}
assert(0);
}
void Transform::pre_actual_parameter(Actual_parameter* in, Actual_parameter_list* out)
{
switch(in->classid())
{
case INT::ID:
out->push_back(pre_int(dynamic_cast<INT*>(in)));
return;
case REAL::ID:
out->push_back(pre_real(dynamic_cast<REAL*>(in)));
return;
case STRING::ID:
out->push_back(pre_string(dynamic_cast<STRING*>(in)));
return;
case BOOL::ID:
out->push_back(pre_bool(dynamic_cast<BOOL*>(in)));
return;
case NIL::ID:
out->push_back(pre_nil(dynamic_cast<NIL*>(in)));
return;
case Variable_actual_parameter::ID:
{
Actual_parameter_list* local_out = new Actual_parameter_list;
Actual_parameter_list::const_iterator i;
pre_variable_actual_parameter(dynamic_cast<Variable_actual_parameter*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
}
assert(0);
}
Static_array_key* Transform::pre_static_array_key(Static_array_key* in)
{
switch(in->classid())
{
case INT::ID: return pre_int(dynamic_cast<INT*>(in));
case REAL::ID: return pre_real(dynamic_cast<REAL*>(in));
case STRING::ID: return pre_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return pre_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return pre_nil(dynamic_cast<NIL*>(in));
case Constant::ID: return pre_constant(dynamic_cast<Constant*>(in));
}
assert(0);
}
/* Invoke the right post-transform (manual dispatching) */
/* Do not override unless you know what you are doing */
void Transform::post_statement(Statement* in, Statement_list* out)
{
switch(in->classid())
{
case Class_def::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_class_def(dynamic_cast<Class_def*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Interface_def::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_interface_def(dynamic_cast<Interface_def*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Method::ID:
{
Method_list* local_out = new Method_list;
Method_list::const_iterator i;
post_method(dynamic_cast<Method*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Return::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_return(dynamic_cast<Return*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Static_declaration::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_static_declaration(dynamic_cast<Static_declaration*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Global::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_global(dynamic_cast<Global*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Try::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_try(dynamic_cast<Try*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Throw::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_throw(dynamic_cast<Throw*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case If::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_if(dynamic_cast<If*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Loop::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_loop(dynamic_cast<Loop*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Foreach::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_foreach(dynamic_cast<Foreach*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Break::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_break(dynamic_cast<Break*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Continue::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_continue(dynamic_cast<Continue*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_var::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_assign_var(dynamic_cast<Assign_var*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_var_var::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_assign_var_var(dynamic_cast<Assign_var_var*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_array::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_assign_array(dynamic_cast<Assign_array*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_next::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_assign_next(dynamic_cast<Assign_next*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Assign_field::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_assign_field(dynamic_cast<Assign_field*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Eval_expr::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_eval_expr(dynamic_cast<Eval_expr*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Pre_op::ID:
{
Statement_list* local_out = new Statement_list;
Statement_list::const_iterator i;
post_pre_op(dynamic_cast<Pre_op*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case FOREIGN::ID:
out->push_back(post_foreign(dynamic_cast<FOREIGN*>(in)));
return;
}
assert(0);
}
void Transform::post_member(Member* in, Member_list* out)
{
switch(in->classid())
{
case Method::ID:
{
Method_list* local_out = new Method_list;
Method_list::const_iterator i;
post_method(dynamic_cast<Method*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Attribute::ID:
{
Member_list* local_out = new Member_list;
Member_list::const_iterator i;
post_attribute(dynamic_cast<Attribute*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
}
assert(0);
}
Static_value* Transform::post_static_value(Static_value* in)
{
switch(in->classid())
{
case INT::ID: return post_int(dynamic_cast<INT*>(in));
case REAL::ID: return post_real(dynamic_cast<REAL*>(in));
case STRING::ID: return post_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return post_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return post_nil(dynamic_cast<NIL*>(in));
case Static_array::ID: return post_static_array(dynamic_cast<Static_array*>(in));
case Constant::ID: return post_constant(dynamic_cast<Constant*>(in));
}
assert(0);
}
Expr* Transform::post_expr(Expr* in)
{
switch(in->classid())
{
case Cast::ID: return post_cast(dynamic_cast<Cast*>(in));
case Unary_op::ID: return post_unary_op(dynamic_cast<Unary_op*>(in));
case Bin_op::ID: return post_bin_op(dynamic_cast<Bin_op*>(in));
case Constant::ID: return post_constant(dynamic_cast<Constant*>(in));
case Instanceof::ID: return post_instanceof(dynamic_cast<Instanceof*>(in));
case Method_invocation::ID: return post_method_invocation(dynamic_cast<Method_invocation*>(in));
case New::ID: return post_new(dynamic_cast<New*>(in));
case INT::ID: return post_int(dynamic_cast<INT*>(in));
case REAL::ID: return post_real(dynamic_cast<REAL*>(in));
case STRING::ID: return post_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return post_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return post_nil(dynamic_cast<NIL*>(in));
case VARIABLE_NAME::ID: return post_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
case Variable_variable::ID: return post_variable_variable(dynamic_cast<Variable_variable*>(in));
case Array_access::ID: return post_array_access(dynamic_cast<Array_access*>(in));
case Field_access::ID: return post_field_access(dynamic_cast<Field_access*>(in));
case Array_next::ID: return post_array_next(dynamic_cast<Array_next*>(in));
case FOREIGN::ID: return post_foreign(dynamic_cast<FOREIGN*>(in));
}
assert(0);
}
Rvalue* Transform::post_rvalue(Rvalue* in)
{
switch(in->classid())
{
case INT::ID: return post_int(dynamic_cast<INT*>(in));
case REAL::ID: return post_real(dynamic_cast<REAL*>(in));
case STRING::ID: return post_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return post_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return post_nil(dynamic_cast<NIL*>(in));
case VARIABLE_NAME::ID: return post_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
}
assert(0);
}
Variable_name* Transform::post_variable_name(Variable_name* in)
{
switch(in->classid())
{
case VARIABLE_NAME::ID: return post_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
case Variable_variable::ID: return post_variable_variable(dynamic_cast<Variable_variable*>(in));
}
assert(0);
}
Target* Transform::post_target(Target* in)
{
switch(in->classid())
{
case VARIABLE_NAME::ID: return post_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
case CLASS_NAME::ID: return post_class_name(dynamic_cast<CLASS_NAME*>(in));
}
assert(0);
}
Field_name* Transform::post_field_name(Field_name* in)
{
switch(in->classid())
{
case FIELD_NAME::ID: return post_field_name(dynamic_cast<FIELD_NAME*>(in));
case Variable_field::ID: return post_variable_field(dynamic_cast<Variable_field*>(in));
}
assert(0);
}
Class_name* Transform::post_class_name(Class_name* in)
{
switch(in->classid())
{
case CLASS_NAME::ID: return post_class_name(dynamic_cast<CLASS_NAME*>(in));
case Variable_class::ID: return post_variable_class(dynamic_cast<Variable_class*>(in));
}
assert(0);
}
Method_name* Transform::post_method_name(Method_name* in)
{
switch(in->classid())
{
case METHOD_NAME::ID: return post_method_name(dynamic_cast<METHOD_NAME*>(in));
case Variable_method::ID: return post_variable_method(dynamic_cast<Variable_method*>(in));
}
assert(0);
}
void Transform::post_actual_parameter(Actual_parameter* in, Actual_parameter_list* out)
{
switch(in->classid())
{
case INT::ID:
out->push_back(post_int(dynamic_cast<INT*>(in)));
return;
case REAL::ID:
out->push_back(post_real(dynamic_cast<REAL*>(in)));
return;
case STRING::ID:
out->push_back(post_string(dynamic_cast<STRING*>(in)));
return;
case BOOL::ID:
out->push_back(post_bool(dynamic_cast<BOOL*>(in)));
return;
case NIL::ID:
out->push_back(post_nil(dynamic_cast<NIL*>(in)));
return;
case Variable_actual_parameter::ID:
{
Actual_parameter_list* local_out = new Actual_parameter_list;
Actual_parameter_list::const_iterator i;
post_variable_actual_parameter(dynamic_cast<Variable_actual_parameter*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
}
assert(0);
}
Static_array_key* Transform::post_static_array_key(Static_array_key* in)
{
switch(in->classid())
{
case INT::ID: return post_int(dynamic_cast<INT*>(in));
case REAL::ID: return post_real(dynamic_cast<REAL*>(in));
case STRING::ID: return post_string(dynamic_cast<STRING*>(in));
case BOOL::ID: return post_bool(dynamic_cast<BOOL*>(in));
case NIL::ID: return post_nil(dynamic_cast<NIL*>(in));
case Constant::ID: return post_constant(dynamic_cast<Constant*>(in));
}
assert(0);
}
/* Invoke the right transform-children (manual dispatching) */
/* Do not override unless you what you are doing */
void Transform::children_statement(Statement* in)
{
switch(in->classid())
{
case Class_def::ID:
children_class_def(dynamic_cast<Class_def*>(in));
break;
case Interface_def::ID:
children_interface_def(dynamic_cast<Interface_def*>(in));
break;
case Method::ID:
children_method(dynamic_cast<Method*>(in));
break;
case Return::ID:
children_return(dynamic_cast<Return*>(in));
break;
case Static_declaration::ID:
children_static_declaration(dynamic_cast<Static_declaration*>(in));
break;
case Global::ID:
children_global(dynamic_cast<Global*>(in));
break;
case Try::ID:
children_try(dynamic_cast<Try*>(in));
break;
case Throw::ID:
children_throw(dynamic_cast<Throw*>(in));
break;
case If::ID:
children_if(dynamic_cast<If*>(in));
break;
case Loop::ID:
children_loop(dynamic_cast<Loop*>(in));
break;
case Foreach::ID:
children_foreach(dynamic_cast<Foreach*>(in));
break;
case Break::ID:
children_break(dynamic_cast<Break*>(in));
break;
case Continue::ID:
children_continue(dynamic_cast<Continue*>(in));
break;
case Assign_var::ID:
children_assign_var(dynamic_cast<Assign_var*>(in));
break;
case Assign_var_var::ID:
children_assign_var_var(dynamic_cast<Assign_var_var*>(in));
break;
case Assign_array::ID:
children_assign_array(dynamic_cast<Assign_array*>(in));
break;
case Assign_next::ID:
children_assign_next(dynamic_cast<Assign_next*>(in));
break;
case Assign_field::ID:
children_assign_field(dynamic_cast<Assign_field*>(in));
break;
case Eval_expr::ID:
children_eval_expr(dynamic_cast<Eval_expr*>(in));
break;
case Pre_op::ID:
children_pre_op(dynamic_cast<Pre_op*>(in));
break;
case FOREIGN::ID:
children_foreign(dynamic_cast<FOREIGN*>(in));
break;
}
}
void Transform::children_member(Member* in)
{
switch(in->classid())
{
case Method::ID:
children_method(dynamic_cast<Method*>(in));
break;
case Attribute::ID:
children_attribute(dynamic_cast<Attribute*>(in));
break;
}
}
void Transform::children_static_value(Static_value* in)
{
switch(in->classid())
{
case INT::ID:
children_int(dynamic_cast<INT*>(in));
break;
case REAL::ID:
children_real(dynamic_cast<REAL*>(in));
break;
case STRING::ID:
children_string(dynamic_cast<STRING*>(in));
break;
case BOOL::ID:
children_bool(dynamic_cast<BOOL*>(in));
break;
case NIL::ID:
children_nil(dynamic_cast<NIL*>(in));
break;
case Static_array::ID:
children_static_array(dynamic_cast<Static_array*>(in));
break;
case Constant::ID:
children_constant(dynamic_cast<Constant*>(in));
break;
}
}
void Transform::children_expr(Expr* in)
{
switch(in->classid())
{
case Cast::ID:
children_cast(dynamic_cast<Cast*>(in));
break;
case Unary_op::ID:
children_unary_op(dynamic_cast<Unary_op*>(in));
break;
case Bin_op::ID:
children_bin_op(dynamic_cast<Bin_op*>(in));
break;
case Constant::ID:
children_constant(dynamic_cast<Constant*>(in));
break;
case Instanceof::ID:
children_instanceof(dynamic_cast<Instanceof*>(in));
break;
case Method_invocation::ID:
children_method_invocation(dynamic_cast<Method_invocation*>(in));
break;
case New::ID:
children_new(dynamic_cast<New*>(in));
break;
case INT::ID:
children_int(dynamic_cast<INT*>(in));
break;
case REAL::ID:
children_real(dynamic_cast<REAL*>(in));
break;
case STRING::ID:
children_string(dynamic_cast<STRING*>(in));
break;
case BOOL::ID:
children_bool(dynamic_cast<BOOL*>(in));
break;
case NIL::ID:
children_nil(dynamic_cast<NIL*>(in));
break;
case VARIABLE_NAME::ID:
children_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
break;
case Variable_variable::ID:
children_variable_variable(dynamic_cast<Variable_variable*>(in));
break;
case Array_access::ID:
children_array_access(dynamic_cast<Array_access*>(in));
break;
case Field_access::ID:
children_field_access(dynamic_cast<Field_access*>(in));
break;
case Array_next::ID:
children_array_next(dynamic_cast<Array_next*>(in));
break;
case FOREIGN::ID:
children_foreign(dynamic_cast<FOREIGN*>(in));
break;
}
}
void Transform::children_rvalue(Rvalue* in)
{
switch(in->classid())
{
case INT::ID:
children_int(dynamic_cast<INT*>(in));
break;
case REAL::ID:
children_real(dynamic_cast<REAL*>(in));
break;
case STRING::ID:
children_string(dynamic_cast<STRING*>(in));
break;
case BOOL::ID:
children_bool(dynamic_cast<BOOL*>(in));
break;
case NIL::ID:
children_nil(dynamic_cast<NIL*>(in));
break;
case VARIABLE_NAME::ID:
children_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
break;
}
}
void Transform::children_variable_name(Variable_name* in)
{
switch(in->classid())
{
case VARIABLE_NAME::ID:
children_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
break;
case Variable_variable::ID:
children_variable_variable(dynamic_cast<Variable_variable*>(in));
break;
}
}
void Transform::children_target(Target* in)
{
switch(in->classid())
{
case VARIABLE_NAME::ID:
children_variable_name(dynamic_cast<VARIABLE_NAME*>(in));
break;
case CLASS_NAME::ID:
children_class_name(dynamic_cast<CLASS_NAME*>(in));
break;
}
}
void Transform::children_field_name(Field_name* in)
{
switch(in->classid())
{
case FIELD_NAME::ID:
children_field_name(dynamic_cast<FIELD_NAME*>(in));
break;
case Variable_field::ID:
children_variable_field(dynamic_cast<Variable_field*>(in));
break;
}
}
void Transform::children_class_name(Class_name* in)
{
switch(in->classid())
{
case CLASS_NAME::ID:
children_class_name(dynamic_cast<CLASS_NAME*>(in));
break;
case Variable_class::ID:
children_variable_class(dynamic_cast<Variable_class*>(in));
break;
}
}
void Transform::children_method_name(Method_name* in)
{
switch(in->classid())
{
case METHOD_NAME::ID:
children_method_name(dynamic_cast<METHOD_NAME*>(in));
break;
case Variable_method::ID:
children_variable_method(dynamic_cast<Variable_method*>(in));
break;
}
}
void Transform::children_actual_parameter(Actual_parameter* in)
{
switch(in->classid())
{
case INT::ID:
children_int(dynamic_cast<INT*>(in));
break;
case REAL::ID:
children_real(dynamic_cast<REAL*>(in));
break;
case STRING::ID:
children_string(dynamic_cast<STRING*>(in));
break;
case BOOL::ID:
children_bool(dynamic_cast<BOOL*>(in));
break;
case NIL::ID:
children_nil(dynamic_cast<NIL*>(in));
break;
case Variable_actual_parameter::ID:
children_variable_actual_parameter(dynamic_cast<Variable_actual_parameter*>(in));
break;
}
}
void Transform::children_static_array_key(Static_array_key* in)
{
switch(in->classid())
{
case INT::ID:
children_int(dynamic_cast<INT*>(in));
break;
case REAL::ID:
children_real(dynamic_cast<REAL*>(in));
break;
case STRING::ID:
children_string(dynamic_cast<STRING*>(in));
break;
case BOOL::ID:
children_bool(dynamic_cast<BOOL*>(in));
break;
case NIL::ID:
children_nil(dynamic_cast<NIL*>(in));
break;
case Constant::ID:
children_constant(dynamic_cast<Constant*>(in));
break;
}
}
}
|