public IndexNode(string p_Name, VarAccessType p_AccessType, PositionData p_PositionData)
: base(NodeType.INDEX, p_PositionData)
{
Name = p_Name;
AccessType = p_AccessType;
IsAnonymous = false;
}
public BinaryNode(Node p_Left, OperatorType p_Op, Node p_Right, PositionData p_PositionData)
: base(NodeType.BINARY, p_PositionData)
{
Left = p_Left;
Op = p_Op;
Right = p_Right;
}
public VariableNode(string p_Name, List <IndexNode> p_Indexes, PositionData p_PositionData)
: base(NodeType.VARIABLE, p_PositionData)
{
Name = p_Name;
Indexes = p_Indexes;
IsAnonymous = false;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
private Nullable <Variable> GetVar(string p_name, PositionData p_positionData)
{
int top_index = env.Count - 1;
for (int i = top_index; i >= 0; i--)
{
var this_env = env[i];
if (this_env.Contains(p_name))
{
bool is_in_function = upvalueStack.Count != 0;// if we are compiling a function this stack will not be empty
bool isGlobal = (i == 0);
if (!isGlobal)
{
if (is_in_function && i < funStartEnv.Peek()) // not global
{
List <Variable> this_upvalues = upvalueStack.Peek();
Variable this_upvalue = GetOrSetUpValue(p_name, this_env.IndexOf(p_name), i, this_upvalues);
return(this_upvalue);
}
// local var
return(new Variable(p_name, this_env.IndexOf(p_name), top_index - i, ValueType.Local));
}
if (isGlobal && globals.Contains(p_name)) // Sanity check
{
return(new Variable(p_name, this_env.IndexOf(p_name), 0, ValueType.Global));
}
Error("Var finding gone mad! Variable: " + p_name + " not found!", p_positionData);
return(null);
}
}
Error("Variable: " + p_name + " not found!", p_positionData);
return(null);
}
public LogicalNode(Node p_Left, OperatorType p_Op, Node p_Right, PositionData p_PositionData)
: base(NodeType.LOGICAL, p_PositionData)
{
Left = p_Left;
Right = p_Right;
Op = p_Op;
}
public IfNode(Node p_Condition, Node p_ThenBranch, Node p_ElseBranch, PositionData p_PositionData)
: base(NodeType.IF, p_PositionData)
{
Condition = p_Condition;
ThenBranch = p_ThenBranch;
ElseBranch = p_ElseBranch;
}
public VariableNode(Node p_Expression, List <IndexNode> p_Indexes, PositionData p_PositionData)
: base(NodeType.VARIABLE, p_PositionData)
{
Name = null;
Expression = p_Expression;
Indexes = p_Indexes;
IsAnonymous = true;
}
public IndexNode(Node p_Expression, VarAccessType p_AccessType, PositionData p_PositionData)
: base(NodeType.INDEX, p_PositionData)
{
Name = null;
Expression = p_Expression;
AccessType = p_AccessType;
IsAnonymous = true;
}
Node CompoundVar()
{
Consume(TokenType.IDENTIFIER, "Expected identifier.", true);
TokenString last_token = Previous() as TokenString;
string name = last_token.value;
PositionData position_data = last_token.PositionData;
List <IndexNode> indexes = IndexedAccess();
VariableNode indexed_variable = new VariableNode(name, indexes, position_data);
Node method_call = MethodAccess(indexed_variable);
return(method_call);
}
private void ChunkProgram(ProgramNode p_node)
{
PositionData position_data = p_node.PositionData;
if (p_node.Statements != null)
{
foreach (Node n in p_node.Statements)
{
ChunkIt(n);
}
if (p_node.Statements.Count > 1)
{
position_data = p_node.Statements[p_node.Statements.Count - 1].PositionData;
}
}
Add(OpCode.EXIT, position_data);
}
private void LoadVariable(Variable p_variable, PositionData p_positionData)
{
switch (p_variable.type)
{
case ValueType.Local:
Add(OpCode.LOAD_VARIABLE, (Operand)p_variable.address, (Operand)p_variable.envIndex, p_positionData);
break;
case ValueType.Global:
Add(OpCode.LOAD_GLOBAL, (Operand)p_variable.address, p_positionData);
break;
case ValueType.UpValue:
int this_index = upvalueStack.Peek().IndexOf(p_variable);
Add(OpCode.LOAD_UPVALUE, (Operand)this_index, p_positionData);
break;
case ValueType.Expression:
ChunkIt(p_variable.expression);
break;
}
}
public ReturnNode(Node p_Expr, PositionData p_PositionData)
: base(NodeType.RETURN, p_PositionData)
{
Expr = p_Expr;
}
public FunctionCallNode(VariableNode p_Name, PositionData p_PositionData)
: base(NodeType.FUNCTION_CALL, p_PositionData)
{
Variable = p_Name;
Calls = new List <CallInfo>();
}
public BlockNode(List <Node> p_Statements, PositionData p_PositionData)
: base(NodeType.BLOCK, p_PositionData)
{
Statements = p_Statements;
}
public StmtExprNode(Node p_Expr, PositionData p_PositionData)
: base(NodeType.STMT_EXPR, p_PositionData)
{
Expr = p_Expr;
}
public FunctionDeclarationNode(VariableNode p_Variable, List <string> p_Parameters, List <Node> p_Body, PositionData p_PositionData)
: base(p_Parameters, p_Body, p_PositionData, NodeType.FUNCTION_DECLARATION)
{
Variable = p_Variable;
}
public FunctionExpressionNode(List <string> p_Parameters, List <Node> p_Body, PositionData p_PositionData, NodeType p_Type = NodeType.FUNCTION_EXPRESSION)
: base(p_Type, p_PositionData)
{
Parameters = p_Parameters;
Body = p_Body;
}
public UnaryNode(OperatorType p_Op, Node p_Right, PositionData p_PositionData)
: base(NodeType.UNARY, p_PositionData)
{
Op = p_Op;
Right = p_Right;
}
public LiteralNode(bool p_Value, PositionData p_PositionData)
: base(NodeType.LITERAL, p_PositionData)
{
Value = p_Value;
ValueType = p_Value.GetType();
}
public WhileNode(Node p_Condition, Node p_Body, PositionData p_PositionData)
: base(NodeType.WHILE, p_PositionData)
{
Condition = p_Condition;
Body = p_Body;
}
public ForNode(Node p_Initializer, Node p_Condition, Node p_Finalizer, Node p_Body, PositionData p_PositionData)
: base(NodeType.FOR, p_PositionData)
{
Initializer = p_Initializer;
Condition = p_Condition;
Finalizer = p_Finalizer;
Body = p_Body;
}
public LiteralNode(PositionData p_PositionData)
: base(NodeType.LITERAL, p_PositionData)
{
Value = null;
ValueType = null;
}
public TableNode(Dictionary <Node, Node> p_Map, PositionData p_PositionData)
: base(NodeType.TABLE, p_PositionData)
{
Map = p_Map;
}
public ProgramNode(List <Node> p_Statements, PositionData p_PositionData)
: base(NodeType.PROGRAM, p_PositionData)
{
Statements = p_Statements;
}
public ListNode(List <Node> p_Elements, PositionData p_PositionData)
: base(NodeType.LIST, p_PositionData)
{
Elements = p_Elements;
}
public VarDeclarationNode(string p_Name, Node p_Initializer, PositionData p_PositionData)
: base(NodeType.VAR_DECLARATION, p_PositionData)
{
Name = p_Name;
Initializer = p_Initializer;
}
public MemberFunctionDeclarationNode(String p_Name, List <string> p_Parameters, List <Node> p_Body, PositionData p_PositionData)
: base(p_Parameters, p_Body, p_PositionData, NodeType.MEMBER_FUNCTION_DECLARATION)
{
Name = p_Name;
}
public AssignmentNode(VariableNode p_Assigned, Node p_Value, AssignmentOperatorType p_Op, PositionData p_PositionData)
: base(NodeType.ASSIGMENT_OP, p_PositionData)
{
Assigned = p_Assigned;
Value = p_Value;
Op = p_Op;
}
public void AddPosition(PositionData p_positionData)
{
positions.Add(p_positionData);
}
public GroupingNode(Node p_Expr, PositionData p_PositionData)
: base(NodeType.GROUPING, p_PositionData)
{
Expr = p_Expr;
}
