public VarNode(SourcePosition position, IdentNode name, ExpressionNode defaultValue, bool exported, bool final) : base(position)
{
Name = name;
DefaultValue = defaultValue;
Exported = exported;
Final = final;
}
public TryCatchNode(SourcePosition position, StatementNode @try, StatementNode @catch, IdentNode error) : base(position)
{
Try = @try;
Catch = @catch;
Error = error;
ID = currentID++;
}
public RepeatNode(IdentNode iterator, ExpressionNode start, ExpressionNode end, StatementNode statement)
{
this.iterator = iterator;
this.start = start;
this.end = end;
this.statement = statement;
}
public void ProcessConstant(SqlNode constant, bool resolveIdent)
{
// If the constant is an IDENT, figure out what it means...
bool isIdent = (constant.Type == HqlSqlWalker.IDENT || constant.Type == HqlSqlWalker.WEIRD_IDENT);
if (resolveIdent && isIdent && IsAlias(constant.Text))
{
// IDENT is a class alias in the FROM.
IdentNode ident = (IdentNode)constant;
// Resolve to an identity column.
ident.Resolve(false, true);
}
else
{
// IDENT might be the name of a class.
IQueryable queryable = _walker.SessionFactoryHelper.FindQueryableUsingImports(constant.Text);
if (isIdent && queryable != null)
{
constant.Text = queryable.DiscriminatorSQLValue;
}
// Otherwise, it's a literal.
else
{
ProcessLiteral(constant);
}
}
}
public ProcNode(SourcePosition position, IdentNode name, bool exported) : base(position)
{
Name = name;
Exported = exported;
Parameters = new List <ParameterNode>();
Statements = new List <StatementNode>();
}
public ForKeyValueIteratorNode(SourcePosition position, IdentNode key, IdentNode value, ExpressionNode from, StatementNode code) : base(position)
{
Key = key;
Value = value;
From = from;
Code = code;
}
private IdentNode parseIdent()
{
expect(TokenType.IDENT);
var ident = new IdentNode(current().Data);
next();
return(ident);
}
private IdentNode ParseIdent()
{
Expect(TokenType.IDENT);
var ident = new IdentNode(Position(), Current().Text);
Next();
return(ident);
}
public ForRangeNode(SourcePosition position, IdentNode iterator, ExpressionNode start, ExpressionNode end, ExpressionNode by, StatementNode code) : base(position)
{
Iterator = iterator;
Start = start;
End = end;
Code = code;
By = by;
}
public OptionNode(IdentNode key, ExpressionNode @case, ExpressionNode caseDecision,
ExpressionNode defaultDecision)
{
Key = key;
Case = @case;
CaseDecision = caseDecision;
DefaultDecision = defaultDecision;
ID = currentID++;
}
private void generateIdent(ILGenerator il, IdentNode node, Dictionary <string, LocalBuilder> locals)
{
if (locals.ContainsKey(node.Ident))
{
il.Emit(OpCodes.Ldloc, locals[node.Ident]);
}
else
{
il.Emit(OpCodes.Ldarg_2);
}
}
public void Visit(IdentNode node)
{
SymbolTableEntry info;
if (symbolTable.TryLookup(node.Name, out info))
{
info.EmitLookup(il);
}
else
{
OnCodeGenError(new SemanticErrorEventArgs(String.Format("`{0}` is not in scope", node.Name)));
}
}
public void VisitIdent(IdentNode node)
{
UpdateLine(node);
if (asm.IsLocal(node.Value))
{
asm.GetLocal(node.Value);
}
else if (asm.IsUpValue(node.Value))
{
GetUpValue(node.Value);
}
else
{
asm.GetGlobal(node.Value);
}
}
IASTNode GenerateSyntheticDotNodeForNonQualifiedPropertyRef(IASTNode property, FromElement fromElement)
{
IASTNode dot = (IASTNode)adaptor.Create(DOT, "{non-qualified-property-ref}");
// TODO : better way?!?
((DotNode)dot).PropertyPath = ((FromReferenceNode)property).Path;
IdentNode syntheticAlias = (IdentNode)adaptor.Create(IDENT, "{synthetic-alias}");
syntheticAlias.FromElement = fromElement;
syntheticAlias.IsResolved = true;
dot.SetFirstChild(syntheticAlias);
dot.AddChild(property);
return(dot);
}
public void VisitId(IdentNode n)
{
idOrNum = new IdentificatorValue(n.Name);
}
public void VisitIdent(IdentNode node)
{
writeLine(node.Ident);
}
public ForIteratorNode(SourcePosition position, IdentNode iterator, ExpressionNode from, StatementNode code) : base(position)
{
Iterator = iterator;
From = from;
Code = code;
}
public abstract void VisitIdent(IdentNode node);
public VarNode(IdentNode name, ExpressionNode defaultValue)
{
this.name = name;
this.defaultValue = defaultValue;
}
public IdentNodeTests()
{
subject = new IdentNode(new SourcePosition(2, 4), "foo");
}
public void VisitIdent(IdentNode node)
{
VisitIdentHandler(node);
}
public DesignationNode makeDesignationNode(DesignationNode node, IdentNode ident)
{
return(null);
}
public override void VisitIdent(IdentNode node)
{
}
public EnumDeclNode getEnumDecl(IdentNode idNode)
{
return(null);
}
//- enums -------------------------------------------------------------
public EnumDeclNode startEnumSpec(IdentNode idNode, EnumeratorNode enumer)
{
return(null);
}
public AssignNode(IdentNode name, ExpressionNode value)
{
this.name = name;
this.value = value;
}
//- struct/unions -----------------------------------------------------
//public Declaration makeTypeDeclNode(DeclSpecNode declspecs)
//{
// TypeDeclNode typdef = declspecs.baseType;
// Declaration decl = new Declaration();
// decl.decls.Add(typdef);
// return decl;
//}
public StructDeclNode starttructSpec(StructDeclNode node, IdentNode idNode, StructDeclarationNode field, bool isUnion)
{
return(null);
}
public DefNode(IdentNode name)
{
this.name = name;
parameters = new List <IdentNode>();
code = new List <StatementNode>();
}
public StructDeclNode getStructDecl(IdentNode idNode, bool isUnion)
{
return(null);
}
public EnumDeclNode(IdentNode idNode)
: base("enum")
{
// TODO: Complete member initialization
this.idNode = idNode;
}