public static ExpressionParserResult ParseFunction(IVariableTypeProvider VariableTypeProvider, String Signature, String Body)
{
var LinesSignature = new List <TextLine>();
LinesSignature.Add(new TextLine {
Text = Signature, Range = new TextRange {
Start = new TextPosition {
CharIndex = 0, Row = 1, Column = 1
}, End = new TextPosition {
CharIndex = Signature.Length, Row = 1, Column = Signature.Length + 1
}
}
});
var LinesBody = new List <TextLine>();
LinesBody.Add(new TextLine {
Text = Body, Range = new TextRange {
Start = new TextPosition {
CharIndex = 0, Row = 1, Column = 1
}, End = new TextPosition {
CharIndex = Body.Length, Row = 1, Column = Body.Length + 1
}
}
});
var tSignature = new Text {
Path = "Signature", Lines = LinesSignature
};
var tBody = new Text {
Path = "Body", Lines = LinesBody
};
var p = new Parser(tSignature, tBody);
return(p.ParseFunction(VariableTypeProvider, LinesSignature.Single().Range, LinesBody.Single().Range));
}
public VariableProvider(IVariableCategoryProvider variableCategoryProvider, IValidationRuleProvider validationRuleProvider, IRoleProvider roleProvider, IVariableTypeProvider variableTypeProvider)
{
this._VariableCategoryProvider = variableCategoryProvider;
this._ValidationRuleProvider = validationRuleProvider;
this._RoleProvider = roleProvider;
this._VariableTypeProvider = variableTypeProvider;
}
private PrimitiveType BindFunctionExpr(IVariableTypeProvider VariableTypeProvider, Dictionary <Expr, PrimitiveType> TypeDict, FunctionExpr fe)
{
foreach (var p in fe.Parameters)
{
BindExpr(VariableTypeProvider, TypeDict, p);
}
var ParameterTypes = fe.Parameters.Select(p => TypeDict[p]).ToList();
List <FunctionParameterAndReturnTypes> Functions;
try
{
Functions = VariableTypeProvider.GetOverloads(fe.Name);
}
catch (Exception ex)
{
throw new InvalidSyntaxException("'{0}' : FunctionNotExist".Formats(fe.Name), new FileTextRange {
Text = Text, Range = Positions[fe]
}, ex);
}
var Sorted = Functions.Where(fs => IsOverloadSatisfied(ParameterTypes, fs.ParameterTypes)).GroupBy(fs => GetOverloadTypeConversionPoint(ParameterTypes, fs.ParameterTypes)).OrderBy(g => g.Key).ToList();
if (Sorted.Count == 0)
{
throw new InvalidSyntaxException("'{0}' : FunctionNotExist".Formats(fe.Name), new FileTextRange {
Text = Text, Range = Positions[fe]
});
}
var MostMatchedGroup = Sorted.First().ToList();
if (MostMatchedGroup.Count > 1)
{
throw new InvalidSyntaxException("'{0}' : MultipleFunctionOverloadExist".Formats(fe.Name), new FileTextRange {
Text = Text, Range = Positions[fe]
});
}
var MostMatchedSignature = MostMatchedGroup.Single();
for (int k = 0; k < ParameterTypes.Count; k += 1)
{
var pt = ParameterTypes[k];
var fspt = MostMatchedSignature.ParameterTypes[k];
if (pt == PrimitiveType.Int && fspt == PrimitiveType.Real)
{
var feCReal = new FunctionExpr {
Name = "creal", Parameters = new List <Expr> {
fe.Parameters[k]
}
};
var CReal = Expr.CreateFunction(feCReal);
var Range = Positions[fe.Parameters[k]];
Positions.Add(feCReal, Range);
Positions.Add(CReal, Range);
TypeDict.Add(CReal, PrimitiveType.Real);
fe.Parameters[k] = CReal;
}
}
return(MostMatchedSignature.ReturnType);
}
public ExpressionParserExprResult ParseExpr(IVariableTypeProvider VariableTypeProvider, TextRange Body)
{
var br = BindExpr(VariableTypeProvider, Body);
var epr = new ExpressionParserExprResult
{
Body = br.Semantics,
TypeDict = br.TypeDict,
Positions = Positions
};
return(epr);
}
public TypeBinderResult Bind(IVariableTypeProvider VariableTypeProvider, TextRange RangeInLine)
{
var Result = st.Translate(RangeInLine);
var TypeDict = new Dictionary <Expr, PrimitiveType>();
BindExpr(VariableTypeProvider, TypeDict, Result.Semantics);
var tbr = new TypeBinderResult
{
Semantics = Result.Semantics,
TypeDict = TypeDict
};
return(tbr);
}
public ExpressionParserExprResult ParseBody(IVariableTypeProvider VariableTypeProvider, FunctionDecl Declaration, TextRange Body)
{
var d = Declaration;
var dParameters = d.Parameters.ToDictionary(p => p.Name, p => p.Type);
var vtp = new VariableTypeProviderCombiner(new SimpleVariableTypeProvider(dParameters), VariableTypeProvider);
var br = BindExpr(vtp, d.ReturnValue, Body);
var epr = new ExpressionParserExprResult
{
Body = br.Semantics,
TypeDict = br.TypeDict,
Positions = Positions
};
return(epr);
}
public static ExpressionParserExprResult ParseBody(IVariableTypeProvider VariableTypeProvider, FunctionDecl Declaration, String Body)
{
var LinesBody = new List <TextLine>();
LinesBody.Add(new TextLine {
Text = Body, Range = new TextRange {
Start = new TextPosition {
CharIndex = 0, Row = 1, Column = 1
}, End = new TextPosition {
CharIndex = Body.Length, Row = 1, Column = Body.Length + 1
}
}
});
var tBody = new Text {
Path = "Body", Lines = LinesBody
};
var p = new Parser(null, tBody);
return(p.ParseBody(VariableTypeProvider, Declaration, LinesBody.Single().Range));
}
public ExpressionParserResult ParseFunction(IVariableTypeProvider VariableTypeProvider, FunctionDecl Declaration, TextRange Body)
{
var d = Declaration;
var epbr = ParseBody(VariableTypeProvider, d, Body);
var fd = new FunctionDef
{
Name = d.Name,
Parameters = d.Parameters,
ReturnValue = d.ReturnValue,
Body = epbr.Body
};
var epr = new ExpressionParserResult
{
Definition = fd,
TypeDict = epbr.TypeDict,
Positions = Positions
};
return(epr);
}
public TypeBinderResult Bind(IVariableTypeProvider VariableTypeProvider, PrimitiveType ReturnType, TextRange RangeInLine)
{
var Result = st.Translate(RangeInLine);
var TypeDict = new Dictionary <Expr, PrimitiveType>();
BindExpr(VariableTypeProvider, TypeDict, Result.Semantics);
var rt = TypeDict[Result.Semantics];
if (rt == PrimitiveType.Int && ReturnType == PrimitiveType.Real)
{
var feCReal = new FunctionExpr {
Name = "creal", Parameters = new List <Expr> {
Result.Semantics
}
};
var CReal = Expr.CreateFunction(feCReal);
var Range = Positions[Result.Semantics];
Positions.Add(feCReal, Range);
Positions.Add(CReal, Range);
TypeDict.Add(CReal, PrimitiveType.Real);
Result.Semantics = CReal;
}
else if (rt != ReturnType)
{
throw new InvalidSyntaxException("TypeMismatch : '{0}' expected.".Formats(GetTypeString(ReturnType)), new FileTextRange {
Text = Text, Range = Positions[Result.Semantics]
});
}
var tbr = new TypeBinderResult
{
Semantics = Result.Semantics,
TypeDict = TypeDict
};
return(tbr);
}
private void BindExpr(IVariableTypeProvider VariableTypeProvider, Dictionary <Expr, PrimitiveType> TypeDict, Expr e)
{
if (e.OnLiteral)
{
var l = e.Literal;
if (l.OnBooleanValue)
{
TypeDict.Add(e, PrimitiveType.Boolean);
}
else if (l.OnIntValue)
{
TypeDict.Add(e, PrimitiveType.Int);
}
else if (l.OnRealValue)
{
TypeDict.Add(e, PrimitiveType.Real);
}
else
{
throw new InvalidOperationException();
}
}
else if (e.OnVariable)
{
List <FunctionParameterAndReturnTypes> t;
try
{
t = VariableTypeProvider.GetOverloads(e.Variable.Name).Where(fs => fs.ParameterTypes == null).ToList();
}
catch (Exception ex)
{
throw new InvalidSyntaxException(String.Format("'{0}' : VariableNotExist", e.Variable.Name), new FileTextRange {
Text = Text, Range = Positions[e]
}, ex);
}
if (t.Count == 0)
{
throw new InvalidSyntaxException("'{0}' : VariableNotExist".Formats(e.Variable.Name), new FileTextRange {
Text = Text, Range = Positions[e]
});
}
if (t.Count > 1)
{
throw new InvalidSyntaxException("'{0}' : VariableFunctionOverloadExist".Formats(e.Variable.Name), new FileTextRange {
Text = Text, Range = Positions[e]
});
}
TypeDict.Add(e, t.Single().ReturnType);
}
else if (e.OnFunction)
{
var t = BindFunctionExpr(VariableTypeProvider, TypeDict, e.Function);
TypeDict.Add(e, t);
}
else if (e.OnIf)
{
var Condition = e.If.Condition;
var TruePart = e.If.TruePart;
var FalsePart = e.If.FalsePart;
BindExpr(VariableTypeProvider, TypeDict, Condition);
var ConditionType = TypeDict[Condition];
if (ConditionType != PrimitiveType.Boolean)
{
throw new InvalidSyntaxException("TypeMismatch : 'Boolean' expected.", new FileTextRange {
Text = Text, Range = Positions[Condition]
});
}
BindExpr(VariableTypeProvider, TypeDict, TruePart);
var TruePartType = TypeDict[TruePart];
BindExpr(VariableTypeProvider, TypeDict, FalsePart);
var FalsePartType = TypeDict[FalsePart];
PrimitiveType ReturnType;
if (TruePartType == PrimitiveType.Int && FalsePartType == PrimitiveType.Real)
{
var fe = new FunctionExpr {
Name = "creal", Parameters = new List <Expr> {
TruePart
}
};
var CReal = Expr.CreateFunction(fe);
var Range = Positions[TruePart];
Positions.Add(fe, Range);
Positions.Add(CReal, Range);
TypeDict.Add(CReal, PrimitiveType.Real);
e.If.TruePart = CReal;
ReturnType = PrimitiveType.Real;
}
else if (TruePartType == PrimitiveType.Real && FalsePartType == PrimitiveType.Int)
{
var fe = new FunctionExpr {
Name = "creal", Parameters = new List <Expr> {
FalsePart
}
};
var CReal = Expr.CreateFunction(fe);
var Range = Positions[FalsePart];
Positions.Add(fe, Range);
Positions.Add(CReal, Range);
TypeDict.Add(CReal, PrimitiveType.Real);
e.If.FalsePart = CReal;
ReturnType = PrimitiveType.Real;
}
else if (TruePartType != FalsePartType)
{
throw new InvalidSyntaxException("TypeMismatch: true_part is '{0}' and false_part is '{1}'.".Formats(GetTypeString(TruePartType), GetTypeString(FalsePartType)), new FileTextRange {
Text = Text, Range = Positions[e]
});
}
else
{
ReturnType = TruePartType;
}
TypeDict.Add(e, ReturnType);
}
else if (e.OnAndAlso)
{
var Left = e.AndAlso.Left;
var Right = e.AndAlso.Right;
BindExpr(VariableTypeProvider, TypeDict, Left);
var LeftType = TypeDict[Left];
if (LeftType != PrimitiveType.Boolean)
{
throw new InvalidSyntaxException("TypeMismatch : 'Boolean' expected.", new FileTextRange {
Text = Text, Range = Positions[Left]
});
}
BindExpr(VariableTypeProvider, TypeDict, Right);
var RightType = TypeDict[Right];
if (RightType != PrimitiveType.Boolean)
{
throw new InvalidSyntaxException("TypeMismatch : 'Boolean' expected.", new FileTextRange {
Text = Text, Range = Positions[Right]
});
}
TypeDict.Add(e, PrimitiveType.Boolean);
}
else if (e.OnOrElse)
{
var Left = e.OrElse.Left;
var Right = e.OrElse.Right;
BindExpr(VariableTypeProvider, TypeDict, Left);
var LeftType = TypeDict[Left];
if (LeftType != PrimitiveType.Boolean)
{
throw new InvalidSyntaxException("TypeMismatch : 'Boolean' expected.", new FileTextRange {
Text = Text, Range = Positions[Left]
});
}
BindExpr(VariableTypeProvider, TypeDict, Right);
var RightType = TypeDict[Right];
if (RightType != PrimitiveType.Boolean)
{
throw new InvalidSyntaxException("TypeMismatch : 'Boolean' expected.", new FileTextRange {
Text = Text, Range = Positions[Right]
});
}
TypeDict.Add(e, PrimitiveType.Boolean);
}
else
{
throw new InvalidOperationException();
}
}
private TypeBinderResult BindExpr(IVariableTypeProvider VariableTypeProvider, TextRange RangeInLine)
{
var r = tb.Bind(VariableTypeProvider, RangeInLine);
return(r);
}
public ExpressionParserResult ParseFunction(IVariableTypeProvider VariableTypeProvider, TextRange Signature, TextRange Body)
{
var p = new Parser(SignatureText, BodyText);
return(p.ParseFunction(VariableTypeProvider, Signature, Body));
}
public ExpressionParserExprResult ParseBody(IVariableTypeProvider VariableTypeProvider, FunctionDecl Declaration, TextRange Body)
{
var p = new Parser(SignatureText, BodyText);
return(p.ParseBody(VariableTypeProvider, Declaration, Body));
}
