| /******************************************************************************* |
| * Copyright (c) 2016 Obeo. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| * |
| *******************************************************************************/ |
| package org.eclipse.acceleo.tests.utils; |
| |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.acceleo.ASTNode; |
| import org.eclipse.acceleo.AcceleoPackage; |
| import org.eclipse.acceleo.Block; |
| import org.eclipse.acceleo.Comment; |
| import org.eclipse.acceleo.CommentBody; |
| import org.eclipse.acceleo.ErrorBinding; |
| import org.eclipse.acceleo.ErrorComment; |
| import org.eclipse.acceleo.ErrorExpressionStatement; |
| import org.eclipse.acceleo.ErrorFileStatement; |
| import org.eclipse.acceleo.ErrorForStatement; |
| import org.eclipse.acceleo.ErrorIfStatement; |
| import org.eclipse.acceleo.ErrorImport; |
| import org.eclipse.acceleo.ErrorLetStatement; |
| import org.eclipse.acceleo.ErrorMetamodel; |
| import org.eclipse.acceleo.ErrorModule; |
| import org.eclipse.acceleo.ErrorProtectedArea; |
| import org.eclipse.acceleo.ErrorQuery; |
| import org.eclipse.acceleo.ErrorTemplate; |
| import org.eclipse.acceleo.ErrorVariable; |
| import org.eclipse.acceleo.ExpressionStatement; |
| import org.eclipse.acceleo.FileStatement; |
| import org.eclipse.acceleo.ForStatement; |
| import org.eclipse.acceleo.IfStatement; |
| import org.eclipse.acceleo.Import; |
| import org.eclipse.acceleo.Metamodel; |
| import org.eclipse.acceleo.Module; |
| import org.eclipse.acceleo.ModuleDocumentation; |
| import org.eclipse.acceleo.ModuleElement; |
| import org.eclipse.acceleo.ModuleElementDocumentation; |
| import org.eclipse.acceleo.ModuleReference; |
| import org.eclipse.acceleo.ParameterDocumentation; |
| import org.eclipse.acceleo.ProtectedArea; |
| import org.eclipse.acceleo.Query; |
| import org.eclipse.acceleo.Statement; |
| import org.eclipse.acceleo.Template; |
| import org.eclipse.acceleo.TextStatement; |
| import org.eclipse.acceleo.Variable; |
| import org.eclipse.acceleo.aql.parser.AcceleoAstResult; |
| import org.eclipse.acceleo.query.ast.Binding; |
| import org.eclipse.acceleo.query.ast.BooleanLiteral; |
| import org.eclipse.acceleo.query.ast.Call; |
| import org.eclipse.acceleo.query.ast.CallType; |
| import org.eclipse.acceleo.query.ast.CollectionTypeLiteral; |
| import org.eclipse.acceleo.query.ast.Conditional; |
| import org.eclipse.acceleo.query.ast.EnumLiteral; |
| import org.eclipse.acceleo.query.ast.Error; |
| import org.eclipse.acceleo.query.ast.Expression; |
| import org.eclipse.acceleo.query.ast.IntegerLiteral; |
| import org.eclipse.acceleo.query.ast.Lambda; |
| import org.eclipse.acceleo.query.ast.Let; |
| import org.eclipse.acceleo.query.ast.NullLiteral; |
| import org.eclipse.acceleo.query.ast.RealLiteral; |
| import org.eclipse.acceleo.query.ast.SequenceInExtensionLiteral; |
| import org.eclipse.acceleo.query.ast.SetInExtensionLiteral; |
| import org.eclipse.acceleo.query.ast.StringLiteral; |
| import org.eclipse.acceleo.query.ast.TypeLiteral; |
| import org.eclipse.acceleo.query.ast.TypeSetLiteral; |
| import org.eclipse.acceleo.query.ast.VarRef; |
| import org.eclipse.acceleo.query.ast.VariableDeclaration; |
| import org.eclipse.acceleo.query.ast.util.AstSwitch; |
| import org.eclipse.acceleo.util.AcceleoSwitch; |
| import org.eclipse.emf.ecore.EClassifier; |
| |
| /** |
| * Serialize a {@link Template}. |
| * |
| * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a> |
| */ |
| public class ModuleAstSerializer extends AcceleoSwitch<Void> { |
| /** Prefix we'll use for the error messages on missing names. */ |
| private static final String MISSING_NAME_MESSAGE_PREFIX = "missing name: "; |
| |
| /** Prefix we'll use for the error messages on a missing open parenthesis. */ |
| private static final String MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX = "missing open parenthesis: "; |
| |
| /** Prefix we'll use for the error messages on a missing closing parenthesis. */ |
| private static final String MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX = "missing close parenthesis: "; |
| |
| /** Prefix we'll use for the error messages on a missing separator closing parenthesis. */ |
| private static final String MISSING_SEPARATOR_CLOSE_PARENTHESIS_MESSAGE_PREFIX = "missing separator close parenthesis: "; |
| |
| /** Prefix we'll use for the error messages on a missing header ending. */ |
| private static final String MISSING_END_HEADER_MESSAGE_PREFIX = "missing end header: "; |
| |
| /** Prefix we'll use for the error messages on a missing block ending. */ |
| private static final String MISSING_END_MESSAGE_PREFIX = "missing end: "; |
| |
| /** Prefix we'll use for the error messages on a missing colon. */ |
| private static final String MISSING_COLON_MESSAGE_PREFIX = "missing colon: "; |
| |
| /** Prefix we'll use for the error messages on a missing type. */ |
| private static final String MISSING_TYPE_MESSAGE_PREFIX = "missing type: "; |
| |
| /** The string we'll use as a placeholder for null objects. */ |
| private static final String NULL_STRING = "null"; |
| |
| /** |
| * Serialize a {@link Expression}. |
| * |
| * @author <a href="mailto:yvan.lussaud@obeo.fr">Yvan Lussaud</a> |
| */ |
| private final class QueryAstSerializer extends AstSwitch<Void> { |
| |
| /** |
| * The {@link StringBuilder} used to serialize. |
| */ |
| private StringBuilder builder; |
| |
| /** |
| * Serializes the given {@link Expression}. |
| * |
| * @param expression |
| * the {@link Expression} |
| * @return the serialized {@link Expression} |
| */ |
| public String serialize(Expression expression) { |
| builder = new StringBuilder(); |
| |
| doSwitch(expression); |
| |
| return builder.toString(); |
| } |
| |
| @Override |
| public Void caseBinding(Binding binding) { |
| builder.append(binding.getName()); |
| if (binding.getType() != null) { |
| builder.append(' ').append(':').append(' '); |
| builder.append(doSwitch(binding.getType())); |
| } |
| builder.append(' ').append('=').append(' '); |
| builder.append(doSwitch(binding.getValue())); |
| return null; |
| } |
| |
| @Override |
| public Void caseBooleanLiteral(BooleanLiteral booleanLiteral) { |
| builder.append(booleanLiteral.isValue()); |
| return null; |
| } |
| |
| @Override |
| public Void caseCall(Call call) { |
| if (call.getType() == CallType.COLLECTIONCALL) { |
| builder.append("->"); |
| } else { |
| builder.append('.'); |
| } |
| builder.append(call.getServiceName()); |
| builder.append('('); |
| final StringBuilder previousBuilder = builder; |
| builder = new StringBuilder(); |
| for (Expression argument : call.getArguments()) { |
| doSwitch(argument); |
| builder.append(',').append(' '); |
| } |
| if (builder.length() > 0) { |
| previousBuilder.append(builder.substring(0, builder.length() - 2)); |
| } |
| builder = previousBuilder; |
| builder.append(')'); |
| return null; |
| } |
| |
| @Override |
| public Void caseCollectionTypeLiteral(CollectionTypeLiteral collectionTypeLiteral) { |
| if (collectionTypeLiteral.getValue() == List.class) { |
| builder.append("Sequence("); |
| } else if (collectionTypeLiteral.getValue() == Set.class) { |
| builder.append("OrderedSet("); |
| } else { |
| builder.append("***invalid type of collection ***("); |
| } |
| doSwitch(collectionTypeLiteral.getElementType()); |
| builder.append(")"); |
| return null; |
| } |
| |
| @Override |
| public Void caseConditional(Conditional conditional) { |
| builder.append("if ("); |
| doSwitch(conditional.getPredicate()); |
| builder.append(") then "); |
| doSwitch(conditional.getTrueBranch()); |
| builder.append(" else "); |
| doSwitch(conditional.getFalseBranch()); |
| builder.append(" endif "); |
| return null; |
| } |
| |
| @Override |
| public Void caseEnumLiteral(EnumLiteral enumLiteral) { |
| builder.append(enumLiteral.getLiteral().getEEnum().getEPackage().getName()); |
| builder.append("::"); |
| builder.append(enumLiteral.getLiteral().getEEnum().getName()); |
| builder.append("::"); |
| builder.append(enumLiteral.getLiteral().getName()); |
| return null; |
| } |
| |
| @Override |
| public Void caseError(Error error) { |
| builder.append("***ERROR***"); |
| return null; |
| } |
| |
| @Override |
| public Void caseIntegerLiteral(IntegerLiteral object) { |
| builder.append(object.getValue()); |
| return null; |
| } |
| |
| @Override |
| public Void caseLambda(Lambda lambda) { |
| doSwitch(lambda.getParameters().get(0)); |
| builder.append(" | "); |
| doSwitch(lambda.getExpression()); |
| return null; |
| } |
| |
| @Override |
| public Void caseLet(Let let) { |
| builder.append("let "); |
| final StringBuilder previousBuilder = builder; |
| builder = new StringBuilder(); |
| for (Binding binding : let.getBindings()) { |
| doSwitch(binding); |
| builder.append(',').append(' '); |
| } |
| previousBuilder.append(builder.substring(0, builder.length() - 2)); |
| builder.append(" in "); |
| doSwitch(let.getBody()); |
| return super.caseLet(let); |
| } |
| |
| @Override |
| public Void caseNullLiteral(NullLiteral nullLiteral) { |
| builder.append(NULL_STRING); |
| return null; |
| } |
| |
| @Override |
| public Void caseSequenceInExtensionLiteral(SequenceInExtensionLiteral sequenceInExtensionLiteral) { |
| builder.append("Sequence{"); |
| if (!sequenceInExtensionLiteral.getValues().isEmpty()) { |
| for (Expression value : sequenceInExtensionLiteral.getValues()) { |
| doSwitch(value); |
| builder.append(',').append(' '); |
| } |
| } |
| builder.append('}'); |
| return null; |
| } |
| |
| @Override |
| public Void caseRealLiteral(RealLiteral realLiteral) { |
| builder.append(realLiteral.getValue()); |
| return null; |
| } |
| |
| @Override |
| public Void caseSetInExtensionLiteral(SetInExtensionLiteral setInExtensionLiteral) { |
| builder.append("OrderedSet{"); |
| if (!setInExtensionLiteral.getValues().isEmpty()) { |
| final StringBuilder previousBuilder = builder; |
| builder = new StringBuilder(); |
| for (Expression value : setInExtensionLiteral.getValues()) { |
| doSwitch(value); |
| builder.append(',').append(' '); |
| } |
| previousBuilder.append(builder.substring(0, builder.length() - 2)); |
| } |
| builder.append('}'); |
| return null; |
| } |
| |
| @Override |
| public Void caseStringLiteral(StringLiteral stringLiteral) { |
| builder.append('\''); |
| builder.append(stringLiteral.getValue()); |
| builder.append('\''); |
| return null; |
| } |
| |
| @Override |
| public Void caseTypeSetLiteral(TypeSetLiteral typeSetLiteral) { |
| builder.append('{'); |
| if (!typeSetLiteral.getTypes().isEmpty()) { |
| final StringBuilder previousBuilder = builder; |
| builder = new StringBuilder(); |
| for (TypeLiteral type : typeSetLiteral.getTypes()) { |
| doSwitch(type); |
| builder.append(" | "); |
| } |
| previousBuilder.append(builder.substring(0, builder.length() - 3)); |
| } |
| builder.append('}'); |
| return null; |
| } |
| |
| @Override |
| public Void caseTypeLiteral(TypeLiteral object) { |
| if (object.getValue() instanceof Class) { |
| builder.append(((Class<?>)object.getValue()).getName()); |
| } else if (object.getValue() instanceof EClassifier) { |
| builder.append(((EClassifier)object.getValue()).getName()); |
| } |
| return null; |
| } |
| |
| @Override |
| public Void caseVariableDeclaration(VariableDeclaration variableDeclaration) { |
| builder.append(variableDeclaration.getName()); |
| if (variableDeclaration.getType() != null) { |
| builder.append(' ').append(':').append(' '); |
| doSwitch(variableDeclaration.getType()); |
| } |
| builder.append(' ').append('=').append(' '); |
| doSwitch(variableDeclaration.getExpression()); |
| return null; |
| } |
| |
| @Override |
| public Void caseVarRef(VarRef varRef) { |
| builder.append(varRef.getVariableName()); |
| return null; |
| } |
| |
| } |
| |
| /** |
| * The {@link StringBuilder} used to serialize. |
| */ |
| private StringBuilder builder; |
| |
| /** |
| * The {@link QueryAstSerializer}. |
| */ |
| private QueryAstSerializer querySerializer = new QueryAstSerializer(); |
| |
| /** |
| * Current indentation. |
| */ |
| private String indentation; |
| |
| /** |
| * The {@link AcceleoAstResult}. |
| */ |
| private AcceleoAstResult ast; |
| |
| /** |
| * Increases indentation. |
| */ |
| protected void indent() { |
| indentation = indentation + " "; |
| } |
| |
| /** |
| * Decreases indentation. |
| */ |
| protected void deindent() { |
| indentation = indentation.substring(0, indentation.length() - 2); |
| } |
| |
| /** |
| * Serializes the given {@link AcceleoAstResult}. |
| * |
| * @param astResult |
| * the {@link AcceleoAstResult} |
| * @return the serialized {@link AcceleoAstResult} |
| */ |
| public String serialize(AcceleoAstResult astResult) { |
| this.ast = astResult; |
| builder = new StringBuilder(); |
| indentation = ""; |
| |
| doSwitch(astResult.getModule()); |
| |
| return builder.toString(); |
| } |
| |
| /** |
| * Creates a new line with the right indentation. |
| */ |
| protected void newLine() { |
| builder.append(AbstractLanguageTestSuite.DEFAULT_END_OF_LINE_CHARACTER + indentation); |
| } |
| |
| @Override |
| public Void caseModule(Module module) { |
| if (module.getDocumentation() != null) { |
| doSwitch(module.getDocumentation()); |
| } |
| newLine(); |
| builder.append("header position " + module.getStartHeaderPosition()); |
| builder.append(".."); |
| builder.append(module.getEndHeaderPosition()); |
| newLine(); |
| builder.append("module " + module.getName()); |
| indent(); |
| for (Metamodel metamodel : module.getMetamodels()) { |
| newLine(); |
| doSwitch(metamodel); |
| } |
| if (module.getExtends() != null) { |
| newLine(); |
| builder.append("extends "); |
| doSwitch(module.getExtends()); |
| } |
| for (Import imported : module.getImports()) { |
| newLine(); |
| doSwitch(imported); |
| } |
| for (ModuleElement element : module.getModuleElements()) { |
| newLine(); |
| doSwitch(element); |
| } |
| deindent(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorModule(ErrorModule errorModule) { |
| builder.append("*** error module ***"); |
| newLine(); |
| builder.append(MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX + errorModule.getMissingOpenParenthesis()); |
| newLine(); |
| builder.append("missing EPackage: " + errorModule.getMissingEPackage()); |
| newLine(); |
| builder.append(MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorModule.getMissingCloseParenthesis()); |
| newLine(); |
| builder.append(MISSING_END_HEADER_MESSAGE_PREFIX + errorModule.getMissingEndHeader()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseImport(Import imp) { |
| builder.append("imports "); |
| doSwitch(imp.getModule()); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorImport(ErrorImport errorImport) { |
| builder.append("*** error import ***"); |
| newLine(); |
| builder.append(MISSING_END_MESSAGE_PREFIX + errorImport.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseModuleReference(ModuleReference moduleReference) { |
| builder.append(moduleReference.getQualifiedName()); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseMetamodel(Metamodel metamodel) { |
| if (metamodel.getReferencedPackage() != null) { |
| builder.append("metamodel " + metamodel.getReferencedPackage().getNsURI()); |
| } else { |
| builder.append("metamodel null"); |
| } |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorMetamodel(ErrorMetamodel errorMetamodel) { |
| builder.append("*** error metamodel ***"); |
| newLine(); |
| builder.append("missing end quote: " + errorMetamodel.getMissingEndQuote()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseTemplate(Template template) { |
| if (template.getDocumentation() != null) { |
| doSwitch(template.getDocumentation()); |
| } |
| newLine(); |
| builder.append(template.getVisibility().getName()); |
| builder.append(" template " + template.getName() + '('); |
| final StringBuilder previousBuilder = builder; |
| builder = new StringBuilder(); |
| for (Variable variable : template.getParameters()) { |
| doSwitch(variable); |
| builder.append(", "); |
| } |
| if (builder.length() >= 2) { |
| previousBuilder.append(builder.substring(0, builder.length() - 2)); |
| } |
| builder = previousBuilder; |
| builder.append(')'); |
| if (template.isMain()) { |
| newLine(); |
| builder.append("@main"); |
| } |
| if (template.getGuard() != null) { |
| newLine(); |
| builder.append("guard "); |
| doSwitch(template.getGuard()); |
| } |
| if (template.getPost() != null) { |
| newLine(); |
| builder.append("post "); |
| doSwitch(template.getPost()); |
| } |
| doSwitch(template.getBody()); |
| newLine(); |
| builder.append("[/template]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorTemplate(ErrorTemplate errorTemplate) { |
| builder.append("*** error template ***"); |
| newLine(); |
| builder.append("missing visibility: " + errorTemplate.getMissingVisibility()); |
| newLine(); |
| builder.append(MISSING_NAME_MESSAGE_PREFIX + errorTemplate.getMissingName()); |
| newLine(); |
| builder.append(MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX + errorTemplate.getMissingOpenParenthesis()); |
| newLine(); |
| builder.append("missing parameters: " + errorTemplate.getMissingParameters()); |
| newLine(); |
| builder.append(MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorTemplate.getMissingCloseParenthesis()); |
| newLine(); |
| builder.append("missing guard open parenthesis: " + errorTemplate.getMissingGuardOpenParenthesis()); |
| newLine(); |
| builder.append("missing guard close parenthesis: " + errorTemplate.getMissingGuardCloseParenthesis()); |
| newLine(); |
| builder.append("missing post close parenthesis: " + errorTemplate.getMissingPostCloseParenthesis()); |
| newLine(); |
| builder.append("missing post end header: " + errorTemplate.getMissingEndHeader()); |
| newLine(); |
| builder.append("missing post end: " + errorTemplate.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseBlock(Block block) { |
| indent(); |
| for (Statement statement : block.getStatements()) { |
| newLine(); |
| doSwitch(statement); |
| } |
| deindent(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseBinding(org.eclipse.acceleo.Binding binding) { |
| builder.append(binding.getName()); |
| builder.append(" : "); |
| if (binding.getType() != null) { |
| builder.append(querySerializer.serialize(binding.getType().getAst())); |
| } else { |
| builder.append(NULL_STRING); |
| } |
| builder.append(" = "); |
| doSwitch(binding.getInitExpression()); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorBinding(ErrorBinding errorBinding) { |
| builder.append("*** error binding ***"); |
| newLine(); |
| builder.append(MISSING_NAME_MESSAGE_PREFIX + errorBinding.getMissingName()); |
| newLine(); |
| builder.append(MISSING_COLON_MESSAGE_PREFIX + errorBinding.getMissingColon()); |
| newLine(); |
| builder.append(MISSING_TYPE_MESSAGE_PREFIX + errorBinding.getMissingType()); |
| newLine(); |
| builder.append("missing affectation symbol: " + errorBinding.getMissingAffectationSymbole()); |
| newLine(); |
| builder.append("missing affectation symbol position: " + errorBinding |
| .getMissingAffectationSymbolePosition()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseComment(Comment comment) { |
| builder.append("[comment "); |
| doSwitch(comment.getBody()); |
| builder.append(" /]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorComment(ErrorComment errorComment) { |
| builder.append("*** error comment ***"); |
| newLine(); |
| builder.append("missing end header: " + errorComment.getMissingEndHeader()); |
| newLine(); |
| return null; |
| } |
| |
| @Override |
| public Void caseCommentBody(CommentBody commentBody) { |
| builder.append(commentBody.getValue()); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseExpression(org.eclipse.acceleo.Expression expression) { |
| builder.append(querySerializer.serialize(expression.getAst().getAst())); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseFileStatement(FileStatement file) { |
| builder.append("[file url "); |
| doSwitch(file.getUrl()); |
| builder.append(" mode "); |
| builder.append(file.getMode().getName()); |
| if (file.getCharset() != null) { |
| builder.append(" charset "); |
| doSwitch(file.getCharset()); |
| } |
| doSwitch(file.getBody()); |
| newLine(); |
| builder.append("[/file]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorFileStatement(ErrorFileStatement errorFileStatement) { |
| builder.append("*** error file statement ***"); |
| newLine(); |
| builder.append("missing open mode: " + errorFileStatement.getMissingOpenMode()); |
| newLine(); |
| builder.append(MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX + errorFileStatement |
| .getMissingOpenParenthesis()); |
| newLine(); |
| builder.append("missing comma: " + errorFileStatement.getMissingComma()); |
| newLine(); |
| builder.append(MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorFileStatement |
| .getMissingCloseParenthesis()); |
| newLine(); |
| builder.append(MISSING_END_HEADER_MESSAGE_PREFIX + errorFileStatement.getMissingEndHeader()); |
| newLine(); |
| builder.append(MISSING_END_MESSAGE_PREFIX + errorFileStatement.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseForStatement(ForStatement forStatement) { |
| builder.append("[for "); |
| if (forStatement.getBinding() != null) { |
| doSwitch(forStatement.getBinding()); |
| } else { |
| builder.append("null binding"); |
| } |
| if (forStatement.getSeparator() != null) { |
| builder.append(" separator "); |
| doSwitch(forStatement.getSeparator()); |
| } |
| doSwitch(forStatement.getBody()); |
| newLine(); |
| builder.append("[/for]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorForStatement(ErrorForStatement errorForStatement) { |
| builder.append("*** error for statement ***"); |
| newLine(); |
| builder.append(MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX + errorForStatement |
| .getMissingOpenParenthesis()); |
| newLine(); |
| builder.append("missing binding: " + errorForStatement.getMissingBinding()); |
| newLine(); |
| builder.append(MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorForStatement |
| .getMissingCloseParenthesis()); |
| newLine(); |
| builder.append(MISSING_SEPARATOR_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorForStatement |
| .getMissingSeparatorCloseParenthesis()); |
| newLine(); |
| builder.append(MISSING_END_HEADER_MESSAGE_PREFIX + errorForStatement.getMissingEndHeader()); |
| newLine(); |
| builder.append(MISSING_END_MESSAGE_PREFIX + errorForStatement.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseIfStatement(IfStatement ifStatement) { |
| builder.append("[if "); |
| doSwitch(ifStatement.getCondition()); |
| doSwitch(ifStatement.getThen()); |
| if (ifStatement.getElse() != null) { |
| newLine(); |
| builder.append("[else]"); |
| doSwitch(ifStatement.getElse()); |
| } |
| newLine(); |
| builder.append("[/if]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorIfStatement(ErrorIfStatement errorIfStatement) { |
| builder.append("*** error if statement ***"); |
| newLine(); |
| builder.append(MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX + errorIfStatement |
| .getMissingOpenParenthesis()); |
| newLine(); |
| builder.append(MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorIfStatement |
| .getMissingCloseParenthesis()); |
| newLine(); |
| builder.append(MISSING_END_HEADER_MESSAGE_PREFIX + errorIfStatement.getMissingEndHeader()); |
| newLine(); |
| builder.append(MISSING_END_MESSAGE_PREFIX + errorIfStatement.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseLetStatement(org.eclipse.acceleo.LetStatement let) { |
| builder.append("[let "); |
| for (Variable variable : let.getVariables()) { |
| newLine(); |
| doSwitch(variable); |
| } |
| |
| doSwitch(let.getBody()); |
| newLine(); |
| builder.append("[/let]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorLetStatement(ErrorLetStatement errorLetStatement) { |
| builder.append("*** error let statement ***"); |
| newLine(); |
| builder.append("missing bindings: " + errorLetStatement.getMissingBindings()); |
| newLine(); |
| builder.append(MISSING_END_HEADER_MESSAGE_PREFIX + errorLetStatement.getMissingEndHeader()); |
| newLine(); |
| builder.append(MISSING_END_MESSAGE_PREFIX + errorLetStatement.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseQuery(Query query) { |
| if (query.getDocumentation() != null) { |
| doSwitch(query.getDocumentation()); |
| } |
| builder.append(query.getVisibility().getName()); |
| builder.append(" query " + query.getName() + '('); |
| final StringBuilder previousBuilder = builder; |
| if (!query.getParameters().isEmpty()) { |
| builder = new StringBuilder(); |
| for (Variable variable : query.getParameters()) { |
| doSwitch(variable); |
| builder.append(", "); |
| } |
| previousBuilder.append(builder.substring(0, builder.length() - 2)); |
| builder = previousBuilder; |
| } |
| builder.append(") "); |
| builder.append(") : "); |
| if (query.getType() != null) { |
| builder.append(querySerializer.serialize(query.getType().getAst())); |
| } else { |
| builder.append(NULL_STRING); |
| } |
| builder.append(' '); |
| doSwitch(query.getBody()); |
| newLine(); |
| builder.append("/]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorQuery(ErrorQuery errorQuery) { |
| builder.append("*** error query ***"); |
| newLine(); |
| builder.append("missing visibility: " + errorQuery.getMissingVisibility()); |
| newLine(); |
| builder.append(MISSING_NAME_MESSAGE_PREFIX + errorQuery.getMissingName()); |
| newLine(); |
| builder.append(MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX + errorQuery.getMissingOpenParenthesis()); |
| newLine(); |
| builder.append("missing parameters: " + errorQuery.getMissingParameters()); |
| newLine(); |
| builder.append(MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorQuery.getMissingCloseParenthesis()); |
| newLine(); |
| builder.append(MISSING_COLON_MESSAGE_PREFIX + errorQuery.getMissingColon()); |
| newLine(); |
| builder.append(MISSING_TYPE_MESSAGE_PREFIX + errorQuery.getMissingType()); |
| newLine(); |
| builder.append("missing equal: " + errorQuery.getMissingEqual()); |
| newLine(); |
| builder.append(MISSING_END_MESSAGE_PREFIX + errorQuery.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseTextStatement(TextStatement text) { |
| builder.append(text.getValue().replaceAll("\r\n", |
| AbstractLanguageTestSuite.DEFAULT_END_OF_LINE_CHARACTER + indentation).replaceAll("\r", |
| AbstractLanguageTestSuite.DEFAULT_END_OF_LINE_CHARACTER + indentation)); |
| builder.append(" " + text.isNewLineNeeded()); |
| return null; |
| } |
| |
| @Override |
| public Void caseExpressionStatement(ExpressionStatement expressionStatement) { |
| builder.append('['); |
| doSwitch(expressionStatement.getExpression()); |
| builder.append("/]"); |
| builder.append(" " + expressionStatement.isNewLineNeeded()); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorExpressionStatement(ErrorExpressionStatement errorExpressionStatement) { |
| builder.append("*** error expression statement ***"); |
| newLine(); |
| builder.append(MISSING_END_HEADER_MESSAGE_PREFIX + errorExpressionStatement.getMissingEndHeader()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseVariable(Variable variable) { |
| if (variable.eClass() == AcceleoPackage.eINSTANCE.getVariable()) { |
| builder.append(variable.getName()); |
| builder.append(" : "); |
| if (variable.getType() != null) { |
| builder.append(querySerializer.serialize(variable.getType().getAst())); |
| } else { |
| builder.append(NULL_STRING); |
| } |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorVariable(ErrorVariable errorVariable) { |
| builder.append("*** error variable ***"); |
| newLine(); |
| builder.append(MISSING_NAME_MESSAGE_PREFIX + errorVariable.getMissingName()); |
| newLine(); |
| builder.append(MISSING_COLON_MESSAGE_PREFIX + errorVariable.getMissingColon()); |
| newLine(); |
| builder.append(MISSING_TYPE_MESSAGE_PREFIX + errorVariable.getMissingType()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseProtectedArea(ProtectedArea protectedArea) { |
| builder.append("[protected "); |
| doSwitch(protectedArea.getId()); |
| doSwitch(protectedArea.getBody()); |
| newLine(); |
| builder.append("[/protected]"); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseErrorProtectedArea(ErrorProtectedArea errorProtectedArea) { |
| builder.append("*** error protected area ***"); |
| newLine(); |
| builder.append(MISSING_OPEN_PARENTHESIS_MESSAGE_PREFIX + errorProtectedArea |
| .getMissingOpenParenthesis()); |
| newLine(); |
| builder.append(MISSING_CLOSE_PARENTHESIS_MESSAGE_PREFIX + errorProtectedArea |
| .getMissingCloseParenthesis()); |
| newLine(); |
| builder.append(MISSING_END_HEADER_MESSAGE_PREFIX + errorProtectedArea.getMissingEndHeader()); |
| newLine(); |
| builder.append(MISSING_END_MESSAGE_PREFIX + errorProtectedArea.getMissingEnd()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseModuleDocumentation(ModuleDocumentation modueDocumentation) { |
| doSwitch(modueDocumentation.getBody()); |
| newLine(); |
| builder.append("author: " + modueDocumentation.getAuthor()); |
| newLine(); |
| builder.append("version: " + modueDocumentation.getVersion()); |
| newLine(); |
| builder.append("since: " + modueDocumentation.getSince()); |
| newLine(); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseModuleElementDocumentation(ModuleElementDocumentation moduleElementDocumentation) { |
| doSwitch(moduleElementDocumentation.getBody()); |
| for (ParameterDocumentation documentation : moduleElementDocumentation.getParameterDocumentation()) { |
| newLine(); |
| doSwitch(documentation); |
| } |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseParameterDocumentation(ParameterDocumentation parameterDocumentation) { |
| doSwitch(parameterDocumentation.getBody()); |
| |
| return null; |
| } |
| |
| @Override |
| public Void caseASTNode(ASTNode node) { |
| builder.append(" (" + ast.getStartPosition(node)); |
| builder.append(".."); |
| builder.append(ast.getEndPosition(node) + ")"); |
| return null; |
| } |
| |
| } |