private void JsonObject(TerminalSet _TS, out BaseTerm t)
{
BaseTerm e;
List <BaseTerm> listItems = new List <BaseTerm>();
GetSymbol(new TerminalSet(terminalCount, LCuBracket), true, true);
GetSymbol(new TerminalSet(terminalCount, StringLiteral, RCuBracket), false, true);
if (symbol.TerminalId == StringLiteral)
{
while (true)
{
JsonPair(new TerminalSet(terminalCount, Comma, RCuBracket), out e);
listItems.Add(e);
GetSymbol(new TerminalSet(terminalCount, Comma, RCuBracket), false, true);
if (symbol.TerminalId == Comma)
{
symbol.SetProcessed();
}
else
{
break;
}
}
}
GetSymbol(new TerminalSet(terminalCount, RCuBracket), true, true);
t = JsonTerm.FromArray(listItems.ToArray());
}
private void JsonArray(TerminalSet _TS, out BaseTerm t)
{
BaseTerm e;
List <BaseTerm> listItems = new List <BaseTerm>();
GetSymbol(new TerminalSet(terminalCount, LSqBracket), true, true);
GetSymbol(new TerminalSet(terminalCount, IntLiteral, RealLiteral, StringLiteral, LSqBracket, RSqBracket, LCuBracket,
TrueSym, FalseSym, NullSym), false, true);
if (symbol.IsMemberOf(IntLiteral, RealLiteral, StringLiteral, LSqBracket, LCuBracket, TrueSym, FalseSym, NullSym))
{
while (true)
{
JsonValue(new TerminalSet(terminalCount, Comma, RSqBracket), out e);
listItems.Add(e);
GetSymbol(new TerminalSet(terminalCount, Comma, RSqBracket), false, true);
if (symbol.TerminalId == Comma)
{
symbol.SetProcessed();
}
else
{
break;
}
}
}
GetSymbol(new TerminalSet(terminalCount, RSqBracket), true, true);
t = new CompoundTerm("array", ListTerm.ListFromArray(listItems.ToArray(), BaseTerm.EMPTYLIST));
}
// Computes set of expected terms in a parser state. While there may be extended list of symbols expected at some point,
// we want to reorganize and reduce it. For example, if the current state expects all arithmetic operators as an input,
// it would be better to not list all operators (+, -, *, /, etc) but simply put "operator" covering them all.
// To achieve this grammar writer can group operators (or any other terminals) into named groups using Grammar's methods
// AddTermReportGroup, AddNoReportGroup etc. Then instead of reporting each operator separately, Irony would include
// a single "group name" to represent them all.
// The "expected report set" is not computed during parser construction (it would bite considerable time), but on demand during parsing,
// when error is detected and the expected set is actually needed for error message.
// Multi-threading concerns. When used in multi-threaded environment (web server), the LanguageData would be shared in
// application-wide cache to avoid rebuilding the parser data on every request. The LanguageData is immutable, except
// this one case - the expected sets are constructed late by CoreParser on the when-needed basis.
// We don't do any locking here, just compute the set and on return from this function the state field is assigned.
// We assume that this field assignment is an atomic, concurrency-safe operation. The worst thing that might happen
// is "double-effort" when two threads start computing the same set around the same time, and the last one to finish would
// leave its result in the state field.
#endregion
internal static StringSet ComputeGroupedExpectedSetForState(Grammar grammar, ParserState state)
{
var terms = new TerminalSet();
terms.UnionWith(state.ExpectedTerminals);
var result = new StringSet();
//Eliminate no-report terminals
foreach (var group in grammar.TermReportGroups)
{
if (group.GroupType == TermReportGroupType.DoNotReport)
{
terms.ExceptWith(group.Terminals);
}
}
//Add normal and operator groups
foreach (var group in grammar.TermReportGroups)
{
if ((group.GroupType == TermReportGroupType.Normal || group.GroupType == TermReportGroupType.Operator) &&
terms.Overlaps(group.Terminals))
{
result.Add(group.Alias);
terms.ExceptWith(group.Terminals);
}
}
//Add remaining terminals "as is"
foreach (var terminal in terms)
{
result.Add(terminal.ErrorAlias);
}
return(result);
}
void JsonObject(TerminalSet _TS, out BaseTerm t)
{
#if LL1_tracing
ReportParserProcEntry("JsonObject");
#endif
BaseTerm e;
List <BaseTerm> listItems = new List <BaseTerm> ();
GetSymbol(new TerminalSet(terminalCount, LCuBracket), true, true);
GetSymbol(new TerminalSet(terminalCount, StringLiteral, RCuBracket), false, true);
if (symbol.Terminal == StringLiteral)
{
while (true)
{
JsonPair(new TerminalSet(terminalCount, Comma, RCuBracket), out e);
listItems.Add(e);
GetSymbol(new TerminalSet(terminalCount, Comma, RCuBracket), false, true);
if (symbol.Terminal == Comma)
{
symbol.SetProcessed();
}
else
{
break;
}
}
}
GetSymbol(new TerminalSet(terminalCount, RCuBracket), true, true);
t = JsonTerm.FromArray(listItems.ToArray());
#if LL1_tracing
ReportParserProcExit("JsonObject");
#endif
}
public Core(CoreFactory factory, int id, Production production, int dot)
{
this.factory = factory;
Id = id;
Production = production;
Dot = dot;
First = new TerminalSet();
}
public TerminalSet GetLookaheadsInConflict()
{
var lkhc = new TerminalSet();
lkhc.UnionWith(Lookaheads);
lkhc.IntersectWith(State.BuilderData.Conflicts);
return(lkhc);
}
public TerminalSet GetShiftReduceConflicts()
{
var result = new TerminalSet();
result.UnionWith(Conflicts);
result.IntersectWith(ShiftTerminals);
return(result);
}
public TerminalSet GetReduceReduceConflicts()
{
var result = new TerminalSet();
result.UnionWith(Conflicts);
result.ExceptWith(ShiftTerminals);
return(result);
}
/// <summary>
/// Closes this item to a set of items
/// </summary>
/// <param name="closure">The list to close</param>
/// <param name="map">The current helper map</param>
public override void CloseTo(List <Item> closure, Dictionary <Rule, Dictionary <int, List <Item> > > map)
{
// the item was of the form [Var -> alpha .] (reduction)
// nothing to do
if (Action == LRActionCode.Reduce)
{
return;
}
// Get the next symbol in the item
Symbol next = GetNextSymbol();
// Here the item is of the form [Var -> alpha . next beta]
// If the next symbol is not a variable : do nothing
// If the next symbol is a variable :
Variable nextVar = next as Variable;
if (nextVar == null)
{
return;
}
// Firsts is a copy of the Firsts set for beta (next choice)
// Firsts will contains symbols that may follow Next
// Firsts will therefore be the lookahead for child items
TerminalSet firsts = new TerminalSet(GetNextChoice().Firsts);
// If beta is nullifiable (contains ε) :
if (firsts.Contains(Epsilon.Instance))
{
// Remove ε
firsts.Remove(Epsilon.Instance);
// Add the item's lookaheads
firsts.AddRange(lookaheads);
}
// For each rule that has Next as a head variable :
foreach (Rule rule in nextVar.Rules)
{
if (!map.ContainsKey(rule))
{
map.Add(rule, new Dictionary <int, List <Item> >());
}
Dictionary <int, List <Item> > sub = map[rule];
if (sub.ContainsKey(0))
{
List <Item> previouses = sub[0];
ItemLALR1 previous = previouses[0] as ItemLALR1;
previous.Lookaheads.AddRange(firsts);
}
else
{
List <Item> items = new List <Item>();
sub.Add(0, items);
ItemLALR1 New = new ItemLALR1(rule, 0, firsts);
closure.Add(New);
items.Add(New);
}
}
}
private void JsonPair(TerminalSet _TS, out BaseTerm t)
{
BaseTerm t0, t1;
GetSymbol(new TerminalSet(terminalCount, StringLiteral), true, true);
t0 = new StringTerm(symbol.ToString().Dequoted());
GetSymbol(new TerminalSet(terminalCount, Colon), true, true);
JsonValue(_TS, out t1);
t = new OperatorTerm(opTable, PrologParser.COLON, t0, t1);
}
private void RemoveTerminals(TerminalSet terms, params Terminal[] termsToRemove)
{
foreach (var termToRemove in termsToRemove)
{
if (terms.Contains(termToRemove))
{
terms.Remove(termToRemove);
}
}
}
private void JsonStruct(TerminalSet _TS)
{
GetSymbol(new TerminalSet(terminalCount, LSqBracket, LCuBracket), false, true);
if (symbol.TerminalId == LCuBracket)
{
JsonObject(_TS, out jsonListTerm);
}
else
{
JsonArray(_TS, out jsonListTerm);
}
}
public void Add_WhenTerminalIsNotInSet_AddTerminalToSet()
{
// Arrange:
var ts = new TerminalSet();
const string terminal = "t";
// Act:
ts.Add(terminal);
// Assert:
Assert.AreEqual(1, ts.AsEnumerable().Count());
Assert.IsTrue(ts.AsEnumerable().Contains(terminal));
}
public Token Preview(TerminalSet skipTerms)
{
Token tkn;
while (true)
{
tkn = ReadToken();
if (tkn.Terminal == _grammar.Eof || !skipTerms.Contains(tkn.Terminal))
{
break;
}
}
return(tkn);
}
void JsonPair(TerminalSet _TS, out BaseTerm t)
{
#if LL1_tracing
ReportParserProcEntry("JsonPair");
#endif
BaseTerm t0, t1;
GetSymbol(new TerminalSet(terminalCount, StringLiteral), true, true);
t0 = new StringTerm(symbol.ToString().Dequoted());
GetSymbol(new TerminalSet(terminalCount, Colon), true, true);
JsonValue(_TS, out t1);
t = new OperatorTerm(opTable, PrologParser.COLON, t0, t1);
#if LL1_tracing
ReportParserProcExit("JsonPair");
#endif
}
public void Includes_WhenTerminalsIncludeTestFor_ReturnsExpected(string[] terminals, string testFor, bool expected)
{
// Arrange:
var ts = new TerminalSet();
foreach (var terminal in terminals)
{
ts.Add(terminal);
}
// Act:
var actual = ts.Includes(testFor);
// Assert:
Assert.AreEqual(expected, actual);
}
public void IsEmpty_WhenTerminalsHasValues_ReturnsExpected(string[] terminals, bool expected)
{
// Arrange:
var ts = new TerminalSet();
foreach (var terminal in terminals)
{
ts.Add(terminal);
}
// Act:
var actual = ts.IsEmpty();
// Assert:
Assert.AreEqual(expected, actual);
}
private void JsonValue(TerminalSet _TS, out BaseTerm t)
{
GetSymbol(new TerminalSet(terminalCount, IntLiteral, RealLiteral, StringLiteral, LSqBracket, LCuBracket, TrueSym,
FalseSym, NullSym), false, true);
if (symbol.TerminalId == LCuBracket)
{
JsonObject(_TS, out t);
}
else if (symbol.TerminalId == LSqBracket)
{
JsonArray(_TS, out t);
}
else
{
JsonLiteral(_TS, out t);
}
}
public override LR1Set Close()
{
for (var repeat = 0; repeat < 1; ++repeat)
{
for (var i = 0; i < Count; ++i)
{
var from = this[i];
if (!from.IsComplete && from.PostDot is Nonterminal nonterminal)
{
Debug.Assert(nonterminal.IsPid);
var lookahead = new TerminalSet(from.Core.Next.First);
if (lookahead.WithEpsilon)
{
lookahead.UnionWith(from.Lookahead);
lookahead.WithEpsilon = false;
}
foreach (var production in nonterminal.Productions)
{
var add = true;
foreach (var old in this)
{
if (old.Core.Equals(production.Initial))
{
old.Lookahead.UnionWith(lookahead);
add = false;
//break;
}
}
if (add)
{
Debug.Assert(production.Initial != null);
Add(new LR1(production.Initial, false, lookahead));
}
}
}
}
}
Freeze();
return(this);
}
void JsonStruct(TerminalSet _TS)
{
#if LL1_tracing
ReportParserProcEntry("JsonStruct");
#endif
GetSymbol(new TerminalSet(terminalCount, LSqBracket, LCuBracket), false, true);
if (symbol.Terminal == LCuBracket)
{
JsonObject(_TS, out jsonListTerm);
}
else
{
JsonArray(_TS, out jsonListTerm);
}
#if LL1_tracing
ReportParserProcExit("JsonStruct");
#endif
}
void JsonLiteral(TerminalSet _TS, out BaseTerm t)
{
#if LL1_tracing
ReportParserProcEntry("JsonLiteral");
#endif
GetSymbol(new TerminalSet(terminalCount, IntLiteral, RealLiteral, StringLiteral, TrueSym, FalseSym, NullSym), false,
true);
if (symbol.IsMemberOf(IntLiteral, RealLiteral))
{
GetSymbol(new TerminalSet(terminalCount, IntLiteral, RealLiteral), false, true);
if (symbol.Terminal == IntLiteral)
{
symbol.SetProcessed();
}
else
{
symbol.SetProcessed();
}
t = new DecimalTerm(symbol.ToDecimal());
}
else if (symbol.Terminal == StringLiteral)
{
symbol.SetProcessed();
t = new StringTerm(symbol.ToString().Dequoted());
}
else if (symbol.Terminal == TrueSym)
{
symbol.SetProcessed();
t = new AtomTerm("true");
}
else if (symbol.Terminal == FalseSym)
{
symbol.SetProcessed();
t = new AtomTerm("false");
}
else
{
symbol.SetProcessed();
t = new AtomTerm("null");
}
#if LL1_tracing
ReportParserProcExit("JsonLiteral");
#endif
}
internal static StringSet ComputeGroupedExpectedSetForState(Grammar grammar, ParserState state)
{
var terms = new TerminalSet();
terms.UnionWith(state.ExpectedTerminals);
var result = new StringSet();
//Eliminate no-report terminals
foreach(var group in grammar.TermReportGroups)
if (group.GroupType == TermReportGroupType.DoNotReport)
terms.ExceptWith(group.Terminals);
//Add normal and operator groups
foreach(var group in grammar.TermReportGroups)
if((group.GroupType == TermReportGroupType.Normal || group.GroupType == TermReportGroupType.Operator) &&
terms.Overlaps(group.Terminals)) {
result.Add(group.Alias);
terms.ExceptWith(group.Terminals);
}
//Add remaining terminals "as is"
foreach(var terminal in terms)
result.Add(terminal.ErrorAlias);
return result;
}
private void JsonLiteral(TerminalSet _TS, out BaseTerm t)
{
GetSymbol(new TerminalSet(terminalCount, IntLiteral, RealLiteral, StringLiteral, TrueSym, FalseSym, NullSym), false,
true);
if (symbol.IsMemberOf(IntLiteral, RealLiteral))
{
GetSymbol(new TerminalSet(terminalCount, IntLiteral, RealLiteral), false, true);
if (symbol.TerminalId == IntLiteral)
{
symbol.SetProcessed();
}
else
{
symbol.SetProcessed();
}
t = new DecimalTerm(symbol.ToDecimal());
}
else if (symbol.TerminalId == StringLiteral)
{
symbol.SetProcessed();
t = new StringTerm(symbol.ToString().Dequoted());
}
else if (symbol.TerminalId == TrueSym)
{
symbol.SetProcessed();
t = new AtomTerm("true");
}
else if (symbol.TerminalId == FalseSym)
{
symbol.SetProcessed();
t = new AtomTerm("false");
}
else
{
symbol.SetProcessed();
t = new AtomTerm("null");
}
}
/// <summary>
/// Returns a <see cref="System.String"/> that represents the current <see cref="Hime.SDK.Grammars.LR.Item"/>.
/// </summary>
/// <param name="withLookaheads">Whether to show the lookaheads</param>
/// <returns>
/// A <see cref="System.String"/> that represents the current <see cref="Hime.SDK.Grammars.LR.Item"/>.
/// </returns>
public string ToString(bool withLookaheads)
{
StringBuilder builder = new StringBuilder("[");
builder.Append(rule.Head.ToString());
builder.Append(" ->");
int i = 0;
foreach (RuleBodyElement part in rule.Body.Choices[0])
{
if (i == position)
{
builder.Append(" *");
}
builder.Append(" ");
builder.Append(part.ToString());
i++;
}
if (i == position)
{
builder.Append(" *");
}
if (withLookaheads)
{
builder.Append(" ][ ");
TerminalSet lookaheads = Lookaheads;
for (int j = 0; j != lookaheads.Count; j++)
{
if (j != 0)
{
builder.Append(" ");
}
builder.Append(lookaheads[j].ToString());
}
}
builder.Append("]");
return(builder.ToString());
}
void JsonValue(TerminalSet _TS, out BaseTerm t)
{
#if LL1_tracing
ReportParserProcEntry("JsonValue");
#endif
GetSymbol(new TerminalSet(terminalCount, IntLiteral, RealLiteral, StringLiteral, LSqBracket, LCuBracket, TrueSym,
FalseSym, NullSym), false, true);
if (symbol.Terminal == LCuBracket)
{
JsonObject(_TS, out t);
}
else if (symbol.Terminal == LSqBracket)
{
JsonArray(_TS, out t);
}
else
{
JsonLiteral(_TS, out t);
}
#if LL1_tracing
ReportParserProcExit("JsonValue");
#endif
}
public void Union_WhenTwoSets_ReturnsUnionOfSets(string[] set1, string[] set2, string[] expected)
{
// Arrange:
var ts1 = new TerminalSet();
foreach (var terminal in set1)
{
ts1.Add(terminal);
}
var ts2 = new TerminalSet();
foreach (var terminal in set2)
{
ts2.Add(terminal);
}
// Act:
ts1.Union(ts2, false);
// Assert:
Assert.That(ts1.AsEnumerable(), Is.EquivalentTo(expected));
}
private void Predefined(TerminalSet _TS)
{
Term head;
bool opt = true;
TermNode body = null;
Globals.EraseVariables();
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, ImpliesSym, LSqBracket, LCuBracket, PrologString), false, true);
if (symbol.Terminal == ImpliesSym)
{
symbol.SetProcessed();
OperatorDefinition(new TerminalSet(Dot), false);
}
else
{
PrologTerm(new TerminalSet(Dot, ImpliesSym, DCGArrowSym, BuiltinAssignSym), out head);
GetSymbol(new TerminalSet(Dot, ImpliesSym, DCGArrowSym, BuiltinAssignSym), false, true);
if (symbol.IsMemberOf(ImpliesSym, DCGArrowSym, BuiltinAssignSym))
{
GetSymbol(new TerminalSet(ImpliesSym, DCGArrowSym, BuiltinAssignSym), false, true);
if (symbol.Terminal == BuiltinAssignSym)
{
symbol.SetProcessed();
GetSymbol(new TerminalSet(Operator, Atom), false, true);
if (symbol.Terminal == Atom)
{
symbol.SetProcessed();
}
else
{
symbol.SetProcessed();
}
ps.AddPredefined(new ClauseNode(head, new TermNode(symbol.ToString())));
opt = false;
}
else if (symbol.Terminal == ImpliesSym)
{
symbol.SetProcessed();
Query(new TerminalSet(Dot), out body);
ps.AddPredefined(new ClauseNode(head, body));
opt = false;
}
else
{
symbol.SetProcessed();
Term term;
PrologTerm(new TerminalSet(Dot), out term);
body = term.ToDCG(ref head);
ps.AddPredefined(new ClauseNode(head, body));
opt = false;
}
}
if (opt) ps.AddPredefined(new ClauseNode(head, null));
}
GetSymbol(new TerminalSet(Dot), true, true);
}
private void PotentialOpName(TerminalSet _TS, out string name, out bool quoted)
{
GetSymbol(new TerminalSet() /*any symbol*/, false, true);
if (symbol.Terminal == StringLiteral)
{
symbol.SetProcessed();
name = Utils.MakeAtom(symbol.ToUnquoted());
quoted = (name[0] == '\'');
}
else
{
ANYTEXT(_TS);
IsValidOpFormat(name = symbol.ToString(), true);
quoted = false;
}
}
private void OperatorDefinition(TerminalSet _TS, bool user)
{
string name;
string typeStr;
bool quoted;
try
{
terminalTable[COMMA] = Comma;
GetSymbol(new TerminalSet(OpSym), true, true);
GetSymbol(new TerminalSet(LeftParen), true, true);
GetSymbol(new TerminalSet(IntLiteral), true, true);
int prec = symbol.ToInt();
GetSymbol(new TerminalSet(Comma), true, true);
GetSymbol(new TerminalSet(Atom), true, true);
typeStr = symbol.ToString();
GetSymbol(new TerminalSet(Comma), true, true);
GetSymbol(new TerminalSet() /*any symbol*/, false, true);
if (symbol.Terminal == LSqBracket)
{
symbol.SetProcessed();
while (true)
{
PotentialOpName(new TerminalSet(Comma, RSqBracket), out name, out quoted);
AddPrologOperator(prec, typeStr, name, quoted);
GetSymbol(new TerminalSet(Comma, RSqBracket), false, true);
if (symbol.Terminal == Comma)
{
symbol.SetProcessed();
}
else
break;
}
GetSymbol(new TerminalSet(RSqBracket), true, true);
}
else
{
PotentialOpName(new TerminalSet(RightParen), out name, out quoted);
AddPrologOperator(prec, typeStr, name, quoted);
}
GetSymbol(new TerminalSet(RightParen), true, true);
}
finally
{
terminalTable[COMMA] = Operator;
}
}
private void List(TerminalSet _TS, out Term term)
{
Term beforeBar;
Term afterBar = null;
ArrayList elements = null;
terminalTable[DOT] = Atom;
terminalTable[OP] = Atom;
GetSymbol(new TerminalSet(LSqBracket), true, true);
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, RSqBracket, LCuBracket, PrologString), false, true);
if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, PrologString))
{
PrologTerm(new TerminalSet(RSqBracket, VBar), out beforeBar);
elements = beforeBar.ArgumentsToArrayList(false);
GetSymbol(new TerminalSet(RSqBracket, VBar), false, true);
if (symbol.Terminal == VBar)
{
symbol.SetProcessed();
PrologTerm(new TerminalSet(RSqBracket), out afterBar);
}
}
terminalTable[DOT] = Dot;
terminalTable[OP] = OpSym;
GetSymbol(new TerminalSet(RSqBracket), true, true);
if (afterBar == null) term = Term.NULLLIST; else term = afterBar;
if (elements != null)
for (int i = elements.Count - 1; i >= 0; i--) term = new ListTerm((Term)elements[i], term);
}
public GenericResolverHint(TerminalSet skipTokens) : base(ParserActionType.Reduce)
{
this.skipTokens = skipTokens;
}
public LR1(Core core, bool inKernel, TerminalSet lookahead)
: base(core, inKernel)
{
Debug.Assert(!lookahead.IsEmpty);
Lookahead = lookahead;
}
/// <summary>
/// Initializes this item
/// </summary>
/// <param name="rule">The underlying rule</param>
/// <param name="position">The dot position in the rule</param>
/// <param name="lookaheads">The lookaheads for this item</param>
public ItemLALR1(Rule rule, int position, TerminalSet lookaheads) : base(rule, position)
{
this.lookaheads = new TerminalSet(lookaheads);
}
public string TerminalImageSet(TerminalSet ts)
{
StringBuilder result = new StringBuilder();
bool isFirst = true;
int[] ii;
ts.ToIntArray(out ii);
ArrayList a;
foreach (int i in ii)
{
a = TerminalsOf(i);
bool isImage = false;
if (a != null)
foreach (TermDescr td in a)
{
isImage = true;
if (isFirst) isFirst = false; else result.Append(", ");
result.Append(td.Image);
}
if (!isImage)
{
if (isFirst) isFirst = false; else result.Append(", ");
result.Append("<" + (string)names[i] + ">");
}
}
return result.ToString();
}
private void TreeConstruction(TerminalSet _TS)
{
Term t;
PrologTerm(_TS, out t);
Console.WriteLine("Final tree: {0}", t.ToTree());
Console.WriteLine("Final term: {0}", t.ToString());
}
private void PrologTerm(TerminalSet _TS, out Term t)
{
Term lastInfix = null;
string s;
ArrayList termInfixArr = new ArrayList();
termInfixArr.Add(null);
do
{
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, PrologString), false, true);
if (symbol.Terminal == Operator)
{
symbol.SetProcessed();
t = new Term((OperatorDescr)symbol.OValue);
}
else if (symbol.IsMemberOf(StringLiteral, Atom))
{
GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
if (symbol.Terminal == Atom)
{
symbol.SetProcessed();
s = symbol.ToString();
}
else
{
symbol.SetProcessed();
s = Utils.UnquoteIfUnnecessary(symbol.ToString());
}
Term[] terms = null;
bool b = is1000OperatorSetting;
GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, PrologString), false, true);
if (symbol.Terminal == LeftParen)
{
symbol.SetProcessed();
Set1000Operators(true);
terminalTable[DOT] = Atom;
terminalTable[OP] = Atom;
PrologTerm(new TerminalSet(RightParen), out t);
terminalTable[DOT] = Dot;
terminalTable[OP] = OpSym;
terms = t.ArgumentsToTermArray();
Set1000Operators(b);
GetSymbol(new TerminalSet(RightParen), true, true);
}
if (terms == null) t = new Term(s); else t = new Term(s, terms);
}
else if (symbol.Terminal == Identifier)
{
symbol.SetProcessed();
s = symbol.ToString();
t = Globals.GetVariable(s);
if (t == null)
{
t = new NamedVar(s);
Globals.SetVariable(t, s);
}
}
else if (symbol.Terminal == Anonymous)
{
symbol.SetProcessed();
t = new Term();
}
else if (symbol.IsMemberOf(IntLiteral, RealLiteral))
{
GetSymbol(new TerminalSet(IntLiteral, RealLiteral), false, true);
if (symbol.Terminal == IntLiteral)
{
symbol.SetProcessed();
}
else
{
symbol.SetProcessed();
}
t = new Term(symbol.ToString(), FType.number);
}
else if (symbol.Terminal == LSqBracket)
{
List(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, PrologString), out t);
}
else if (symbol.Terminal == LCuBracket)
{
DCGBracketList(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, PrologString), out t);
}
else if (symbol.Terminal == PrologString)
{
symbol.SetProcessed();
t = new Term(symbol.ToUnquoted(), FType.text);
}
else if (symbol.Terminal == CutSym)
{
symbol.SetProcessed();
t = new Cut(0);
}
else
{
symbol.SetProcessed();
PrologTerm(new TerminalSet(RightParen), out t);
GetSymbol(new TerminalSet(RightParen), true, true);
t.IsPacked = true;
}
termInfixArr.Add(t);
Term.AnalyzeInput(ref termInfixArr, ref lastInfix);
GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, PrologString), false, true);
} while (!(_TS.Contains(symbol.Terminal)));
termInfixArr.Add(null);
Term.AnalyzeInput(ref termInfixArr, ref lastInfix);
t = Term.InfixToPrefix(termInfixArr);
}
private void Program(TerminalSet _TS)
{
do
{
ClauseNode(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString));
GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString), false, true);
} while (!(_TS.Contains(symbol.Terminal)));
}
/// <summary>
/// Initializes this item
/// </summary>
/// <param name="copied">The item to copy</param>
public ItemLALR1(Item copied) : base(copied.BaseRule, copied.DotPosition)
{
lookaheads = new TerminalSet();
}
private void PrologCode(TerminalSet _TS)
{
inQueryMode = false;
try
{
SeeEndOfLine = false;
GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, OpSym, BuiltinSym, ProgramSym, ReadingSym, PrologString, QMark), false,
true);
if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, OpSym, BuiltinSym, ProgramSym, ReadingSym, PrologString, QMark))
{
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, OpSym, BuiltinSym, ProgramSym, ReadingSym, PrologString,
QMark), false, true);
if (symbol.Terminal == BuiltinSym)
{
symbol.SetProcessed();
parseMode = ParseMode.Builtin;
Initialize();
Predefineds(_TS);
}
else if (symbol.Terminal == ProgramSym)
{
symbol.SetProcessed();
parseMode = ParseMode.Program;
Initialize();
Program(_TS);
}
else if (symbol.Terminal == ReadingSym)
{
symbol.SetProcessed();
parseMode = ParseMode.Reading;
ClauseSequence(_TS);
}
else
{
Globals.EraseVariables();
parseMode = ParseMode.Query;
inQueryMode = true;
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, OpSym, PrologString, QMark), false, true);
if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, PrologString, QMark))
{
terminalTable[DOT] = Dot;
Set1000Operators(true);
Query(new TerminalSet(Dot), out queryNode);
}
else
{
OperatorDefinition(new TerminalSet(Dot), true);
queryNode = null;
}
GetSymbol(new TerminalSet(Dot), true, true);
}
}
}
finally
{
terminalTable[COMMA] = Operator;
terminalTable[OP] = OpSym;
terminalTable[DOT] = Dot;
Terminate();
}
}
public static bool IsTerminal(string cmd)
{
return(TerminalSet.Contains(cmd));
}
private void Query(TerminalSet _TS, out TermNode body)
{
Term t = null;
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, PrologString, QMark), false, true);
if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, PrologString))
{
PrologTerm(_TS, out t);
body = t.ToGoalList();
}
else
{
symbol.SetProcessed();
body = Term.TREEROOT.ToGoalList();
TreeConstruction(_TS);
}
}
private void ANYTEXT(TerminalSet followers)
{
StreamPointer anyStart;
StreamPointer follower;
if (symbol.IsProcessed)
anyTextStart = streamInPtr.Position;
else
anyTextStart = symbol.Start;
if (followers.Contains(symbol.Terminal) && !symbol.IsProcessed)
{
anyTextFinal = anyTextStart; // empty, nullstring
anyTextFPlus = anyTextStart;
return;
}
parseAnyText = true;
anyStart = streamInPtr;
do
{
follower = streamInPtr;
NextSymbol();
symbol.FinalPlus = symbol.Start; // up to next symbol
anyTextFPlus = symbol.Start;
}
while (symbol.Terminal != EndOfInput && !followers.Contains(symbol.Terminal));
InitCh(follower);
symbol.Start = anyTextStart;
symbol.LineNo = anyStart.LineNo;
symbol.LineStart = anyStart.LineStart;
symbol.Final = streamInPtr.Position;
symbol.Terminal = Undefined;
symbol.SetProcessed(true);
anyTextFinal = streamInPtr.Position;
parseAnyText = false;
}
private void UnpersistentDeclaration(TerminalSet _TS)
{
GetSymbol(new TerminalSet(Unpersistent), true, true);
Term t;
PrologTerm(_TS, out t);
ps.SetUnpersistent(t);
}
private void ClauseNode(TerminalSet _TS)
{
Term head;
TermNode body = null;
ClauseNode c;
if (parseMode != ParseMode.Reading) Globals.EraseVariables();
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString), false, true);
if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, PrologString))
{
PrologTerm(new TerminalSet(Dot, ImpliesSym, DCGArrowSym), out head);
if (!head.IsGoal)
PrologIO.Error("Illegal predicate head: {0}", head.ToString());
GetSymbol(new TerminalSet(Dot, ImpliesSym, DCGArrowSym), false, true);
if (symbol.IsMemberOf(ImpliesSym, DCGArrowSym))
{
GetSymbol(new TerminalSet(ImpliesSym, DCGArrowSym), false, true);
if (symbol.Terminal == ImpliesSym)
{
symbol.SetProcessed();
Query(new TerminalSet(Dot), out body);
}
else
{
symbol.SetProcessed();
Term t;
PrologTerm(new TerminalSet(Dot), out t);
body = t.ToDCG(ref head);
}
}
c = new ClauseNode(head, body);
if (parseMode == ParseMode.Reading) readTerm = new Term(c).CleanUp(); else ps.AddClause(c);
}
else if (symbol.Terminal == PromptSym)
{
symbol.SetProcessed();
bool m = inQueryMode;
bool o = is1000OperatorSetting;
int k = terminalTable[DOT];
try
{
parseMode = ParseMode.Query;
inQueryMode = true;
terminalTable[DOT] = Dot;
Set1000Operators(true);
Query(new TerminalSet(Dot), out queryNode);
PrologIO.Error("'?-' querymode in file not yet supported");
}
finally
{
inQueryMode = m;
terminalTable[DOT] = k;
Set1000Operators(o);
}
}
else
{
symbol.SetProcessed();
terminalTable.Add(Persistent, "Persistent", "persistent");
terminalTable.Add(Module, "Module", "module");
terminalTable.Add(UndefPredAction, "UndefPredAction", "undef_pred_action");
try
{
GetSymbol(new TerminalSet(LSqBracket, OpSym, EnsureLoaded, Discontiguous, AllDiscontiguous, Dynamic, Persistent,
Module, UndefPredAction), false, true);
if (symbol.Terminal == OpSym)
{
OperatorDefinition(new TerminalSet(Dot), true);
}
else if (symbol.Terminal == EnsureLoaded)
{
symbol.SetProcessed();
GetSymbol(new TerminalSet(LeftParen), true, true);
GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
if (symbol.Terminal == Atom)
{
symbol.SetProcessed();
}
else
{
symbol.SetProcessed();
}
string fileName = Utils.ExtendedFileName(symbol.ToString().ToLower(), ".pl");
if (Globals.ConsultedFiles[fileName] == null)
{
ps.Consult(fileName);
Globals.ConsultedFiles[fileName] = true;
}
GetSymbol(new TerminalSet(RightParen), true, true);
}
else if (symbol.Terminal == Discontiguous)
{
symbol.SetProcessed();
Term t;
PrologTerm(new TerminalSet(Dot), out t);
ps.SetDiscontiguous(t);
}
else if (symbol.Terminal == AllDiscontiguous)
{
symbol.SetProcessed();
ps.SetDiscontiguous(true);
}
else if (symbol.Terminal == UndefPredAction)
{
symbol.SetProcessed();
Term t;
PrologTerm(new TerminalSet(Dot), out t);
ps.SetUndefPredAction(t, true);
}
else if (symbol.Terminal == Dynamic)
{
symbol.SetProcessed();
Term t;
PrologTerm(new TerminalSet(Dot), out t);
}
else if (symbol.Terminal == Persistent)
{
PersistentDeclaration(new TerminalSet(Dot));
}
else if (symbol.Terminal == Module)
{
symbol.SetProcessed();
GetSymbol(new TerminalSet(LeftParen), true, true);
try
{
terminalTable[COMMA] = Comma;
GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
if (symbol.Terminal == Atom)
{
symbol.SetProcessed();
}
else
{
symbol.SetProcessed();
}
ps.SetModuleName(symbol.ToString());
GetSymbol(new TerminalSet(Comma), true, true);
}
finally
{
terminalTable[COMMA] = Operator;
}
Term t;
PrologTerm(new TerminalSet(RightParen), out t);
GetSymbol(new TerminalSet(RightParen), true, true);
}
else
{
symbol.SetProcessed();
int lines = 0;
int files = 0;
try
{
while (true)
{
GetSymbol(new TerminalSet(StringLiteral, Atom), false, true);
if (symbol.Terminal == Atom)
{
symbol.SetProcessed();
}
else
{
symbol.SetProcessed();
}
string fileName = Utils.FileNameFromSymbol(symbol.ToString(), ".pl");
terminalTable[COMMA] = Operator;
lines += ps.Consult(fileName);
files++;
terminalTable[COMMA] = Comma;
GetSymbol(new TerminalSet(Comma, RSqBracket), false, true);
if (symbol.Terminal == Comma)
{
symbol.SetProcessed();
}
else
break;
}
if (files > 1) PrologIO.Message("Grand total is {0} lines", lines);
}
finally
{
terminalTable[COMMA] = Operator;
}
GetSymbol(new TerminalSet(RSqBracket), true, true);
}
}
finally
{
terminalTable.Remove("module");
terminalTable.Remove("persistent");
terminalTable.Remove("undef_pred_action");
}
}
GetSymbol(new TerminalSet(Dot), true, true);
}
public TerminalSet Union(params int[] ta)
{
TerminalSet union = new TerminalSet(x); // create an identical TerminalSet
foreach (int terminal in ta) union[terminal] = true; // ... and unify
return union;
}
private void ClauseSequence(TerminalSet _TS)
{
Monitor.Enter(PrologEngine.TermMonitor);
do
{
ClauseNode(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString));
Monitor.Pulse(PrologEngine.TermMonitor);
Monitor.Wait(PrologEngine.TermMonitor);
GetSymbol(_TS.Union(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
ImpliesSym, PromptSym, LSqBracket, LCuBracket, PrologString), false, true);
} while (!(_TS.Contains(symbol.Terminal)));
readTerm = new Term(EOF);
Monitor.Pulse(PrologEngine.TermMonitor);
Monitor.Exit(PrologEngine.TermMonitor);
}
public GenericResolverHint(TerminalSet skipTokens) : base(ParserActionType.Reduce)
{
this.skipTokens = skipTokens;
}
private void DCGBracketList(TerminalSet _TS, out Term term)
{
Term head;
ArrayList elements = null;
GetSymbol(new TerminalSet(LCuBracket), true, true);
GetSymbol(new TerminalSet(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous,
CutSym, LSqBracket, LCuBracket, RCuBracket, PrologString), false, true);
if (symbol.IsMemberOf(LeftParen, Identifier, IntLiteral, RealLiteral, StringLiteral, Operator, Atom, Anonymous, CutSym,
LSqBracket, LCuBracket, PrologString))
{
PrologTerm(new TerminalSet(RCuBracket), out head);
elements = head.ArgumentsToArrayList(true);
}
GetSymbol(new TerminalSet(RCuBracket), true, true);
term = new DCGTerm();
if (elements != null)
for (int i = elements.Count - 1; i >= 0; i--) term = new DCGTerm((Term)elements[i], term);
}
private void RemoveTerminals(TerminalSet terms, params Terminal[] termsToRemove)
{
foreach(var termToRemove in termsToRemove)
if (terms.Contains(termToRemove)) terms.Remove(termToRemove);
}
private void EOL(TerminalSet followers, bool GenXCPN)
{
GetSymbol(new TerminalSet(EndOfLine), true, GenXCPN);
while (symbol.Terminal == EndOfLine)
{
NextSymbol();
}
symbol.SetProcessed(false);
}
private bool GetSymbol(TerminalSet followers, bool done, bool genXCPN)
{
string s;
if (symbol.IsProcessed) NextSymbol();
symbol.SetProcessed(done);
if (parseAnyText || followers.IsEmpty()) return true;
if (syntaxErrorStat) return false;
if (symbol.Terminal == ANYSYM || followers.Contains(symbol.Terminal))
return true;
else
{
if (terminalAsId && symbol.Terminal != Identifier)
{
int t = symbol.Terminal;
symbol.Terminal = Identifier;
if (symbol.HasIdFormat && followers.Contains(symbol.Terminal))
{
return true;
}
symbol.Terminal = t; // restore error value
}
switch (symbol.Terminal)
{
case EndOfLine:
if (seeEndOfLine) s = "<EndOfLine>"; else goto default;
s = "<EndOfLine>";
break;
case EndOfInput:
s = "<EndOfInput>";
break;
default:
s = String.Format("\"{0}\"", symbol.ToString());
break;
}
}
s = String.Format("*** Unexpected symbol: {0}{1}*** Expected one of: {2}", s,
Environment.NewLine, terminalTable.TerminalImageSet(followers));
if (genXCPN)
SyntaxError = s;
else
errorMessage = s;
return true;
}
public Token Preview(TerminalSet skipTerms) {
Token tkn;
while (true) {
tkn = ReadToken();
if (tkn.Terminal == _grammar.Eof || !skipTerms.Contains(tkn.Terminal)) break;
}
return tkn;
}
