public virtual void WriteModule(Symbol module)
{
Notation.Record[] recs = notation.Select(module, Descriptor.Version, 2);
if (recs.Length > 0)
{
WriteText("xquery version ");
WriteLiteral((Literal)recs[0].Arg0);
if (recs[0].Arg1 != null)
{
WriteText(" encoding ");
WriteLiteral((Literal)recs[0].Arg1);
}
WriteSeparator();
}
recs = notation.Select(module, Descriptor.Root, 1);
if (recs.Length == 0)
throw new InvalidOperationException();
Notation.Record[] recs_c = notation.Select(recs[0].Arg0,
new Descriptor[] { Descriptor.Query, Descriptor.Library });
if (recs_c.Length > 0)
if (recs_c[0].descriptor == Descriptor.Query)
{
WriteProlog(recs_c[0].args[0]);
WriteExpr(recs_c[0].args[1]);
}
else
{
WriteModuleDecl(recs_c[0].Arg0);
WriteProlog(recs_c[0].args[1]);
}
}
public virtual void WriteModuleDecl(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.ModuleNamespace, 2);
if (recs.Length > 0)
{
WriteText("module namespace ");
WriteQName((Qname)recs[0].Arg0);
WriteText(" = ");
WriteLiteral((Literal)recs[0].Arg1);
WriteSeparator();
}
}
public virtual void WriteOrderByClause(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] {
Descriptor.OrderBy, Descriptor.StableOrderBy });
if (recs.Length > 0)
{
switch (recs[0].descriptor)
{
case Descriptor.OrderBy:
WriteText(" order by ");
break;
case Descriptor.StableOrderBy:
WriteText(" stable order by ");
break;
}
Symbol[] arr = Lisp.ToArray<Symbol>(recs[0].args[0]);
for (int k = 0; k < arr.Length; k++)
{
if (k > 0)
WriteText(", ");
WriteExprSingle(arr[k]);
Notation.Record[] recs1 = notation.Select(arr[k], Descriptor.Modifier, 1);
if (recs1.Length > 0)
{
Symbol[] modifier = Lisp.ToArray<Symbol>(recs1[0].args[0]);
if (modifier[0] != null)
switch (((TokenWrapper)modifier[0]).Data)
{
case Token.ASCENDING:
WriteText(" ascending");
break;
case Token.DESCENDING:
WriteText(" descending");
break;
}
if (modifier[1] != null)
switch (((TokenWrapper)modifier[1]).Data)
{
case Token.EMPTY_GREATEST:
WriteText(" empty greatest");
break;
case Token.EMPTY_LEAST:
WriteText(" empty least");
break;
}
if (modifier[2] != null)
{
WriteText(" collation ");
WriteLiteral((Literal)modifier[2]);
}
}
}
}
}
public virtual void WriteStepExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] { Descriptor.AxisStep,
Descriptor.FilterExpr }, 1);
if (recs.Length > 0)
{
switch (recs[0].descriptor)
{
case Descriptor.AxisStep:
WriteAxisStep(recs[0]);
break;
case Descriptor.FilterExpr:
WriteFilterExpr(recs[0]);
break;
}
}
else
throw new InvalidOperationException();
}
public virtual void WriteWhereClause(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.Where, 1);
if (recs.Length > 0)
{
WriteText(" where ");
WriteExprSingle(recs[0].Arg0);
}
}
public virtual void WriteInstanceofExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.InstanceOf, 2);
if (recs.Length > 0)
{
WriteTreatExpr(recs[0].Arg0);
WriteText(" instance of ");
WriteSequenceType(recs[0].Arg1);
}
else
WriteTreatExpr(sym);
}
public virtual void WriteUnaryExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.Unary, 2);
if (recs.Length > 0)
{
TokenWrapper[] arr = Lisp.ToArray<TokenWrapper>(recs[0].args[0]);
foreach (TokenWrapper w in arr)
WriteText((char)w.Data);
WriteValueExpr(recs[0].Arg1);
}
else
WriteValueExpr(sym);
}
public virtual void WriteRangeExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.Range, 2);
if (recs.Length > 0)
{
WriteAdditiveExpr(recs[0].Arg0);
WriteText(" to ");
WriteAdditiveExpr(recs[0].Arg1);
}
else
WriteAdditiveExpr(sym);
}
public virtual void WritePredicateList(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.PredicateList, 1);
if (recs.Length > 0)
{
Symbol[] arr = Lisp.ToArray<Symbol>(recs[0].args[0]);
foreach (Symbol expr in arr)
{
Notation.Record[] recs1 = notation.Select(expr, Descriptor.Predicate, 1);
if (recs1.Length > 0)
{
WriteText('[');
WriteExpr(recs1[0].args[0]);
WriteText(']');
}
}
}
}
public virtual void WriteTypeDecl(Symbol sym)
{
WriteText(" as ");
WriteSequenceType(sym);
}
public virtual void WriteSequenceType(Symbol sym)
{
if (sym.Tag == Tag.TokenWrapper &&
((TokenWrapper)sym).Data == Token.EMPTY_SEQUENCE)
WriteText("empty-sequence()");
else
{
WriteItemType(sym);
Notation.Record[] recs = notation.Select(sym, Descriptor.Occurrence, 1);
if (recs.Length > 0)
{
TokenWrapper w = (TokenWrapper)recs[0].Arg0;
switch (w.Data)
{
case Token.Indicator1:
WriteText("* ");
break;
case Token.Indicator2:
WriteText("+ ");
break;
case Token.Indicator3:
WriteText("? ");
break;
}
}
}
}
public virtual void WriteCommonContent(Symbol sym)
{
if (sym.Tag == Tag.Literal)
WriteText(((Literal)sym).Data);
else if (sym.Tag == Tag.PredefinedEntityRef)
WriteText(((PredefinedEntityRef)sym).Data);
else if (sym.Tag == Tag.CharRef)
{
if (sym is CharRefHex)
{
CharRefHex charRef = (CharRefHex)sym;
WriteText(String.Format("&x{0};", charRef.Data));
}
else
{
CharRef charRef = (CharRef)sym;
WriteText(String.Format("&{0};", charRef.Data));
}
}
else
{
Notation.Record[] recs = notation.Select(sym, Descriptor.EnclosedExpr, 1);
if (recs.Length > 0)
{
WriteText('{');
WriteExpr(recs[0].args[0]);
WriteText('}');
}
else
throw new InvalidOperationException();
}
}
public virtual void WriteComputedConstructor(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] { Descriptor.CompDocConstructor,
Descriptor.CompElemConstructor, Descriptor.CompAttrConstructor, Descriptor.CompTextConstructor,
Descriptor.CompCommentConstructor, Descriptor.CompPIConstructor });
if (recs.Length > 0)
{
switch (recs[0].descriptor)
{
case Descriptor.CompDocConstructor:
WriteText("document {");
SmartNewLine();
WriteExpr(recs[0].args[0]);
SmartNewLine();
WriteText('}');
SmartNewLine();
break;
case Descriptor.CompElemConstructor:
WriteText("element ");
if (recs[0].args[0] is Qname)
WriteQName((Qname)recs[0].args[0]);
else
{
WriteText("{");
WriteExpr(recs[0].args[0]);
WriteText("}");
}
SmartNewLine();
WriteText("{");
if (recs[0].args[1] != null)
{
SmartNewLine();
WriteExpr(recs[0].args[1]);
SmartNewLine();
}
WriteText('}');
SmartNewLine();
break;
case Descriptor.CompAttrConstructor:
WriteText("attribute ");
if (recs[0].args[0] is Qname)
WriteQName((Qname)recs[0].args[0]);
else
{
SmartNewLine();
WriteText("{");
WriteExpr(recs[0].args[0]);
WriteText("}");
}
SmartNewLine();
WriteText("{");
if (recs[0].args[1] != null)
{
SmartNewLine();
WriteExpr(recs[0].args[1]);
SmartNewLine();
}
WriteText('}');
SmartNewLine();
break;
case Descriptor.CompTextConstructor:
WriteText("text {");
WriteExpr(recs[0].args[0]);
WriteText('}');
SmartNewLine();
break;
case Descriptor.CompCommentConstructor:
WriteText("comment {");
WriteExpr(recs[0].args[0]);
WriteText('}');
SmartNewLine();
break;
case Descriptor.CompPIConstructor:
WriteText("processing-instruction ");
if (recs[0].args[0] is Qname)
WriteQName((Qname)recs[0].args[0]);
else
{
WriteText("{");
WriteExpr(recs[0].args[0]);
WriteText("}");
}
SmartNewLine();
WriteText("{");
if (recs[0].args[1] != null)
{
SmartNewLine();
WriteExpr(recs[0].args[1]);
SmartNewLine();
}
WriteText('}');
SmartNewLine();
break;
}
}
else
throw new InvalidOperationException();
}
public virtual void WriteDirElemContent(Symbol sym)
{
if (sym.Tag == Tag.Literal)
WriteText(((Literal)sym).Data);
else if (sym.Tag == Tag.Constructor)
WriteDirectConstructor(sym);
else
{
Notation.Record[] recs = notation.Select(sym, Descriptor.CDataSection, 1);
if (recs.Length > 0)
{
WriteText("<![CDATA[");
WriteText(((Literal)recs[0].Arg0).Data);
WriteText("]]>");
}
else
WriteCommonContent(sym);
}
}
public virtual void WriteDirectConstructor(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] { Descriptor.DirElemConstructor,
Descriptor.DirCommentConstructor, Descriptor.DirPIConstructor });
if (recs.Length > 0)
{
switch (recs[0].descriptor)
{
case Descriptor.DirElemConstructor:
WriteDirElemConstructor(recs[0]);
break;
case Descriptor.DirCommentConstructor:
WriteText("<!--");
WriteText(((Literal)recs[0].Arg0).Data);
WriteText("-->");
break;
case Descriptor.DirPIConstructor:
WriteText("<?");
WriteText(((Literal)recs[0].Arg0).Data);
if (recs[0].Arg1 != null)
{
WriteText(' ');
WriteText(((Literal)recs[0].Arg1).Data);
}
WriteText("?>");
break;
}
}
else
WriteComputedConstructor(sym);
}
public virtual void WritePrimaryExpr(Symbol sym)
{
if (sym.Tag == Tag.Literal)
WriteLiteral((Literal)sym);
else if (sym.Tag == Tag.Integer)
WriteInteger((IntegerValue)sym);
else if (sym.Tag == Tag.Double)
WriteDouble((DoublelValue)sym);
else if (sym.Tag == Tag.Decimal)
WriteDecimal((DecimalValue)sym);
else if (sym.Tag == Tag.VarName)
{
WriteText('$');
WriteVarName((VarName)sym);
}
else if (sym.Tag == Tag.TokenWrapper)
{
if (((TokenWrapper)sym).Data == '.')
WriteText('.');
}
else
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] { Descriptor.ParenthesizedExpr,
Descriptor.Ordered, Descriptor.Unordered, Descriptor.Funcall });
if (recs.Length > 0)
{
switch (recs[0].descriptor)
{
case Descriptor.ParenthesizedExpr:
WriteParenthesizedExpr(recs[0]);
break;
case Descriptor.Ordered:
case Descriptor.Unordered:
WriteOrderedExpr(recs[0]);
break;
case Descriptor.Funcall:
WriteFuncallExpr(recs[0]);
break;
}
}
else
WriteDirectConstructor(sym);
}
}
public virtual void WriteAndExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.And, 2);
if (recs.Length > 0)
{
WriteAndExpr(recs[0].Arg0);
WriteText(" and ");
WriteComparisonExpr(recs[0].Arg1);
}
else
WriteComparisonExpr(sym);
}
public virtual void WriteAdditiveExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.Add, 3);
if (recs.Length > 0)
{
WriteAdditiveExpr(recs[0].Arg0);
TokenWrapper w = (TokenWrapper)recs[0].Arg1;
WriteText((char)w.Data);
WriteMultiplicativeExpr(recs[0].Arg2);
}
else
WriteMultiplicativeExpr(sym);
}
public virtual void WriteComparisonExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] { Descriptor.ValueComp,
Descriptor.GeneralComp, Descriptor.NodeComp }, 3);
if (recs.Length > 0)
{
WriteRangeExpr(recs[0].Arg0);
switch (recs[0].descriptor)
{
case Descriptor.ValueComp:
{
TokenWrapper w = (TokenWrapper)recs[0].Arg1;
switch (w.Data)
{
case Token.EQ:
WriteText(" eq ");
break;
case Token.NE:
WriteText(" ne ");
break;
case Token.LT:
WriteText(" lt ");
break;
case Token.GT:
WriteText(" gt ");
break;
case Token.GE:
WriteText(" ge ");
break;
}
}
break;
case Descriptor.GeneralComp:
{
Literal lit = (Literal)recs[0].Arg1;
WriteText(lit.Data);
}
break;
case Descriptor.NodeComp:
{
if (recs[0].Arg1.Tag == Tag.TokenWrapper)
{
if (((TokenWrapper)recs[0].Arg1).Data == Token.IS)
WriteText(" is ");
}
else
{
Literal lit = (Literal)recs[0].Arg1;
WriteText(lit.Data);
}
}
break;
}
WriteRangeExpr(recs[0].Arg2);
}
else
WriteRangeExpr(sym);
}
public virtual void WriteUnionExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym,
new Descriptor[] { Descriptor.Union, Descriptor.Concatenate }, 2);
if (recs.Length > 0)
{
WriteUnionExpr(recs[0].Arg0);
switch (recs[0].descriptor)
{
case Descriptor.Union:
WriteText(" union ");
break;
case Descriptor.Concatenate:
WriteText('|');
break;
}
WriteIntersectExceptExpr(recs[0].Arg1);
}
else
WriteIntersectExceptExpr(sym);
}
public virtual void WriteItemType(Symbol sym)
{
if (sym.Tag == Tag.TokenWrapper)
{
TokenWrapper w = (TokenWrapper)sym;
if (w.Data == Token.ITEM)
WriteText("item()");
}
else if (sym.Tag == Tag.Qname)
WriteTypeName(sym);
else
WriteKindTest(sym);
}
public virtual void WriteNodeTest(Symbol sym)
{
if (sym.Tag == Tag.TokenWrapper)
WriteText('*');
else if (sym.Tag == Tag.Qname)
WriteQName((Qname)sym);
else
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] { Descriptor.Wildcard1, Descriptor.Wildcard2 }, 1);
if (recs.Length > 0)
{
switch (recs[0].descriptor)
{
case Descriptor.Wildcard1:
WriteQName((Qname)recs[0].Arg0);
WriteText(":*");
break;
case Descriptor.Wildcard2:
WriteText("*:");
WriteQName((Qname)recs[0].Arg0);
break;
}
}
else
WriteKindTest(sym);
}
}
public virtual void WriteMultiplicativeExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.Mul, 3);
if (recs.Length > 0)
{
WriteMultiplicativeExpr(recs[0].Arg0);
TokenWrapper w = (TokenWrapper)recs[0].Arg1;
switch (w.Data)
{
case Token.ML:
WriteText('*');
break;
case Token.DIV:
WriteText(" div ");
break;
case Token.IDIV:
WriteText(" idiv ");
break;
case Token.MOD:
WriteText(" mod ");
break;
}
WriteUnionExpr(recs[0].Arg2);
}
else
WriteUnionExpr(sym);
}
public virtual void WriteKindTest(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.KindTest, 1);
if (recs.Length > 0)
{
if (recs[0].Arg0.Tag == Tag.TokenWrapper)
{
TokenWrapper w = (TokenWrapper)recs[0].Arg0;
switch (w.Data)
{
case Token.NODE:
WriteText("node()");
break;
case Token.TEXT:
WriteText("text()");
break;
case Token.COMMENT:
WriteText("comment()");
break;
case Token.PROCESSING_INSTRUCTION:
WriteText("processing-instruction()");
break;
case Token.ELEMENT:
WriteText("element()");
break;
case Token.ATTRIBUTE:
WriteText("attribute()");
break;
case Token.DOCUMENT_NODE:
WriteText("document-node()");
break;
default:
throw new InvalidOperationException();
}
}
else
{
Notation.Record[] recs1 = notation.Select(recs[0].Arg0);
switch (recs1[0].descriptor)
{
case Descriptor.DocumentNode:
WriteDocumentTest(recs1[0]);
break;
case Descriptor.ProcessingInstruction:
WritePITest(recs1[0]);
break;
case Descriptor.Element:
WriteElementTest(recs1[0]);
break;
case Descriptor.Attribute:
WriteAttributeTest(recs1[0]);
break;
case Descriptor.SchemaElement:
WriteSchemaElementTest(recs1[0]);
break;
case Descriptor.SchemaAttribute:
WriteSchemaAttributeTest(recs1[0]);
break;
default:
throw new InvalidOperationException();
}
}
}
}
public virtual void WriteIntersectExceptExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.IntersectExcept, 3);
if (recs.Length > 0)
{
WriteIntersectExceptExpr(recs[0].Arg0);
TokenWrapper w = (TokenWrapper)recs[0].Arg1;
switch (w.Data)
{
case Token.INTERSECT:
WriteText(" intersect ");
break;
case Token.EXCEPT:
WriteText(" except ");
break;
}
WriteInstanceofExpr(recs[0].Arg2);
}
else
WriteInstanceofExpr(sym);
}
public virtual void WriteTypeName(Symbol sym)
{
WriteQName((Qname)sym);
}
public virtual void WriteCastExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, Descriptor.CastAs, 2);
if (recs.Length > 0)
{
WriteUnaryExpr(recs[0].Arg0);
WriteText(" cast as ");
WriteSequenceType(recs[0].Arg1);
}
else
WriteUnaryExpr(sym);
}
public virtual void WriteExprSingle(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym);
switch (recs[0].descriptor)
{
case Descriptor.FLWORExpr:
WriteFLORExpr(recs[0]);
break;
case Descriptor.Some:
case Descriptor.Every:
WriteQuantifiedExpr(recs[0]);
break;
case Descriptor.Typeswitch:
WriteTypeswitch(recs[0]);
break;
case Descriptor.If:
WriteIfExpr(recs[0]);
break;
default:
WriteOrExpr(sym);
break;
}
}
public virtual void WriteValueExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym);
if (recs.Length > 0)
{
switch (recs[0].descriptor)
{
case Descriptor.ExtensionExpr:
WriteExtensionExpr(recs[0]);
break;
case Descriptor.Validate:
WriteValidateExpr(recs[0]);
break;
default:
WritePathExpr(sym);
break;
}
}
}
public virtual void WriteRelativePathExpr(Symbol sym)
{
Notation.Record[] recs = notation.Select(sym, new Descriptor[] { Descriptor.Child,
Descriptor.Descendant }, 2);
if (recs.Length > 0)
{
WriteRelativePathExpr(recs[0].Arg0);
switch (recs[0].descriptor)
{
case Descriptor.Child:
WriteText('/');
break;
case Descriptor.Descendant:
WriteText("//");
break;
}
WriteStepExpr(recs[0].Arg1);
}
else
WriteStepExpr(sym);
}
