public override void ProcessNode(ConditionalConstructNode node)
{
List <NodeBase> conditions = node.Conditions;
List <NodeBase> expressionSets = node.ExpressionSets;
GroupingNode elseExpressionNode = node.ElseExpressionNode;
ProcessConditionalSection(ConditionalStage.If, conditions[0], expressionSets[0] as GroupingNode);
int lastElifIndex = conditions.Count - 2;
for (int i = 1; i <= lastElifIndex; i++)
{
ProcessConditionalSection(ConditionalStage.ElseIf, conditions[i], expressionSets[i] as GroupingNode);
}
if (elseExpressionNode != null)
{
ProcessConditionalSection(ConditionalStage.Else, null, elseExpressionNode);
}
}
public override void ProcessNode(ConditionalConstructNode node)
{
}
public override void ProcessNode(BslFunctionCallNode node)
{
ExpressionReference expressionReference = m_decompilerLookup.FunctionOpCodeLookup[node.OperationCode];
FunctionReference functionReference;
OperatorReference operatorReference;
GlobalReference globalReference;
if ((functionReference = expressionReference as FunctionReference) != null)
{
if (functionReference.Function.IsOverloadedByBooleanArgument)
{
node.Children.Add(new BoolValueNode(functionReference.Overload == 1));
}
node.Replace(new PslFunctionUsageNode(functionReference.Function, node.Children));
foreach (NodeBase child in node.Children)
{
child.VisitThis(this);
}
}
else if ((operatorReference = expressionReference as OperatorReference) != null)
{
switch (operatorReference.Operation.Specification)
{
case FunctionSpecification.Begin:
node.Replace(new GroupingNode(node.Children));
foreach (NodeBase child in node.Children)
{
child.VisitThis(this);
}
break;
case FunctionSpecification.BeginRandom:
ValueDiscrepancy vd = SingleValueDiscrepancySearch.Perform(node.Children);
if (vd != null)
{
short typeIndex = vd.TypeIndex;
string pluralTypeName = m_engineDefinition.GetTypeName(typeIndex);
List <NodeBase> randomizerExpressions = node.Children[0].Children;
VariableNode iteratorParameter = new VariableNode(pluralTypeName + "s", typeIndex, true, true, null);
vd.Nodes[0].Replace(new VariableReferenceValueNode(iteratorParameter, typeIndex));
List <NodeBase> parameters = new List <NodeBase>();
parameters.Add(iteratorParameter);
ScriptNode randomFunction = new ScriptNode("Randomize" + StringOps.CapitalizeWords(pluralTypeName), ScriptType.Random, (short)IntegralValueType.Void, randomizerExpressions);
m_scriptInsertionQueue.QueueInsertion(m_state.CurrentScriptIndex, randomFunction);
List <NodeBase> randomFunctionArguments = new List <NodeBase>();
randomFunctionArguments.Add(new PslArrayNode(typeIndex, vd.Nodes));
node.Replace(new ScriptCallNode(randomFunction, randomFunctionArguments));
foreach (NodeBase child in node.Children)
{
child.VisitThis(this);
}
}
break;
case FunctionSpecification.If:
// Early recursion to identify GroupingNodes and sub Ifs before constructing conditional node
foreach (NodeBase child in node.Children)
{
child.VisitThis(this);
}
ConditionalConstructNode conditionalConstruct = null;
NodeBase condition = node.Children[0];
GroupingNode expressions = GroupingNode.MakeGrouping(node.Children[1]);
GroupingNode elseExpressions = null;
if (node.Children.Count > 2)
{
elseExpressions = GroupingNode.MakeGrouping(node.Children[2]);
ConditionalConstructNode embeddedIf;
if (elseExpressions.Children.Count == 1 && (embeddedIf = elseExpressions.Children[0] as ConditionalConstructNode) != null)
{
BoolValueNode potentialAlwaysTrueStatement = embeddedIf.Conditions[0] as BoolValueNode;
if (potentialAlwaysTrueStatement != null && potentialAlwaysTrueStatement.Value)
{
elseExpressions = embeddedIf.ExpressionSets[0] as GroupingNode;
}
else
{
conditionalConstruct = embeddedIf;
conditionalConstruct.InsertConditional(condition, expressions);
}
}
}
if (conditionalConstruct == null)
{
List <NodeBase> conditions = new List <NodeBase>();
conditions.Add(condition);
List <NodeBase> expressionSets = new List <NodeBase>();
expressionSets.Add(expressions);
conditionalConstruct = new ConditionalConstructNode(conditions, expressionSets, elseExpressions);
}
node.Replace(conditionalConstruct);
break;
case FunctionSpecification.Cond:
throw new NeedMoreResearchException("How does cond look in compiled form - how are its children mapped out?");
//node.Replace(new ConditionalConstructNode());
//break;
default:
List <NodeBase> children = node.Children;
node.Replace(new PslOperatorUsageNode(operatorReference.Operation, children));
foreach (NodeBase child in children)
{
child.VisitThis(this);
}
break;
}
}
else if ((globalReference = expressionReference as GlobalReference) != null)
{
switch (globalReference.Method)
{
case GlobalReference.AccessMethod.Get:
node.Replace(new PslGameGlobalReferenceNode(globalReference.Global));
break;
case GlobalReference.AccessMethod.Set:
List <NodeBase> operands = new List <NodeBase>();
operands.Add(new PslGameGlobalReferenceNode(globalReference.Global));
operands.Add(node.Children[0]);
node.Replace(new PslOperatorUsageNode(m_engineDefinition.SpecificFunctions[(int)FunctionSpecification.Set], operands));
operands[1].VisitThis(this);
break;
}
}
else if (expressionReference is CasterReference)
{
node.Replace(node.Children[0]);
node.Children[0].VisitThis(this);
}
}
public abstract void ProcessNode(ConditionalConstructNode node);
