public PreOpDeclaration(String keyword,
bool delim, CodeBody body, VariableType returnType,
FunctionParameter operand, List<Specifier> specs,
SourcePosition start, SourcePosition end)
: base(ASTNodeType.PrefixOperator, keyword, delim, body, returnType, specs, start, end)
{
Operand = operand;
}
public VariableDeclaration(VariableType type, List<Specifier> specs,
List<VariableIdentifier> names, SourcePosition start, SourcePosition end)
: base(ASTNodeType.VariableDeclaration, start, end)
{
Specifiers = specs;
VarType = type;
Variables = names;
}
// TODO: this is only for text decompiling, should extend to a full ast for modification.
public Class ConvertClass()
{
VariableType parent;
if (Object.SuperField != null)
parent = new VariableType(Object.SuperField.Name, null, null);
else
parent = new VariableType("object", null, null);
VariableType outer;
if (Object.OuterClass != null)
outer = new VariableType(Object.OuterClass.Name, null, null);
else
outer = new VariableType(parent.Name, null, null);
// TODO: specifiers
// TODO: operators
// TODO: components
// TODO: constants
// TODO: interfaces
var Types = new List<VariableType>();
foreach (var member in Object.Structs)
Types.Add(ConvertStruct(member));
foreach (var member in Object.Enums)
Types.Add(ConvertEnum(member));
var Vars = new List<VariableDeclaration>();
foreach (var member in Object.Variables)
Vars.Add(ConvertVariable(member));
var Funcs = new List<Function>();
foreach (var member in Object.DefinedFunctions)
Funcs.Add(ConvertFunction(member));
var States = new List<State>();
foreach (var member in Object.States)
States.Add(ConvertState(member));
AST = new Class(Object.Name, new List<Specifier>(), Vars, Types, Funcs,
States, parent, outer, new List<OperatorDeclaration>(), null, null);
// Ugly quick fix:
foreach (var member in Types)
member.Outer = AST;
foreach (var member in Vars)
member.Outer = AST;
foreach (var member in Funcs)
member.Outer = AST;
foreach (var member in States)
member.Outer = AST;
var propObject = PCC.GetExportObject(Object.DefaultPropertyIndex);
if (propObject != null && propObject.DefaultProperties != null && propObject.DefaultProperties.Count != 0)
AST.DefaultProperties = ConvertDefaultProperties(propObject.DefaultProperties);
return AST;
}
public InOpDeclaration(String keyword, int precedence,
bool delim, CodeBody body, VariableType returnType,
FunctionParameter leftOp, FunctionParameter rightOp,
List<Specifier> specs, SourcePosition start, SourcePosition end)
: base(ASTNodeType.InfixOperator, keyword, delim, body, returnType, specs, start, end)
{
LeftOperand = leftOp;
RightOperand = rightOp;
Precedence = precedence;
}
public Struct(String name, List<Specifier> specs,
List<VariableDeclaration> members,
SourcePosition start, SourcePosition end, VariableType parent = null)
: base(name, start, end)
{
Type = ASTNodeType.Struct;
Specifiers = specs;
Members = members;
Parent = parent;
}
public OperatorDeclaration(ASTNodeType type, String keyword,
bool delim, CodeBody body, VariableType returnType,
List<Specifier> specs, SourcePosition start, SourcePosition end)
: base(type, start, end)
{
OperatorKeyword = keyword;
isDelimiter = delim;
Body = body;
ReturnType = returnType;
Specifiers = specs;
Locals = new List<VariableDeclaration>();
}
public Function(String name, VariableType returntype, CodeBody body,
List<Specifier> specs, List<FunctionParameter> parameters,
SourcePosition start, SourcePosition end)
: base(ASTNodeType.Function, start, end)
{
Name = name;
Body = body;
ReturnType = returntype;
Specifiers = specs;
Parameters = parameters;
Locals = new List<VariableDeclaration>();
}
public bool GetInOperator(out InOpDeclaration op, String name, VariableType lhs, VariableType rhs)
{
op = null;
var lookup = Operators.FirstOrDefault(opdecl => opdecl.Value.Type == ASTNodeType.InfixOperator && opdecl.Value.OperatorKeyword == name
&& (opdecl.Value as InOpDeclaration).LeftOperand.VarType.Name.ToLower() == lhs.Name.ToLower()
&& (opdecl.Value as InOpDeclaration).RightOperand.VarType.Name.ToLower() == rhs.Name.ToLower());
if (lookup.Equals(new KeyValuePair<String, OperatorDeclaration>()))
return false;
op = lookup.Value as InOpDeclaration;
return true;
}
public Class(String name, List<Specifier> specs,
List<VariableDeclaration> vars, List<VariableType> types, List<Function> funcs,
List<State> states, VariableType parent, VariableType outer, List<OperatorDeclaration> ops,
SourcePosition start, SourcePosition end)
: base(name, start, end)
{
Parent = parent;
OuterClass = outer;
Specifiers = specs;
VariableDeclarations = vars;
TypeDeclarations = types;
Functions = funcs;
States = states;
Operators = ops;
Type = ASTNodeType.Class;
}
public bool VisitNode(VariableType node)
{
Append(node.Name);
return true;
}
public CastExpression(VariableType type, Expression expr, SourcePosition start, SourcePosition end)
: base(ASTNodeType.CastExpression, start, end)
{
CastType = type;
CastTarget = expr;
}
public void BasicClassTest()
{
var source =
"class Test Deprecated Transient; \n" +
"var enum ETestnumeration {\n" +
" TEST_value1,\n" +
" TEST_value2,\n" +
" TEST_value3,\n" +
"} inlineNumeration, testnum2;\n" +
"var private deprecated int X; \n" +
"VAR INT Y, Z; \n" +
"var ETestnumeration testnum;\n" +
"struct transient testStruct\n" +
"{ var float a, b, c; };\n" +
"var private struct transient twoStruct extends testStruct\n" +
"{\n" +
" var etestnumeration num;\n" +
"} structA, structB;\n" +
"function float funcB( testStruct one, float two ) \n" +
"{\n" +
" local float c;" +
" one.a = 1.3 * c;" +
" while (true)" +
" {" +
" c = c - c - c;" +
" }" +
" if (false) {" +
" switch(one.a) {" +
" case one.a:" +
" c = one.a;" +
" break;" +
" case 1.2:" +
" case 1.3:" +
" c = c + 0.5;" +
" break;" +
" default:" +
" c = 6.6;" +
" }" +
" }" +
" return one.a + 0.33 * (0.66 + 0.1) * 1.5;\n" +
"}\n" +
"private simulated function float MyFunc( out testStruct one, coerce optional float two ) \n" +
"{\n" +
" return one.b + funcB(one, two);\n" +
"}\n" +
"auto state MyState\n" +
"{\n" +
"ignores MyFunc;\n" +
"function StateFunc()\n" +
"{\n" +
"}\n" +
"\n" +
"Begin:\n" +
" moredragons\n" +
"}\n" +
"\n" +
"final static operator(254) int >>>( coerce float left, coerce float right )\n" +
"{\n" +
" all the dragons\n" +
"}\n" +
"\n" +
"\n" +
"\n";
var parser = new ClassOutlineParser(new TokenStream<String>(new StringLexer(source)), log);
var symbols = new SymbolTable();
Class obj = new Class("Object", null, null, null, null, null, null, null, null, null, null);
obj.OuterClass = obj;
symbols.PushScope(obj.Name);
symbols.AddSymbol(obj.Name, obj);
VariableType integer = new VariableType("int", null, null);
symbols.AddSymbol(integer.Name, integer);
VariableType floatingpoint = new VariableType("float", null, null);
symbols.AddSymbol(floatingpoint.Name, floatingpoint);
InOpDeclaration plus_float = new InOpDeclaration("+", 20, false, null, floatingpoint, new FunctionParameter(floatingpoint, null, null, null, null),
new FunctionParameter(floatingpoint, null, null, null, null), null, null, null);
symbols.AddOperator(plus_float);
InOpDeclaration sub_float = new InOpDeclaration("-", 20, false, null, floatingpoint, new FunctionParameter(floatingpoint, null, null, null, null),
new FunctionParameter(floatingpoint, null, null, null, null), null, null, null);
symbols.AddOperator(sub_float);
InOpDeclaration mult_float = new InOpDeclaration("*", 16, false, null, floatingpoint, new FunctionParameter(floatingpoint, null, null, null, null),
new FunctionParameter(floatingpoint, null, null, null, null), null, null, null);
symbols.AddOperator(mult_float);
Class node = (Class)parser.ParseDocument();
var ClassValidator = new ClassValidationVisitor(log, symbols);
node.AcceptVisitor(ClassValidator);
symbols.GoDirectlyToStack(node.GetInheritanceString());
foreach (Function f in node.Functions)
{
symbols.PushScope(f.Name);
var p = new CodeBodyParser(new TokenStream<String>(new StringLexer(source)), f.Body, symbols, f, log);
var b = p.ParseBody();
symbols.PopScope();
}
var CodeBuilder = new CodeBuilderVisitor();
node.AcceptVisitor(CodeBuilder);
Console.Write(CodeBuilder.GetCodeString());
Assert.IsTrue(log.AllErrors.Count == 0);
return;
}
public Variable(List<Specifier> specs, VariableIdentifier name,
VariableType type, SourcePosition start, SourcePosition end)
: base(type, specs, new List<VariableIdentifier> { name }, start, end)
{
Type = ASTNodeType.Variable;
}
public FunctionParameter(VariableType type, List<Specifier> specs,
VariableIdentifier variable, SourcePosition start, SourcePosition end)
: base(specs, variable, type, start, end)
{
Type = ASTNodeType.FunctionParameter;
}
public ObjectLiteral(NameLiteral objectName, VariableType @class = null, SourcePosition start = null, SourcePosition end = null) : base(ASTNodeType.ObjectLiteral, start, end)
{
Class = @class;
Name = objectName;
}
private bool TypeEquals(VariableType a, VariableType b)
{
return a.Name.ToLower() == b.Name.ToLower();
}
public StaticArrayType(VariableType elementType, int size, SourcePosition start = null, SourcePosition end = null) : base(elementType.Name, start, end)
{
ElementType = elementType;
Size = size;
}
public bool VisitNode(VariableType node)
{
// This should never be called.
throw new NotImplementedException();
}
public ClassType(VariableType classLimiter, SourcePosition start = null, SourcePosition end = null) : base(CLASS, start, end, EPropertyType.Object)
{
ClassLimiter = classLimiter;
}
public Class TryParseClass()
{
Func<ASTNode> classParser = () =>
{
if (Tokens.ConsumeToken(TokenType.Class) == null)
return Error("Expected class declaration!");
var name = Tokens.ConsumeToken(TokenType.Word);
if (name == null)
return Error("Expected class name!");
var parentClass = TryParseParent();
if (parentClass == null)
{
Log.LogMessage("No parent class specified for " + name.Value + ", interiting from Object");
parentClass = new VariableType("Object", null, null);
}
var outerClass = TryParseOuter();
var specs = ParseSpecifiers(GlobalLists.ClassSpecifiers);
if (Tokens.ConsumeToken(TokenType.SemiColon) == null)
return Error("Expected semi-colon!", CurrentPosition, CurrentPosition.GetModifiedPosition(0, 1, 1));
var variables = new List<VariableDeclaration>();
var types = new List<VariableType>();
while (CurrentTokenType == TokenType.InstanceVariable
|| CurrentTokenType == TokenType.Struct
|| CurrentTokenType == TokenType.Enumeration)
{
if (CurrentTokenType == TokenType.InstanceVariable)
{
var variable = TryParseVarDecl();
if (variable == null)
return Error("Malformed instance variable!", CurrentPosition, CurrentPosition.GetModifiedPosition(0, 1, 1));
variables.Add(variable);
}
else
{
var type = TryParseEnum() ?? TryParseStruct() ?? new VariableType("INVALID", null, null);
if (type.Name == "INVALID")
return Error("Malformed type declaration!", CurrentPosition, CurrentPosition.GetModifiedPosition(0, 1, 1));
types.Add(type);
if (Tokens.ConsumeToken(TokenType.SemiColon) == null)
return Error("Expected semi-colon!", CurrentPosition, CurrentPosition.GetModifiedPosition(0, 1, 1));
}
}
List<Function> funcs = new List<Function>();
List<State> states = new List<State>();
List<OperatorDeclaration> ops = new List<OperatorDeclaration>();
ASTNode declaration;
do
{
declaration = (ASTNode)TryParseFunction() ??
(ASTNode)TryParseOperatorDecl() ??
(ASTNode)TryParseState() ??
(ASTNode)null;
if (declaration == null && !Tokens.AtEnd())
return Error("Expected function/state/operator declaration!",
CurrentPosition, CurrentPosition.GetModifiedPosition(0, 1, 1));
if (declaration.Type == ASTNodeType.Function)
funcs.Add((Function)declaration);
else if (declaration.Type == ASTNodeType.State)
states.Add((State)declaration);
else
ops.Add((OperatorDeclaration)declaration);
} while (!Tokens.AtEnd());
// TODO: should AST-nodes accept null values? should they make sure they dont present any?
return new Class(name.Value, specs, variables, types, funcs, states, parentClass, outerClass, ops, name.StartPosition, name.EndPosition);
};
return (Class)Tokens.TryGetTree(classParser);
}
public DynamicArrayType(VariableType elementType, SourcePosition start = null, SourcePosition end = null) : base(elementType.Name, start, end)
{
ElementType = elementType;
}
