public FieldDeclaration(string name, Expression defaultValue, TokenPosition position)
: base(position)
{
SetName(name);
this.defaultValue = defaultValue;
this.variable = null;
}
public MakeReference(Expression referencedType, ReferenceFlow flow, bool streamRef, TokenPosition position)
: base(position)
{
this.referencedType = referencedType;
this.flow = flow;
this.streamReference = streamRef;
}
public CaseLabel(Expression constant, AstNode children, TokenPosition position)
: base(position)
{
this.constant = constant;
this.children = children;
this.block = null;
}
public IsExpression(Expression value, Expression compare, TokenPosition position)
: base(position)
{
this.value = value;
this.compare = compare;
this.targetType = null;
}
public ConstructorInitializer(bool baseCall, AstNode arguments, TokenPosition position)
: base(position)
{
this.baseCall = baseCall;
this.arguments = arguments;
this.ctorGroup = null;
}
public GenericSignature(GenericParameter parameters, GenericConstraint constraints,
TokenPosition position)
: base(position)
{
this.parameters = parameters;
this.constraints = constraints;
}
public GenericParameter(string name, TokenPosition position)
: base(position)
{
SetName(name);
this.isValueType = false;
this.bases = null;
}
public MakeArray(Expression valueType, int dimensions, TokenPosition position)
: base(position)
{
this.valueType = valueType;
this.dimensions = dimensions;
this.isReadOnly = false;
}
public AssignmentExpression(Expression variable, Expression value, TokenPosition position)
: base(position)
{
this.variable = variable;
this.value = value;
this.delayedCoercion = false;
}
public IndirectAccess(Expression basePointer, string name, TokenPosition position)
: base(position)
{
SetName(name);
this.basePointer = basePointer;
this.slot = -1;
}
public LocalVariablesDeclaration(Expression type, VariableDeclaration variables,
TokenPosition position)
: base(position)
{
this.type = type;
this.variables = variables;
}
public FixedVariableDecl(string name, Expression value, TokenPosition position)
: base(position)
{
SetName(name);
this.value = value;
this.variable = null;
}
public MemberAccess(Expression reference, string name, TokenPosition position)
: base(position)
{
SetName(name);
this.reference = reference;
this.slot = -1;
}
public MakeFunctionPointer(Expression returnType, AstNode arguments, MemberFlags flags, TokenPosition position)
: base(position)
{
this.returnType = returnType;
this.arguments = arguments;
this.flags = flags;
}
public override Token CreateToken(string tokenstr, TokenPosition pos)
{
Token retval = base.CreateToken (tokenstr, pos);
Boolean keyword_found = false;
foreach(string str in KeywordList)
{
if (KeywordsCheckCase == true)
{
if (str.ToUpper() == tokenstr.ToUpper())
keyword_found = true;
}
else if (str == tokenstr)
{
keyword_found = true;
}
if (keyword_found == true)
{
retval.Type = FECT.TokenTypes.Find(KeywordTokenID);
break;
}
}
return(retval);
}
public VariableDeclaration(string name, Expression initialValue,
TokenPosition position)
: base(position)
{
SetName(name);
this.initialValue = initialValue;
}
public ClassDefinition(MemberFlags flags, string name,
GenericSignature genericSignature,
AstNode bases, AstNode children, TokenPosition position)
: base(flags, name, genericSignature,
bases, children, position)
{
}
public SubscriptAccess(Expression array, Expression index, TokenPosition position)
: base(position)
{
this.array = array;
this.index = index;
this.indexCoercions = null;
}
public SwitchStatement(Expression constant, AstNode cases, TokenPosition position)
: base(position)
{
this.constant = constant;
this.cases = cases;
this.defaultCase = null;
this.caseDictionary = new Dictionary<ConstantValue, CaseLabel> ();
}
public FieldDefinition(MemberFlags flags, Expression typeNode,
FieldDeclaration declarations, TokenPosition position)
: base(position)
{
this.flags = flags;
this.typeNode = typeNode;
this.declarations = declarations;
}
public ForStatement(AstNode decls, Expression cond, AstNode incr, AstNode job,
TokenPosition position)
: base(job, position)
{
this.decls = decls;
this.cond = cond;
this.incr = incr;
}
public TernaryOperation(Expression cond, Expression left, Expression right,
TokenPosition position)
: base(position)
{
this.cond = cond;
this.left = left;
this.right = right;
}
public FunctionArgument(Expression typeExpression, bool @params, string name, TokenPosition position)
: base(position)
{
SetName(name);
this.typeExpression = typeExpression;
this.@params = @params;
this.variable = null;
}
public TryStatement(AstNode tryStatement, AstNode catchList,
AstNode finallyStatement, TokenPosition position)
: base(position)
{
this.tryStatement = tryStatement;
this.catchList = catchList;
this.finallyStatement = finallyStatement;
}
public AttributeInstance(Expression attributeExpr, AttributeArgument arguments,
TokenPosition position)
: base(position)
{
this.attributeExpr = attributeExpr;
this.arguments = arguments;
this.attributeClass = null;
}
public EnumDefinition(MemberFlags flags, string name, AstNode children,
Expression typeExpr, TokenPosition position)
: base(children, position)
{
SetName(name);
this.flags = flags;
this.typeExpr = typeExpr;
}
public NewExpression(Expression typeExpression, Expression arguments, TokenPosition position)
: base(position)
{
this.typeExpression = typeExpression;
this.arguments = arguments;
this.constructor = null;
this.objectType = null;
}
public FunctionPrototype(MemberFlags flags, Expression returnType,
FunctionArgument arguments, Expression nameExpression,
GenericSignature genericSignature,
TokenPosition position)
: this(flags, returnType, arguments, "", genericSignature, position)
{
this.nameExpression = nameExpression;
}
public ForEachStatement(Expression typeExpression, string name, Expression container,
AstNode children, TokenPosition position)
: base(children, position)
{
SetName(name);
this.typeExpression = typeExpression;
this.container = container;
}
public AttributeArgument(Expression value, string name, TokenPosition position)
: base(position)
{
SetName(name);
this.value = value;
this.property = null;
this.attributeClass = null;
}
public SyntaxToken(TokenPosition position)
{
Position = position;
}
public void SetPosition(TokenPosition position)
{
this.position = position;
}
public SizeOfExpression(Expression typeExpression, TokenPosition position)
: base(position)
{
this.typeExpression = typeExpression;
}
/// <summary>
/// Initializes a new token
/// </summary>
/// <param name="tokenType"></param>
/// <param name="text"></param>
/// <param name="position"></param>
public Token(TokenType tokenType, string text, TokenPosition position)
{
this.Type = tokenType;
this.Text = text;
this.Position = position;
}
public virtual void CheckAmbiguity(TokenPosition where)
{
// Do nothing.
}
public PrefixOperation(int op, Expression variable, TokenPosition position)
: base(position)
{
this.operation = op;
this.variable = variable;
}
public ArrayAccessNode(ISyntaxElement left, List <ISyntaxElement> arguments, TokenPosition position)
: base(position)
{
Left = left;
Arguments = arguments;
}
public ImportObjectMethod(string externalName, string importName, List <string> generics, List <string> arguments, TokenPosition position)
{
ExternalName = externalName;
ImportName = importName;
Generics = generics;
Arguments = arguments;
Position = position;
}
public ImportScriptNode(string dotNetType, string methodName, string internalName, List <string> arguments, TokenPosition position)
: base(position)
{
DotNetType = dotNetType;
MethodName = methodName;
ImportName = internalName;
Arguments = arguments;
}
public Expression(TokenPosition position)
: base(position)
{
this.hints = 0;
}
public T Evaluate <T>(string s, IParserContext context, TokenPosition tokenPosition)
{
return(ParseWithContext(s, context, tokenPosition).Evaluate <T>());
}
public object EvaluateToObject(string s, IParserContext context, TokenPosition tokenPosition)
{
return(ParseWithContext(s, context, tokenPosition).EvaluateToObject());
}
public IValueWithType Evaluate(string s, IParserContext context, TokenPosition tokenPosition)
{
return(ParseWithContext(s, context, tokenPosition).Evaluate());
}
public VariableToken(string name, TokenPosition position)
: base(position)
{
Name = name;
}
public PropertyDefinition(MemberFlags flags, Expression propertyType,
Expression nameExpr, AstNode indices, AstNode accessors, TokenPosition position)
: this(flags, propertyType, "", indices, accessors, position)
{
this.nameExpression = nameExpr;
}
public IExpressionWithContext ParseWithContext(string s, IParserContext context, TokenPosition position)
{
return(new ExpressionWithContext(Parse(s, position), context));
}
public ReturnNode(ISyntaxElement result, TokenPosition position)
: base(position)
{
Result = result;
}
public BinaryOperatorNode(TokenPosition position) : base(position)
{
}
public CastOperation(Expression target, Expression value, TokenPosition position)
: base(position)
{
this.target = target;
this.value = value;
}
public ObjectImportArgument(string name, string value, TokenPosition pos)
{
Name = name;
Value = value;
Position = pos;
}
public Token CreateInstance(string value, TokenPosition position)
{
return(new Token(value, TokenType, position));
}
public Statement(TokenPosition position)
: base(position)
{
}
public DefaultExpression(Expression typeExpression, TokenPosition position)
: base(position)
{
this.typeExpression = typeExpression;
}
public IntegerConstant(int value, TokenPosition position)
: base(position)
{
SetNodeType(ConstantType.Create(ChelaType.GetIntType()));
this.value = value;
}
public SwitchNode(ISyntaxElement value, List <SwitchCase> cases, ISyntaxElement defaultCase, int defaultIndex, TokenPosition position)
: base(position)
{
Value = value;
Cases = cases;
DefaultCase = defaultCase;
DefaultIndex = defaultIndex;
}
public Token(string value, TokenPosition position, TokenType type)
{
Position = position;
Value = value;
Type = type;
}
public ProcedureCallNode(TokenPosition position) : base(position)
{
}
public WhileStatement(Expression cond, AstNode job, TokenPosition position)
: base(position)
{
this.cond = cond;
this.job = job;
}
public IExpressionWithContext ParseWithContext(string s, TokenPosition position)
{
return(new ExpressionWithContext(Parse(s, position), _defaultContext));
}
/// <summary>
/// Initializes a new token
/// </summary>
/// <param name="tokenType"></param>
/// <param name="position"></param>
public Token(TokenType tokenType, TokenPosition position)
{
this.Type = tokenType;
this.Text = tokenType.Symbol;
this.Position = position;
}
