public override object Visit(AST.UsingDeclaration usingDeclaration, object data)
{
Using u = new Using();
u.Usings.Add(usingDeclaration.Namespace);
cu.Usings.Add(u);
return data;
}
public override object Visit(AST.UsingAliasDeclaration usingAliasDeclaration, object data)
{
Using u = new Using();
u.Aliases[usingAliasDeclaration.Alias] = usingAliasDeclaration.Namespace;
cu.Usings.Add(u);
return data;
}
public override object Visit(AST.TypeDeclaration typeDeclaration, object data)
{
DefaultRegion region = GetRegion(typeDeclaration.StartLocation, typeDeclaration.EndLocation);
Class c = new Class(cu, TranslateClassType(typeDeclaration.Type), typeDeclaration.Modifier, region);
if (currentClass.Count > 0) {
Class cur = ((Class)currentClass.Peek());
cur.InnerClasses.Add(c);
c.FullyQualifiedName = String.Concat(cur.FullyQualifiedName, '.', typeDeclaration.Name);
} else {
if (currentNamespace.Count == 0) {
c.FullyQualifiedName = typeDeclaration.Name;
} else {
c.FullyQualifiedName = String.Concat(currentNamespace.Peek(), '.', typeDeclaration.Name);
}
cu.Classes.Add(c);
}
if (typeDeclaration.BaseTypes != null) {
foreach (string type in typeDeclaration.BaseTypes) {
c.BaseTypes.Add(type);
}
}
currentClass.Push(c);
object ret = typeDeclaration.AcceptChildren(this, data);
currentClass.Pop();
c.UpdateModifier();
return ret;
}
public override object Visit(AST.InvocationExpression invocationExpression, object data)
{
Expression[] arg_expr = new Expression[invocationExpression.Parameters.Count];
int i = 0;
foreach (AST.Expression pexpr in invocationExpression.Parameters)
arg_expr[i++] = (Expression)pexpr.AcceptVisitor (this, data);
return new InvocationExpression ((Expression)invocationExpression.TargetObject.AcceptVisitor (this, data),
arg_expr);
}
// ModifierEnum VisitModifier(ICSharpCode.SharpRefactory.Parser.Modifier m)
// {
// return (ModifierEnum)m;
// }
public override object Visit(AST.NamespaceDeclaration namespaceDeclaration, object data)
{
string name;
if (currentNamespace.Count == 0) {
name = namespaceDeclaration.NameSpace;
} else {
name = String.Concat((string)currentNamespace.Peek(), '.', namespaceDeclaration.NameSpace);
}
currentNamespace.Push(name);
object ret = namespaceDeclaration.AcceptChildren(this, data);
currentNamespace.Pop();
return ret;
}
public override object Visit(AST.PrimitiveExpression primitiveExpression, object data)
{
object v = primitiveExpression.Value;
Type t = v.GetType();
if (t == typeof (bool))
return new BoolExpression ((bool)v);
else if (t == typeof (long))
return new NumberExpression ((long)v);
else if (t == typeof (int))
return new NumberExpression ((int)v);
else
throw new EvaluationException (String.Format ("unhandled primitive expression: `{0}'", primitiveExpression.ToString()));
}
public override object Visit(AST.ConditionalExpression conditionalExpression, object data)
{
Expression test_expr = (Expression)conditionalExpression.TestCondition.AcceptVisitor (this, data);
Expression true_expr = (Expression)conditionalExpression.TrueExpression.AcceptVisitor (this, data);
Expression false_expr = (Expression)conditionalExpression.FalseExpression.AcceptVisitor (this, data);
return new ConditionalExpression (test_expr, true_expr, false_expr);
}
public override object Visit(AST.ArrayInitializerExpression arrayInitializerExpression, object data)
{
throw new EvaluationException ("AST.ArrayInitializerExpression not yet implemented");
}
public override object Visit(AST.ArrayCreationParameter arrayCreationParameter, object data)
{
throw new EvaluationException ("AST.ArrayCreationParameter not yet implemented");
}
public override object Visit(AST.ObjectCreateExpression objectCreateExpression, object data)
{
throw new EvaluationException ("AST.ObjectCreateExpression not yet implemented");
}
public override object Visit(AST.ConstructorDeclaration constructorDeclaration, object data)
{
DefaultRegion region = GetRegion(constructorDeclaration.StartLocation, constructorDeclaration.EndLocation);
DefaultRegion bodyRegion = GetRegion(constructorDeclaration.EndLocation, constructorDeclaration.Body != null ? constructorDeclaration.Body.EndLocation : new Point(-1, -1));
Class c = (Class)currentClass.Peek();
Constructor constructor = new Constructor(constructorDeclaration.Modifier, region, bodyRegion);
ParameterCollection parameters = new ParameterCollection();
if (constructorDeclaration.Parameters != null) {
foreach (AST.ParameterDeclarationExpression par in constructorDeclaration.Parameters) {
ReturnType parType = new ReturnType(par.TypeReference);
Parameter p = new Parameter(par.ParameterName, parType);
parameters.Add(p);
}
}
constructor.Parameters = parameters;
c.Methods.Add(constructor);
return null;
}
public override object Visit(AST.EventDeclaration eventDeclaration, object data)
{
DefaultRegion region = GetRegion(eventDeclaration.StartLocation, eventDeclaration.EndLocation);
DefaultRegion bodyRegion = GetRegion(eventDeclaration.BodyStart, eventDeclaration.BodyEnd);
ReturnType type = new ReturnType(eventDeclaration.TypeReference);
Class c = (Class)currentClass.Peek();
Event e = null;
if (eventDeclaration.VariableDeclarators != null) {
foreach (ICSharpCode.SharpRefactory.Parser.AST.VariableDeclaration varDecl in eventDeclaration.VariableDeclarators) {
e = new Event(varDecl.Name, type, eventDeclaration.Modifier, region, bodyRegion);
c.Events.Add(e);
}
} else {
e = new Event(eventDeclaration.Name, type, eventDeclaration.Modifier, region, bodyRegion);
c.Events.Add(e);
}
return null;
}
public override object Visit(AST.IdentifierExpression identifierExpression, object data)
{
return new SimpleNameExpression (identifierExpression.Identifier);
}
public override object Visit(AST.FieldReferenceExpression fieldReferenceExpression, object data)
{
return new MemberAccessExpression ((Expression)fieldReferenceExpression.TargetObject.AcceptVisitor (this, data),
fieldReferenceExpression.FieldName);
}
public override object Visit(AST.DestructorDeclaration destructorDeclaration, object data)
{
DefaultRegion region = GetRegion(destructorDeclaration.StartLocation, destructorDeclaration.EndLocation);
DefaultRegion bodyRegion = GetRegion(destructorDeclaration.EndLocation, destructorDeclaration.Body != null ? destructorDeclaration.Body.EndLocation : new Point(-1, -1));
Class c = (Class)currentClass.Peek();
Destructor destructor = new Destructor(c.Name, destructorDeclaration.Modifier, region, bodyRegion);
c.Methods.Add(destructor);
return null;
}
public override object Visit(AST.FieldDeclaration fieldDeclaration, object data)
{
DefaultRegion region = GetRegion(fieldDeclaration.StartLocation, fieldDeclaration.EndLocation);
Class c = (Class)currentClass.Peek();
ReturnType type = null;
if (fieldDeclaration.TypeReference == null) {
Debug.Assert(c.ClassType == ClassType.Enum);
} else {
type = new ReturnType(fieldDeclaration.TypeReference);
}
if (currentClass.Count > 0) {
foreach (AST.VariableDeclaration field in fieldDeclaration.Fields) {
Field f = new Field(type, field.Name, fieldDeclaration.Modifier, region);
c.Fields.Add(f);
}
}
return null;
}
public override object Visit(AST.CompilationUnit compilationUnit, object data)
{
//TODO: usings, Comments
compilationUnit.AcceptChildren(this, data);
return cu;
}
public override object Visit(AST.IndexerDeclaration indexerDeclaration, object data)
{
DefaultRegion region = GetRegion(indexerDeclaration.StartLocation, indexerDeclaration.EndLocation);
DefaultRegion bodyRegion = GetRegion(indexerDeclaration.BodyStart, indexerDeclaration.BodyEnd);
ParameterCollection parameters = new ParameterCollection();
Indexer i = new Indexer(new ReturnType(indexerDeclaration.TypeReference), parameters, indexerDeclaration.Modifier, region, bodyRegion);
if (indexerDeclaration.Parameters != null) {
foreach (AST.ParameterDeclarationExpression par in indexerDeclaration.Parameters) {
ReturnType parType = new ReturnType(par.TypeReference);
Parameter p = new Parameter(par.ParameterName, parType);
parameters.Add(p);
}
}
Class c = (Class)currentClass.Peek();
c.Indexer.Add(i);
return null;
}
public override object Visit(AST.BinaryOperatorExpression binaryOperatorExpression, object data)
{
throw new EvaluationException ("AST.TypeReferenceExpression not yet implemented");
}
public override object Visit(AST.UncheckedExpression uncheckedExpression, object data)
{
throw new EvaluationException ("AST.UncheckedExpression not yet implemented");
}
public override object Visit(AST.ParenthesizedExpression parenthesizedExpression, object data)
{
return parenthesizedExpression.Expression.AcceptVisitor (this, data);
}
public override object Visit(AST.PropertyDeclaration propertyDeclaration, object data)
{
DefaultRegion region = GetRegion(propertyDeclaration.StartLocation, propertyDeclaration.EndLocation);
DefaultRegion bodyRegion = GetRegion(propertyDeclaration.BodyStart, propertyDeclaration.BodyEnd);
ReturnType type = new ReturnType(propertyDeclaration.TypeReference);
Class c = (Class)currentClass.Peek();
Property property = new Property(propertyDeclaration.Name, type, propertyDeclaration.Modifier, region, bodyRegion);
c.Properties.Add(property);
return null;
}
public override object Visit(AST.StackAllocExpression stackAllocExpression, object data)
{
throw new EvaluationException ("AST.StackAllocExpression not yet implemented");
}
public override object Visit(AST.ThisReferenceExpression thisReferenceExpression, object data)
{
return new ThisExpression ();
}
public override object Visit(AST.TypeOfExpression typeOfExpression, object data)
{
throw new EvaluationException ("AST.TypeOfExpression not yet implemented");
}
public override object Visit(AST.BaseReferenceExpression baseReferenceExpression, object data)
{
return new BaseExpression ();
}
public override object Visit(AST.PointerReferenceExpression pointerReferenceExpression, object data)
{
throw new EvaluationException ("AST.PointerReferenceExpression not yet implemented");
}
public override object Visit(AST.MethodDeclaration methodDeclaration, object data)
{
DefaultRegion region = GetRegion(methodDeclaration.StartLocation, methodDeclaration.EndLocation);
DefaultRegion bodyRegion = GetRegion(methodDeclaration.EndLocation, methodDeclaration.Body != null ? methodDeclaration.Body.EndLocation : new Point(-1, -1));
// Console.WriteLine(region + " --- " + bodyRegion);
ReturnType type = new ReturnType(methodDeclaration.TypeReference);
Class c = (Class)currentClass.Peek();
Method method = new Method(String.Concat(methodDeclaration.Name), type, methodDeclaration.Modifier, region, bodyRegion);
ParameterCollection parameters = new ParameterCollection();
if (methodDeclaration.Parameters != null) {
foreach (AST.ParameterDeclarationExpression par in methodDeclaration.Parameters) {
ReturnType parType = new ReturnType(par.TypeReference);
Parameter p = new Parameter(par.ParameterName, parType);
parameters.Add(p);
}
}
method.Parameters = parameters;
c.Methods.Add(method);
return null;
}
