public void BuildReturnParameters(ProcedureInvocation invocation, SequenceVariable[] ReturnVars, InheritanceType ownerType, out String returnParameterDeclarations, out String returnArguments, out String returnAssignments)
{
// can't use the normal xgrs variables for return value receiving as the type of an out-parameter must be invariant
// this is bullshit, as it is perfectly safe to assign a subtype to a variable of a supertype
// so we create temporary variables of exact type, which are used to receive the return values,
// and finally we assign these temporary variables to the real xgrs variables
returnParameterDeclarations = "";
returnArguments = "";
returnAssignments = "";
for (int i = 0; i < ownerType.GetProcedureMethod(invocation.Name).Outputs.Length; ++i)
{
String varName;
if (ReturnVars.Length != 0)
{
varName = GetUniqueId() + ReturnVars[i].PureName;
}
else
{
varName = GetUniqueId();
}
String typeName = TypesHelper.DotNetTypeToXgrsType(ownerType.GetProcedureMethod(invocation.Name).Outputs[i]);
String tmpvarName = "tmpvar_" + varName;
returnParameterDeclarations += TypesHelper.XgrsTypeToCSharpType(typeName, model) + " " + tmpvarName + "; ";
returnArguments += ", out " + tmpvarName;
if (ReturnVars.Length != 0)
{
returnAssignments += SetVar(ReturnVars[i], tmpvarName);
}
}
}
public void BuildOutParameters(SequenceInvocation invocation, SequenceVariable[] ReturnVars, out String outParameterDeclarations, out String outArguments, out String outAssignments)
{
outParameterDeclarations = "";
outArguments = "";
outAssignments = "";
for (int i = 0; i < actionsTypeInformation.sequencesToOutputTypes[invocation.PackagePrefixedName].Count; ++i)
{
String varName;
if (ReturnVars.Length != 0)
{
varName = GetUniqueId() + ReturnVars[i].PureName;
}
else
{
varName = GetUniqueId();
}
String typeName = actionsTypeInformation.sequencesToOutputTypes[invocation.PackagePrefixedName][i];
outParameterDeclarations += TypesHelper.XgrsTypeToCSharpType(typeName, model) + " tmpvar_" + varName
+ " = " + TypesHelper.DefaultValueString(typeName, model) + ";";
outArguments += ", ref tmpvar_" + varName;
if (ReturnVars.Length != 0)
{
outAssignments += SetVar(ReturnVars[i], "tmpvar_" + varName);
}
}
}
public String BuildParameters(Invocation invocation, SequenceExpression[] ArgumentExpressions, SourceBuilder source)
{
String parameters = "";
for (int i = 0; i < ArgumentExpressions.Length; i++)
{
String typeName;
if (actionsTypeInformation.rulesToInputTypes.ContainsKey(invocation.PackagePrefixedName))
{
typeName = actionsTypeInformation.rulesToInputTypes[invocation.PackagePrefixedName][i];
}
else if (actionsTypeInformation.sequencesToInputTypes.ContainsKey(invocation.PackagePrefixedName))
{
typeName = actionsTypeInformation.sequencesToInputTypes[invocation.PackagePrefixedName][i];
}
else if (actionsTypeInformation.proceduresToInputTypes.ContainsKey(invocation.PackagePrefixedName))
{
typeName = actionsTypeInformation.proceduresToInputTypes[invocation.PackagePrefixedName][i];
}
else
{
typeName = actionsTypeInformation.functionsToInputTypes[invocation.PackagePrefixedName][i];
}
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
parameters += ", " + cast + exprGen.GetSequenceExpression(ArgumentExpressions[i], source);
}
return(parameters);
}
/// <summary>
/// Returns string containing a C# assignment to set the sequence-local variable / graph-global variable given
/// to the value as computed by the C# expression in the string given
/// </summary>
public string SetVar(SequenceVariable seqVar, String valueToWrite)
{
if (seqVar.Type == "")
{
return("procEnv.SetVariableValue(\"" + seqVar.PureName + "\", " + valueToWrite + ");\n");
}
else
{
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(seqVar.Type, model) + ")";
return("var_" + seqVar.Prefix + seqVar.PureName + " = " + cast + "(" + valueToWrite + ");\n");
}
}
public String BuildParameters(Invocation invocation, SequenceExpression[] ArgumentExpressions, IProcedureDefinition procedureMethod, SourceBuilder source)
{
String parameters = "";
for (int i = 0; i < ArgumentExpressions.Length; i++)
{
String typeName = TypesHelper.DotNetTypeToXgrsType(procedureMethod.Inputs[i]);
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
parameters += ", " + cast + exprGen.GetSequenceExpression(ArgumentExpressions[i], source);
}
return(parameters);
}
private void GenerateGenericExternalDefinedSequenceApplicationMethod(SourceBuilder source, DefinedSequenceInfo sequence)
{
source.AppendFront("public override bool Apply(GRGEN_LIBGR.IGraphProcessingEnvironment procEnv, object[] arguments, out object[] returnValues)");
source.AppendFront("{\n");
source.Indent();
source.AppendFront("GRGEN_LGSP.LGSPGraph graph = ((GRGEN_LGSP.LGSPActionExecutionEnvironment)procEnv).graph;\n");
for (int i = 0; i < sequence.Parameters.Length; ++i)
{
string typeName = TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.ParameterTypes[i]), model);
source.AppendFront(typeName + " var_" + sequence.Parameters[i]);
source.Append(" = (" + typeName + ")arguments[" + i + "];\n");
}
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
string typeName = TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.OutParameterTypes[i]), model);
source.AppendFront(typeName + " var_" + sequence.OutParameters[i]);
source.Append(" = " + TypesHelper.DefaultValueString(typeName, model) + ";\n");
}
source.AppendFront("bool result = ApplyXGRS_" + sequence.Name + "((GRGEN_LGSP.LGSPGraphProcessingEnvironment)procEnv");
for (int i = 0; i < sequence.Parameters.Length; ++i)
{
source.Append(", var_" + sequence.Parameters[i]);
}
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.Append(", ref var_" + sequence.OutParameters[i]);
}
source.Append(");\n");
source.AppendFront("returnValues = ReturnValues;\n");
if (sequence.OutParameters.Length > 0)
{
source.AppendFront("if(result) {\n");
source.Indent();
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.AppendFront("returnValues[" + i + "] = var_" + sequence.OutParameters[i] + ";\n");
}
source.Unindent();
source.AppendFront("}\n");
}
source.AppendFront("return result;\n");
source.Unindent();
source.AppendFront("}\n");
}
private void GenerateExactExternalDefinedSequenceApplicationMethod(SourceBuilder source, DefinedSequenceInfo sequence)
{
source.AppendFront("public static bool Apply_" + sequence.Name + "(GRGEN_LIBGR.IGraphProcessingEnvironment procEnv");
for (int i = 0; i < sequence.Parameters.Length; ++i)
{
source.Append(", " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.ParameterTypes[i]), model) + " var_");
source.Append(sequence.Parameters[i]);
}
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.Append(", ref " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.OutParameterTypes[i]), model) + " var_");
source.Append(sequence.OutParameters[i]);
}
source.Append(")\n");
source.AppendFront("{\n");
source.Indent();
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
string typeName = TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.OutParameterTypes[i]), model);
source.AppendFront(typeName + " vari_" + sequence.OutParameters[i]);
source.Append(" = " + TypesHelper.DefaultValueString(typeName, model) + ";\n");
}
source.AppendFront("bool result = ApplyXGRS_" + sequence.Name + "((GRGEN_LGSP.LGSPGraphProcessingEnvironment)procEnv");
for (int i = 0; i < sequence.Parameters.Length; ++i)
{
source.Append(", var_" + sequence.Parameters[i]);
}
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.Append(", ref var_" + sequence.OutParameters[i]);
}
source.Append(");\n");
if (sequence.OutParameters.Length > 0)
{
source.AppendFront("if(result) {\n");
source.Indent();
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.AppendFront("var_" + sequence.OutParameters[i]);
source.Append(" = vari_" + sequence.OutParameters[i] + ";\n");
}
source.Unindent();
source.AppendFront("}\n");
}
source.AppendFront("return result;\n");
source.Unindent();
source.AppendFront("}\n");
}
private void GenerateInternalDefinedSequenceApplicationMethodStub(SourceBuilder source, DefinedSequenceInfo sequence, String externalActionsExtensionFilename)
{
source.AppendFrontFormat("// You must implement the following function in the same partial class in ./{0}\n", externalActionsExtensionFilename);
source.AppendFront("//public static bool ApplyXGRS_" + sequence.Name + "(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv");
for (int i = 0; i < sequence.Parameters.Length; ++i)
{
source.Append(", " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.ParameterTypes[i]), model) + " var_");
source.Append(sequence.Parameters[i]);
}
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.Append(", ref " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.OutParameterTypes[i]), model) + " var_");
source.Append(sequence.OutParameters[i]);
}
source.Append(")\n");
}
/// <summary>
/// Returns string containing a C# declaration of the variable given
/// </summary>
public string DeclareVar(SequenceVariable seqVar)
{
if (seqVar.Type != "")
{
StringBuilder sb = new StringBuilder();
sb.Append(TypesHelper.XgrsTypeToCSharpType(seqVar.Type, model));
sb.Append(" ");
sb.Append("var_" + seqVar.Prefix + seqVar.PureName);
sb.Append(" = ");
sb.Append(TypesHelper.DefaultValueString(seqVar.Type, model));
sb.Append(";\n");
return(sb.ToString());
}
else
{
return("");
}
}
private static void GenerateInternalObjectTypeAttributeInitializer(SequenceCheckingEnvironment env, IGraphModel model, SequenceExpressionNew attributeInitializer, SourceBuilder source)
{
if (attributeInitializer.AttributeInitializationList == null)
{
return; // plain constructor without attribute initialization list
}
string internalObjectType = "GRGEN_MODEL." + attributeInitializer.ConstructedType;
source.Append("\n");
source.AppendFront("public static ");
source.Append(internalObjectType);
source.Append(" fillFromSequence_" + attributeInitializer.Id + "(");
BaseObjectType objectType = env.Model.ObjectModel.GetType(attributeInitializer.ConstructedType);
if (objectType != null)
{
source.Append("long uniqueId");
}
for (int i = 0; i < attributeInitializer.AttributeInitializationList.Count; ++i)
{
KeyValuePair <string, SequenceExpression> attributeInitialization = attributeInitializer.AttributeInitializationList[i];
if (i > 0 || objectType != null)
{
source.Append(", ");
}
string valueType = TypesHelper.XgrsTypeToCSharpType(env.TypeOfMemberOrAttribute(attributeInitializer.ConstructedType, attributeInitialization.Key), model);
source.AppendFormat("{0} {1}", valueType, "param" + i);
}
source.Append(")\n");
source.AppendFront("{\n");
source.Indent();
source.AppendFrontFormat("{0} obj = new {0}({1});\n", internalObjectType, objectType != null ? "uniqueId" : "");
for (int i = 0; i < attributeInitializer.AttributeInitializationList.Count; ++i)
{
KeyValuePair <string, SequenceExpression> attributeInitialization = attributeInitializer.AttributeInitializationList[i];
source.AppendFrontFormat("obj.{0} = {1};\n", attributeInitialization.Key, "param" + i);
}
source.AppendFront("return obj;\n");
source.Unindent();
source.AppendFront("}\n");
}
public String BuildParameters(Invocation invocation, SequenceExpression[] ArgumentExpressions, IFunctionDefinition functionMethod, SourceBuilder source)
{
String parameters = "";
for (int i = 0; i < ArgumentExpressions.Length; i++)
{
if (ArgumentExpressions[i] != null)
{
String typeName = TypesHelper.DotNetTypeToXgrsType(functionMethod.Inputs[i]);
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
parameters += ", " + cast + exprGen.GetSequenceExpression(ArgumentExpressions[i], source);
}
else
{
// the sequence parser always emits all argument expressions, for interpreted and compiled
throw new Exception("Internal error: missing argument expressions");
}
}
return(parameters);
}
public static void GenerateContainerConstructor(IGraphModel model, SequenceExpressionContainerConstructor containerConstructor, SourceBuilder source)
{
string containerType = TypesHelper.XgrsTypeToCSharpType(GetContainerType(containerConstructor), model);
string valueType = TypesHelper.XgrsTypeToCSharpType(containerConstructor.ValueType, model);
string keyType = null;
if (containerConstructor is SequenceExpressionMapConstructor)
{
keyType = TypesHelper.XgrsTypeToCSharpType(((SequenceExpressionMapConstructor)containerConstructor).KeyType, model);
}
source.Append("\n");
source.AppendFront("public static ");
source.Append(containerType);
source.Append(" fillFromSequence_" + containerConstructor.Id);
source.Append("(");
for (int i = 0; i < containerConstructor.ContainerItems.Length; ++i)
{
if (i > 0)
{
source.Append(", ");
}
if (keyType != null)
{
source.AppendFormat("{0} paramkey{1}, ", keyType, i);
}
source.AppendFormat("{0} param{1}", valueType, i);
}
source.Append(")\n");
source.AppendFront("{\n");
source.Indent();
source.AppendFrontFormat("{0} container = new {0}();\n", containerType);
for (int i = 0; i < containerConstructor.ContainerItems.Length; ++i)
{
source.AppendFrontFormat(GetAddToContainer(containerConstructor, "param" + i, keyType != null ? "paramkey" + i : null));
}
source.AppendFront("return container;\n");
source.Unindent();
source.AppendFront("}\n");
}
public String BuildParametersInDeclarations(Invocation invocation, SequenceExpression[] ArgumentExpressions, SourceBuilder source, out String declarations)
{
String parameters = "";
declarations = "";
for (int i = 0; i < ArgumentExpressions.Length; i++)
{
String typeName;
if (actionsTypeInformation.rulesToInputTypes.ContainsKey(invocation.PackagePrefixedName))
{
typeName = actionsTypeInformation.rulesToInputTypes[invocation.PackagePrefixedName][i];
}
else
{
typeName = actionsTypeInformation.sequencesToInputTypes[invocation.PackagePrefixedName][i];
}
String type = TypesHelper.XgrsTypeToCSharpType(typeName, model);
String name = "tmpvar_" + GetUniqueId();
declarations += type + " " + name + " = " + "(" + type + ")" + exprGen.GetSequenceExpression(ArgumentExpressions[i], source) + ";";
parameters += ", " + name;
}
return(parameters);
}
public bool GenerateXGRSCode(string xgrsName, String package, String xgrsStr,
String[] paramNames, GrGenType[] paramTypes,
String[] defToBeYieldedToNames, GrGenType[] defToBeYieldedToTypes,
SourceBuilder source, int lineNr)
{
Dictionary <String, String> varDecls = new Dictionary <String, String>();
for (int i = 0; i < paramNames.Length; ++i)
{
varDecls.Add(paramNames[i], TypesHelper.DotNetTypeToXgrsType(paramTypes[i]));
}
for (int i = 0; i < defToBeYieldedToNames.Length; ++i)
{
varDecls.Add(defToBeYieldedToNames[i], TypesHelper.DotNetTypeToXgrsType(defToBeYieldedToTypes[i]));
}
Sequence seq;
try
{
SequenceParserEnvironmentCompiled parserEnv = new SequenceParserEnvironmentCompiled(package, actionNames, model);
List <string> warnings = new List <string>();
seq = SequenceParser.ParseSequence(xgrsStr, parserEnv, varDecls, warnings);
foreach (string warning in warnings)
{
Console.Error.WriteLine("The exec statement \"" + xgrsStr
+ "\" given on line " + lineNr + " reported back:\n" + warning);
}
seq.Check(env);
seq.SetNeedForProfilingRecursive(emitProfiling);
}
catch (ParseException ex)
{
Console.Error.WriteLine("The exec statement \"" + xgrsStr
+ "\" given on line " + lineNr + " caused the following error:\n" + ex.Message);
return(false);
}
catch (SequenceParserException ex)
{
Console.Error.WriteLine("The exec statement \"" + xgrsStr
+ "\" given on line " + lineNr + " caused the following error:\n");
HandleSequenceParserException(ex);
return(false);
}
source.Append("\n");
source.AppendFront("public static bool ApplyXGRS_" + xgrsName + "(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv");
for (int i = 0; i < paramNames.Length; ++i)
{
source.Append(", " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(paramTypes[i]), model) + " var_");
source.Append(paramNames[i]);
}
for (int i = 0; i < defToBeYieldedToTypes.Length; ++i)
{
source.Append(", ref " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(defToBeYieldedToTypes[i]), model) + " var_");
source.Append(defToBeYieldedToNames[i]);
}
source.Append(")\n");
source.AppendFront("{\n");
source.Indent();
source.AppendFront("GRGEN_LGSP.LGSPGraph graph = procEnv.graph;\n");
source.AppendFront("GRGEN_LGSP.LGSPActions actions = procEnv.curActions;\n");
neededEntitiesEmitter.Reset();
if (fireDebugEvents)
{
source.AppendFrontFormat("procEnv.DebugEntering(\"{0}\", \"{1}\");\n",
InjectExec(xgrsName), xgrsStr.Replace("\\", "\\\\").Replace("\"", "\\\""));
}
neededEntitiesEmitter.EmitNeededVarAndRuleEntities(seq, source);
seqGen.EmitSequence(seq, source);
if (fireDebugEvents)
{
source.AppendFrontFormat("procEnv.DebugExiting(\"{0}\");\n",
InjectExec(xgrsName));
}
source.AppendFront("return " + seqGen.GetSequenceResult(seq) + ";\n");
source.Unindent();
source.AppendFront("}\n");
List <SequenceExpressionContainerConstructor> containerConstructors = new List <SequenceExpressionContainerConstructor>();
Dictionary <SequenceVariable, SetValueType> variables = new Dictionary <SequenceVariable, SetValueType>();
seq.GetLocalVariables(variables, containerConstructors, null);
foreach (SequenceExpressionContainerConstructor cc in containerConstructors)
{
SequenceContainerConstructorEmitter.GenerateContainerConstructor(model, cc, source);
}
return(true);
}
private void GenerateInternalDefinedSequenceApplicationMethod(SourceBuilder source, DefinedSequenceInfo sequence, Sequence seq)
{
source.AppendFront("public static bool ApplyXGRS_" + sequence.Name + "(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv");
for (int i = 0; i < sequence.Parameters.Length; ++i)
{
source.Append(", " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.ParameterTypes[i]), model) + " var_");
source.Append(sequence.Parameters[i]);
}
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.Append(", ref " + TypesHelper.XgrsTypeToCSharpType(TypesHelper.DotNetTypeToXgrsType(sequence.OutParameterTypes[i]), model) + " var_");
source.Append(sequence.OutParameters[i]);
}
source.Append(")\n");
source.AppendFront("{\n");
source.Indent();
source.AppendFront("GRGEN_LGSP.LGSPGraph graph = procEnv.graph;\n");
source.AppendFront("GRGEN_LGSP.LGSPActions actions = procEnv.curActions;\n");
neededEntitiesEmitter.Reset();
if (fireDebugEvents)
{
source.AppendFrontFormat("procEnv.DebugEntering(\"{0}\"", sequence.Name);
for (int i = 0; i < sequence.Parameters.Length; ++i)
{
source.Append(", var_");
source.Append(sequence.Parameters[i]);
}
source.Append(");\n");
}
neededEntitiesEmitter.EmitNeededVarAndRuleEntities(seq, source);
seqGen.EmitSequence(seq, source);
if (fireDebugEvents)
{
source.AppendFrontFormat("procEnv.DebugExiting(\"{0}\"", sequence.Name);
for (int i = 0; i < sequence.OutParameters.Length; ++i)
{
source.Append(", var_");
source.Append(sequence.OutParameters[i]);
}
source.Append(");\n");
}
source.AppendFront("return " + seqGen.GetSequenceResult(seq) + ";\n");
source.Unindent();
source.AppendFront("}\n");
List <SequenceExpressionContainerConstructor> containerConstructors = new List <SequenceExpressionContainerConstructor>();
Dictionary <SequenceVariable, SetValueType> variables = new Dictionary <SequenceVariable, SetValueType>();
seq.GetLocalVariables(variables, containerConstructors, null);
foreach (SequenceExpressionContainerConstructor cc in containerConstructors)
{
SequenceContainerConstructorEmitter.GenerateContainerConstructor(model, cc, source);
}
}
public void BuildReturnParameters(RuleInvocation invocation, SequenceVariable[] ReturnVars,
out String returnParameterDeclarations, out String returnArguments, out String returnAssignments,
out String returnParameterDeclarationsAllCall, out String intermediateReturnAssignmentsAllCall, out String returnAssignmentsAllCall)
{
// can't use the normal xgrs variables for return value receiving as the type of an out-parameter must be invariant
// this is bullshit, as it is perfectly safe to assign a subtype to a variable of a supertype
// so we create temporary variables of exact type, which are used to receive the return values,
// and finally we assign these temporary variables to the real xgrs variables
StringBuilder sbReturnParameterDeclarations = new StringBuilder();
StringBuilder sbReturnArguments = new StringBuilder();
StringBuilder sbReturnAssignments = new StringBuilder();
StringBuilder sbReturnParameterDeclarationsAllCall = new StringBuilder();
StringBuilder sbIntermediateReturnAssignmentsAllCall = new StringBuilder();
StringBuilder sbReturnAssignmentsAllCall = new StringBuilder();
for (int i = 0; i < actionsTypeInformation.rulesToOutputTypes[invocation.PackagePrefixedName].Count; ++i)
{
String varName;
if (ReturnVars.Length != 0)
{
varName = GetUniqueId() + ReturnVars[i].PureName;
}
else
{
varName = GetUniqueId();
}
String typeName = actionsTypeInformation.rulesToOutputTypes[invocation.PackagePrefixedName][i];
String tmpvarName = "tmpvar_" + varName;
sbReturnParameterDeclarations.Append(TypesHelper.XgrsTypeToCSharpType(typeName, model));
sbReturnParameterDeclarations.Append(" ");
sbReturnParameterDeclarations.Append(tmpvarName);
sbReturnParameterDeclarations.Append("; ");
String returnListValueVarType = typeName;
String tmpvarListName = "tmpvarlist_" + varName;
if (ReturnVars.Length != 0 && ReturnVars[i].Type != "" && ReturnVars[i].Type.StartsWith("array<"))
{
returnListValueVarType = TypesHelper.ExtractSrc(ReturnVars[i].Type);
}
if (ReturnVars.Length != 0)
{
sbReturnParameterDeclarationsAllCall.Append("List<");
sbReturnParameterDeclarationsAllCall.Append(TypesHelper.XgrsTypeToCSharpType(returnListValueVarType, model));
sbReturnParameterDeclarationsAllCall.Append("> ");
sbReturnParameterDeclarationsAllCall.Append(tmpvarListName);
sbReturnParameterDeclarationsAllCall.Append(" = new List<");
sbReturnParameterDeclarationsAllCall.Append(TypesHelper.XgrsTypeToCSharpType(returnListValueVarType, model));
sbReturnParameterDeclarationsAllCall.Append(">(); ");
}
sbReturnArguments.Append(", out ");
sbReturnArguments.Append(tmpvarName);
if (ReturnVars.Length != 0)
{
sbReturnAssignments.Append(SetVar(ReturnVars[i], tmpvarName));
sbIntermediateReturnAssignmentsAllCall.Append(tmpvarListName);
sbIntermediateReturnAssignmentsAllCall.Append(".Add((");
sbIntermediateReturnAssignmentsAllCall.Append(TypesHelper.XgrsTypeToCSharpType(returnListValueVarType, model));
sbIntermediateReturnAssignmentsAllCall.Append(")");
sbIntermediateReturnAssignmentsAllCall.Append(tmpvarName);
sbIntermediateReturnAssignmentsAllCall.Append("); ");
sbReturnAssignmentsAllCall.Append(SetVar(ReturnVars[i], tmpvarListName));
}
}
returnParameterDeclarations = sbReturnParameterDeclarations.ToString();
returnArguments = sbReturnArguments.ToString();
returnAssignments = sbReturnAssignments.ToString();
returnParameterDeclarationsAllCall = sbReturnParameterDeclarationsAllCall.ToString();
intermediateReturnAssignmentsAllCall = sbIntermediateReturnAssignmentsAllCall.ToString();
returnAssignmentsAllCall = sbReturnAssignmentsAllCall.ToString();
}
