/*
* <copyright>
*
* Copyright (c) 2005-2006 Sven Efftinge and others.
* 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:
* Sven Efftinge - Initial API and implementation
*
* </copyright>
*/
package org.eclipse.gmf.internal.xpand.expression.parser;
import java.util.List;
import org.eclipse.gmf.internal.xpand.expression.ast.BooleanLiteral;
import org.eclipse.gmf.internal.xpand.expression.ast.BooleanOperation;
import org.eclipse.gmf.internal.xpand.expression.ast.Case;
import org.eclipse.gmf.internal.xpand.expression.ast.Cast;
import org.eclipse.gmf.internal.xpand.expression.ast.ChainExpression;
import org.eclipse.gmf.internal.xpand.expression.ast.CollectionExpression;
import org.eclipse.gmf.internal.xpand.expression.ast.ConstructorCallExpression;
import org.eclipse.gmf.internal.xpand.expression.ast.DeclaredParameter;
import org.eclipse.gmf.internal.xpand.expression.ast.Expression;
import org.eclipse.gmf.internal.xpand.expression.ast.FeatureCall;
import org.eclipse.gmf.internal.xpand.expression.ast.Identifier;
import org.eclipse.gmf.internal.xpand.expression.ast.IfExpression;
import org.eclipse.gmf.internal.xpand.expression.ast.IntegerLiteral;
import org.eclipse.gmf.internal.xpand.expression.ast.LetExpression;
import org.eclipse.gmf.internal.xpand.expression.ast.ListLiteral;
import org.eclipse.gmf.internal.xpand.expression.ast.NullLiteral;
import org.eclipse.gmf.internal.xpand.expression.ast.OperationCall;
import org.eclipse.gmf.internal.xpand.expression.ast.RealLiteral;
import org.eclipse.gmf.internal.xpand.expression.ast.StringLiteral;
import org.eclipse.gmf.internal.xpand.expression.ast.SwitchExpression;
import org.eclipse.gmf.internal.xpand.expression.ast.SyntaxElement;
import org.eclipse.gmf.internal.xpand.expression.ast.TypeSelectExpression;
import lpg.lpgjavaruntime.IToken;
/**
* @author Sven Efftinge
* @author Arno Haase
*/
public class ExpressionFactory {
private String fileName;
public ExpressionFactory(final String string) {
fileName = string;
}
protected static int end(final IToken c) {
return c.getEndColumn();
}
protected static int start(final IToken c) {
return c.getColumn() - 1;
}
protected static int line(final IToken c) {
return c.getLine();
}
public StringLiteral createStringLiteral(final IToken t) {
return handle(new StringLiteral(start(t), end(t), line(t), t.getStartOffset(), t.getEndOffset(), t.toString()));
}
public IntegerLiteral createIntegerLiteral(final IToken t) {
return handle(new IntegerLiteral(start(t), end(t), line(t), t.getStartOffset(), t.getEndOffset(), t.toString()));
}
public BooleanLiteral createBooleanLiteral(final IToken t) {
return handle(new BooleanLiteral(start(t), end(t), line(t), t.getStartOffset(), t.getEndOffset(), t.toString()));
}
public NullLiteral createNullLiteral(final IToken t) {
return handle(new NullLiteral(start(t), end(t), t.getStartOffset(), t.getEndOffset(), line(t)));
}
public ListLiteral createListLiteral(final IToken start, final IToken end, final List<Expression> paramExpr) {
return handle(new ListLiteral(start(start), end(end), line(start), start.getStartOffset(), end.getEndOffset(), paramExpr.toArray(new Expression[paramExpr.size()])));
}
public FeatureCall createFeatureCall(final Identifier name, final Expression target) {
return handle(new FeatureCall(name.getStart(), name.getEnd(), name.getLine(), name.getStartOffset(), name.getEndOffset(), name, target));
}
public Identifier createIdentifier(IToken name) {
return new Identifier(start(name), end(name), line(name), name.getStartOffset(), name.getEndOffset(), name.toString());
}
public OperationCall createOperationCall(final IToken endToken, final IToken name, final Expression target, final List<Expression> parameterExpressions) {
final int start = start(name);
final int line = line(name);
final int end = end(endToken);
final Expression[] params = parameterExpressions.toArray(new Expression[parameterExpressions.size()]);
return handle(new OperationCall(start, end, line, name.getStartOffset(), endToken.getEndOffset(), createIdentifier(name), target, params));
}
// XXX
public OperationCall createOperationCall(final int start, final int end, final int line, final int startOffset, final int endOffset, final IToken name, final Expression target, final List<Expression> parameterExpressions) {
final Expression[] params = parameterExpressions.toArray(new Expression[parameterExpressions.size()]);
return handle(new OperationCall(start, end, line, startOffset, endOffset, createIdentifier(name), target, params));
}
public IfExpression createIf(final Expression cond, final Expression then, final Expression elseExpr) {
final int start = cond.getStart();
final int line = cond.getLine();
final int end = elseExpr.getEnd();
return handle(new IfExpression(start, end, line, cond.getStartOffset(), elseExpr.getEndOffset(), cond, then, elseExpr));
}
public CollectionExpression createCollectionExpression(final IToken opName, final IToken endToken, final IToken elementName, final Expression closure, final Expression target) {
return handle(new CollectionExpression(end(endToken), endToken.getEndOffset(), createIdentifier(opName), elementName == null ? null : elementName.toString(), closure, target));
}
public DeclaredParameter createDeclaredParameter(final Identifier type, final Identifier name) {
return handle(new DeclaredParameter(type.getStart(), name.getEnd(), type.getLine(), type.getStartOffset(), name.getEndOffset(), type, name));
}
public Expression createCast(final IToken start, final Identifier t, final Expression e) {
return handle(new Cast(start(start), e.getEnd(), line(start), start.getStartOffset(), e.getEndOffset(), t, e));
}
protected <T extends SyntaxElement> T handle(final T expr) {
expr.setFileName(fileName);
return expr;
}
public Case createCase(final IToken start, final Expression cond, final Expression then) {
return handle(new Case(start(start), then.getEnd(), line(start), start.getStartOffset(), then.getEndOffset(), cond, then));
}
public SwitchExpression createSwitchExpression(final IToken start, final IToken end, final Expression switchExpr, final List<Case> cases, final Expression defaultExpr) {
return handle(new SwitchExpression(start(start), end(end), line(start), start.getStartOffset(), end.getEndOffset(), switchExpr, cases, defaultExpr));
}
public ChainExpression createChainExpression(final Expression head, final Expression next) {
return handle(new ChainExpression(head.getStart(), next.getEnd(), head.getLine(), head.getStartOffset(), next.getEndOffset(), head, next));
}
public RealLiteral createRealLiteral(final IToken token) {
return handle(new RealLiteral(start(token), end(token), line(token), token.getStartOffset(), token.getEndOffset(), token.toString()));
}
public FeatureCall createTypeSelectExpression(final IToken id, final IToken c1, final Identifier ident, final Expression e) {
return handle(new TypeSelectExpression(end(c1), c1.getEndOffset(), createIdentifier(id), ident, e));
}
public BooleanOperation createBooleanOperation(final int start, final int end, final int line, final int startOffset, final int endOffest, final IToken name, final Expression e, final Expression r) {
return handle(new BooleanOperation(start, end, line, startOffset, endOffest, name.toString(), e, r));
}
public LetExpression createLetExpression(final IToken start, final IToken v, final Expression varExpr, final Expression target) {
return handle(new LetExpression(start(start), target.getEnd(), line(start), start.getStartOffset(), target.getEndOffset(), createIdentifier(v), varExpr, target));
}
public Expression createConstructorCall(final IToken s, final Identifier type) {
return handle(new ConstructorCallExpression(start(s), type.getEnd(), line(s), s.getStartOffset(), type.getEndOffset(), type));
}
}