static void GenerateEndMethodImpl(CodeClass c, MethodInfo endProcessMethod, string name, MethodInfo mi)
{
CodeMethod m = c.ImplementMethod(mi);
CodeBuilder b = m.CodeBuilder;
ParameterInfo [] pinfos = mi.GetParameters();
ParameterInfo p = pinfos [0];
CodeArgumentReference asyncResultRef = m.GetArg(0);
CodeVariableDeclaration paramsDecl = new CodeVariableDeclaration(typeof(object []), "parameters");
b.CurrentBlock.Add(paramsDecl);
CodeVariableReference paramsRef = paramsDecl.Variable;
b.Assign(paramsRef,
new CodeNewArray(typeof(object), new CodeLiteral(pinfos.Length - 1)));
/*
* for (int i = 0; i < pinfos.Length - 2; i++) {
* ParameterInfo par = pinfos [i];
* if (!par.IsOut)
* b.Assign (
* new CodeArrayItem (paramsRef, new CodeLiteral (i)),
* new CodeCast (typeof (object),
* new CodeArgumentReference (par.ParameterType, par.Position + 1, "arg" + i)));
* }
*/
#if USE_OD_REFERENCE_IN_PROXY
CodePropertyReference argMethodInfo = GetOperationMethod(m, b, name, "EndMethod");
#else
CodeMethodCall argMethodInfo = new CodeMethodCall(typeof(MethodBase), "GetCurrentMethod");
#endif
CodeLiteral argOperName = new CodeLiteral(name);
CodeVariableReference retValue = null;
if (mi.ReturnType == typeof(void))
{
b.Call(m.GetThis(), endProcessMethod, argMethodInfo, argOperName, paramsRef, asyncResultRef);
}
else
{
CodeVariableDeclaration retValueDecl = new CodeVariableDeclaration(mi.ReturnType, "retValue");
b.CurrentBlock.Add(retValueDecl);
retValue = retValueDecl.Variable;
b.Assign(retValue,
new CodeCast(mi.ReturnType,
b.CallFunc(m.GetThis(), endProcessMethod, argMethodInfo, argOperName, paramsRef, asyncResultRef)));
}
// FIXME: fill out parameters
if (retValue != null)
{
b.Return(retValue);
}
}
static void GenerateBeginMethodImpl(CodeClass c, MethodInfo beginProcessMethod, string name, MethodInfo mi)
{
CodeMethod m = c.ImplementMethod(mi);
CodeBuilder b = m.CodeBuilder;
// object [] parameters = new object [x];
// parameters [0] = arg1;
// parameters [1] = arg2;
// ...
// (return) BeginProcess (Contract.Operations [operName].BeginMethod, operName, parameters, asyncCallback, userState);
ParameterInfo [] pinfos = mi.GetParameters();
CodeVariableDeclaration paramsDecl = new CodeVariableDeclaration(typeof(object []), "parameters");
b.CurrentBlock.Add(paramsDecl);
CodeVariableReference paramsRef = paramsDecl.Variable;
b.Assign(paramsRef,
new CodeNewArray(typeof(object), new CodeLiteral(pinfos.Length - 2)));
for (int i = 0; i < pinfos.Length - 2; i++)
{
ParameterInfo par = pinfos [i];
if (!par.IsOut)
{
b.Assign(
new CodeArrayItem(paramsRef, new CodeLiteral(i)),
new CodeCast(typeof(object), m.GetArg(i)));
}
}
#if USE_OD_REFERENCE_IN_PROXY
CodePropertyReference argMethodInfo = GetOperationMethod(m, b, name, "BeginMethod");
#else
CodeMethodCall argMethodInfo = new CodeMethodCall(typeof(MethodBase), "GetCurrentMethod");
#endif
CodeLiteral argOperName = new CodeLiteral(name);
ParameterInfo p = pinfos [pinfos.Length - 2];
CodeArgumentReference callbackRef = new CodeArgumentReference(typeof(AsyncCallback), p.Position + 1, p.Name);
p = pinfos [pinfos.Length - 1];
CodeArgumentReference stateRef = new CodeArgumentReference(typeof(object), p.Position + 1, p.Name);
CodeVariableDeclaration retValueDecl = new CodeVariableDeclaration(mi.ReturnType, "retValue");
b.CurrentBlock.Add(retValueDecl);
CodeVariableReference retValue = retValueDecl.Variable;
b.Assign(retValue,
new CodeCast(mi.ReturnType,
b.CallFunc(m.GetThis(), beginProcessMethod, argMethodInfo, argOperName, paramsRef, callbackRef, stateRef)));
b.Return(retValue);
}
public override Verb CreateVerb(string[] tokens)
{
var variable = tokens[2];
Color(position, tokens[1].Length, KeyWords);
Color(variable.Length, Variables);
Color(tokens[3].Length, Structures);
var index = NextPosition;
if (GetExpression(source, index, LoopWhile()).If(out var initialization, out index))
{
var builder = new CodeBuilder();
builder.AssignToNewField(false, variable, initialization);
var block = builder.Block;
block.Expression = false;
initialization = block;
if (parser.Scan(source, index, "^ /(' '*) /('while' | 'until') /b"))
{
var direction = parser.Tokens[2];
var isWhile = direction == "while";
parser.Colorize(Whitespaces, KeyWords);
index = parser.Position;
if (GetExpression(source, index, LoopThen()).If(out var condition, out index))
{
condition.Expression = false;
if (GetExpression(source, index, LoopEnd()).If(out var increment, out index))
{
increment.Expression = false;
builder.Clear();
builder.Variable(variable);
builder.Assign();
builder.Inline(increment);
increment = builder.Block;
if (GetOneOrMultipleBlock(source, index).If(out var body, out index))
{
overridePosition = index;
return(new Loop(initialization, isWhile, condition, increment, body)
{
Index = position
});
}
}
}
}
}
return(null);
}
protected virtual Lambda createPartial(List <ParameterValue> values)
{
var builder = new CodeBuilder();
foreach (var parameterValue in values)
{
var parameterName = parameterValue.Name;
if (parameterValue.Value.Type == ValueType.Any)
{
builder.Parameter(parameterName);
builder.VariableAsArgument(parameterName);
}
else
{
builder.Define(parameterName);
builder.Assign();
builder.Value(parameterValue.Value);
builder.End();
}
}
builder.Inline(block);
return(builder.Lambda());
}
public static Block ConvertBlocks(Parameters parameters, Block finalValue, Block checkExpresion, Block invariant,
Block increment, Array test = null)
{
var builder = new CodeBuilder();
builder.Define(VAR_ACCUM);
builder.Assign();
builder.Parenthesize(finalValue);
builder.End();
builder.Push();
builder.Push();
builder.Exit();
var ifThen = builder.Pop();
builder.If(checkExpresion, ifThen);
builder.Variable(VAR_ACCUM);
builder.Assign();
builder.Parenthesize(invariant);
builder.End();
var setup = true;
var parameterIndex = 0;
foreach (var verb in increment)
{
if (setup)
{
var length = parameters.VariableNames.Length;
Assert(parameterIndex < length, LOCATION, "No more parameters");
builder.Define(VAR_MANGLE + parameters[parameterIndex++].Name);
builder.Assign();
setup = false;
}
if (verb is AppendToArray)
{
builder.End();
setup = true;
}
else
{
builder.Verb(verb);
}
}
builder.End();
foreach (var variableName in parameters.VariableNames)
{
builder.Variable(variableName);
builder.Assign();
builder.Variable(VAR_MANGLE + variableName);
builder.End();
}
var actions = builder.Pop();
builder.Push();
if (test == null)
{
builder.Value(true);
}
else
{
builder.Variable(parameters[0].Name);
builder.Verb(new When());
builder.Value(test);
}
var whileCondition = builder.Pop();
builder.While(whileCondition, actions);
builder.End();
builder.Return();
if (finalValue.Count == 1)
{
if (NameFromVariable(finalValue[0]).IsSome)
{
builder.Parenthesize(finalValue);
}
else
{
builder.Variable(VAR_ACCUM);
}
}
else
{
builder.Variable(VAR_ACCUM);
}
builder.End();
return(builder.Block);
}
static void addEnumerationSupport(string className)
{
var staticCode = new CodeBuilder();
var builder = new CodeBuilder();
builder.Push();
builder.Verb(new PushArrayLiteral(new Array()));
var expression = builder.Pop(true);
builder.AssignToNewField(true, "valueToName", expression);
builder.Push();
builder.Verb(new PushArrayLiteral(new Array()));
expression = builder.Pop(true);
builder.AssignToNewField(true, "nameToValue", expression);
//builder.Setter("valueToName", SetterName("default"), new NotMatched<Verb>(), new Failure("No such value").Pushed);
/* builder.Define("valueToName", Protected);
* builder.Assign();
* builder.Verb(new PushArrayLiteral(new Array()));
* builder.End();
* builder.Variable("valueToName");
* builder.SendMessage("default");
* builder.Assign();
* builder.Error("No such value");
* builder.End();
*
* builder.Define("nameToValue", Protected);
* builder.Assign();
* builder.Verb(new PushArrayLiteral(new Array()));
* builder.End();
* builder.Variable("nameToValue");
* builder.SendMessage("default");
* builder.Assign();
* builder.Error("No such name");
* builder.End();*/
staticCode.Inline(builder);
var arguments = new CodeBuilder();
builder = new CodeBuilder();
builder.Parameter("value");
builder.Define("name");
builder.Assign();
builder.Variable("valueToName");
builder.Indexer("value");
builder.End();
builder.Return();
builder.Variable(className);
arguments.VariableAsArgument("value");
arguments.VariableAsArgument("name");
builder.Invoke(arguments.Arguments);
builder.End();
staticCode.Function("fromValue", builder);
arguments = new CodeBuilder();
builder = new CodeBuilder();
builder.Parameter("name");
builder.Define("value");
builder.Assign();
builder.Variable("nameToValue");
builder.Indexer("name");
builder.End();
builder.Return();
builder.Variable(className);
arguments.VariableAsArgument("value");
arguments.VariableAsArgument("name");
builder.Invoke(arguments.Arguments);
builder.End();
staticCode.Function("fromName", builder);
builder = new CodeBuilder();
builder.Return();
builder.Variable("valueToName");
builder.End();
staticCode.Function("names", builder);
AddStaticBlock(staticCode.Block);
}
static void GenerateMethodImpl(CodeClass c, MethodInfo processMethod, string name, MethodInfo mi)
{
CodeMethod m = c.ImplementMethod(mi);
CodeBuilder b = m.CodeBuilder;
// object [] parameters = new object [x];
// parameters [0] = arg1;
// parameters [1] = arg2;
// ...
// (return) Process (Contract.Operations [operName].SyncMethod, operName, parameters);
ParameterInfo [] pinfos = mi.GetParameters();
CodeVariableDeclaration paramsDecl = new CodeVariableDeclaration(typeof(object []), "parameters");
b.CurrentBlock.Add(paramsDecl);
CodeVariableReference paramsRef = paramsDecl.Variable;
b.Assign(paramsRef,
new CodeNewArray(typeof(object), new CodeLiteral(pinfos.Length)));
for (int i = 0; i < pinfos.Length; i++)
{
ParameterInfo par = pinfos [i];
if (!par.IsOut)
{
b.Assign(
new CodeArrayItem(paramsRef, new CodeLiteral(i)),
new CodeCast(typeof(object),
new CodeArgumentReference(par.ParameterType, par.Position + 1, "arg" + i)));
}
}
#if USE_OD_REFERENCE_IN_PROXY
CodePropertyReference argMethodInfo = GetOperationMethod(m, b, name, "SyncMethod");
#else
CodeMethodCall argMethodInfo = new CodeMethodCall(typeof(MethodBase), "GetCurrentMethod");
#endif
CodeLiteral argOperName = new CodeLiteral(name);
CodeVariableReference retValue = null;
if (mi.ReturnType == typeof(void))
{
b.Call(m.GetThis(), processMethod, argMethodInfo, argOperName, paramsRef);
}
else
{
CodeVariableDeclaration retValueDecl = new CodeVariableDeclaration(mi.ReturnType, "retValue");
b.CurrentBlock.Add(retValueDecl);
retValue = retValueDecl.Variable;
b.Assign(retValue,
new CodeCast(mi.ReturnType,
b.CallFunc(m.GetThis(), processMethod, argMethodInfo, argOperName, paramsRef)));
}
for (int i = 0; i < pinfos.Length; i++)
{
ParameterInfo par = pinfos [i];
if (par.IsOut || par.ParameterType.IsByRef)
{
b.Assign(
new CodeArgumentReference(par.ParameterType, par.Position + 1, "arg" + i),
new CodeCast(par.ParameterType.GetElementType(),
new CodeArrayItem(paramsRef, new CodeLiteral(i))));
}
}
if (retValue != null)
{
b.Return(retValue);
}
}
protected static void addEnumerationSupport(string className)
{
var staticCode = new CodeBuilder();
var builder = new CodeBuilder();
builder.Push();
builder.Verb(new PushArrayLiteral(new Array()));
var expression = builder.Pop(true);
builder.AssignToNewField(true, "valueToName", expression);
builder.Push();
builder.Verb(new PushArrayLiteral(new Array()));
expression = builder.Pop(true);
builder.AssignToNewField(true, "nameToValue", expression);
staticCode.Inline(builder);
var arguments = new CodeBuilder();
builder = new CodeBuilder();
builder.Parameter("value");
builder.Define("name");
builder.Assign();
builder.Variable("valueToName");
builder.Indexer("value");
builder.End();
builder.Return();
builder.Variable(className);
arguments.VariableAsArgument("value");
arguments.VariableAsArgument("name");
builder.Invoke(arguments.Arguments);
builder.End();
staticCode.Function("fromValue", builder);
arguments = new CodeBuilder();
builder = new CodeBuilder();
builder.Parameter("name");
builder.Define("value");
builder.Assign();
builder.Variable("nameToValue");
builder.Indexer("name");
builder.End();
builder.Return();
builder.Variable(className);
arguments.VariableAsArgument("value");
arguments.VariableAsArgument("name");
builder.Invoke(arguments.Arguments);
builder.End();
staticCode.Function("fromName", builder);
builder = new CodeBuilder();
builder.Return();
builder.Variable("valueToName");
builder.End();
staticCode.Function("names", builder);
AddStaticBlock(staticCode.Block);
}
void modifyBlocks()
{
/* var builder = new CodeBuilder();
* var finalBuilder = new CodeBuilder();
* initialize(builder);
* initialize(finalBuilder);
* var count = block.Count;
* var foundArguments = false;
* foreach (var verb in block)
* {
* Invoke invoke;
* if (!verb.IsA(out invoke))
* continue;
*
* builder.Parenthesize(trimArgumentBlock(invoke.Arguments.ArgumentsBlock));
* finalBuilder.Parenthesize(finalValue);
* foundArguments = true;
* break;
* }
* Runtime.Assert(foundArguments, LOCATION, "Couldn't determine function call");
* builder.End();
* finalBuilder.End();
* var i = 0;
* while (i < count)
* {
* var verb = block[i];
* Push push;
* if (verb.IsA(out push))
* {
* var value = push.Value;
* Variable variable;
* if (value.IsA(out variable))
* {
* var name = variable.Name;
* if (name == variableName)
* {
* addAccumulator(builder);
* addAccumulator(finalBuilder);
* i++;
* continue;
* }
* if (i + 1 < count && block[i + 1] is Invoke)
* {
* addAccumulator(builder);
* addAccumulator(finalBuilder);
* i += 2;
* continue;
* }
* }
* }
* addVerb(builder, verb);
* addVerb(finalBuilder, verb);
* i++;
* }
* addComma(builder);
* addComma(finalBuilder);
* addValue(builder);
* addValue(finalBuilder);
* modBlock = builder.Block;
* modFinalValue = finalBuilder.Block;*/
var builder = new CodeBuilder();
builder.Define(VAR_ACCUMULATOR);
builder.Assign();
builder.Parenthesize(finalValue);
builder.End();
var actions = new CodeBuilder();
actions.Variable(VAR_ACCUMULATOR);
actions.Assign();
var foundArguments = false;
foreach (var verb in block)
{
Invoke invoke;
if (!verb.IsA(out invoke))
{
continue;
}
builder.Parenthesize(trimArgumentBlock(invoke.Arguments.ArgumentsBlock));
finalBuilder.Parenthesize(finalValue);
foundArguments = true;
break;
}
Runtime.Assert(foundArguments, LOCATION, "Couldn't determine function call");
}
static void initialize(CodeBuilder builder)
{
builder.Define(VAR_VALUE);
builder.Assign();
}