public static FileParserResult ParseFile(Text Text)
{
var TypeFunctions = new HashSet <String>()
{
"Primitive", "Entity", "Enum"
};
var TableParameterFunctions = new HashSet <String>(TypeFunctions.Concat(new List <String> {
"Query"
}));
var TableContentFunctions = TypeFunctions;
var ps = new TreeFormatParseSetting()
{
IsTableParameterFunction = Name => TableParameterFunctions.Contains(Name),
IsTableContentFunction = Name => TableContentFunctions.Contains(Name)
};
var sp = new TreeFormatSyntaxParser(ps, Text);
var ParserResult = sp.Parse();
var ts = new TreeSerializer();
var Types = new List <TypeDef>();
var TypeRefs = new List <TypeDef>();
var Imports = new List <String>();
var Positions = new Dictionary <Object, TextRange>();
foreach (var TopNode in ParserResult.Value.MultiNodesList)
{
if (TopNode.OnFunctionNodes)
{
var pr = new TreeFormatParseResult
{
Value = new Forest {
MultiNodesList = new List <MultiNodes> {
TopNode
}
},
Text = Text,
Positions = ParserResult.Positions,
RawFunctionCalls = ParserResult.RawFunctionCalls
};
var es = new TreeFormatEvaluateSetting
{
FunctionCallEvaluator = (f, nm) =>
{
Action <Object, Object> Mark = (SemanticsObj, SyntaxObj) =>
{
var Range = nm.GetRange(SyntaxObj);
if (Range.OnSome)
{
Positions.Add(SemanticsObj, Range.Value);
}
};
if (TypeFunctions.Contains(f.Name.Text))
{
if (f.Parameters.Count < 1 || f.Parameters.Count > 2)
{
throw new InvalidEvaluationException("InvalidParameterCount", nm.GetFileRange(f), f);
}
var VersionedName = GetLeafNodeValue(f.Parameters[0], nm, "InvalidName");
var TypeRef = ParseTypeRef(VersionedName);
Mark(TypeRef, f.Parameters[0]);
var Name = (String)TypeRef;
var Attributes = new List <KeyValuePair <String, List <String> > >();
var Description = "";
if (f.Parameters.Count >= 2)
{
var DescriptionParameter = f.Parameters[1];
if (!DescriptionParameter.OnLeaf)
{
throw new InvalidEvaluationException("InvalidDescription", nm.GetFileRange(DescriptionParameter), DescriptionParameter);
}
var c = OS.TokenParser.DecomposeDescription(DescriptionParameter.Leaf);
Attributes = c.Attributes;
Mark(Attributes, f.Parameters[1]);
Description = c.Description;
}
var ContentLines = new List <FunctionCallTableLine> {
};
if (f.Content.OnSome)
{
var ContentValue = f.Content.Value;
if (!ContentValue.OnTableContent)
{
throw new InvalidEvaluationException("InvalidContent", nm.GetFileRange(ContentValue), ContentValue);
}
ContentLines = ContentValue.TableContent;
}
switch (f.Name.Text)
{
case "Primitive":
{
var GenericParameters = new List <VariableDef>();
foreach (var Line in ContentLines)
{
String cName = null;
TypeSpec cType = null;
var cAttributes = new List <KeyValuePair <String, List <String> > >();
var cDescription = "";
if (Line.Nodes.Count == 2)
{
cName = GetLeafNodeValue(Line.Nodes[0], nm, "InvalidFieldName");
cType = ParseTypeSpec(Line.Nodes[1], nm, Positions);
}
else if (Line.Nodes.Count == 3)
{
cName = GetLeafNodeValue(Line.Nodes[0], nm, "InvalidFieldName");
cType = ParseTypeSpec(Line.Nodes[1], nm, Positions);
var c = OS.TokenParser.DecomposeDescription(GetLeafNodeValue(Line.Nodes[2], nm, "InvalidDescription"));
cAttributes = c.Attributes;
Mark(cAttributes, Line.Nodes[2]);
cDescription = c.Description;
}
else if (Line.Nodes.Count == 0)
{
continue;
}
else
{
throw new InvalidEvaluationException("InvalidLineNodeCount", nm.GetFileRange(Line), Line);
}
if (cName.StartsWith("'"))
{
cName = new String(cName.Skip(1).ToArray());
var gp = new VariableDef {
Name = cName, Type = cType, Attributes = cAttributes, Description = cDescription, Attribute = null
};
Mark(gp, Line);
GenericParameters.Add(gp);
}
else
{
throw new InvalidEvaluationException("InvalidLine", nm.GetFileRange(Line), Line);
}
}
var p = new PrimitiveDef {
Name = Name, Attributes = Attributes, Description = Description
};
Mark(p, f);
var t = TypeDef.CreatePrimitive(p);
Mark(t, f);
Types.Add(t);
return(new List <TFSemantics.Node> {
});
}
case "Entity":
{
var Fields = new List <VariableDef>();
foreach (var Line in ContentLines)
{
String cName = null;
TypeSpec cType = null;
var cAttributes = new List <KeyValuePair <String, List <String> > >();
var cDescription = "";
if (Line.Nodes.Count == 2)
{
cName = GetLeafNodeValue(Line.Nodes[0], nm, "InvalidFieldName");
cType = ParseTypeSpec(Line.Nodes[1], nm, Positions);
}
else if (Line.Nodes.Count == 3)
{
cName = GetLeafNodeValue(Line.Nodes[0], nm, "InvalidFieldName");
cType = ParseTypeSpec(Line.Nodes[1], nm, Positions);
var c = OS.TokenParser.DecomposeDescription(GetLeafNodeValue(Line.Nodes[2], nm, "InvalidDescription"));
cAttributes = c.Attributes;
Mark(cAttributes, Line.Nodes[2]);
cDescription = c.Description;
}
else if (Line.Nodes.Count == 0)
{
continue;
}
else
{
throw new InvalidEvaluationException("InvalidLineNodeCount", nm.GetFileRange(Line), Line);
}
var p = new VariableDef {
Name = cName, Type = cType, Attributes = cAttributes, Description = cDescription
};
Mark(p, Line);
Fields.Add(p);
}
var ed = new EntityDef {
Name = Name, Fields = Fields, Attributes = Attributes, Description = Description
};
Mark(ed, f);
var t = TypeDef.CreateEntity(ed);
Mark(t, f);
Types.Add(t);
return(new List <TFSemantics.Node> {
});
}
case "Enum":
{
var Literals = new List <LiteralDef>();
Int64 NextValue = 0;
foreach (var Line in ContentLines)
{
String cName = null;
Int64 cValue = NextValue;
var cAttributes = new List <KeyValuePair <String, List <String> > >();
var cDescription = "";
if (Line.Nodes.Count == 1)
{
cName = GetLeafNodeValue(Line.Nodes[0], nm, "InvalidLiteralName");
cValue = NextValue;
}
else if (Line.Nodes.Count == 2)
{
cName = GetLeafNodeValue(Line.Nodes[0], nm, "InvalidLiteralName");
cValue = NumericStrings.InvariantParseInt64(GetLeafNodeValue(Line.Nodes[1], nm, "InvalidLiteralValue"));
}
else if (Line.Nodes.Count == 3)
{
cName = GetLeafNodeValue(Line.Nodes[0], nm, "InvalidLiteralName");
cValue = NumericStrings.InvariantParseInt64(GetLeafNodeValue(Line.Nodes[1], nm, "InvalidLiteralValue"));
var c = OS.TokenParser.DecomposeDescription(GetLeafNodeValue(Line.Nodes[2], nm, "InvalidDescription"));
cAttributes = c.Attributes;
Mark(cAttributes, Line.Nodes[2]);
cDescription = c.Description;
}
else if (Line.Nodes.Count == 0)
{
continue;
}
else
{
throw new InvalidEvaluationException("InvalidLineNodeCount", nm.GetFileRange(Line), Line);
}
NextValue = cValue + 1;
var ltl = new LiteralDef {
Name = cName, Value = cValue, Attributes = cAttributes, Description = cDescription
};
Mark(ltl, Line);
Literals.Add(ltl);
}
var r = (TypeRef)("Int");
Mark(r, f);
var UnderlyingType = TypeSpec.CreateTypeRef(r);
Mark(UnderlyingType, f);
var ed = new EnumDef {
Name = Name, UnderlyingType = UnderlyingType, Literals = Literals, Attributes = Attributes, Description = Description
};
Mark(ed, f);
var t = TypeDef.CreateEnum(ed);
Mark(t, f);
Types.Add(t);
return(new List <TFSemantics.Node> {
});
}
default:
{
throw new InvalidEvaluationException("UnknownFunction", nm.GetFileRange(f), f);
}
}
}
else if (f.Name.Text == "Query")
{
if (f.Parameters.Count != 0)
{
throw new InvalidEvaluationException("InvalidParameterCount", nm.GetFileRange(f), f);
}
var Verbs = new Dictionary <String, Func <Verb> >
{
{ "Select", () => Verb.CreateSelect() },
{ "Lock", () => Verb.CreateLock() },
{ "Insert", () => Verb.CreateInsert() },
{ "Update", () => Verb.CreateUpdate() },
{ "Upsert", () => Verb.CreateUpsert() },
{ "Delete", () => Verb.CreateDelete() }
};
var Numerals = new Dictionary <String, Func <Numeral> >
{
{ "Optional", () => Numeral.CreateOptional() },
{ "One", () => Numeral.CreateOne() },
{ "Many", () => Numeral.CreateMany() },
{ "All", () => Numeral.CreateAll() },
{ "Range", () => Numeral.CreateRange() },
{ "Count", () => Numeral.CreateCount() }
};
Func <int, TextLine, List <QueryDef> > ParseQueryDef = (IndentLevel, Line) =>
{
var l = new List <TFSemantics.Node>();
List <TFSemantics.Node> cl = null;
TextPosition clStart = default(TextPosition);
TextPosition clEnd = default(TextPosition);
if (Line.Text.Length < IndentLevel * 4)
{
return(new List <QueryDef> {
});
}
var LineRange = new TextRange {
Start = Text.Calc(Line.Range.Start, IndentLevel * 4), End = Line.Range.End
};
var Range = LineRange;
while (true)
{
var tpr = TreeFormatTokenParser.ReadToken(Text, pr.Positions, Range);
if (!tpr.OnSome)
{
break;
}
var v = tpr.Value.Token;
if (v.OnSingleLineComment)
{
break;
}
if (v.OnLeftParenthesis)
{
if (cl != null)
{
throw new InvalidTokenException("DoubleLeftParenthesis", new FileTextRange {
Text = Text, Range = Range
}, "(");
}
cl = new List <TFSemantics.Node>();
clStart = Range.Start;
clEnd = Range.End;
}
else if (v.OnRightParenthesis)
{
if (cl == null)
{
throw new InvalidTokenException("DismatchedRightParenthesis", new FileTextRange {
Text = Text, Range = Range
}, ")");
}
if (cl.Count == 0)
{
throw new InvalidTokenException("EmptyIndex", new FileTextRange {
Text = Text, Range = Range
}, ")");
}
if (tpr.Value.RemainingChars.OnSome)
{
clEnd = tpr.Value.RemainingChars.Value.End;
}
l.Add(nm.MakeStemNode("", cl, new TextRange {
Start = clStart, End = clEnd
}));
cl = null;
clStart = default(TextPosition);
clEnd = default(TextPosition);
}
else if (v.OnSingleLineLiteral)
{
if (cl != null)
{
cl.Add(nm.MakeLeafNode(v.SingleLineLiteral, pr.Positions[v]));
}
else
{
l.Add(nm.MakeLeafNode(v.SingleLineLiteral, pr.Positions[v]));
}
}
else
{
throw new InvalidTokenException("UnknownToken", new FileTextRange {
Text = Text, Range = Range
}, Text.GetTextInLine(Range));
}
if (!tpr.Value.RemainingChars.OnSome)
{
break;
}
Range = tpr.Value.RemainingChars.Value;
}
if (cl != null)
{
throw new InvalidTokenException("DismatchedRightParentheses", new FileTextRange {
Text = Text, Range = Range
}, "");
}
if (l.Count == 0)
{
return(new List <QueryDef> {
});
}
if (l.Count != 4 && l.Count != 6 && l.Count != 8)
{
throw new InvalidSyntaxException("InvalidQuery", new FileTextRange {
Text = Text, Range = LineRange
});
}
var From = GetLeafNodeValue(l[0], nm, "InvalidFrom");
if (From != "From")
{
throw new InvalidTokenException("InvalidFrom", nm.GetFileRange(l[0]), From);
}
var EntityName = GetLeafNodeValue(l[1], nm, "InvalidEntityName");
var VerbName = GetLeafNodeValue(l[2], nm, "InvalidVerb");
if (!Verbs.ContainsKey(VerbName))
{
throw new InvalidTokenException("InvalidVerb", nm.GetFileRange(l[2]), VerbName);
}
var Verb = Verbs[VerbName]();
Mark(Verb, l[2]);
var NumeralName = GetLeafNodeValue(l[3], nm, "InvalidNumeral");
if (!Numerals.ContainsKey(NumeralName))
{
throw new InvalidTokenException("InvalidNumeral", nm.GetFileRange(l[3]), NumeralName);
}
var Numeral = Numerals[NumeralName]();
Mark(Numeral, l[3]);
var By = new List <String> {
};
var OrderBy = new List <KeyColumn> {
};
if (l.Count >= 6)
{
var ByOrOrderByName = GetLeafNodeValue(l[4], nm, "InvalidByOrOrderBy");
if (ByOrOrderByName == "By")
{
if (l[5].OnLeaf)
{
By = new List <String> {
l[5].Leaf
};
}
else if (l[5].OnStem)
{
By = l[5].Stem.Children.Select(c => GetLeafNodeValue(c, nm, "InvalidKeyColumn")).ToList();
}
else
{
throw new InvalidSyntaxException("InvalidBy", nm.GetFileRange(l[5]));
}
Mark(By, l[5]);
}
else if (ByOrOrderByName == "OrderBy")
{
if (l[5].OnLeaf)
{
OrderBy = (new List <String> {
l[5].Leaf
}).Select(c => c.EndsWith("-") ? new KeyColumn {
Name = c.Substring(0, c.Length - 1), IsDescending = true
} : new KeyColumn {
Name = c, IsDescending = false
}).ToList();
}
else if (l[5].OnStem)
{
OrderBy = l[5].Stem.Children.Select(c => GetLeafNodeValue(c, nm, "InvalidKeyColumn")).Select(c => c.EndsWith("-") ? new KeyColumn {
Name = c.Substring(0, c.Length - 1), IsDescending = true
} : new KeyColumn {
Name = c, IsDescending = false
}).ToList();
}
else
{
throw new InvalidSyntaxException("InvalidOrderBy", nm.GetFileRange(l[5]));
}
Mark(OrderBy, l[5]);
}
else
{
throw new InvalidSyntaxException("InvalidByOrOrderBy", nm.GetFileRange(l[5]));
}
}
if (l.Count >= 8)
{
if (OrderBy.Count != 0)
{
throw new InvalidSyntaxException("InvalidOrderBy", nm.GetFileRange(l[6]));
}
var OrderByName = GetLeafNodeValue(l[6], nm, "InvalidOrderBy");
if (OrderByName == "OrderBy")
{
if (l[7].OnLeaf)
{
OrderBy = (new List <String> {
l[7].Leaf
}).Select(c => c.EndsWith("-") ? new KeyColumn {
Name = c.Substring(0, c.Length - 1), IsDescending = true
} : new KeyColumn {
Name = c, IsDescending = false
}).ToList();
}
else if (l[7].OnStem)
{
OrderBy = l[7].Stem.Children.Select(c => GetLeafNodeValue(c, nm, "InvalidKeyColumn")).Select(c => c.EndsWith("-") ? new KeyColumn {
Name = c.Substring(0, c.Length - 1), IsDescending = true
} : new KeyColumn {
Name = c, IsDescending = false
}).ToList();
}
else
{
throw new InvalidSyntaxException("InvalidOrderBy", nm.GetFileRange(l[7]));
}
Mark(OrderBy, l[7]);
}
else
{
throw new InvalidSyntaxException("InvalidOrderBy", nm.GetFileRange(l[7]));
}
}
var q = new QueryDef {
EntityName = EntityName, Verb = Verb, Numeral = Numeral, By = By, OrderBy = OrderBy
};
Mark(q, Line);
return(new List <QueryDef> {
q
});
};
var Queries = f.Content.Value.LineContent.Lines.SelectMany(Line => ParseQueryDef(f.Content.Value.LineContent.IndentLevel, Line)).ToList();
Mark(Queries, f);
var ql = new QueryListDef {
Queries = Queries
};
Mark(ql, f);
var t = TypeDef.CreateQueryList(ql);
Mark(t, f);
Types.Add(t);
return(new List <TFSemantics.Node> {
});
}
else
{
throw new InvalidEvaluationException("UnknownFunction", nm.GetFileRange(f), f);
}
}
};
var e = new TreeFormatEvaluator(es, pr);
e.Evaluate();
}
else
{
var pr = new TreeFormatParseResult
{
Value = new Forest {
MultiNodesList = new List <MultiNodes> {
TopNode
}
},
Text = Text,
Positions = ParserResult.Positions,
RawFunctionCalls = ParserResult.RawFunctionCalls
};
var es = new TreeFormatEvaluateSetting {
};
var e = new TreeFormatEvaluator(es, pr);
var er = e.Evaluate();
if (er.Value.Nodes.Count > 0)
{
var ReadResult = ts.Read <Schema>(CollectionOperations.CreatePair(er.Value, er.Positions));
Types.AddRange(ReadResult.Key.Types);
TypeRefs.AddRange(ReadResult.Key.TypeRefs);
Imports.AddRange(ReadResult.Key.Imports);
foreach (var p in ReadResult.Value)
{
if (p.Value.Range.OnSome)
{
Positions.Add(p.Key, p.Value.Range.Value);
}
}
}
}
}
var Schema = new Schema {
Types = Types, TypeRefs = TypeRefs, Imports = Imports
};
return(new FileParserResult {
Schema = Schema, Text = Text, Positions = Positions
});
}
private void Load(String TreePath, StreamReader Reader, List <Semantics.Node> EntityMappings)
{
var Functions = new HashSet <String>()
{
"Map"
};
var TableParameterFunctions = Functions;
var TableContentFunctions = new HashSet <String>(Functions.Except(new List <String> {
"Map"
}));
TreeFormatParseSetting ps;
if (tfpo == null)
{
ps = new TreeFormatParseSetting()
{
IsTableParameterFunction = Name => TableParameterFunctions.Contains(Name),
IsTableContentFunction = Name => TableContentFunctions.Contains(Name)
};
}
else
{
ps = new TreeFormatParseSetting()
{
IsTableParameterFunction = Name =>
{
if (TableParameterFunctions.Contains(Name))
{
return(true);
}
return(tfpo.IsTableParameterFunction(Name));
},
IsTableContentFunction = Name =>
{
if (TableContentFunctions.Contains(Name))
{
return(true);
}
return(tfpo.IsTableContentFunction(Name));
},
IsTreeParameterFunction = tfpo.IsTreeParameterFunction,
IsTreeContentFunction = tfpo.IsTreeContentFunction
};
}
var pr = TreeFile.ReadRaw(Reader, TreePath, ps);
var Text = pr.Text;
Func <int, Syntax.TextLine, ISemanticsNodeMaker, List <Semantics.Node> > ParseEntityMappingsAsSemanticsNodes = (IndentLevel, Line, nm) =>
{
var l = new List <Semantics.Node>();
List <Semantics.Node> cl = null;
Syntax.TextPosition clStart = default(Syntax.TextPosition);
Syntax.TextPosition clEnd = default(Syntax.TextPosition);
if (Line.Text.Length < IndentLevel * 4)
{
return(new List <Semantics.Node> {
});
}
var LineRange = new Syntax.TextRange {
Start = Text.Calc(Line.Range.Start, IndentLevel * 4), End = Line.Range.End
};
var Range = LineRange;
while (true)
{
var tpr = TreeFormatTokenParser.ReadToken(Text, pr.Positions, Range);
if (!tpr.OnSome)
{
break;
}
var v = tpr.Value.Token;
if (v.OnSingleLineComment)
{
break;
}
if (v.OnLeftParenthesis)
{
if (cl != null)
{
throw new Syntax.InvalidTokenException("DoubleLeftParenthesis", new Syntax.FileTextRange {
Text = Text, Range = Range
}, "(");
}
cl = new List <Semantics.Node>();
clStart = Range.Start;
clEnd = Range.End;
}
else if (v.OnRightParenthesis)
{
if (cl == null)
{
throw new Syntax.InvalidTokenException("DismatchedRightParenthesis", new Syntax.FileTextRange {
Text = Text, Range = Range
}, ")");
}
if (cl.Count == 0)
{
throw new Syntax.InvalidTokenException("EmptyIndex", new Syntax.FileTextRange {
Text = Text, Range = Range
}, ")");
}
if (tpr.Value.RemainingChars.OnSome)
{
clEnd = tpr.Value.RemainingChars.Value.End;
}
l.Add(nm.MakeStemNode("", cl, new Syntax.TextRange {
Start = clStart, End = clEnd
}));
cl = null;
clStart = default(Syntax.TextPosition);
clEnd = default(Syntax.TextPosition);
}
else if (v.OnSingleLineLiteral)
{
if (cl != null)
{
cl.Add(nm.MakeLeafNode(v.SingleLineLiteral, pr.Positions[v]));
}
else
{
l.Add(nm.MakeLeafNode(v.SingleLineLiteral, pr.Positions[v]));
}
}
else if (v.OnPreprocessDirective && (v.PreprocessDirective == "Empty"))
{
if (cl != null)
{
cl.Add(nm.MakeEmptyNode(pr.Positions[v]));
}
else
{
l.Add(nm.MakeEmptyNode(pr.Positions[v]));
}
}
else
{
throw new Syntax.InvalidTokenException("UnknownToken", new Syntax.FileTextRange {
Text = Text, Range = Range
}, Text.GetTextInLine(Range));
}
if (!tpr.Value.RemainingChars.OnSome)
{
break;
}
Range = tpr.Value.RemainingChars.Value;
}
if (cl != null)
{
throw new Syntax.InvalidTokenException("DismatchedRightParentheses", new Syntax.FileTextRange {
Text = Text, Range = Range
}, "");
}
if (l.Count == 0)
{
return(new List <Semantics.Node> {
});
}
if (l.Count < 3)
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
var EntityToken = GetLeafNodeValue(l[0], nm, "InvalidEntityToken");
if (EntityToken != "Entity")
{
throw new Syntax.InvalidSyntaxException("InvalidEntityToken", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
var EntityName = GetLeafNodeValue(l[1], nm, "InvalidEntityName");
var EntityMethodToken = GetLeafNodeValue(l[2], nm, "InvalidEntityMethodToken");
if (EntityMethodToken == "New")
{
if (l.Count != 3)
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
return(new List <Semantics.Node>
{
MakeStemNode("EntityMapping",
MakeStemNode("EntityName", MakeLeafNode(EntityName)),
MakeStemNode("Method", MakeStemNode("New", MakeEmptyNode()))
)
});
}
else if (EntityMethodToken == "From")
{
if (l.Count != 4)
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
var EntityNameSource = GetLeafNodeValue(l[3], nm, "InvalidEntityName");
return(new List <Semantics.Node>
{
MakeStemNode("EntityMapping",
MakeStemNode("EntityName", MakeLeafNode(EntityName)),
MakeStemNode("Method", MakeStemNode("Copy", MakeLeafNode(EntityNameSource)))
)
});
}
else if (EntityMethodToken == "Field")
{
if (l.Count < 6)
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
var FieldName = GetLeafNodeValue(l[3], nm, "InvalidFieldName");
var FieldMethodToken = GetLeafNodeValue(l[4], nm, "InvalidFieldMethodToken");
if (FieldMethodToken == "New")
{
if (l.Count != 6)
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
if (!EntityFields.ContainsKey(EntityName))
{
throw new Syntax.InvalidSyntaxException("EntityNotExist", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
var e = EntityFields[EntityName];
if (!e.ContainsKey(FieldName))
{
throw new Syntax.InvalidSyntaxException("FieldNotExist", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
var Literal = l[5];
Semantics.Node Value;
var f = e[FieldName];
if (f.Type.OnTypeRef)
{
if (Literal.OnEmpty)
{
throw new Syntax.InvalidSyntaxException("FieldTypeIncompatible", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
else
{
Value = MakeStemNode("Some", MakeStemNode(f.Type.TypeRef.Value + "Value", Literal));
}
}
else if (f.Type.OnOptional)
{
if (Literal.OnEmpty)
{
Value = MakeStemNode("None", MakeEmptyNode());
}
else
{
Value = MakeStemNode("Some", MakeStemNode(f.Type.Optional.Value + "Value", Literal));
}
}
else if (f.Type.OnList)
{
if (f.Type.List.Value == "Byte")
{
if (Literal.OnEmpty)
{
throw new Syntax.InvalidSyntaxException("FieldTypeIncompatible", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
else
{
Value = MakeStemNode("Some", MakeStemNode("BinaryValue", Literal));
}
}
else
{
throw new InvalidOperationException();
}
}
else
{
throw new Syntax.InvalidSyntaxException("FieldTypeIncompatible", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
return(new List <Semantics.Node>
{
MakeStemNode("EntityMapping",
MakeStemNode("EntityName", MakeLeafNode(EntityName)),
MakeStemNode("Method", MakeStemNode("Field",
MakeStemNode("FieldName", MakeLeafNode(FieldName)),
MakeStemNode("Method", MakeStemNode("New", Value))
))
)
});
}
else if (FieldMethodToken == "From")
{
if (l.Count != 6)
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
var FieldNameSource = GetLeafNodeValue(l[5], nm, "InvalidFieldName");
return(new List <Semantics.Node>
{
MakeStemNode("EntityMapping",
MakeStemNode("EntityName", MakeLeafNode(EntityName)),
MakeStemNode("Method", MakeStemNode("Field",
MakeStemNode("FieldName", MakeLeafNode(FieldName)),
MakeStemNode("Method", MakeStemNode("Copy", MakeLeafNode(FieldNameSource)))
))
)
});
}
else
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
}
else
{
throw new Syntax.InvalidSyntaxException("InvalidEntityMapping", new Syntax.FileTextRange {
Text = Text, Range = LineRange
});
}
};
var es = new TreeFormatEvaluateSetting()
{
FunctionCallEvaluator = (f, nm) =>
{
if (f.Parameters.Count == 0)
{
if (f.Name.Text == "Map")
{
var Nodes = f.Content.Value.LineContent.Lines.SelectMany(Line => ParseEntityMappingsAsSemanticsNodes(f.Content.Value.LineContent.IndentLevel, Line, nm)).ToArray();
return(new List <Semantics.Node>
{
MakeStemNode("ListOfEntityMapping", Nodes)
});
}
else
{
if (tfeo != null)
{
return(tfeo.FunctionCallEvaluator(f, nm));
}
throw new Syntax.InvalidEvaluationException("UnknownFunction", nm.GetFileRange(f), f);
}
}
else
{
throw new Syntax.InvalidEvaluationException("InvalidParameterCount", nm.GetFileRange(f), f);
}
},
TokenParameterEvaluator = tfeo != null ? tfeo.TokenParameterEvaluator : null
};
var tfe = new TreeFormatEvaluator(es, pr);
var t = tfe.Evaluate();
foreach (var n in t.Value.Nodes)
{
EntityMappings.AddRange(n.Stem.Children);
}
foreach (var p in t.Positions)
{
Positions.Add(p.Key, p.Value);
}
}