//adds to finish if node is a type that can be a finish dependency
//otherwise adds to execute dependencies
public void tryFinish(INode_Expression node)
{
if( node.typeName == "identifier" )
_finishDepends.UnionWith(Depends.depends(node));
else
_executeDepends.UnionWith(Depends.depends(node));
}
public Node_Argument(
Node_Identifier @parameterName,
INode_Expression @value,
string @nodeSource )
{
m_parameterName = @parameterName;
m_value = @value;
m_nodeSource = @nodeSource;
}
public Node_And(
INode_Expression @first,
INode_Expression @second,
string @nodeSource )
{
m_first = @first;
m_second = @second;
m_nodeSource = @nodeSource;
}
IScope _scope; //should have already been trimmed for closure
#endregion Fields
#region Constructors
public Function_Client(
IList<ParameterImpl> parameters, NType returnType,
INode_Expression body, IScope scope )
{
_parameters = parameters;
_returnType = returnType;
_body = body;
_scope = scope;
}
public static void reserveAny( INode_Expression node, IScope scope )
{
switch(node.typeName) {
//these nodes have scope
//xxx automate
case "conditional" :
case "function" :
case "object" :
case "try-catch" :
break;
//these nodes cannot contain declare-* children
//xxx automate
case "identifier" :
case "integer" :
case "string" :
case "rational" :
break;
//xxx these need to be moved into the below category
case "and" :
case "nand" :
case "or" :
case "nor" :
case "xor" :
case "xnor" :
break;
//can contain declare-* nodes, and don't have scope
case "assign" :
reserveAny( (node as Node_Assign).value, scope );
break;
case "call" :
reserve(node as Node_Call, scope);
break;
case "compound" :
reserve(node as Node_Compound, scope);
break;
case "declare-assign" :
reserve(node as Node_DeclareAssign, scope);
break;
case "declare-empty" :
reserve(node as Node_DeclareEmpty, scope);
break;
case "extract-member" :
reserveAny( (node as Node_ExtractMember).source, scope );
break;
case "set-property" :
reserveAny( (node as Node_SetProperty).source, scope );
reserveAny( (node as Node_SetProperty).value, scope );
break;
default :
throw new Exception(String.Format("unrecognized node type '{0}'", node.typeName));
}
}
public void add(
IScidentre ws, INode_Expression typeExpr, INode_Expression valueExpr, IScope scope )
{
Entry entry = new Entry(
ws,
typeExpr, valueExpr,
scope,
null, null,
State.EMPTY,
new HashSet<Entry>() );
_entries.Add(entry);
_entryLookup.Add(ws, entry);
}
Client_Generator(INode_Expression body, IScope scope)
{
_closure = GE.createClosure(Depends.depends(body), scope);
_thread = new Thread(new ThreadStart(delegate() {
try {
Executor.executeAny(body, _closure);
}
catch(ClientException e) {
_exception = e;
}
}));
_thread.IsBackground = true;
_yieldValues.Add(_thread, null);
}
public Node_Catcher(
INode_Expression @type,
Node_Identifier @name,
INode_Expression @test,
INode_Expression @result,
string @nodeSource )
{
m_type = @type;
m_name = @name;
m_test = @test;
m_result = @result;
m_nodeSource = @nodeSource;
}
public Node_Case(
IList<INode_Expression> @testValues,
INode_Expression @result,
string @nodeSource )
{
m_testValues = @testValues;
m_result = @result;
m_nodeSource = @nodeSource;
}
public Node_Caller(
INode_Expression @interface,
Node_Identifier @methodName,
string @nodeSource )
{
m_interface = @interface;
m_methodName = @methodName;
m_nodeSource = @nodeSource;
}
public Node_ParameterInfo(
Node_Direction @direction,
INode_Expression @type,
Node_Identifier @name,
Node_Boolean @hasDefaultValue,
string @nodeSource )
{
m_direction = @direction;
m_type = @type;
m_name = @name;
m_hasDefaultValue = @hasDefaultValue;
m_nodeSource = @nodeSource;
}
public static IType tryWrap( INode_Expression node, IScope scope )
{
//xxx
return new NType();
}
public Node_DeclareEmpty(
Node_Identifier @name,
INode_Expression @type,
string @nodeSource )
{
m_name = @name;
m_type = @type;
m_nodeSource = @nodeSource;
}
public Node_DeclareAssign(
Node_Identifier @name,
Node_Boolean @constant,
INode_Expression @type,
Node_Boolean @breed,
INode_Expression @value,
string @nodeSource )
{
m_name = @name;
m_constant = @constant;
m_type = @type;
m_breed = @breed;
m_value = @value;
m_nodeSource = @nodeSource;
}
public Node_TryCatch(
INode_Expression @try,
IList<Node_Catcher> @catchers,
INode_Expression @onSuccess,
INode_Expression @finally,
string @nodeSource )
{
m_try = @try;
m_catchers = @catchers;
m_onSuccess = @onSuccess;
m_finally = @finally;
m_nodeSource = @nodeSource;
}
public Node_SetProperty(
INode_Expression @source,
Node_Identifier @propertyName,
INode_Expression @value,
string @nodeSource )
{
m_source = @source;
m_propertyName = @propertyName;
m_value = @value;
m_nodeSource = @nodeSource;
}
public Node_Select(
INode_Expression @inputValue,
IList<Node_Case> @cases,
INode_Expression @else,
string @nodeSource )
{
m_inputValue = @inputValue;
m_cases = @cases;
m_else = @else;
m_nodeSource = @nodeSource;
}
public Node_Breeder(
INode_Expression @type,
string @nodeSource )
{
m_type = @type;
m_nodeSource = @nodeSource;
}
public Node_Raise(
INode_Expression @value,
string @nodeSource )
{
m_value = @value;
m_nodeSource = @nodeSource;
}
public Node_Property(
Node_Identifier @name,
Node_Boolean @writable,
INode_Expression @type,
string @nodeSource )
{
m_name = @name;
m_writable = @writable;
m_type = @type;
m_nodeSource = @nodeSource;
}
public Node_Method(
Node_Identifier @name,
INode_Expression @interface,
string @nodeSource )
{
m_name = @name;
m_interface = @interface;
m_nodeSource = @nodeSource;
}
public Node_Conditional(
INode_Expression @test,
INode_Expression @result,
INode_Expression @else,
string @nodeSource )
{
m_test = @test;
m_result = @result;
m_else = @else;
m_nodeSource = @nodeSource;
}
public Node_Curry(
INode_Expression @function,
IList<Node_Argument> @arguments,
Node_Boolean @call,
string @nodeSource )
{
m_function = @function;
m_arguments = @arguments;
m_call = @call;
m_nodeSource = @nodeSource;
}
public Node_MemberImplementation(
Node_MemberType @memberType,
Node_Identifier @name,
INode_Expression @interface,
INode_Expression @function,
string @nodeSource )
{
m_memberType = @memberType;
m_name = @name;
m_interface = @interface;
m_function = @function;
m_nodeSource = @nodeSource;
}
public Node_Worker(
INode_Expression @face,
IList<Node_Worker> @childWorkers,
IList<Node_MemberImplementation> @memberImplementations,
string @nodeSource )
{
m_face = @face;
m_childWorkers = @childWorkers;
m_memberImplementations = @memberImplementations;
m_nodeSource = @nodeSource;
}
public Node_Call(
INode_Expression @receiver,
IList<Node_Argument> @arguments,
string @nodeSource )
{
m_receiver = @receiver;
m_arguments = @arguments;
m_nodeSource = @nodeSource;
}
public Node_DeclareFirst(
Node_Identifier @name,
Node_Boolean @overload,
INode_Expression @type,
Node_Boolean @breed,
INode_Expression @value,
string @nodeSource )
{
m_name = @name;
m_overload = @overload;
m_type = @type;
m_breed = @breed;
m_value = @value;
m_nodeSource = @nodeSource;
}
public Node_Callee(
IList<Node_ParameterInfo> @parameterInfos,
INode_Expression @returnType,
string @nodeSource )
{
m_parameterInfos = @parameterInfos;
m_returnType = @returnType;
m_nodeSource = @nodeSource;
}
public Node_TypeSelect(
INode_Expression @inputValue,
Node_Identifier @castedName,
Node_Boolean @requireMatch,
IList<Node_TypeCase> @typeCases,
INode_Expression @else,
string @nodeSource )
{
m_inputValue = @inputValue;
m_castedName = @castedName;
m_requireMatch = @requireMatch;
m_typeCases = @typeCases;
m_else = @else;
m_nodeSource = @nodeSource;
}
public Node_Breed(
INode_Expression @parent,
INode_Expression @interface,
string @nodeSource )
{
m_parent = @parent;
m_interface = @interface;
m_nodeSource = @nodeSource;
}
