public ForStatement(IStatement[] preLoopAssignment, EvaluationStatement condition, IStatement[] afterLoopEvaluations, IStatement statement, StatementInfo info)
: base(condition, statement, info)
{
PreLoopAssignment = preLoopAssignment;
AfterLoopEvaluations = afterLoopEvaluations;
var children = new List <IStatement>();
if (preLoopAssignment != null)
{
children.AddRange(preLoopAssignment);
}
if (condition != null)
{
children.Add(condition);
}
if (afterLoopEvaluations != null)
{
children.AddRange(afterLoopEvaluations);
}
if (statement != null)
{
children.Add(statement);
}
TraversableChildren = children.ToArray();
}
public ArrayStatement(TypeDescriptor type, EvaluationStatement length, EvaluationStatement[] elements, StatementInfo info)
{
Info = info;
Type = type;
Length = length;
Elements = elements;
}
public static BitwiseEvaluationStatement CreateNot(BitwiseNotOperator op, EvaluationStatement operand,
StatementInfo info, IStatement parentStatement = null)
{
return(new BitwiseEvaluationStatement(null, op, operand, info)
{
ParentStatement = parentStatement
});
}
public static ArithmeticEvaluationStatement CreatePrefixDecrement(DecrementOperator op,
EvaluationStatement operand, StatementInfo info, IStatement parentStatement = null)
{
return(new ArithmeticEvaluationStatement(true, null, op, operand, info)
{
ParentStatement = parentStatement
});
}
public static ArithmeticEvaluationStatement CreateNegate(NegativeNumberOperator op,
EvaluationStatement operand, StatementInfo info, IStatement parentStatement = null)
{
return(new ArithmeticEvaluationStatement(null, op, operand, info)
{
ParentStatement = parentStatement
});
}
public static ArithmeticEvaluationStatement CreatePostfix(ArithmeticOperator op,
EvaluationStatement operand, StatementInfo info, IStatement parentStatement = null)
{
return(new ArithmeticEvaluationStatement(operand, op, null, info)
{
ParentStatement = parentStatement
});
}
public TypeCastStatement(TypeDescriptor typeDescriptor, EvaluationStatement target, StatementInfo info, IStatement parentStatement)
{
TypeDescriptor = typeDescriptor;
Target = target;
Info = info;
ParentStatement = parentStatement;
}
public SwitchCaseStatement(EvaluationStatement switchTarget, ConditionalBlockStatement[] cases, StatementInfo info)
{
SwitchTarget = switchTarget;
Cases = cases;
Info = info;
TraversableChildren = StatementHelpers.CreateChildren(new IStatement[] { switchTarget }.Union(cases).ToArray());
Branches = cases.Select(x => x.Statement).ToArray();
}
public VariableDefinitionStatement(
TypeDescriptor typeDescriptor,
string name,
bool isConstant,
EvaluationStatement value,
StatementInfo info)
: base(typeDescriptor, name, value, value != null, info)
{
IsConstant = isConstant;
}
public DefinitionStatement(TypeDescriptor typeDescriptor, string name, EvaluationStatement defaultValue,
bool hasDefaultValue, StatementInfo info)
{
TypeDescriptor = typeDescriptor;
Name = name;
DefaultValue = defaultValue;
HasDefaultValue = hasDefaultValue;
Info = info;
TraversableChildren = StatementHelpers.CreateChildren(defaultValue);
}
public BitwiseEvaluationStatement(EvaluationStatement left, BitwiseOperator @operator,
EvaluationStatement right, StatementInfo info, IStatement parentStatement = null)
{
Left = left;
Operator = @operator;
Right = right;
Info = info;
ParentStatement = parentStatement;
TraversableChildren = StatementHelpers.CreateChildren(left, @operator, right);
}
public ArithmeticEvaluationStatement(EvaluationStatement left, ArithmeticOperator @operator,
EvaluationStatement right, StatementInfo info, IStatement parentStatement = null)
{
CanBeEmbedded = false;
Left = left;
Operator = @operator;
Right = right;
Info = info;
ParentStatement = parentStatement;
TraversableChildren = StatementHelpers.CreateChildren(left, @operator, right);
}
public static TypeDescriptor GetDataType(this EvaluationStatement evaluationStatement, Context context,
Scope scope)
{
switch (evaluationStatement)
{
case ConstantValueStatement constantValueStatement:
{
return(constantValueStatement.TypeDescriptor);
}
case VariableAccessStatement variableAccessStatement:
{
if (scope.TryGetVariableInfo(variableAccessStatement, out var variableInfo))
{
return(variableInfo.TypeDescriptor);
}
if (scope.TryGetConstantInfo(variableAccessStatement, out var constantInfo))
{
return(constantInfo.TypeDescriptor);
}
if (scope.TryGetPrototypeInfo(variableAccessStatement, out var functionInfo) ||
scope.TryGetFunctionInfo(variableAccessStatement, out functionInfo))
{
return(new TypeDescriptor(DataTypes.Delegate,
new TypeDescriptor.LookupInfo(functionInfo.ClassName, functionInfo.Name)));
}
throw new IdentifierNotFoundCompilerException(variableAccessStatement.VariableName,
variableAccessStatement.Info);
}
case FunctionCallStatement functionCallStatement:
{
var funcInfo = FunctionStatementTranspilerBase.GetFunctionInfoFromFunctionCall(context, scope,
functionCallStatement, out var sourceObjectInfo);
if (funcInfo == null)
{
throw new IdentifierNotFoundCompilerException(functionCallStatement.FunctionName,
functionCallStatement.Info);
}
return(funcInfo.TypeDescriptor);
}
case BitwiseEvaluationStatement bitwiseEvaluationStatement:
{
switch (bitwiseEvaluationStatement.Operator)
{
case BitwiseNotOperator _:
{
return(bitwiseEvaluationStatement.Right.GetDataType(context, scope));
}
case BitwiseAndOperator _:
case BitwiseOrOperator _:
case XorOperator _:
{
return(OperateDataTypes(
bitwiseEvaluationStatement.Operator,
bitwiseEvaluationStatement.Left.GetDataType(context, scope),
bitwiseEvaluationStatement.Right.GetDataType(context, scope)
));
}
}
return(TypeDescriptor.Numeric);
}
case LogicalEvaluationStatement _: //logicalEvaluationStatement
{
return(TypeDescriptor.Boolean);
}
case ArithmeticEvaluationStatement arithmeticEvaluationStatement:
{
switch (arithmeticEvaluationStatement.Operator)
{
case IncrementOperator _:
case DecrementOperator _:
case NegativeNumberOperator _:
{
return((arithmeticEvaluationStatement.Right ?? arithmeticEvaluationStatement.Left)
.GetDataType(context, scope));
}
case AdditionOperator _:
case SubtractionOperator _:
case MultiplicationOperator _:
case DivisionOperator _:
//case ReminderOperator _:
case ModulusOperator _:
{
return(OperateDataTypes(
arithmeticEvaluationStatement.Operator,
arithmeticEvaluationStatement.Left.GetDataType(context, scope),
arithmeticEvaluationStatement.Right.GetDataType(context, scope)
));
}
}
return(TypeDescriptor.Numeric);
}
case AssignmentStatement assignmentStatement:
{
return(assignmentStatement.LeftSide.GetDataType(context, scope));
}
case TypeCastStatement typeCastStatement:
{
return(typeCastStatement.TypeDescriptor);
}
case IndexerAccessStatement indexerAccessStatement:
{
var type = indexerAccessStatement.Source.GetDataType(context, scope);
if (!type.IsArray())
{
throw new InvalidStatementStructureCompilerException(indexerAccessStatement,
indexerAccessStatement.Info);
}
//NOTE: multi-dimensional arrays is not supported.
return(type ^ DataTypes.Array);
}
case ArrayStatement arrayStatement:
{
return(arrayStatement.Type);
}
default:
throw new InvalidOperationException();
}
}
public TypeCastStatement(TypeDescriptor typeDescriptor, EvaluationStatement target, StatementInfo info)
{
TypeDescriptor = typeDescriptor;
Target = target;
Info = info;
}
