/// <summary>
/// Creates an instance of a SequenceParserException used by the SequenceParser, when the function
/// with the given name does not exist or input or output parameters do not match.
/// </summary>
/// <param name="paramBindings">The parameter bindings of the function invocation.</param>
/// <param name="errorKind">The kind of error.</param>
/// <param name="badParamIndex">The index of a bad parameter or -1 if another error occurred.</param>
public SequenceParserException(InvocationParameterBindings paramBindings, SequenceParserError errorKind, int badParamIndex)
{
Kind = errorKind;
Name = paramBindings.Name;
NumGivenInputs = paramBindings.Arguments.Length;
BadParamIndex = badParamIndex;
ClassifyDefinitionType(paramBindings);
}
void ClassifyDefinitionType(InvocationParameterBindings paramBindings)
{
if (paramBindings is RuleInvocationParameterBindings)
{
DefType = DefinitionType.Action;
}
else if (paramBindings is SequenceInvocationParameterBindings)
{
DefType = DefinitionType.Sequence;
}
else if (paramBindings is ProcedureInvocationParameterBindings)
{
DefType = DefinitionType.Procedure;
}
else if (paramBindings is FunctionInvocationParameterBindings)
{
DefType = DefinitionType.Function;
}
}
protected override bool IsCalledEntityExisting(InvocationParameterBindings paramBindings, GrGenType ownerType)
{
// besides determining whether the called entity exists, this function
// resolves pre- and context packages to packages, i.e. calls of entities from packages
// without package prefix are changed to package calls (may occur for entities from the same package)
if(paramBindings is RuleInvocationParameterBindings)
{
RuleInvocationParameterBindings ruleParamBindings = (RuleInvocationParameterBindings)paramBindings;
if(ruleParamBindings.PrePackage != null)
{
ruleParamBindings.Package = ruleParamBindings.PrePackage;
ruleParamBindings.PackagePrefixedName = ruleParamBindings.PrePackage + "::" + ruleParamBindings.Name;
return Array.IndexOf(ruleNames, ruleParamBindings.PrePackage + "::" + ruleParamBindings.Name) != -1;
}
else
{
if(Array.IndexOf(ruleNames, ruleParamBindings.Name) != -1)
{
ruleParamBindings.Package = null;
ruleParamBindings.PackagePrefixedName = ruleParamBindings.Name;
return true;
}
if(ruleParamBindings.PrePackageContext != null)
{
ruleParamBindings.Package = ruleParamBindings.PrePackageContext;
ruleParamBindings.PackagePrefixedName = ruleParamBindings.PrePackageContext + "::" + ruleParamBindings.Name;
return Array.IndexOf(ruleNames, ruleParamBindings.PrePackageContext + "::" + ruleParamBindings.Name) != -1;
}
return false;
}
}
else if(paramBindings is SequenceInvocationParameterBindings)
{
SequenceInvocationParameterBindings seqParamBindings = (SequenceInvocationParameterBindings)paramBindings;
if(seqParamBindings.PrePackage != null)
{
seqParamBindings.Package = seqParamBindings.PrePackage;
seqParamBindings.PackagePrefixedName = seqParamBindings.PrePackage + "::" + seqParamBindings.Name;
return Array.IndexOf(sequenceNames, seqParamBindings.PrePackage + "::" + seqParamBindings.Name) != -1;
}
else
{
if(Array.IndexOf(sequenceNames, seqParamBindings.Name) != -1)
{
seqParamBindings.Package = null;
seqParamBindings.PackagePrefixedName = seqParamBindings.Name;
return true;
}
if(seqParamBindings.PrePackageContext != null)
{
seqParamBindings.Package = seqParamBindings.PrePackageContext;
seqParamBindings.PackagePrefixedName = seqParamBindings.PrePackageContext + "::" + seqParamBindings.Name;
return Array.IndexOf(sequenceNames, seqParamBindings.PrePackageContext + "::" + seqParamBindings.Name) != -1;
}
return false;
}
}
else if(paramBindings is ProcedureInvocationParameterBindings)
{
ProcedureInvocationParameterBindings procParamBindings = (ProcedureInvocationParameterBindings)paramBindings;
if(ownerType != null)
{
return ownerType.GetProcedureMethod(procParamBindings.Name) != null;
}
else
{
if(procParamBindings.PrePackage != null)
{
procParamBindings.Package = procParamBindings.PrePackage;
procParamBindings.PackagePrefixedName = procParamBindings.PrePackage + "::" + procParamBindings.Name;
return Array.IndexOf(procedureNames, procParamBindings.PrePackage + "::" + procParamBindings.Name) != -1;
}
else
{
if(Array.IndexOf(procedureNames, procParamBindings.Name) != -1)
{
procParamBindings.Package = null;
procParamBindings.PackagePrefixedName = procParamBindings.Name;
return true;
}
if(procParamBindings.PrePackageContext != null)
{
procParamBindings.Package = procParamBindings.PrePackageContext;
procParamBindings.PackagePrefixedName = procParamBindings.PrePackageContext + "::" + procParamBindings.Name;
return Array.IndexOf(procedureNames, procParamBindings.PrePackageContext + "::" + procParamBindings.Name) != -1;
}
return false;
}
}
}
else if(paramBindings is FunctionInvocationParameterBindings)
{
FunctionInvocationParameterBindings funcParamBindings = (FunctionInvocationParameterBindings)paramBindings;
if(ownerType != null)
{
return ownerType.GetFunctionMethod(funcParamBindings.Name) != null;
}
else
{
if(funcParamBindings.PrePackage != null)
{
funcParamBindings.Package = funcParamBindings.PrePackage;
funcParamBindings.PackagePrefixedName = funcParamBindings.PrePackage + "::" + funcParamBindings.Name;
return Array.IndexOf(functionNames, funcParamBindings.PrePackage + "::" + funcParamBindings.Name) != -1;
}
else
{
if(Array.IndexOf(functionNames, funcParamBindings.Name) != -1)
{
funcParamBindings.Package = null;
funcParamBindings.PackagePrefixedName = funcParamBindings.Name;
return true;
}
if(funcParamBindings.PrePackageContext != null)
{
funcParamBindings.Package = funcParamBindings.PrePackageContext;
funcParamBindings.PackagePrefixedName = funcParamBindings.PrePackageContext + "::" + funcParamBindings.Name;
return Array.IndexOf(functionNames, funcParamBindings.PrePackageContext + "::" + funcParamBindings.Name) != -1;
}
return false;
}
}
}
throw new Exception("Internal error");
}
protected override string OutputParameterType(int i, InvocationParameterBindings paramBindings, GrGenType ownerType)
{
if(paramBindings is RuleInvocationParameterBindings)
{
RuleInvocationParameterBindings ruleParamBindings = (RuleInvocationParameterBindings)paramBindings;
return TypesHelper.DotNetTypeToXgrsType(ruleParamBindings.Action.RulePattern.Outputs[i]);
}
else if(paramBindings is SequenceInvocationParameterBindings)
{
SequenceInvocationParameterBindings seqParamBindings = (SequenceInvocationParameterBindings)paramBindings;
if(seqParamBindings.SequenceDef is SequenceDefinitionInterpreted)
{
SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqParamBindings.SequenceDef;
return seqDef.OutputVariables[i].Type;
}
else
{
SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqParamBindings.SequenceDef;
return TypesHelper.DotNetTypeToXgrsType(seqDef.SeqInfo.OutParameterTypes[i]);
}
}
else if(paramBindings is ProcedureInvocationParameterBindings)
{
ProcedureInvocationParameterBindings procParamBindings = (ProcedureInvocationParameterBindings)paramBindings;
if(ownerType != null)
return TypesHelper.DotNetTypeToXgrsType(ownerType.GetProcedureMethod(procParamBindings.Name).Outputs[i]);
else
return TypesHelper.DotNetTypeToXgrsType(procParamBindings.ProcedureDef.Outputs[i]);
}
throw new Exception("Internal error");
}
protected override int NumOutputParameters(InvocationParameterBindings paramBindings, GrGenType ownerType)
{
if(paramBindings is RuleInvocationParameterBindings)
{
RuleInvocationParameterBindings ruleParamBindings = (RuleInvocationParameterBindings)paramBindings;
return ruleParamBindings.Action.RulePattern.Outputs.Length;
}
else if(paramBindings is SequenceInvocationParameterBindings)
{
SequenceInvocationParameterBindings seqParamBindings = (SequenceInvocationParameterBindings)paramBindings;
if(seqParamBindings.SequenceDef is SequenceDefinitionInterpreted)
{
SequenceDefinitionInterpreted seqDef = (SequenceDefinitionInterpreted)seqParamBindings.SequenceDef;
return seqDef.OutputVariables.Length;
}
else
{
SequenceDefinitionCompiled seqDef = (SequenceDefinitionCompiled)seqParamBindings.SequenceDef;
return seqDef.SeqInfo.OutParameterTypes.Length;
}
}
else if(paramBindings is ProcedureInvocationParameterBindings)
{
ProcedureInvocationParameterBindings procParamBindings = (ProcedureInvocationParameterBindings)paramBindings;
if(ownerType != null)
return ownerType.GetProcedureMethod(procParamBindings.Name).Outputs.Length;
else
return procParamBindings.ProcedureDef.Outputs.Length;
}
throw new Exception("Internal error");
}
protected override bool IsCalledEntityExisting(InvocationParameterBindings paramBindings, GrGenType ownerType)
{
if(paramBindings is RuleInvocationParameterBindings)
{
RuleInvocationParameterBindings ruleParamBindings = (RuleInvocationParameterBindings)paramBindings;
return ruleParamBindings.Action != null;
}
else if(paramBindings is SequenceInvocationParameterBindings)
{
SequenceInvocationParameterBindings seqParamBindings = (SequenceInvocationParameterBindings)paramBindings;
return seqParamBindings.SequenceDef != null;
}
else if(paramBindings is ProcedureInvocationParameterBindings)
{
ProcedureInvocationParameterBindings procParamBindings = (ProcedureInvocationParameterBindings)paramBindings;
if(ownerType != null)
return ownerType.GetProcedureMethod(procParamBindings.Name) != null;
else
return procParamBindings.ProcedureDef != null;
}
else if(paramBindings is FunctionInvocationParameterBindings)
{
FunctionInvocationParameterBindings funcParamBindings = (FunctionInvocationParameterBindings)paramBindings;
if(ownerType != null)
return ownerType.GetFunctionMethod(funcParamBindings.Name) != null;
else
return funcParamBindings.FunctionDef != null;
}
throw new Exception("Internal error");
}
protected abstract string OutputParameterType(int i, InvocationParameterBindings paramBindings, GrGenType ownerType);
private String BuildParameters(InvocationParameterBindings paramBindings, IProcedureDefinition procedureMethod)
{
String parameters = "";
for(int i = 0; i < paramBindings.ArgumentExpressions.Length; i++)
{
if(paramBindings.ArgumentExpressions[i] != null)
{
String typeName = TypesHelper.DotNetTypeToXgrsType(procedureMethod.Inputs[i]);
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
parameters += ", " + cast + GetSequenceExpression(paramBindings.ArgumentExpressions[i], null);
}
else
{
// the sequence parser always emits all argument expressions, for interpreted and compiled
throw new Exception("Internal error: missing argument expressions");
}
}
return parameters;
}
protected override string OutputParameterType(int i, InvocationParameterBindings paramBindings, GrGenType ownerType)
{
if(paramBindings is RuleInvocationParameterBindings)
{
RuleInvocationParameterBindings ruleParamBindings = (RuleInvocationParameterBindings)paramBindings;
return rulesToOutputTypes[ruleParamBindings.PackagePrefixedName][i];
}
else if(paramBindings is SequenceInvocationParameterBindings)
{
SequenceInvocationParameterBindings seqParamBindings = (SequenceInvocationParameterBindings)paramBindings;
return sequencesToOutputTypes[seqParamBindings.PackagePrefixedName][i];
}
else if(paramBindings is ProcedureInvocationParameterBindings)
{
ProcedureInvocationParameterBindings procParamBindings = (ProcedureInvocationParameterBindings)paramBindings;
if(ownerType != null)
return TypesHelper.DotNetTypeToXgrsType(ownerType.GetProcedureMethod(procParamBindings.Name).Outputs[i]);
else
return proceduresToOutputTypes[procParamBindings.PackagePrefixedName][i];
}
throw new Exception("Internal error");
}
void ClassifyDefinitionType(InvocationParameterBindings paramBindings)
{
if(paramBindings is RuleInvocationParameterBindings)
DefType = DefinitionType.Action;
else if(paramBindings is SequenceInvocationParameterBindings)
DefType = DefinitionType.Sequence;
else if(paramBindings is ProcedureInvocationParameterBindings)
DefType = DefinitionType.Procedure;
else if(paramBindings is FunctionInvocationParameterBindings)
DefType = DefinitionType.Function;
}
/// <summary>
/// Creates an instance of a SequenceParserException used by the SequenceParser, when the function
/// with the given name does not exist or input or output parameters do not match.
/// </summary>
/// <param name="paramBindings">The parameter bindings of the function invocation.</param>
/// <param name="errorKind">The kind of error.</param>
/// <param name="badParamIndex">The index of a bad parameter or -1 if another error occurred.</param>
public SequenceParserException(InvocationParameterBindings paramBindings, SequenceParserError errorKind, int badParamIndex)
{
Kind = errorKind;
Name = paramBindings.Name;
NumGivenInputs = paramBindings.Arguments.Length;
BadParamIndex = badParamIndex;
ClassifyDefinitionType(paramBindings);
}
/// <summary>
/// Creates an instance of a SequenceParserException used by the SequenceParser, when the function
/// with the given name does not exist or input or output parameters do not match.
/// </summary>
/// <param name="paramBindings">The parameter bindings of the function invocation.</param>
/// <param name="errorKind">The kind of error.</param>
public SequenceParserException(InvocationParameterBindings paramBindings, SequenceParserError errorKind)
: this(paramBindings, errorKind, -1)
{
}
private String BuildParametersInDeclarations(InvocationParameterBindings paramBindings, out String declarations)
{
String parameters = "";
declarations = "";
for(int i = 0; i < paramBindings.ArgumentExpressions.Length; i++)
{
if(paramBindings.ArgumentExpressions[i] != null)
{
String typeName;
if(rulesToInputTypes.ContainsKey(paramBindings.PackagePrefixedName))
typeName = rulesToInputTypes[paramBindings.PackagePrefixedName][i];
else
typeName = sequencesToInputTypes[paramBindings.PackagePrefixedName][i];
String type = TypesHelper.XgrsTypeToCSharpType(typeName, model);
String name = "tmpvar_" + tmpVarCtr.ToString();
++tmpVarCtr;
declarations += type + " " + name + " = " + "(" + type + ")" + GetSequenceExpression(paramBindings.ArgumentExpressions[i], null) + ";";
parameters += ", " + name;
}
else
{
// the sequence parser always emits all argument expressions, for interpreted and compiled
throw new Exception("Internal error: missing argument expressions");
}
}
return parameters;
}
private String BuildParametersInObject(InvocationParameterBindings paramBindings)
{
String parameters = ", new object[] { ";
for(int i = 0; i < paramBindings.ArgumentExpressions.Length; i++)
{
if(paramBindings.ArgumentExpressions[i] != null)
{
parameters += ", " + GetSequenceExpression(paramBindings.ArgumentExpressions[i], null);
}
else
{
// the sequence parser always emits all argument expressions, for interpreted and compiled
throw new Exception("Internal error: missing argument expressions");
}
}
return parameters + " }";
}
protected override int NumOutputParameters(InvocationParameterBindings paramBindings, GrGenType ownerType)
{
if(paramBindings is RuleInvocationParameterBindings)
{
RuleInvocationParameterBindings ruleParamBindings = (RuleInvocationParameterBindings)paramBindings;
return rulesToOutputTypes[ruleParamBindings.PackagePrefixedName].Count;
}
else if(paramBindings is SequenceInvocationParameterBindings)
{
SequenceInvocationParameterBindings seqParamBindings = (SequenceInvocationParameterBindings)paramBindings;
return sequencesToOutputTypes[seqParamBindings.PackagePrefixedName].Count;
}
else if(paramBindings is ProcedureInvocationParameterBindings)
{
ProcedureInvocationParameterBindings procParamBindings = (ProcedureInvocationParameterBindings)paramBindings;
if(ownerType != null)
return ownerType.GetProcedureMethod(procParamBindings.Name).Outputs.Length;
else
return proceduresToOutputTypes[procParamBindings.PackagePrefixedName].Count;
}
throw new Exception("Internal error");
}
/// <summary>
/// Creates an instance of a SequenceParserException used by the SequenceParser, when the function
/// with the given name does not exist or input or output parameters do not match.
/// </summary>
/// <param name="paramBindings">The parameter bindings of the function invocation.</param>
/// <param name="errorKind">The kind of error.</param>
public SequenceParserException(InvocationParameterBindings paramBindings, SequenceParserError errorKind)
: this(paramBindings, errorKind, -1)
{
}
protected abstract bool IsCalledEntityExisting(InvocationParameterBindings paramBindings, GrGenType ownerType);
protected abstract int NumOutputParameters(InvocationParameterBindings paramBindings, GrGenType ownerType);
private String BuildParameters(InvocationParameterBindings paramBindings)
{
String parameters = "";
for (int i = 0; i < paramBindings.ArgumentExpressions.Length; i++)
{
if (paramBindings.ArgumentExpressions[i] != null)
{
String typeName;
if(rulesToInputTypes.ContainsKey(paramBindings.PackagePrefixedName))
typeName = rulesToInputTypes[paramBindings.PackagePrefixedName][i];
else if(sequencesToInputTypes.ContainsKey(paramBindings.PackagePrefixedName))
typeName = sequencesToInputTypes[paramBindings.PackagePrefixedName][i];
else if(proceduresToInputTypes.ContainsKey(paramBindings.PackagePrefixedName))
typeName = proceduresToInputTypes[paramBindings.PackagePrefixedName][i];
else
typeName = functionsToInputTypes[paramBindings.PackagePrefixedName][i];
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(typeName, model) + ")";
parameters += ", " + cast + GetSequenceExpression(paramBindings.ArgumentExpressions[i], null);
}
else
{
// the sequence parser always emits all argument expressions, for interpreted and compiled
throw new Exception("Internal error: missing argument expressions");
}
}
return parameters;
}
