private static TypeSpec TranslateTypeSpec(OS.TypeSpec t, Text Text, Dictionary <Object, TextRange> InnerPositions, Dictionary <Object, TextRange> Positions)
{
if (t.OnTypeRef)
{
var r = TypeSpec.CreateTypeRef((TypeRef)(t.TypeRef.VersionedName()));
if (InnerPositions.ContainsKey(t))
{
Positions.Add(r, InnerPositions[t]);
}
return(r);
}
else if (t.OnGenericTypeSpec && t.GenericTypeSpec.TypeSpec.OnTypeRef && t.GenericTypeSpec.TypeSpec.TypeRef.NameMatches("Optional") && t.GenericTypeSpec.ParameterValues.Count == 1)
{
var Parameter = t.GenericTypeSpec.ParameterValues.Single();
var InnerType = TranslateTypeSpec(Parameter, Text, InnerPositions, Positions);
if (InnerType.OnTypeRef)
{
var r = TypeSpec.CreateOptional(InnerType.TypeRef);
if (InnerPositions.ContainsKey(t))
{
Positions.Add(r, InnerPositions[t]);
}
return(r);
}
}
else if (t.OnGenericTypeSpec && t.GenericTypeSpec.TypeSpec.OnTypeRef && t.GenericTypeSpec.TypeSpec.TypeRef.NameMatches("List") && t.GenericTypeSpec.ParameterValues.Count == 1)
{
var Parameter = t.GenericTypeSpec.ParameterValues.Single();
if (Parameter.OnTypeRef && Parameter.TypeRef.NameMatches("Byte"))
{
var r = TypeSpec.CreateTypeRef((TypeRef)("Binary"));
if (InnerPositions.ContainsKey(t))
{
Positions.Add(r, InnerPositions[t]);
}
return(r);
}
else
{
var InnerType = TranslateTypeSpec(Parameter, Text, InnerPositions, Positions);
if (InnerType.OnTypeRef)
{
var r = TypeSpec.CreateList(InnerType.TypeRef);
if (InnerPositions.ContainsKey(t))
{
Positions.Add(r, InnerPositions[t]);
}
return(r);
}
}
}
var oRange = InnerPositions.ContainsKey(t) ? InnerPositions[t] : TreeFormat.Optional <TextRange> .Empty;
var FileRange = new FileTextRange {
Text = Text, Range = oRange
};
throw new InvalidEvaluationException("InvalidTypeSpec", FileRange, t);
}
private PrimitiveType ParseType(String e, FileTextRange r)
{
if (e.Equals("Boolean", StringComparison.Ordinal))
{
return(PrimitiveType.Boolean);
}
if (e.Equals("Int", StringComparison.Ordinal))
{
return(PrimitiveType.Int);
}
if (e.Equals("Real", StringComparison.Ordinal))
{
return(PrimitiveType.Real);
}
throw new InvalidSyntaxException("TypeInvalid: " + e, r);
}
private static TypeSpec ParseTypeSpec(TFSemantics.Node TypeNode, ISemanticsNodeMaker nm, Dictionary <Object, TextRange> Positions)
{
var TypeSpecString = GetLeafNodeValue(TypeNode, nm, "InvalidTypeSpec");
var InnerPositions = new Dictionary <Object, TextRange>();
var ts = OS.TypeParser.ParseTypeSpec
(
TypeSpecString,
(o, Start, End) =>
{
var oRange = nm.GetRange(TypeNode);
if (oRange.OnSome)
{
var Range = oRange.Value;
var TypeRange = new TextRange {
Start = nm.Text.Calc(Range.Start, Start), End = nm.Text.Calc(Range.Start, End)
};
InnerPositions.Add(o, TypeRange);
}
},
Index =>
{
var FileRange = TreeFormat.Optional <FileTextRange> .Empty;
var oRange = nm.GetRange(TypeNode);
if (oRange.OnSome)
{
var Range = oRange.Value;
FileRange = new FileTextRange {
Text = nm.Text, Range = new TextRange {
Start = nm.Text.Calc(Range.Start, Index), End = nm.Text.Calc(Range.Start, Index + 1)
}
};
}
return(new InvalidTokenException("InvalidChar", FileRange, TypeSpecString.Substring(Index, 1)));
}
);
return(TranslateTypeSpec(ts, nm.Text, InnerPositions, Positions));
}
public SyntaxParserResult Parse(TextRange RangeInLine)
{
var TokenQueue = new LinkedList <SyntaxRule>();
var r = RangeInLine;
while (true)
{
var t = tp.ReadToken(r);
if (t.Token.OnSome)
{
TokenQueue.AddLast(t.Token.Some);
}
if (!t.RemainingChars.OnSome)
{
break;
}
r = t.RemainingChars.Some;
}
var StateStack = new Stack <int>();
var RuleStack = new Stack <SyntaxRule>();
var BinaryOperatorStack = new Stack <TokenBinaryOperator>();
var State = 0; //初始状态为0
StateStack.Push(State);
Optional <SyntaxRule> Token = Optional <SyntaxRule> .Empty;
Action <SyntaxRule, TextRange> Mark = (st, Range) =>
{
if (st.OnExpr)
{
Positions.Add(st.Expr, Range);
}
else if (st.OnParameterList)
{
Positions.Add(st.ParameterList, Range);
}
else if (st.OnNonnullParameterList)
{
Positions.Add(st.NonnullParameterList, Range);
}
Positions.Add(st, Range);
};
Func <Boolean> EndOfFile = () => TokenQueue.Count == 0;
Action <int> Shift = NewState =>
{
StateStack.Push(NewState);
RuleStack.Push(TokenQueue.First.Value);
TokenQueue.RemoveFirst();
};
Action <Func <SyntaxRule> > Reduce0 = f =>
{
var st = f();
TextRange Range;
if (EndOfFile())
{
Range = new TextRange {
Start = RangeInLine.End, End = RangeInLine.End
};
}
else
{
var NextTokenRange = Positions[Token.Some];
Range = new TextRange {
Start = NextTokenRange.Start, End = NextTokenRange.Start
};
}
Mark(st, Range);
TokenQueue.AddFirst(st);
};
Action <Func <SyntaxRule, SyntaxRule> > Reduce1 = f =>
{
var Rule0 = RuleStack.Pop();
StateStack.Pop();
var st = f(Rule0);
var Rule0Range = Positions[Rule0];
var Range = Rule0Range;
Mark(st, Range);
TokenQueue.AddFirst(st);
};
Action <Func <SyntaxRule, SyntaxRule, SyntaxRule> > Reduce2 = f =>
{
var Rule1 = RuleStack.Pop();
var Rule0 = RuleStack.Pop();
StateStack.Pop();
StateStack.Pop();
var st = f(Rule0, Rule1);
var Rule0Range = Positions[Rule0];
var Rule1Range = Positions[Rule1];
var Range = new TextRange {
Start = Rule0Range.Start, End = Rule1Range.End
};
Mark(st, Range);
TokenQueue.AddFirst(st);
};
Action <Func <SyntaxRule, SyntaxRule, SyntaxRule, SyntaxRule> > Reduce3 = f =>
{
var Rule2 = RuleStack.Pop();
var Rule1 = RuleStack.Pop();
var Rule0 = RuleStack.Pop();
StateStack.Pop();
StateStack.Pop();
StateStack.Pop();
var st = f(Rule0, Rule1, Rule2);
var Rule0Range = Positions[Rule0];
var Rule2Range = Positions[Rule2];
var Range = new TextRange {
Start = Rule0Range.Start, End = Rule2Range.End
};
Mark(st, Range);
TokenQueue.AddFirst(st);
};
Action <Func <SyntaxRule, SyntaxRule, SyntaxRule, SyntaxRule, SyntaxRule> > Reduce4 = f =>
{
var Rule3 = RuleStack.Pop();
var Rule2 = RuleStack.Pop();
var Rule1 = RuleStack.Pop();
var Rule0 = RuleStack.Pop();
StateStack.Pop();
StateStack.Pop();
StateStack.Pop();
StateStack.Pop();
var st = f(Rule0, Rule1, Rule2, Rule3);
var Rule0Range = Positions[Rule0];
var Rule3Range = Positions[Rule3];
var Range = new TextRange {
Start = Rule0Range.Start, End = Rule3Range.End
};
Mark(st, Range);
TokenQueue.AddFirst(st);
};
Action <SyntaxRule> Replace = f =>
{
Mark(f, Positions[Token.Some]);
Token = f;
TokenQueue.First.Value = f;
};
Func <InvalidSyntaxException> MakeInvalidEndOfFile = () =>
{
var Range = new FileTextRange {
Text = Text, Range = new TextRange {
Start = RangeInLine.End, End = RangeInLine.End
}
};
return(new InvalidSyntaxException("InvalidEndOfFile", Range));
};
Func <InvalidSyntaxException> MakeInvalidSyntaxRule = () =>
{
var tr = Positions[Token.Some];
var Range = new FileTextRange {
Text = Text, Range = tr
};
var t = Text.GetTextInLine(tr);
return(new InvalidSyntaxException(String.Format("'{0}' : InvalidSyntaxRuleAtToken", t), Range));
};
while (true)
{
State = StateStack.Peek();
Token = EndOfFile() ? Optional <SyntaxRule> .Empty : TokenQueue.First.Value;
if (State == 0)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnLiteral)
{
Shift(1);
}
else if (t.OnIdentifier)
{
Shift(2);
}
else if (t.OnBinaryOperator)
{
if (t.BinaryOperator.Name == "+" || t.BinaryOperator.Name == "-")
{
Replace(SyntaxRule.CreateUnaryOperator(new TokenUnaryOperator {
Name = t.BinaryOperator.Name
}));
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (t.OnUnaryOperator)
{
Shift(3);
}
else if (t.OnLeftParen)
{
Shift(4);
}
else if (t.OnRightParen)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnComma)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnExpr)
{
Shift(5);
}
else if (t.OnParameterList)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnNonnullParameterList)
{
throw MakeInvalidSyntaxRule();
}
else
{
throw new InvalidOperationException();
}
}
else if (State == 1)
{
Reduce1(l => SyntaxRule.CreateExpr(SyntaxExpr.CreateLiteral(new ProductionLiteral {
Literal = l.Literal
})));
}
else if (State == 2)
{
if (Token.OnSome && Token.Some.OnLeftParen)
{
Shift(6);
}
else
{
Reduce1(i => SyntaxRule.CreateExpr(SyntaxExpr.CreateVariable(new ProductionVariable {
Identifier = i.Identifier
})));
}
}
else if (State == 3)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnLiteral)
{
Shift(1);
}
else if (t.OnIdentifier)
{
Shift(2);
}
else if (t.OnBinaryOperator)
{
if (t.BinaryOperator.Name == "+" || t.BinaryOperator.Name == "-")
{
Replace(SyntaxRule.CreateUnaryOperator(new TokenUnaryOperator {
Name = t.BinaryOperator.Name
}));
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (t.OnUnaryOperator)
{
Shift(3);
}
else if (t.OnLeftParen)
{
Shift(4);
}
else if (t.OnRightParen)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnComma)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnExpr)
{
Shift(7);
}
else if (t.OnParameterList)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnNonnullParameterList)
{
throw MakeInvalidSyntaxRule();
}
else
{
throw new InvalidOperationException();
}
}
else if (State == 4)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnLiteral)
{
Shift(1);
}
else if (t.OnIdentifier)
{
Shift(2);
}
else if (t.OnBinaryOperator)
{
if (t.BinaryOperator.Name == "+" || t.BinaryOperator.Name == "-")
{
Replace(SyntaxRule.CreateUnaryOperator(new TokenUnaryOperator {
Name = t.BinaryOperator.Name
}));
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (t.OnUnaryOperator)
{
Shift(3);
}
else if (t.OnLeftParen)
{
Shift(4);
}
else if (t.OnRightParen)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnComma)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnExpr)
{
Shift(8);
}
else if (t.OnParameterList)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnNonnullParameterList)
{
throw MakeInvalidSyntaxRule();
}
else
{
throw new InvalidOperationException();
}
}
else if (State == 5)
{
if (!Token.OnSome)
{
return(new SyntaxParserResult {
Syntax = RuleStack.Single().Expr
});
}
var t = Token.Some;
if (t.OnBinaryOperator)
{
BinaryOperatorStack.Push(t.BinaryOperator);
Shift(9);
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (State == 6)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnLiteral)
{
Shift(1);
}
else if (t.OnIdentifier)
{
Shift(2);
}
else if (t.OnBinaryOperator)
{
if (t.BinaryOperator.Name == "+" || t.BinaryOperator.Name == "-")
{
Replace(SyntaxRule.CreateUnaryOperator(new TokenUnaryOperator {
Name = t.BinaryOperator.Name
}));
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (t.OnUnaryOperator)
{
Shift(3);
}
else if (t.OnLeftParen)
{
Shift(4);
}
else if (t.OnRightParen)
{
Reduce0(() => SyntaxRule.CreateParameterList(SyntaxParameterList.CreateNull(new ProductionNullParameterList {
})));
}
else if (t.OnComma)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnExpr)
{
Shift(10);
}
else if (t.OnParameterList)
{
Shift(11);
}
else if (t.OnNonnullParameterList)
{
Shift(12);
}
else
{
throw new InvalidOperationException();
}
}
else if (State == 7)
{
if (Token.OnSome && Token.Some.OnLeftParen)
{
Shift(6);
}
else
{
Reduce2((u, e) => SyntaxRule.CreateExpr(SyntaxExpr.CreateUnaryOperator(new ProductionUnaryOperator {
UnaryOperator = u.UnaryOperator, Expr = e.Expr
})));
}
}
else if (State == 8)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnBinaryOperator)
{
BinaryOperatorStack.Push(t.BinaryOperator);
Shift(9);
}
else if (t.OnRightParen)
{
Shift(13);
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (State == 9)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnLiteral)
{
Shift(1);
}
else if (t.OnIdentifier)
{
Shift(2);
}
else if (t.OnBinaryOperator)
{
if (t.BinaryOperator.Name == "+" || t.BinaryOperator.Name == "-")
{
Replace(SyntaxRule.CreateUnaryOperator(new TokenUnaryOperator {
Name = t.BinaryOperator.Name
}));
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (t.OnUnaryOperator)
{
Shift(3);
}
else if (t.OnLeftParen)
{
Shift(4);
}
else if (t.OnRightParen)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnComma)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnExpr)
{
Shift(14);
}
else if (t.OnParameterList)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnNonnullParameterList)
{
throw MakeInvalidSyntaxRule();
}
else
{
throw new InvalidOperationException();
}
}
else if (State == 10)
{
if (Token.OnSome && Token.Some.OnBinaryOperator)
{
BinaryOperatorStack.Push(Token.Some.BinaryOperator);
Shift(9);
}
else
{
Reduce1(e => SyntaxRule.CreateNonnullParameterList(SyntaxNonnullParameterList.CreateSingle(new ProductionSingleParameterList {
Expr = e.Expr
})));
}
}
else if (State == 11)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnRightParen)
{
Shift(15);
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (State == 12)
{
if (Token.OnSome && Token.Some.OnComma)
{
Shift(16);
}
else
{
Reduce1(n => SyntaxRule.CreateParameterList(SyntaxParameterList.CreateNonnull(new ProductionNonnullParameterList {
NonnullParameterList = n.NonnullParameterList
})));
}
}
else if (State == 13)
{
Reduce3((lp, e, rp) => SyntaxRule.CreateExpr(SyntaxExpr.CreateParen(new ProductionParen {
Expr = e.Expr
})));
}
else if (State == 14)
{
if (Token.OnSome && Token.Some.OnBinaryOperator)
{
var sbo = BinaryOperatorStack.Peek();
var bo = Token.Some.BinaryOperator;
var sp = GetPriority(sbo);
var p = GetPriority(bo);
if (p == 3 && p == sp && bo.Name != sbo.Name)
{
throw MakeInvalidSyntaxRule();
}
else if (p >= sp)
{
Reduce3((le, b, re) => SyntaxRule.CreateExpr(SyntaxExpr.CreateBinaryOperator(new ProductionBinaryOperator {
Left = le.Expr, BinaryOperator = b.BinaryOperator, Right = re.Expr
})));
BinaryOperatorStack.Pop();
}
else
{
BinaryOperatorStack.Push(Token.Some.BinaryOperator);
Shift(9);
}
}
else
{
Reduce3((le, b, re) => SyntaxRule.CreateExpr(SyntaxExpr.CreateBinaryOperator(new ProductionBinaryOperator {
Left = le.Expr, BinaryOperator = b.BinaryOperator, Right = re.Expr
})));
BinaryOperatorStack.Pop();
}
}
else if (State == 15)
{
Reduce4((i, lp, p, rp) => SyntaxRule.CreateExpr(SyntaxExpr.CreateFunction(new ProductionFunction {
Identifier = i.Identifier, ParameterList = p.ParameterList
})));
}
else if (State == 16)
{
if (!Token.OnSome)
{
throw MakeInvalidEndOfFile();
}
var t = Token.Some;
if (t.OnLiteral)
{
Shift(1);
}
else if (t.OnIdentifier)
{
Shift(2);
}
else if (t.OnBinaryOperator)
{
if (t.BinaryOperator.Name == "+" || t.BinaryOperator.Name == "-")
{
Replace(SyntaxRule.CreateUnaryOperator(new TokenUnaryOperator {
Name = t.BinaryOperator.Name
}));
}
else
{
throw MakeInvalidSyntaxRule();
}
}
else if (t.OnUnaryOperator)
{
Shift(3);
}
else if (t.OnLeftParen)
{
Shift(4);
}
else if (t.OnRightParen)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnComma)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnExpr)
{
Shift(17);
}
else if (t.OnParameterList)
{
throw MakeInvalidSyntaxRule();
}
else if (t.OnNonnullParameterList)
{
throw MakeInvalidSyntaxRule();
}
else
{
throw new InvalidOperationException();
}
}
else if (State == 17)
{
if (Token.OnSome && Token.Some.OnBinaryOperator)
{
BinaryOperatorStack.Push(Token.Some.BinaryOperator);
Shift(9);
}
else
{
Reduce3((n, c, e) => SyntaxRule.CreateNonnullParameterList(SyntaxNonnullParameterList.CreateMultiple(new ProductionMultipleParameterList {
NonnullParameterList = n.NonnullParameterList, Expr = e.Expr
})));
}
}
else
{
throw new InvalidOperationException();
}
}
throw new InvalidOperationException();
}
