// 'xmldocument$'(['xmldecl$'([version=1.0,encoding=ISO-8859-1])], ...]), [])
static Encoding GetEncodingFromTerm(BaseTerm t, Encoding defEnc)
{
if (t.Arity == 0 || (t = t.Arg(0)).FunctorToString != XMLDECL)
{
return(defEnc);
}
if (!((t = t.Arg(0)) is ListTerm)) // attributes last, find encoding
{
return(defEnc);
}
foreach (BaseTerm b in (ListTerm)t)
{
if (!(b is OperatorTerm) || !((OperatorTerm)b).HasBinaryOperator("="))
{
return(defEnc);
}
OperatorTerm ot = (OperatorTerm)b;
if (ot.Arg(0).FunctorToString == "encoding")
{
return(GetEncodingFromString(ot.Arg(1).FunctorToString));
}
}
return(defEnc);
}
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);
}
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
}
// DCG stuff
public TermNode ToDCG(ref BaseTerm lhs) // called from parser
{
TermNode body = new TermNode();
BaseTerm result = null;
BaseTerm inVar = new Variable();
BaseTerm inVarSave = inVar;
BaseTerm outVar = inVar;
lhs = new DcgTerm(lhs, ref outVar); // outVar becomes new term
BaseTerm remainder;
List <BaseTerm> alternatives = AlternativesToArrayList();
for (int i = 0; i < alternatives.Count; i++)
{
BaseTerm alt = alternatives[i];
bool embedded = (alternatives.Count > 1);
List <BaseTerm> terms = alt.ToTermList();
body.Clear();
remainder = inVarSave;
for (int ii = 0; ii < terms.Count; ii++)
{
DCGGoal(terms[ii], ref body, ref remainder, ref embedded);
}
// create a term-tree from the array
if (i == 0)
{
result = body.TermSeq();
}
else
{
result = new OperatorTerm(SemiOpDescr, result, body.TermSeq());
}
((Variable)remainder).Bind(outVar);
}
return((result == null) ? null : result.ToGoalList()); // empty body treated similar to null
}
static BaseTerm ToTermEx(Node root)
{
BaseTerm [] args = new BaseTerm [3];
string tagName = root.TagName.ToAtom();
args [1] = ListTerm.EMPTYLIST;
Decimal d;
foreach (KeyValuePair <string, string> kv in root.Attributes) // XML Declaration
{
BaseTerm pair;
if (Decimal.TryParse(kv.Value, styleAllowDecPnt, CIC, out d))
{
pair = new OperatorTerm(EqualOpDescr, new AtomTerm(kv.Key), new DecimalTerm(d));
}
else
{
pair = new OperatorTerm(EqualOpDescr, new AtomTerm(kv.Key), new StringTerm(kv.Value));
}
args [1] = new ListTerm(pair, args [1]);
}
args [2] = ListTerm.EMPTYLIST;
if (root.ChildNodes.Count > 0)
{
foreach (Node n in root.ChildNodes)
{
BaseTerm e;
e = null;
switch (n.type)
{
case XmlNodeType.Element:
e = ToTermEx(n);
break;
case XmlNodeType.Comment:
e = new CompoundTerm(COMMENT, new StringTerm(n.text.Trim().EscapeDoubleQuotes()));
break;
case XmlNodeType.Text:
if (Decimal.TryParse(n.text, styleAllowDecPnt, CIC, out d))
{
e = new DecimalTerm(d);
}
else if (n.text.HasAtomFormat())
{
e = new AtomTerm(n.text);
}
else
{
e = new StringTerm(n.text.EscapeDoubleQuotes());
}
break;
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
e = new StringTerm(n.text);
break;
case XmlNodeType.CDATA:
e = new CompoundTerm(CDATA, new StringTerm(n.text.Trim().EscapeDoubleQuotes()));
break;
case XmlNodeType.ProcessingInstruction:
e = new CompoundTerm("processing_instruction", new AtomTerm(n.name.ToAtom()),
new StringTerm(n.text.Trim().EscapeDoubleQuotes()));
break;
default:
break;
}
if (e != null)
{
args [2] = new ListTerm(e, args [2]);
}
}
}
if (args [1].IsEmptyList)
{
return(new CompoundTerm(tagName, args [2]));
}
else
{
return(new CompoundTerm(tagName, args [1], args [2]));
}
}
// ToTerm results in term xml( Pre, Element, Post), where Pre and Post are lists with comments
// and/or processing instructions that come before/after the top-level XML element.
public BaseTerm ToTerm()
{
BaseTerm pre = ListTerm.EMPTYLIST;
BaseTerm post = ListTerm.EMPTYLIST;
BaseTerm t = null;
Node topEl = null;
foreach (Node n in childNodes) // array was constructed in reverse order, so top-level XML-element is entry 0.
{
switch (n.type)
{
case XmlNodeType.Element:
topEl = n;
break;
case XmlNodeType.Comment:
t = new CompoundTerm(COMMENT, new StringTerm(n.Text));
if (topEl == null)
{
post = new ListTerm(t, post);
}
else
{
pre = new ListTerm(t, pre);
}
break;
case XmlNodeType.ProcessingInstruction:
t = new CompoundTerm(INSTRUCTIONS, new AtomTerm(n.name.ToAtom()),
new AtomTerm(n.text.Trim()));
if (topEl == null)
{
post = new ListTerm(t, post);
}
else
{
pre = new ListTerm(t, pre);
}
break;
}
}
BaseTerm xmlDecl = ListTerm.EMPTYLIST;
foreach (KeyValuePair <string, string> kv in Attributes) // XML Declaration (acually a PI) was stored in Attributes
{
BaseTerm pair = new OperatorTerm(EqualOpDescr, new AtomTerm(kv.Key), new AtomTerm(kv.Value));
xmlDecl = new ListTerm(pair, xmlDecl); // [pre, arg2, ...]
}
if (!xmlDecl.IsEmptyList) // enhance term with XML Declaration
{
xmlDecl = new CompoundTerm(XMLDECL, xmlDecl);
pre = new ListTerm(xmlDecl, pre);
}
BaseTerm content = ToTermEx(topEl); // Now process top-level Element
return(new CompoundTerm(XMLDOCUMENT, new BaseTerm [] { pre, content, post }));
}
BaseTerm CopyEx(int newVerNo, bool mustBeNamed)
{
if (IsUnified)
{
return(ChainEnd().CopyEx(newVerNo, mustBeNamed));
}
// A neater solution would be to use overrides for each term subtype.
if (this is Variable)
{
Variable v = (Variable)this;
if (newVerNo == v.verNo)
{
return(v.newVar);
}
v.verNo = newVerNo;
return(v.newVar = (mustBeNamed && this is NamedVariable)
? new NamedVariable(((NamedVariable)v).Name)
: new Variable());
}
else if (this is CatchOpenTerm)
{
CatchOpenTerm c = (CatchOpenTerm)this;
return(new CatchOpenTerm(c.Id, c.ExceptionClass, c.MsgVar.CopyEx(newVerNo, mustBeNamed),
c.SeqNo, c.SaveStackSize));
}
else
{
if (arity == 0)
{
return(this);
}
BaseTerm t = null;
BaseTerm[] a = new BaseTerm[arity];
for (int i = 0; i < arity; i++)
{
if (args[i] != null) // may be null for a GapTerm
{
a[i] = args[i].CopyEx(newVerNo, mustBeNamed); // recursively refresh arguments
}
}
if (this is ListPatternTerm)
{
t = new ListPatternTerm(a);
}
else if (this is AltListTerm)
{
AltListTerm alt = (AltListTerm)this;
t = new AltListTerm(alt.LeftBracket, alt.RightBracket, a[0], a[1]);
}
else if (this is ListTerm)
{
if (((ListTerm)this).CharCodeString == null)
{
t = new ListTerm(a[0], a[1]);
}
else // it's an ISO-style string
{
t = new ListTerm(((ListTerm)this).CharCodeString);
}
}
else if (this is OperatorTerm)
{
t = new OperatorTerm(((OperatorTerm)this).od, a);
}
else if (this is DcgTerm)
{
t = new DcgTerm(functor, a);
}
else if (this is WrapperTerm)
{
t = new WrapperTerm((WrapperTerm)this, a);
}
else if (this is IntRangeTerm)
{
t = new IntRangeTerm((IntRangeTerm)this);
}
else if (this is ListPatternElem)
{
t = new ListPatternElem(a, ((ListPatternElem)this).downRepFactor, ((ListPatternElem)this).IsNegSearch);
}
else if (this is CompoundTerm)
{
t = new CompoundTerm(functor, a);
}
else
{
IO.Error("CopyEx(): type '{0}' not handled explicitly", this.GetType());
}
return(t);
}
}
static BaseTerm ToTermEx(Node root)
{
BaseTerm [] args = new BaseTerm [3];
#if fullyTagged
args [0] = new AtomTerm(root.TagName.ToAtom());
#else
string tagName = root.TagName.ToAtom();
#endif
args [1] = ListTerm.EMPTYLIST;
Decimal d;
foreach (KeyValuePair <string, string> kv in root.Attributes) // XML Declaration
{
BaseTerm pair;
if (Decimal.TryParse(kv.Value, styleAllowDecPnt, Utils.CIC, out d))
{
pair = new OperatorTerm(EqualOpDescr, new AtomTerm(kv.Key), new DecimalTerm(d));
}
else
{
pair = new OperatorTerm(EqualOpDescr, new AtomTerm(kv.Key), new StringTerm(kv.Value));
}
args [1] = new ListTerm(pair, args [1]);
}
args [2] = ListTerm.EMPTYLIST;
if (root.ChildNodes.Count > 0)
{
foreach (Node n in root.ChildNodes)
{
BaseTerm e;
e = null;
switch (n.type)
{
case XmlNodeType.Element:
e = ToTermEx(n);
break;
case XmlNodeType.Comment:
e = new CompoundTerm(COMMENT, new StringTerm(n.text.Trim().EscapeDoubleQuotes()));
break;
case XmlNodeType.Text:
if (Decimal.TryParse(n.text, styleAllowDecPnt, Utils.CIC, out d))
#if fullyTagged
{ e = new CompoundTerm(TEXT, new DecimalTerm(d)); }
else
{
e = new CompoundTerm(TEXT, new StringTerm(n.text.Trim().EscapeDoubleQuotes()));
}
#else
{ e = new DecimalTerm(d); }
else
{
e = new StringTerm(n.text.Trim().EscapeDoubleQuotes());
}
#endif
break;
static BaseTerm ToTermEx(Node root)
{
BaseTerm [] args = new BaseTerm [3];
#if fullyTagged
args [0] = new AtomTerm (root.TagName.ToAtom ());
#else
string tagName = root.TagName.ToAtom ();
#endif
args [1] = ListTerm.EMPTYLIST;
Decimal d;
foreach (KeyValuePair<string, string> kv in root.Attributes) // XML Declaration
{
BaseTerm pair;
if (Decimal.TryParse (kv.Value, styleAllowDecPnt, Utils.CIC, out d))
pair = new OperatorTerm (EqualOpDescr, new AtomTerm (kv.Key), new DecimalTerm (d));
else
pair = new OperatorTerm (EqualOpDescr, new AtomTerm (kv.Key), new StringTerm (kv.Value));
args [1] = new ListTerm (pair, args [1]);
}
args [2] = ListTerm.EMPTYLIST;
if (root.ChildNodes.Count > 0)
{
foreach (Node n in root.ChildNodes)
{
BaseTerm e;
e = null;
switch (n.type)
{
case XmlNodeType.Element:
e = ToTermEx (n);
break;
case XmlNodeType.Comment:
e = new CompoundTerm (COMMENT, new StringTerm (n.text.Trim ().EscapeDoubleQuotes ()));
break;
case XmlNodeType.Text:
if (Decimal.TryParse (n.text, styleAllowDecPnt, Utils.CIC, out d))
#if fullyTagged
e = new CompoundTerm (TEXT, new DecimalTerm (d));
else
e = new CompoundTerm (TEXT, new StringTerm (n.text.Trim ().EscapeDoubleQuotes ()));
#else
e = new DecimalTerm (d);
else
e = new StringTerm (n.text.Trim ().EscapeDoubleQuotes ());
#endif
break;
case XmlNodeType.CDATA:
e = new CompoundTerm (CDATA, new StringTerm (n.text.Trim ().EscapeDoubleQuotes ()));
break;
case XmlNodeType.ProcessingInstruction:
e = new CompoundTerm ("processing_instruction", new AtomTerm (n.name.ToAtom ()),
new StringTerm (n.text.Trim ().EscapeDoubleQuotes ()));
break;
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.Whitespace:
break;
// ToTerm results in term xml( Pre, Element, Post), where Pre and Post are lists with comments
// and/or processing instructions that come before/after the top-level XML element.
public BaseTerm ToTerm()
{
BaseTerm pre = ListTerm.EMPTYLIST;
BaseTerm post = ListTerm.EMPTYLIST;
BaseTerm t = null;
Node topEl = null;
foreach (Node n in childNodes) // array was constructed in reverse order, so top-level XML-element is entry 0.
{
switch (n.type)
{
case XmlNodeType.Element:
topEl = n;
break;
case XmlNodeType.Comment:
t = new CompoundTerm (COMMENT, new StringTerm (n.Text));
if (topEl == null)
post = new ListTerm (t, post);
else
pre = new ListTerm (t, pre);
break;
case XmlNodeType.ProcessingInstruction:
t = new CompoundTerm (INSTRUCTIONS, new AtomTerm (n.name.ToAtom ()),
new AtomTerm (n.text.Trim ()));
if (topEl == null)
post = new ListTerm (t, post);
else
pre = new ListTerm (t, pre);
break;
}
}
BaseTerm xmlDecl = ListTerm.EMPTYLIST;
foreach (KeyValuePair<string, string> kv in Attributes) // XML Declaration (acually a PI) was stored in Attributes
{
BaseTerm pair = new OperatorTerm (EqualOpDescr, new AtomTerm (kv.Key), new AtomTerm (kv.Value));
xmlDecl = new ListTerm (pair, xmlDecl); // [pre, arg2, ...]
}
if (!xmlDecl.IsEmptyList) // enhance term with XML Declaration
{
xmlDecl = new CompoundTerm (XMLDECL, xmlDecl);
pre = new ListTerm (xmlDecl, pre);
}
BaseTerm content = ToTermEx (topEl); // Now process top-level Element
return new CompoundTerm (XMLDOCUMENT, new BaseTerm [] { pre, content, post });
}
