view release on metacpan or  search on metacpan

generator/parser/codegenerator.cpp  view on Meta::CPAN

void CodeGenerator::visitDeleteExpression(DeleteExpressionAST* node)
{
  print( node->scope_token );
  print( node->delete_token );
  print( node->lbracket_token );
  print( node->rbracket_token );

  m_output << " ";

  DefaultVisitor::visitDeleteExpression(node);
}

void CodeGenerator::visitDoStatement(DoStatementAST* node)
{
  printToken( Token_do, true );

  visit(node->statement);

  printToken( Token_while );
  m_output << "(";

  visit(node->expression);

  m_output << ");";
}

void CodeGenerator::visitElaboratedTypeSpecifier(ElaboratedTypeSpecifierAST* node)
{
  print(node->type, true);

  DefaultVisitor::visitElaboratedTypeSpecifier(node);
}

void CodeGenerator::visitEnumSpecifier(EnumSpecifierAST* node)
{
  printToken(Token_enum, true);

  visit(node->name);

  if (node->enumerators) {
    m_output << "{";
    visitCommaPrint(node->enumerators);
    m_output << "}";
  }
}

void CodeGenerator::visitEnumerator(EnumeratorAST* node)
{
  print(node->id);

  if (node->expression) {
    m_output << "=";

    visit(node->expression);
  }
}

void CodeGenerator::visitExceptionSpecification(ExceptionSpecificationAST* node)
{
  printToken(Token_throw);

  m_output << "(";

  print(node->ellipsis);

  DefaultVisitor::visitExceptionSpecification(node);

  m_output << ")";
}

void CodeGenerator::visitExpressionOrDeclarationStatement(ExpressionOrDeclarationStatementAST* node)
{
  DefaultVisitor::visitExpressionOrDeclarationStatement(node);
}

void CodeGenerator::visitExpressionStatement(ExpressionStatementAST* node)
{
  DefaultVisitor::visitExpressionStatement(node);
  m_output << ";";
}

void CodeGenerator::visitForStatement(ForStatementAST* node)
{
  printToken(Token_for);
  m_output << "(";
  if (node->init_statement) {
    visit(node->init_statement);
    // Init statement gives its own ;
  } else {
    m_output << ";";
  }

  visit(node->condition);
  m_output << ";";
  visit(node->expression);
  m_output << ")";
  visit(node->statement);
}

void CodeGenerator::visitFunctionCall(FunctionCallAST* node)
{
  m_output << "(";
  DefaultVisitor::visitFunctionCall(node);
  m_output << ")";
}

void CodeGenerator::visitFunctionDefinition(FunctionDefinitionAST* node)
{
  visit(node->type_specifier);
  visit(node->init_declarator);
  visit(node->constructor_initializers);
  visit(node->function_body);
  visit(node->win_decl_specifiers);
}

void CodeGenerator::visitIfStatement(IfStatementAST* node)
{
  printToken(Token_if);

  m_output << "(";

generator/parser/codegenerator.cpp  view on Meta::CPAN

    m_output << "(";
    visit(node->type_id);
    m_output << ")";
  }

  visit(node->expression);
}

void CodeGenerator::visitStringLiteral(StringLiteralAST* node)
{
  print(node->literals);
}

void CodeGenerator::visitSubscriptExpression(SubscriptExpressionAST* node)
{
  m_output << "[";
  DefaultVisitor::visitSubscriptExpression(node);
  m_output << "]";
}

void CodeGenerator::visitSwitchStatement(SwitchStatementAST* node)
{
  printToken(Token_switch);

  m_output << "(";
  visit(node->condition);
  m_output << ")";

  visit(node->statement);
}

void CodeGenerator::visitTemplateArgument(TemplateArgumentAST* node)
{
  DefaultVisitor::visitTemplateArgument(node);
}

void CodeGenerator::visitTemplateDeclaration(TemplateDeclarationAST* node)
{
  if (node->exported) {
    printToken(Token_export, true);
  }

  printToken(Token_template, true);

  if (node->template_parameters) {
    m_output << "< ";
    commaPrintNodes(this, node->template_parameters);
    m_output << " >";
  }

  visit(node->declaration);
}

void CodeGenerator::visitTemplateParameter(TemplateParameterAST* node)
{
  DefaultVisitor::visitTemplateParameter(node);
}

void CodeGenerator::visitThrowExpression(ThrowExpressionAST* node)
{
  printToken(Token_throw);

  DefaultVisitor::visitThrowExpression(node);
}

void CodeGenerator::visitTranslationUnit(TranslationUnitAST* node)
{
  DefaultVisitor::visitTranslationUnit(node);
}

void CodeGenerator::visitTryBlockStatement(TryBlockStatementAST* node)
{
  printToken(Token_try);
  visit(node->try_block);
  visitNodes(this, node->catch_blocks);
}

void CodeGenerator::visitCatchStatement(CatchStatementAST* node)
{
  printToken(Token_catch);

  m_output << "(";
  visit(node->condition);
  m_output << ")";

  visit(node->statement);
}

void CodeGenerator::visitTypeId(TypeIdAST* node)
{
  DefaultVisitor::visitTypeId(node);
}

void CodeGenerator::visitTypeIdentification(TypeIdentificationAST* node)
{
  print(node->typename_token);

  visit(node->name);

  if (node->expression) {
    m_output << "(";
    visit(node->expression);
    m_output << ")";
  }
}

void CodeGenerator::visitTypeParameter(TypeParameterAST* node)
{
  print(node->type, true);

  visit(node->name);

  if (node->type_id) {
    m_output << "=";
    visit(node->type_id);
  }

  if (node->template_parameters) {
    m_output << "<";
    commaPrintNodes(this, node->template_parameters);
    m_output << ">";