override public Element Get(TranslateRule context, ScopeGroup scope, MethodNode methodNode, IWorkshopTree[] parameters)
{
// Check the method stack if this method was already called.
// Throw a syntax error if it was.
if (context.MethodStackNotRecursive.Contains(this))
{
throw new SyntaxErrorException("Recursion is not allowed in macros.", methodNode.Location);
}
context.MethodStackNotRecursive.Add(this);
int actionCount = context.Actions.Count;
ScopeGroup methodScope = scope.Root().Child();
for (int i = 0; i < parameters.Length; i++)
{
new ElementReferenceVar(Parameters[i].Name, methodScope, methodNode.Parameters[i], parameters[i]);
}
Element result = context.ParseExpression(methodScope, methodScope, Expression);
methodScope.Out(context);
context.MethodStackNotRecursive.Remove(this);
if (context.Actions.Count > actionCount)
{
throw new SyntaxErrorException("Macro cannot result in any actions.", methodNode.Location);
}
return(result);
}
protected void SetupNew(ScopeGroup getter, ScopeGroup scope, IndexedVar store, ScopeGroup typeScope, TranslateRule context, CreateObjectNode node)
{
// Set the default variables in the struct
for (int i = 0; i < DefinedVars.Length; i++)
{
if (DefinedVars[i].Value != null)
{
context.Actions.AddRange(
store.SetVariable(context.ParseExpression(typeScope, typeScope, DefinedVars[i].Value), null, i)
);
}
}
Constructor constructor = Constructors.FirstOrDefault(c => c.Parameters.Length == node.Parameters.Length);
if (constructor == null)
{
throw SyntaxErrorException.NotAConstructor(TypeKind, Name, node.Parameters.Length, node.Location);
}
if (context.MethodStackNotRecursive.Contains(constructor))
{
throw new SyntaxErrorException("Constructors cannot be recursive.", node.Location);
}
context.MethodStackNotRecursive.Add(constructor);
ScopeGroup constructorScope = typeScope.Child();
IWorkshopTree[] parameters = context.ParseParameters(
getter,
scope,
constructor.Parameters,
node.Parameters,
node.TypeName,
node.Location
);
context.AssignParameterVariables(constructorScope, constructor.Parameters, parameters, node);
if (constructor.BlockNode != null)
{
context.ParseBlock(constructorScope, constructorScope, constructor.BlockNode, true, null);
}
constructorScope.Out(context);
context.MethodStackNotRecursive.Remove(constructor);
}
private ParsingData(string file, string content)
{
Rule initialGlobalValues = new Rule(Constants.INTERNAL_ELEMENT + "Initial Global Values");
Rule initialPlayerValues = new Rule(Constants.INTERNAL_ELEMENT + "Initial Player Values", RuleEvent.OngoingPlayer, Team.All, PlayerSelector.All);
globalTranslate = new TranslateRule(initialGlobalValues, Root, this);
playerTranslate = new TranslateRule(initialPlayerValues, Root, this);
GetRulesets(content, file, true, null);
VarCollection = new VarCollection(ReservedGlobalIDs.ToArray(), ReservedGlobalNames.ToArray(), ReservedPlayerIDs.ToArray(), ReservedPlayerNames.ToArray());
Root = new ScopeGroup(VarCollection);
ClassIndexes = IndexedVar.AssignInternalVar(VarCollection, null, "_classIndexes", true);
ClassArray = IndexedVar.AssignInternalVar(VarCollection, null, "_classArray", true);
if (!Diagnostics.ContainsErrors())
{
foreach (var ruleset in Rulesets)
{
GetObjects(ruleset.Value, ruleset.Key, globalTranslate, playerTranslate);
}
}
foreach (var type in DefinedTypes)
{
try
{
type.RegisterParameters(this);
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
foreach (var method in UserMethods)
{
try
{
method.RegisterParameters(this);
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
if (!Diagnostics.ContainsErrors())
{
// Parse the rules.
Rules = new List <Rule>();
for (int i = 0; i < RuleNodes.Count; i++)
{
try
{
var result = TranslateRule.GetRule(RuleNodes[i], Root, this);
Rules.Add(result);
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
foreach (var definedVar in VarCollection.AllVars)
{
try
{
if (definedVar is IndexedVar && definedVar.IsDefinedVar && definedVar.Scope == Root)
{
Node value = ((IDefine)definedVar.Node).Value;
if (value != null)
{
if (((IndexedVar)definedVar).IsGlobal)
{
globalTranslate.Actions.AddRange(((IndexedVar)definedVar).SetVariable(globalTranslate.ParseExpression(Root, Root, value)));
}
else
{
playerTranslate.Actions.AddRange(((IndexedVar)definedVar).SetVariable(playerTranslate.ParseExpression(Root, Root, value)));
}
}
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
globalTranslate.Finish();
playerTranslate.Finish();
// Add the player initial values rule if it was used.
if (initialPlayerValues.Actions.Length > 0)
{
Rules.Insert(0, initialPlayerValues);
}
// Add the global initial values rule if it was used.
if (initialGlobalValues.Actions.Length > 0)
{
Rules.Insert(0, initialGlobalValues);
}
foreach (Rule rule in AdditionalRules)
{
if (rule.Actions.Length > 0)
{
Rules.Add(rule);
}
}
}
Success = !Diagnostics.ContainsErrors();
}
public ParseExpressionTree(TranslateRule translator, ScopeGroup getter, ScopeGroup scope, Node root)
{
if (root is VariableNode)
{
VariableNode variableNode = (VariableNode)root;
Var var = scope.GetVar(getter, ((VariableNode)root).Name, root.Location);
ResultingVariable = var;
//if (!ResultingVariable.Gettable()) throw SyntaxErrorException.CantReadVariable(ResultingVariable.Name, root.Location);
if (ResultingVariable.Gettable())
{
ResultingElement = var.GetVariable();
}
VariableIndex = new Element[variableNode.Index.Length];
for (int i = 0; i < VariableIndex.Length; i++)
{
VariableIndex[i] = translator.ParseExpression(getter, scope, variableNode.Index[i]);
}
for (int i = 0; i < VariableIndex.Length; i++)
{
if (!ResultingVariable.Gettable())
{
throw SyntaxErrorException.CantReadVariable(ResultingVariable.Name, root.Location);
}
ResultingElement = Element.Part <V_ValueInArray>(ResultingElement, VariableIndex[i]);
}
return;
}
if (root is ExpressionTreeNode == false)
{
throw new SyntaxErrorException("Error", root.Location);
}
List <Node> nodes = flatten((ExpressionTreeNode)root);
ScopeGroup currentScope = scope;
Element nodeResult = null;
for (int index = 0; index < nodes.Count; index++)
{
if (nodes[index] is RootNode)
{
currentScope = translator.ParserData.Root;
nodeResult = new V_Null();
}
// If the node is a variable node, get the value.
else if (nodes[index] is VariableNode)
{
VariableNode variableNode = (VariableNode)nodes[index];
Var var = currentScope.GetVar(getter, variableNode.Name, variableNode.Location);
// If this is the last node, set the resulting var.
if (index == nodes.Count - 1)
{
ResultingVariable = var;
}
// Get the variable index
VariableIndex = new Element[variableNode.Index.Length];
for (int i = 0; i < VariableIndex.Length; i++)
{
VariableIndex[i] = translator.ParseExpression(getter, scope, variableNode.Index[i]);
}
// Set the nodeResult.
nodeResult = var.GetVariable(Target);
// Apply the index
for (int i = 0; i < VariableIndex.Length; i++)
{
nodeResult = Element.Part <V_ValueInArray>(nodeResult, VariableIndex[i]);
}
}
// If not, parse the node as an expression.
else
{
nodeResult = translator.ParseExpression(getter, currentScope, nodes[index]);
}
// SupportedType will equal null if the element is not a defined type.
if (nodeResult.SupportedType == null)
{
// If there is no supported type, assume the element or variable is containing a player.
// Reset the scope.
//currentScope = scope;
currentScope = translator.ParserData.Root;
// If this isn't the last node, set the target and reset the nodeResult.
if (index < nodes.Count - 1)
{
Target = nodeResult;
nodeResult = null;
}
}
else
{
// Set the target scope to the type.
currentScope = nodeResult.SupportedType.Type.GetRootScope(nodeResult, nodeResult.SupportedType, translator.ParserData, Target);
}
}
ResultingElement = nodeResult;
}