void visitDeclaration_specifier(Declaration_specifier _p_)
{
switch(_p_->kind)
{
case is_DecClass:
/* Code for DecClass Goes Here */
visitClassName(_p_->u.decclass_.classname_);
visitPointer(_p_->u.decclass_.pointer_);
visitIdent(_p_->u.decclass_.ident_);
break; case is_DecClassNoPoiter:
/* Code for DecClassNoPoiter Goes Here */
visitClassName(_p_->u.decclassnopoiter_.classname_);
visitIdent(_p_->u.decclassnopoiter_.ident_);
break; case is_Type:
/* Code for Type Goes Here */
visitType_specifier(_p_->u.type_.type_specifier_);
break; case is_Storage:
/* Code for Storage Goes Here */
visitStorage_class_specifier(_p_->u.storage_.storage_class_specifier_);
break; case is_SpecProp:
/* Code for SpecProp Goes Here */
visitType_qualifier(_p_->u.specprop_.type_qualifier_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing Declaration_specifier!\n");
exit(1);
}
}
void Skeleton::visitEType(EType *etype)
{
/* Code For EType Goes Here */
visitIdent(etype->ident_);
}
void visitDirect_declarator(Direct_declarator _p_)
{
switch(_p_->kind)
{
case is_Name:
/* Code for Name Goes Here */
visitIdent(_p_->u.name_.ident_);
break; case is_ParenDecl:
/* Code for ParenDecl Goes Here */
visitDeclarator(_p_->u.parendecl_.declarator_);
break; case is_InnitArray:
/* Code for InnitArray Goes Here */
visitDirect_declarator(_p_->u.innitarray_.direct_declarator_);
visitConstant_expression(_p_->u.innitarray_.constant_expression_);
break; case is_Incomplete:
/* Code for Incomplete Goes Here */
visitDirect_declarator(_p_->u.incomplete_.direct_declarator_);
break; case is_NewFuncDec:
/* Code for NewFuncDec Goes Here */
visitDirect_declarator(_p_->u.newfuncdec_.direct_declarator_);
visitParameter_type(_p_->u.newfuncdec_.parameter_type_);
break; case is_OldFuncDef:
/* Code for OldFuncDef Goes Here */
visitDirect_declarator(_p_->u.oldfuncdef_.direct_declarator_);
visitListIdent(_p_->u.oldfuncdef_.listident_);
break; case is_OldFuncDec:
/* Code for OldFuncDec Goes Here */
visitDirect_declarator(_p_->u.oldfuncdec_.direct_declarator_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing Direct_declarator!\n");
exit(1);
}
}
void visitExternal_declaration(External_declaration _p_)
{
switch(_p_->kind)
{
case is_Class:
/* Code for Class Goes Here */
visitClassName(_p_->u.class_.classname_);
visitExtends(_p_->u.class_.extends_);
visitListExternal_declaration(_p_->u.class_.listexternal_declaration_);
break; case is_Namespace:
/* Code for Namespace Goes Here */
visitIdent(_p_->u.namespace_.ident_);
visitListExternal_declaration(_p_->u.namespace_.listexternal_declaration_);
break; case is_Afunc:
/* Code for Afunc Goes Here */
visitFunction_def(_p_->u.afunc_.function_def_);
break; case is_Global:
/* Code for Global Goes Here */
visitDec(_p_->u.global_.dec_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing External_declaration!\n");
exit(1);
}
}
void Skeleton::visitEIdent(EIdent *eident)
{
/* Code For EIdent Goes Here */
visitIdent(eident->ident_);
}
void Skeleton::visitSimpleName(SimpleName *simple_name)
{
/* Code For SimpleName Goes Here */
visitIdent(simple_name->ident_);
}
void Skeleton::visitBareDecl(BareDecl *baredecl)
{
/* Code For BareDecl Goes Here */
baredecl->type_->accept(this);
visitIdent(baredecl->ident_);
}
void visitEnumerator(Enumerator _p_)
{
switch(_p_->kind)
{
case is_EnumInit:
/* Code for EnumInit Goes Here */
visitIdent(_p_->u.enuminit_.ident_);
visitConstant_expression(_p_->u.enuminit_.constant_expression_);
break; case is_Plain:
/* Code for Plain Goes Here */
visitIdent(_p_->u.plain_.ident_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing Enumerator!\n");
exit(1);
}
}
void Skeleton::visitEVector(EVector *evector)
{
/* Code For EVector Goes Here */
visitIdent(evector->ident_);
evector->listexp_->accept(this);
}
void Skeleton::visitSimpleDecl(SimpleDecl *simpledecl)
{
/* Code For SimpleDecl Goes Here */
visitIdent(simpledecl->ident_);
simpledecl->exp_->accept(this);
}
void ShowAbsyn::visitOLab(OLab* p)
{
bufAppend('(');
bufAppend("OLab");
bufAppend(' ');
visitIdent(p->ident_);
bufAppend(')');
}
void visitClassName(ClassName _p_)
{
switch(_p_->kind)
{
case is_ClassWithNamespace:
/* Code for ClassWithNamespace Goes Here */
visitIdent(_p_->u.classwithnamespace_.ident_1);
visitIdent(_p_->u.classwithnamespace_.ident_2);
break; case is_ClassWithoutNamespace:
/* Code for ClassWithoutNamespace Goes Here */
visitIdent(_p_->u.classwithoutnamespace_.ident_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing ClassName!\n");
exit(1);
}
}
void Skeleton::visitArgumentDef(ArgumentDef *argumentdef)
{
/* Code For ArgumentDef Goes Here */
argumentdef->type_->accept(this);
visitIdent(argumentdef->ident_);
}
void Skeleton::visitEFuncCall(EFuncCall *efunccall)
{
/* Code For EFuncCall Goes Here */
visitIdent(efunccall->ident_);
efunccall->listexp_->accept(this);
}
void ShowAbsyn::visitOHex(OHex* p)
{
bufAppend('(');
bufAppend("OHex");
bufAppend(' ');
visitIdent(p->hexconstant_);
bufAppend(')');
}
void visitListIdent(ListIdent listident)
{
while(listident != 0)
{
/* Code For ListIdent Goes Here */
visitIdent(listident->ident_);
listident = listident->listident_;
}
}
void Skeleton::visitTypedDecl(TypedDecl *typeddecl)
{
/* Code For TypedDecl Goes Here */
typeddecl->type_->accept(this);
visitIdent(typeddecl->ident_);
typeddecl->exp_->accept(this);
}
void Skeleton::visitSimpleDeclWith(SimpleDeclWith *simpledeclwith)
{
/* Code For SimpleDeclWith Goes Here */
visitIdent(simpledeclwith->ident_);
simpledeclwith->exp_1->accept(this);
simpledeclwith->exp_2->accept(this);
}
void Skeleton::visitSomeStatement(SomeStatement *somestatement)
{
/* Code For SomeStatement Goes Here */
visitIdent(somestatement->ident_);
somestatement->exp_->accept(this);
somestatement->statementblock_->accept(this);
}
void Skeleton::visitForStatement(ForStatement *forstatement)
{
/* Code For ForStatement Goes Here */
visitIdent(forstatement->ident_);
forstatement->exp_->accept(this);
forstatement->statementblock_->accept(this);
}
void Skeleton::visitEFuncDecl(EFuncDecl *efuncdecl)
{
/* Code For EFuncDecl Goes Here */
visitIdent(efuncdecl->ident_);
efuncdecl->listargument_->accept(this);
efuncdecl->statementblock_->accept(this);
}
void ShowAbsyn::visitOLitAdd(OLitAdd* p)
{
bufAppend('(');
bufAppend("OLitAdd");
bufAppend(' ');
visitIdent(p->hexconstant_);
bufAppend(' ');
bufAppend(')');
}
void Skeleton::visitTypedDeclWith(TypedDeclWith *typeddeclwith)
{
/* Code For TypedDeclWith Goes Here */
typeddeclwith->type_->accept(this);
visitIdent(typeddeclwith->ident_);
typeddeclwith->exp_1->accept(this);
typeddeclwith->exp_2->accept(this);
}
void Skeleton::visitEFuncDeclWithType(EFuncDeclWithType *efuncdeclwithtype)
{
/* Code For EFuncDeclWithType Goes Here */
efuncdeclwithtype->type_->accept(this);
visitIdent(efuncdeclwithtype->ident_);
efuncdeclwithtype->listargument_->accept(this);
efuncdeclwithtype->statementblock_->accept(this);
}
void visitEnum_specifier(Enum_specifier _p_)
{
switch(_p_->kind)
{
case is_EnumDec:
/* Code for EnumDec Goes Here */
visitListEnumerator(_p_->u.enumdec_.listenumerator_);
break; case is_EnumName:
/* Code for EnumName Goes Here */
visitIdent(_p_->u.enumname_.ident_);
visitListEnumerator(_p_->u.enumname_.listenumerator_);
break; case is_EnumVar:
/* Code for EnumVar Goes Here */
visitIdent(_p_->u.enumvar_.ident_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing Enum_specifier!\n");
exit(1);
}
}
void PrintAbsyn::visitOLab(OLab* p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitIdent(p->ident_);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
}
void PrintAbsyn::visitOHex(OHex* p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
visitIdent(p->hexconstant_);
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
}
void PrintAbsyn::visitOLitAdd(OLitAdd* p)
{
int oldi = _i_;
if (oldi > 0) render(_L_PAREN);
render('[');
visitIdent(p->hexconstant_);
render(']');
if (oldi > 0) render(_R_PAREN);
_i_ = oldi;
}
void visitStruct_or_union_spec(Struct_or_union_spec _p_)
{
switch(_p_->kind)
{
case is_Tag:
/* Code for Tag Goes Here */
visitStruct_or_union(_p_->u.tag_.struct_or_union_);
visitIdent(_p_->u.tag_.ident_);
visitListStruct_dec(_p_->u.tag_.liststruct_dec_);
break; case is_Unique:
/* Code for Unique Goes Here */
visitStruct_or_union(_p_->u.unique_.struct_or_union_);
visitListStruct_dec(_p_->u.unique_.liststruct_dec_);
break; case is_TagType:
/* Code for TagType Goes Here */
visitStruct_or_union(_p_->u.tagtype_.struct_or_union_);
visitIdent(_p_->u.tagtype_.ident_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing Struct_or_union_spec!\n");
exit(1);
}
}
void visitLabeled_stm(Labeled_stm _p_)
{
switch(_p_->kind)
{
case is_SlabelOne:
/* Code for SlabelOne Goes Here */
visitIdent(_p_->u.slabelone_.ident_);
visitStm(_p_->u.slabelone_.stm_);
break; case is_SlabelTwo:
/* Code for SlabelTwo Goes Here */
visitConstant_expression(_p_->u.slabeltwo_.constant_expression_);
visitStm(_p_->u.slabeltwo_.stm_);
break; case is_SlabelThree:
/* Code for SlabelThree Goes Here */
visitStm(_p_->u.slabelthree_.stm_);
break;
default:
fprintf(stderr, "Error: bad kind field when printing Labeled_stm!\n");
exit(1);
}
}
