class/Mono.Xml.Ext/Mono.Xml.XPath2/ParserBase.jay

   1 %{
   2 //
   3 // XQueryParser.jay
   4 //
   5 // Author:
   6 //      Atsushi Enomoto <atsushi@ximian.com>
   7 //
   8 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 //
  31 // FIXME:
  32 //      attribute value template
  33 //      handle double literal
  34 //      string literal in XQuery and XPath2 are different
  35 //
  36
  37 #if NET_2_0
  38
  39 using System;
  40 using System.Collections;
  41 using System.IO;
  42 using System.Xml;
  43 using System.Xml.Query;
  44 using System.Xml.Schema;
  45 using System.Xml.XPath;
  46 using System.Security.Policy;
  47 using Mono.Xml.XPath2;
  48 using Mono.Xml.XQuery;
  49 using Mono.Xml;
  50
  51 #if XQUERY_PARSER
  52 namespace Mono.Xml.XQuery.Parser
  53 #elif XPATH2_PARSER
  54 namespace Mono.Xml.XPath2.Parser
  55 #endif
  56 {
  57         internal class Parser
  58         {
  59                 // See also FunctionCall production rule.
  60                 static Hashtable reservedFunctionNames;
  61                 static int yacc_verbose_flag;
  62
  63                 static Parser ()
  64                 {
  65                         reservedFunctionNames = new Hashtable ();
  66                         reservedFunctionNames.Add ("attribute", "attribute");
  67                         reservedFunctionNames.Add ("comment", "comment");
  68                         reservedFunctionNames.Add ("document", "document");
  69                         reservedFunctionNames.Add ("element", "element");
  70                         reservedFunctionNames.Add ("empty", "empty");
  71                         reservedFunctionNames.Add ("if", "if");
  72                         reservedFunctionNames.Add ("item", "item");
  73                         reservedFunctionNames.Add ("node", "node");
  74                         reservedFunctionNames.Add ("processing-instruction", "processing-instruction");
  75                         reservedFunctionNames.Add ("text", "text");
  76                         reservedFunctionNames.Add ("type", "type");
  77                         reservedFunctionNames.Add ("typeswitch", "typeswitch");
  78                 }
  79
  80                 public static XQueryModule Parse (TextReader reader)
  81                 {
  82                         return new Parser ().RunParse (reader);
  83                 }
  84
  85                 private XQueryTokenizer tokenizer;
  86                 private bool isXQueryMode;
  87
  88                 private Parser ()
  89                         : this (true)
  90                 {
  91                 }
  92
  93                 private Parser (bool isXQueryMode)
  94                 {
  95                         this.isXQueryMode = isXQueryMode;
  96                         ErrorOutput = TextWriter.Null;
  97                 }
  98
  99                 // FIXME: we don't need Evidence here at all. It is used only
 100                 // to generate runnable IL (on loading resulting Assembly).
 101                 public XQueryModule RunParse (TextReader source)
 102                 {
 103                         tokenizer = null;
 104                         try {
 105                                 if (Environment.GetEnvironmentVariable ("MONO_DEBUG_XPATH2") == "yes")
 106                                         debug = new yydebug.yyDebugSimple ();
 107                                 tokenizer = new XQueryTokenizer (source);
 108                                 XQueryModule mod = (XQueryModule) yyparse (tokenizer);
 109                                 mod.NSResolver = tokenizer.NSResolver;
 110                                 return mod;
 111                         } catch (yyParser.yyException ex) {
 112                                 throw new XmlQueryCompileException (String.Format ("Tokenizer error at line {0}, column {1}: {2}", tokenizer.LineNumber, tokenizer.LinePosition, ex.Message), ex);
 113                         }
 114                 }
 115
 116                 public XmlTypeCode GetAtomicTypeCode (XmlQualifiedName name)
 117                 {
 118                         if (name.Namespace == InternalPool.XdtNamespace) {
 119                                 switch (name.Name) {
 120                                 case "anyAtomicType":
 121                                         return XmlTypeCode.AnyAtomicType;
 122                                 case "dayTimeDuration":
 123                                         return XmlTypeCode.DayTimeDuration;
 124                                 case "item":
 125                                         return XmlTypeCode.Item;
 126                                 case "untypedAtomic":
 127                                         return XmlTypeCode.UntypedAtomic;
 128                                 case "yearMonthDuration":
 129                                         return XmlTypeCode.YearMonthDuration;
 130                                 }
 131                         } else if (name.Namespace == XmlSchema.Namespace) {
 132                                 switch (name.Name) {
 133                                 case "boolean":
 134                                         return XmlTypeCode.Boolean;
 135                                 case "byte":
 136                                         return XmlTypeCode.Byte;
 137                                 case "date":
 138                                         return XmlTypeCode.Date;
 139                                 case "dateTime":
 140                                         return XmlTypeCode.DateTime;
 141                                 case "decimal":
 142                                         return XmlTypeCode.Decimal;
 143                                 case "double":
 144                                         return XmlTypeCode.Double;
 145                                 case "duration":
 146                                         return XmlTypeCode.Duration;
 147                                 case "entity":
 148                                         return XmlTypeCode.Entity;
 149                                 case "float":
 150                                         return XmlTypeCode.Float;
 151                                 case "gDay":
 152                                         return XmlTypeCode.GDay;
 153                                 case "gMonth":
 154                                         return XmlTypeCode.GMonth;
 155                                 case "gMonthDay":
 156                                         return XmlTypeCode.GMonthDay;
 157                                 case "gYear":
 158                                         return XmlTypeCode.GYear;
 159                                 case "gYearMonth":
 160                                         return XmlTypeCode.GYearMonth;
 161                                 case "hexBinary":
 162                                         return XmlTypeCode.HexBinary;
 163                                 case "id":
 164                                         return XmlTypeCode.Id;
 165                                 case "idref":
 166                                         return XmlTypeCode.Idref;
 167                                 case "int":
 168                                         return XmlTypeCode.Int;
 169                                 case "integer":
 170                                         return XmlTypeCode.Integer;
 171                                 case "language":
 172                                         return XmlTypeCode.Language;
 173                                 case "long":
 174                                         return XmlTypeCode.Long;
 175                                 case "Name":
 176                                         return XmlTypeCode.Name;
 177                                 case "NCName":
 178                                         return XmlTypeCode.NCName;
 179                                 case "negativeInteger":
 180                                         return XmlTypeCode.NegativeInteger;
 181                                 case "NMTOKEN":
 182                                         return XmlTypeCode.NmToken;
 183                                 case "nonNegativeInteger":
 184                                         return XmlTypeCode.NonNegativeInteger;
 185                                 case "nonPositiveInteger":
 186                                         return XmlTypeCode.NonPositiveInteger;
 187                                 case "normalizedString":
 188                                         return XmlTypeCode.NormalizedString;
 189                                 case "NOTATION":
 190                                         return XmlTypeCode.Notation;
 191                                 case "positiveInteger":
 192                                         return XmlTypeCode.PositiveInteger;
 193                                 case "QName":
 194                                         return XmlTypeCode.QName;
 195                                 case "short":
 196                                         return XmlTypeCode.Short;
 197                                 case "string":
 198                                         return XmlTypeCode.String;
 199                                 case "time":
 200                                         return XmlTypeCode.Time;
 201                                 case "token":
 202                                         return XmlTypeCode.Token;
 203                                 case "unsignedByte":
 204                                         return XmlTypeCode.UnsignedByte;
 205                                 case "unsignedInt":
 206                                         return XmlTypeCode.UnsignedInt;
 207                                 case "unsignedLong":
 208                                         return XmlTypeCode.UnsignedLong;
 209                                 case "unsignedShort":
 210                                         return XmlTypeCode.UnsignedShort;
 211                                 }
 212                         }
 213                         throw new XmlQueryCompileException (String.Format ("Unexpected type name was specified as atomic type: {0}", name));
 214                 }
 215
 216 %}
 217
 218 /* --------------------------------------------------------
 219         Tokens
 220 -------------------------------------------------------- */
 221
 222 /* These are for numbers */
 223 //%token SMALL_E //"e"
 224 //%token LARGE_E //"E"
 225
 226 %token DOT                      "."
 227 %token DOT2                     ".."
 228 %token SEMICOLON                ";"
 229 %token OPEN_PAREN               "("
 230 %token OPEN_PAREN_COLON         "(:"
 231 %token PRAGMA_OPEN              "(::"
 232 %token CLOSE_PAREN              ")"
 233 %token COLON                    ":"
 234 %token COLON2                   "::"
 235 %token PRAGMA_CLOSE             "::)"
 236 %token CLOSE_PAREN_COLON        ":)"
 237 %token COLON_EQUAL              ":="
 238 %token OPEN_BRACKET             "["
 239 %token CLOSE_BRACKET            "]"
 240 %token OPEN_CURLY               "{"
 241 %token CLOSE_CURLY              "}"
 242 %token COMMA                    ","
 243 %token DOLLAR                   "$"
 244 %token EQUAL                    "="
 245 %token NOT_EQUAL                "!="
 246 %token LESSER                   "<"
 247 %token LESSER2                  "<<"
 248 %token LESSER_EQUAL             "<="
 249 %token GREATER                  ">"
 250 %token GREATER2                 ">>"
 251 %token GREATER_EQUAL            ">="
 252 %token BAR                      "|"
 253 %token ASTERISK                 "*"
 254 %token PLUS                     "+"
 255 %token MINUS                    "-"
 256 %token SLASH                    "/"
 257 %token SLASH2                   "//"
 258 %token QUESTION                 "?"
 259
 260
 261 %token XQUERY           //"xquery"
 262 %token VERSION          //"version"
 263 %token PRAGMA           //"pragma"
 264 %token EXTENSION        //"extension"
 265 %token MODULE           //"module"
 266 %token NAMESPACE        //"namespace"
 267 %token DECLARE          //"declare"
 268 %token XMLSPACE         //"xmlspace"
 269 %token PRESERVE         //"preserve"
 270 %token STRIP            //"strip"
 271 %token DEFAULT          //"default"
 272 %token DOCUMENT_NODE    //"document-node"
 273 %token DOCUMENT         //"document"
 274 %token ELEMENT          //"element"
 275 %token ATTRIBUTE        //"attribute"
 276 %token PROCESSING_INSTRUCTION //"processing-instruction"
 277 %token COMMENT          //"comment"
 278 %token TEXT             //"text"
 279 %token NODE             //"node"
 280 %token FUNCTION         //"function"
 281 %token COLLATION        //"collation"
 282 %token CONSTRUCTION     //"construction"
 283 %token ORDERING         //"ordering"
 284 %token ORDERED          //"ordered"
 285 %token UNORDERED        //"unordered"
 286 %token BASEURI          //"base-uri"
 287 %token IMPORT           //"import"
 288 %token SCHEMA           //"schema"
 289 %token AT               //"at"
 290 %token VARIABLE         //"variable"
 291 %token AS               //"as"
 292 %token EXTERNAL         //"external"
 293 %token VALIDATION       //"validation"
 294 %token LAX              //"lax"
 295 %token STRICT           //"strict"
 296 %token SKIP             //"skip"
 297 %token RETURN           //"return"
 298 %token FOR              //"for"
 299 %token LET              //"let"
 300 %token IN               //"in"
 301 %token WHERE            //"where"
 302 %token ORDER            //"order"
 303 %token BY               //"by"
 304 %token STABLE           //"stable"
 305 %token ASCENDING        //"ascending"
 306 %token DESCENDING       //"descending"
 307 %token EMPTY            //"empty"
 308 %token GREATEST         //"greatest"
 309 %token LEAST            //"least"
 310 %token SOME             //"some"
 311 %token EVERY            //"every"
 312 %token SATISFIES        //"satisfies"
 313 %token IS               //"is"
 314 %token TO               //"to"
 315 %token EQ               //"eq"
 316 %token NE               //"ne"
 317 %token LT               //"lt"
 318 %token LE               //"le"
 319 %token GT               //"gt"
 320 %token GE               //"ge"
 321 %token AND              //"and"
 322 %token OR               //"or"
 323 %token INSTANCE         //"instance"
 324 %token OF               //"of"
 325 %token IF               //"if"
 326 %token THEN             //"then"
 327 %token ELSE             //"else"
 328 %token TYPESWITCH       //"typeswitch"
 329 %token CASE             //"case"
 330 %token TREAT            //"treat"
 331 %token CASTABLE         //"castable"
 332 %token CAST             //"as"
 333 %token DIV              //"div"
 334 %token IDIV             //"idiv"
 335 %token MOD              //"mod"
 336 %token UNION            //"union"
 337 %token INTERSECT        //"intersect"
 338 %token EXCEPT           //"except"
 339 %token VALIDATE         //"validate"
 340 %token CONTEXT          //"context"
 341 %token NILLABLE         //"nillable"
 342 %token ITEM             //"item"
 343
 344
 345 %token GLOBAL           //"global"
 346 %token TYPE             //"type"
 347
 348 %token CHILD                    //"child"
 349 %token DESCENDANT               //"descendant"
 350 %token ATTRIBUTE                //"attribute"
 351 %token SELF                     //"self"
 352 %token DESCENDANT_OR_SELF       //"descendant-or-self"
 353 %token FOLLOWING_SIBLING        //"following-sibling"
 354 %token FOLLOWING                //"following"
 355 %token PARENT                   //"parent"
 356 %token ANCESTOR                 //"ancestor"
 357 %token PRECEDING_SIBLING        //"preceding-sibling"
 358 %token PRECEDING                //"preceding"
 359 %token ANCESTOR_OR_SELF         //"ancestor-or-self"
 360
 361 %token PRAGMA_START     "(#"
 362 %token PRAGMA_END       "#)"
 363 %token PragmaContents
 364
 365
 366 %token QNAME
 367 %token NCNAME
 368 %token WILD_LOCALNAME
 369 %token WILD_PREFIX
 370
 371 %token STRING_LITERAL
 372 %token DECIMAL_LITERAL
 373 %token DOUBLE_LITERAL
 374
 375 %token PRAGMA_CONTENTS // characters until "::)"
 376
 377
 378 %token PREDEFINED_ENTITY_REF
 379 %token CHAR_REF
 380
 381 // Used only inside Constructor
 382 %token XML_COMMENT_START // "<!--"
 383 %token XML_COMMENT_TO_END // XML comment content immediate before "-->"
 384 %token XML_PI_START // "<?"
 385 %token XML_PI_TO_END // PI content immediate before "?>"
 386 %token XML_CDATA_START // <![CDATA[
 387 %token XML_CDATA_TO_END // CDATA section content immediate before "]]>"
 388 %token EMPTY_TAG_CLOSE // "/>"
 389 %token END_TAG_START // "</". Its appearance depends on the context
 390 %token ATT_VALUE_LITERAL
 391 %token ELEM_CONTENT_LITERAL
 392 %token EXT_CONTENT
 393 %token APOS                     "'"
 394 //%token APOS2                  "''"
 395 %token QUOT                     //""""
 396 //%token QUOT2                  //""""""
 397
 398 %start Module
 399
 400 %%
 401
 402 /* --------------------------------------------------------
 403          Modules and Prologs
 404 -------------------------------------------------------- */
 405
 406 Module // returns Module
 407         : VersionDecl MainModule
 408         {
 409                 string version = (string) $1;
 410                 XQueryMainModule module = (XQueryMainModule) $2;
 411                 module.Version = version;
 412                 $$ = module;
 413         }
 414         | VersionDecl LibraryModule
 415         {
 416                 string version = (string) $1;
 417                 XQueryLibraryModule module = (XQueryLibraryModule) $2;
 418                 $$ = module;
 419         }
 420         ;
 421
 422 VersionDecl // returns string
 423         : // empty
 424         {
 425                 $$ = null;
 426         }
 427         | XQUERY VERSION STRING_LITERAL {
 428                 tokenizer.State = ParseState.Operator;
 429           } SEMICOLON {
 430                 tokenizer.State = ParseState.Default;
 431           }
 432         {
 433                 $$ = (string) $3;
 434         }
 435         ;
 436
 437 MainModule // returns MainModule
 438         : Prolog QueryBody
 439         {
 440                 Prolog prolog = (Prolog) $1;
 441                 ExprSequence body = (ExprSequence) $2;
 442
 443                 XQueryMainModule mod = new XQueryMainModule ();
 444                 mod.Prolog = prolog;
 445                 mod.QueryBody = body;
 446                 $$ = mod;
 447         }
 448         ;
 449
 450 LibraryModule // returns LibraryModule
 451         : ModuleDecl Prolog
 452         {
 453                 XQueryLibraryModule mod = new XQueryLibraryModule ();
 454                 mod.ModuleDecl = (ModuleDecl) $1;
 455                 mod.Prolog = (Prolog) $2;
 456                 $$ = mod;
 457         }
 458         ;
 459
 460 ModuleDecl // returns ModuleDecl
 461         : MODULE NAMESPACE {
 462                 tokenizer.State = ParseState.NamespaceDecl;
 463           } NCName EQUAL STRING_LITERAL {
 464                 tokenizer.State = ParseState.Default;
 465           } SEMICOLON
 466         {
 467                 ModuleDecl decl = new ModuleDecl ();
 468                 decl.Prefix = (string) $4;
 469                 decl.Namespace = (string) $6;
 470                 tokenizer.AddNamespace (decl.Prefix, decl.Namespace);
 471                 $$ = decl;
 472         }
 473         ;
 474
 475 Prolog
 476         : // empty
 477         {
 478                 $$ = new Prolog ();
 479         }
 480         | PrologContent SEMICOLON Prolog
 481         {
 482                 Prolog p = (Prolog) $3;
 483                 p.Add ($1);
 484                 $$ = p;
 485         }
 486         ;
 487
 488 PrologContent
 489         : Setter
 490         | DeclarationOrImport
 491         ;
 492
 493 // FIXME: this production rule is the right one, but it brings
 494 // major shift/reduce conflicts.
 495 /*
 496 Prolog // returns Prolog
 497         : Setters DeclarationsAndImports
 498         {
 499                 Prolog p = (Prolog) $1;
 500                 ArrayList al = (ArrayList) $2;
 501                 if (al != null) {
 502                         foreach (object o in al)
 503                                 p.Add (o);
 504                 }
 505                 $$ = p;
 506         }
 507         ;
 508
 509 Setters // returns Prolog
 510         : // empty
 511         {
 512                 $$ = new Prolog ();
 513         }
 514         | Setter SEMICOLON Setters
 515         {
 516                 Prolog p = (Prolog) $3;
 517                 p.Add ($1);
 518                 $$ = p;
 519         }
 520         ;
 521
 522 DeclarationsAndImports // returns ArrayList
 523         : // empty
 524         {
 525                 $$ = null;
 526         }
 527         | DeclarationOrImport SEMICOLON DeclarationsAndImports
 528         {
 529                 ArrayList al = (ArrayList) $3;
 530                 if (al == null)
 531                         al = new ArrayList ();
 532                 al.Add ($1);
 533                 $$ = al;
 534         }
 535         ;
 536
 537 */
 538
 539 Setter // returns object
 540         : XmlSpaceDecl // XmlSpaceDecl
 541         | DefaultCollationDecl // SimplePrologContent
 542         | BaseURIDecl // SimplePrologContent
 543         | ConstructionDecl // ConstuctionDecl
 544         | DefaultNamespaceDecl // SimplePrologContent
 545         | DefaultOrderingDecl // bool
 546         ;
 547
 548 DeclarationOrImport // returns object
 549         : SchemaImport
 550         | ModuleImport
 551         | NamespaceDecl
 552         | VarDecl
 553         | FunctionDecl
 554         ;
 555
 556 NamespaceDecl // returns XmlQualifiedName
 557         : DECLARE NAMESPACE {
 558                 tokenizer.State = ParseState.NamespaceDecl;
 559           } NCName EQUAL STRING_LITERAL {
 560                 tokenizer.State = ParseState.Default;
 561           }
 562         {
 563                 XmlQualifiedName name = new XmlQualifiedName ((string) $4, (string) $6);
 564                 tokenizer.AddNamespace (name.Name, name.Namespace);
 565                 $$ = name;
 566         }
 567         ;
 568
 569 XmlSpaceDecl // returns XmlSpaceDecl
 570         : DECLARE XMLSPACE {
 571                 tokenizer.State = ParseState.XmlSpaceDecl;
 572           } PRESERVE {
 573                 tokenizer.State = ParseState.Default;
 574           }
 575         {
 576                 $$ = new XmlSpaceDecl (XmlSpace.Preserve);
 577         }
 578         | DECLARE XMLSPACE {
 579                 tokenizer.State = ParseState.XmlSpaceDecl;
 580           } STRIP {
 581                 tokenizer.State = ParseState.Default;
 582           }
 583         {
 584                 $$ = new XmlSpaceDecl (XmlSpace.Default);
 585         }
 586         ;
 587
 588 ConstructionDecl // returns ConstructionDecl
 589         : DECLARE CONSTRUCTION {
 590                 tokenizer.State = ParseState.Operator;
 591           } PRESERVE {
 592                 tokenizer.State = ParseState.Default;
 593           }
 594         {
 595                 $$ = new ConstructionDecl (XmlSpace.Preserve);
 596         }
 597         | DECLARE CONSTRUCTION {
 598                 tokenizer.State = ParseState.Operator;
 599           } STRIP {
 600                 tokenizer.State = ParseState.Default;
 601           }
 602         {
 603                 $$ = new ConstructionDecl (XmlSpace.Default);
 604         }
 605         ;
 606
 607 DefaultNamespaceDecl // returns SimplePrologContent
 608         : DECLARE DEFAULT ELEMENT {
 609                 tokenizer.State = ParseState.NamespaceKeyword;
 610           } NAMESPACE {
 611                 tokenizer.State = ParseState.NamespaceDecl;
 612           } STRING_LITERAL {
 613                 tokenizer.State = ParseState.Default;
 614           }
 615         {
 616                 tokenizer.AddNamespace (String.Empty, (string) $7);
 617                 $$ = new SimplePrologContent (PrologContentType.DefaultElementNamespace, (string) $7);
 618         }
 619         | DECLARE DEFAULT FUNCTION {
 620                 tokenizer.State = ParseState.NamespaceKeyword;
 621           } NAMESPACE {
 622                 tokenizer.State = ParseState.NamespaceDecl;
 623           } STRING_LITERAL {
 624                 tokenizer.State = ParseState.Default;
 625           }
 626         {
 627                 tokenizer.DefaultFunctionNamespace = (string) $5;
 628                 $$ = new SimplePrologContent (PrologContentType.DefaultFunctionNamespace, (string) $5);
 629         }
 630         ;
 631
 632 DefaultCollationDecl // returns SimplePrologContent
 633         : DECLARE DEFAULT COLLATION {
 634                 tokenizer.State = ParseState.NamespaceDecl;
 635           } STRING_LITERAL {
 636                 tokenizer.State = ParseState.Default;
 637           }
 638         {
 639                 $$ = new SimplePrologContent (PrologContentType.DefaultCollation, (string) $4);
 640         }
 641         ;
 642
 643 DefaultOrderingDecl // returns bool
 644         : DECLARE DEFAULT ORDERING {
 645                 tokenizer.State = ParseState.Operator;
 646           } ORDERED {
 647                 tokenizer.State = ParseState.Default;
 648           }
 649         {
 650                 $$ = true;
 651         }
 652         | DECLARE DEFAULT ORDERING {
 653                 tokenizer.State = ParseState.Operator;
 654           } UNORDERED {
 655                 tokenizer.State = ParseState.Default;
 656           }
 657         {
 658                 $$ = false;
 659         }
 660         ;
 661
 662 BaseURIDecl // returns SimplePrologContent
 663         : DECLARE BASEURI {
 664                 tokenizer.State = ParseState.NamespaceDecl;
 665           } STRING_LITERAL {
 666                 tokenizer.State = ParseState.Default;
 667           }
 668         {
 669                 $$ = new SimplePrologContent (PrologContentType.BaseUri, (string) $3);
 670         }
 671         ;
 672
 673 SchemaImport // returns SchemaImport
 674         : IMPORT SCHEMA {
 675                 tokenizer.State = ParseState.NamespaceKeyword;
 676           } OptionalSchemaPrefix STRING_LITERAL {
 677                 tokenizer.State = ParseState.Default;
 678           } OptionalLocations
 679         {
 680                 if ($4 != null)
 681                         tokenizer.AddNamespace ((string) $4, (string) $5);
 682                 $$ = new SchemaImport ((string) $4, (string) $5, (ICollection) $7);
 683         }
 684         ;
 685
 686 OptionalSchemaPrefix // returns string or null
 687         : // empty
 688         {
 689                 $$ = null;
 690         }
 691         | SchemaPrefix
 692         ;
 693
 694 SchemaPrefix // returns string
 695         : NAMESPACE {
 696                 tokenizer.State = ParseState.NamespaceDecl;
 697           } NCName EQUAL {
 698           }
 699         {
 700                 $$ = (string) $3;
 701         }
 702         | DEFAULT ELEMENT NAMESPACE {
 703                 tokenizer.State = ParseState.NamespaceDecl;
 704           }
 705         {
 706                 $$ = "";
 707         }
 708         ;
 709
 710 ModuleImport // returns ModuleImport
 711         : IMPORT MODULE {
 712                 tokenizer.State = ParseState.NamespaceKeyword;
 713           } OptionalModuleNamespace STRING_LITERAL {
 714                 tokenizer.State = ParseState.Default;
 715           } OptionalLocations
 716         {
 717                 $$ = new ModuleImport ((string) $4, (string) $5, (ICollection) $7);
 718                 tokenizer.AddNamespace ((string) $4, (string) $5);
 719         }
 720         ;
 721
 722 OptionalModuleNamespace // returns string
 723         : // empty
 724         {
 725                 $$ = String.Empty;
 726         }
 727         | NAMESPACE {
 728                 tokenizer.State = ParseState.NamespaceDecl;
 729           } NCName EQUAL
 730         {
 731                 $$ = (string) $3;
 732         }
 733         ;
 734
 735 OptionalLocations // returns ArrayList or null
 736         : // empty
 737         {
 738                 $$ = null;
 739         }
 740         | AT STRING_LITERAL AdditionalLocations
 741         {
 742                 ArrayList al = (ArrayList) $3;
 743                 if (al != null)
 744                         al = new ArrayList ();
 745                 al.Add ((string) $2);
 746                 $$ = al;
 747         }
 748         ;
 749
 750 AdditionalLocations // returns ArrayList or null
 751         : // empty
 752         {
 753                 $$ = null;
 754         }
 755         | COMMA STRING_LITERAL AdditionalLocations
 756         {
 757                 ArrayList al = (ArrayList) $3;
 758                 if (al == null)
 759                         al = new ArrayList ();
 760                 al.Add ((string) $2);
 761                 $$ = al;
 762         }
 763         ;
 764
 765 VarDecl // returns VariableDeclaration
 766         : DECLARE VARIABLE DOLLAR {
 767                 tokenizer.PushState (ParseState.Default);
 768                 tokenizer.State = ParseState.VarName;
 769           } VarName {
 770                 tokenizer.State = ParseState.Operator;
 771           } OptionalTypeDeclaration VarDeclBody
 772         {
 773                 $$ = new XQueryVariable ((XmlQualifiedName) $4, (SequenceType) $5, (ExprSequence) $6);
 774         }
 775         ;
 776
 777 VarDeclBody // returns ExprSequence or null
 778         : OPEN_CURLY {
 779                 tokenizer.State = ParseState.Default;
 780           } Expr CloseCurly
 781         {
 782                 $$ = $2;
 783         }
 784         | EXTERNAL {
 785                 // LAMESPEC: This state transition is not described in XQuery 1.0 spec
 786                 tokenizer.PopState ();
 787           }
 788         {
 789                 $$ = null;
 790         }
 791         ;
 792
 793 VarName // returns XmlQualifiedName
 794         : QName {
 795                 tokenizer.State = ParseState.Operator;
 796           }
 797         {
 798                 $$ = $1;
 799         }
 800         ;
 801
 802 OptionalTypeDeclaration // returns SequenceType or null
 803         : // empty
 804         {
 805                 $$ = null;
 806         }
 807         | TypeDeclaration
 808         ;
 809
 810 TypeDeclaration // returns SequenceType
 811         : AS { // Note that this transition applies only at Operator state.
 812                 tokenizer.State = ParseState.ItemType;
 813           } SequenceType
 814         {
 815                 $$ = $2;
 816         }
 817         ;
 818
 819 FunctionDecl // returns FunctionDeclaration
 820         : DECLARE FUNCTION {
 821                 tokenizer.PushState (ParseState.Default);
 822                 tokenizer.State = ParseState.Default;
 823           } QName OPEN_PAREN OptionalParamList CLOSE_PAREN {
 824                 tokenizer.State = ParseState.Operator;
 825           }  OptionalTypeDeclaration FunctionBody
 826         {
 827                 $$ = new FunctionDeclaration (
 828                         (XmlQualifiedName) $4,
 829                         (XQueryFunctionArgumentList) $6,
 830                         (SequenceType) $9,
 831                         (EnclosedExpr) $10);
 832         }
 833         ;
 834
 835 FunctionBody // returns EnclosedExpr or null
 836         : EnclosedExpr
 837         | EXTERNAL
 838         {
 839                 $$ = null;
 840         }
 841         ;
 842
 843 SequenceType // returns SequenceType
 844         : ItemType OptionalOccurenceIndicator
 845         {
 846                 $$ = new SequenceType ((ItemType) $1, (Occurence) $2);
 847         }
 848         | EMPTY OPEN_PAREN CLOSE_PAREN {
 849                 tokenizer.State = ParseState.Operator;
 850           }
 851         {
 852                 $$ = SequenceType.Create (XmlTypeCode.None, Occurence.One);
 853         }
 854         ;
 855
 856 OptionalOccurenceIndicator // returns Occurence
 857         : // empty
 858         {
 859                 $$ = Occurence.One;
 860         }
 861         | OccurenceIndicator
 862         ;
 863
 864 OccurenceIndicator // returns Occurence
 865         : QUESTION
 866         {
 867                 $$ = Occurence.Optional;
 868         }
 869         | ASTERISK
 870         {
 871                 $$ = Occurence.ZeroOrMore;
 872         }
 873         | PLUS
 874         {
 875                 $$ = Occurence.OneOrMore;
 876         }
 877         ;
 878
 879 OptionalParamList // returns XQueryFunctionArgumentList
 880         : // empty
 881         {
 882                 $$ = new XQueryFunctionArgumentList ();
 883         }
 884         | ParamList
 885         ;
 886
 887 ParamList // returns XQueryFunctionArgumentList
 888         : Param
 889         {
 890                 XQueryFunctionArgumentList pl = new XQueryFunctionArgumentList ();
 891                 pl.Add ((XQueryFunctionArgument) $1);
 892                 $$ = pl;
 893         }
 894         | Param COMMA ParamList
 895         {
 896                 XQueryFunctionArgumentList pl = (XQueryFunctionArgumentList) $3;
 897                 pl.Insert (0, (XQueryFunctionArgument) $1);
 898                 $$ = pl;
 899         }
 900         ;
 901
 902 Param // returns XQueryFunctionArgument
 903         : DOLLAR {
 904                 tokenizer.State = ParseState.VarName;
 905           } VarName {
 906                 tokenizer.State = ParseState.Operator;
 907           } OptionalTypeDeclaration
 908         {
 909                 $$ = new XQueryFunctionArgument ((XmlQualifiedName) $3, (SequenceType) $5);
 910         }
 911         ;
 912
 913 QueryBody
 914         : Expr
 915         ;
 916
 917
 918 /* --------------------------------------------------------
 919         Expressions
 920 -------------------------------------------------------- */
 921
 922 Expr // returns ExprSequence
 923         : ExprSequence
 924         {
 925                 ExprSequence seq = (ExprSequence) $1;
 926                 $$ = seq;
 927         }
 928         ;
 929
 930 ExprSequence // returns ExprSequence
 931         : ExprSingle
 932         {
 933                 ExprSequence seq = new ExprSequence ();
 934                 seq.Add ((ExprSingle) $1);
 935                 $$ = seq;
 936         }
 937         | ExprSingle COMMA ExprSequence
 938         {
 939                 ExprSequence seq = (ExprSequence) $3;
 940                 seq.Insert (0, (ExprSingle) $1);
 941                 $$ = seq;
 942         }
 943         ;
 944
 945 #XPath2Start
 946 ExprSingle // returns ExprSingle
 947         : ForExpr
 948         | QuantifiedExpr
 949         | TypeswitchExpr
 950         | IfExpr
 951         | OrExpr
 952         ;
 953 #XPath2End
 954 #XQueryStart
 955 ExprSingle // returns ExprSingle
 956         : FLWORExpr
 957         | QuantifiedExpr
 958         | TypeswitchExpr
 959         | IfExpr
 960         | OrExpr
 961         ;
 962 #XQueryEnd
 963
 964
 965 /* -------------------------------------
 966         ForExpr
 967 ------------------------------------- */
 968
 969 ForExpr
 970         : SimpleForClause RETURN ExprSingle {
 971                 if (isXQueryMode)
 972                         throw new XmlQueryCompileException ("XQuery does not support for expression.");
 973                 ForLetClauseCollection col = new ForLetClauseCollection ();
 974                 col.Add ((ForClause) $1);
 975                 $$ = new FLWORExpr (col, null, null, (ExprSingle) $3);
 976         }
 977         ;
 978
 979 SimpleForClause // returns ForClause
 980         : FOR SimpleForBody
 981         {
 982                 $$ = (ForClause) $2;
 983         }
 984         ;
 985
 986 SimpleForBody // returns ForClause
 987         : SimpleForSingleBody
 988         {
 989                 ForClause fc = new ForClause ();
 990                 fc.Add ((ForSingleBody) $1);
 991                 $$ = fc;
 992         }
 993         | SimpleForSingleBody COMMA SimpleForBody
 994         {
 995                 ForClause fc = (ForClause) $3;
 996                 fc.Insert (0, (ForSingleBody) $1);
 997                 $$ = fc;
 998         }
 999         ;
1000
1001 SimpleForSingleBody // returns ForSingleBody
1002         : DOLLAR {
1003                 tokenizer.State = ParseState.VarName;
1004           } VarName {
1005                 tokenizer.State = ParseState.Operator;
1006           } IN {
1007                 tokenizer.State = ParseState.Default;
1008           } ExprSingle
1009         {
1010                 $$ = new ForSingleBody ((XmlQualifiedName) $3, (SequenceType) $5, null, (ExprSingle) $7);
1011         }
1012         ;
1013
1014
1015 /* -------------------------------------
1016         FLWORExpr
1017 ------------------------------------- */
1018
1019 FLWORExpr // returns FLWORExpr
1020         : RepeatedForLetClause OptionalWhereClause OptionalOrderByClause RETURN {
1021                 tokenizer.State = ParseState.Default;
1022           } ExprSingle
1023         {
1024                 if (!isXQueryMode)
1025                         throw new XmlQueryCompileException ("XPath2 does not support FLWOR expression.");
1026                 ForLetClauseCollection col = (ForLetClauseCollection) $1;
1027                 $$ = new FLWORExpr (col, (ExprSequence) $2, (OrderSpecList) $3, (ExprSingle) $6);
1028         }
1029         ;
1030
1031 RepeatedForLetClause // returns ForLetClauseCollection
1032         : ForLetClause
1033         {
1034                 ForLetClauseCollection col = new ForLetClauseCollection ();
1035                 col.Add ((ForLetClause) $1);
1036                 $$ = col;
1037         }
1038         | ForLetClause RepeatedForLetClause
1039         {
1040                 ForLetClauseCollection col = (ForLetClauseCollection) $2;
1041                 col.Insert (0, (ForLetClause) $1);
1042                 $$ = col;
1043         }
1044         ;
1045
1046 ForLetClause // returns ForLetClause
1047         : ForClause
1048         | LetClause
1049         ;
1050
1051 OptionalWhereClause // returns ExprSequence or null
1052         : // empty
1053         {
1054                 $$ = null;
1055         }
1056         | WhereClause
1057         ;
1058
1059 OptionalOrderByClause
1060         : // empty
1061         {
1062                 $$ = null;
1063         }
1064         | OrderByClause
1065         ;
1066
1067 ForClause // returns ForClause
1068         : FOR ForBody
1069         {
1070                 ForClause fc = (ForClause) $2;
1071                 $$ = fc;
1072         }
1073         ;
1074
1075 ForBody
1076         : ForSingleBody
1077         {
1078                 ForClause fc = new ForClause ();
1079                 fc.Add ((ForSingleBody) $1);
1080                 $$ = fc;
1081         }
1082         | ForSingleBody COMMA ForBody
1083         {
1084                 ForClause fc = (ForClause) $3;
1085                 fc.Insert (0, (ForSingleBody) $1);
1086                 $$ = fc;
1087         }
1088         ;
1089
1090 ForSingleBody // returns ForSingleBody
1091         : DOLLAR {
1092                 tokenizer.State = ParseState.VarName;
1093           } VarName {
1094                 tokenizer.State = ParseState.Operator;
1095           } OptionalTypeDeclaration OptionalPositionalVar IN {
1096                 tokenizer.State = ParseState.Default;
1097           } ExprSingle
1098         {
1099                 $$ = new ForSingleBody ((XmlQualifiedName) $3, (SequenceType) $5, (XmlQualifiedName) $6, (ExprSingle) $9);
1100         }
1101         ;
1102
1103 LetClause
1104         : LET LetBody
1105         {
1106                 LetClause let = (LetClause) $2;
1107                 $$ = let;
1108         }
1109         ;
1110
1111 LetBody
1112         : LetSingleBody
1113         {
1114                 LetClause lc = new LetClause ();
1115                 lc.Add ((LetSingleBody) $1);
1116                 $$ = lc;
1117         }
1118         | LetSingleBody COMMA LetBody
1119         {
1120                 LetClause let = (LetClause) $3;
1121                 let.Insert (0, (LetSingleBody) $1);
1122                 $$ = let;
1123         }
1124
1125 LetSingleBody
1126         : DOLLAR {
1127                 tokenizer.State = ParseState.VarName;
1128           } VarName {
1129                 tokenizer.State = ParseState.Operator;
1130           } OptionalTypeDeclaration COLON_EQUAL {
1131                 tokenizer.State = ParseState.Default;
1132           } ExprSingle
1133         {
1134                 $$ = new LetSingleBody ((XmlQualifiedName) $3, (SequenceType) $5, (ExprSingle) $8);
1135         }
1136         ;
1137
1138 OptionalPositionalVar // returns XmlQualifiedName
1139         : // empty
1140         {
1141                 $$ = XmlQualifiedName.Empty;
1142         }
1143         | PositionalVar
1144         ;
1145
1146 PositionalVar
1147         : AT {
1148                 tokenizer.State = ParseState.Default;
1149           } DOLLAR {
1150                 tokenizer.State = ParseState.VarName;
1151           } VarName {
1152                 tokenizer.State = ParseState.Operator;
1153           }
1154         {
1155                 $$ = $5;
1156         }
1157         ;
1158
1159 WhereClause // returns ExprSequence
1160         : WHERE {
1161                 tokenizer.State = ParseState.Default;
1162           } Expr
1163         {
1164                 $$ = $3;
1165         }
1166         ;
1167
1168 OrderByClause // returns OrderSpecList
1169         : ORDER BY {
1170                 tokenizer.State = ParseState.Default;
1171           } OrderSpecList
1172         {
1173                 OrderSpecList l = (OrderSpecList) $4;
1174                 $$ = l;
1175         }
1176         | STABLE ORDER BY {
1177                 tokenizer.State = ParseState.Default;
1178           } OrderSpecList
1179         {
1180                 OrderSpecList l = (OrderSpecList) $5;
1181                 l.IsStable = true;
1182                 $$ = l;
1183         }
1184         ;
1185
1186 OrderSpecList // returns OrderSpecList
1187         : OrderSpec
1188         {
1189                 OrderSpecList osl = new OrderSpecList ();
1190                 osl.Add ((OrderSpec) $1);
1191                 $$ = osl;
1192         }
1193         | OrderSpec COMMA OrderSpecList
1194         {
1195                 OrderSpecList l = (OrderSpecList) $3;
1196                 l.Insert (0, (OrderSpec) $1);
1197                 $$ = l;
1198         }
1199         ;
1200
1201 OrderSpec // returns OrderSpec
1202         : ExprSingle OrderModifier
1203         {
1204                 $$ = new OrderSpec ((ExprSingle) $1, (OrderModifier) $2);
1205         }
1206         ;
1207
1208 OrderModifier
1209         : OrderSpecBase OrderEmptyHandling OptionalCollation
1210         {
1211                 $$ = new OrderModifier ((XmlSortOrder) $1, (XmlSortOrder) $2, (string) $3);
1212         }
1213         ;
1214
1215 OrderSpecBase // returns XmlSortOrder
1216         : // empty
1217         {
1218                 $$ = XmlSortOrder.Ascending;
1219         }
1220         | ASCENDING
1221         {
1222                 $$ = XmlSortOrder.Ascending;
1223         }
1224         | DESCENDING
1225         {
1226                 $$ = XmlSortOrder.Descending;
1227         }
1228         ;
1229
1230 /* FIXME: check if it is correct (especially empty case) */
1231 OrderEmptyHandling // returns XmlSortOrder
1232         : // empty
1233         {
1234                 $$ = XmlSortOrder.Ascending;
1235         }
1236         | EMPTY GREATEST
1237         {
1238                 $$ = XmlSortOrder.Ascending;
1239         }
1240         | EMPTY LEAST
1241         {
1242                 $$ = XmlSortOrder.Descending;
1243         }
1244         ;
1245
1246 OptionalCollation // returns string
1247         : // empty
1248         {
1249                 $$ = null;
1250         }
1251         | COLLATION STRING_LITERAL
1252         {
1253                 $$ = $2;
1254         }
1255         ;
1256
1257 /* -------------------------------------
1258         QuantifiedExpr
1259 ------------------------------------- */
1260
1261 QuantifiedExpr
1262         : SOME QuantifiedExprBody SATISFIES ExprSingle
1263         {
1264                 QuantifiedExprBodyList l = (QuantifiedExprBodyList) $2;
1265                 $$ = new QuantifiedExpr (false, l, (ExprSingle) $4);
1266         }
1267         | EVERY QuantifiedExprBody SATISFIES ExprSingle
1268         {
1269                 QuantifiedExprBodyList l = (QuantifiedExprBodyList) $2;
1270                 $$ = new QuantifiedExpr (true, l, (ExprSingle) $4);
1271         }
1272         ;
1273
1274 QuantifiedExprBody
1275         : SingleQuantifiedExprBody
1276         {
1277                 QuantifiedExprBodyList l = new QuantifiedExprBodyList ();
1278                 l.Add ((QuantifiedExprBody) $1);
1279                 $$ = l;
1280         }
1281         | SingleQuantifiedExprBody COMMA QuantifiedExprBody
1282         {
1283                 QuantifiedExprBodyList l = (QuantifiedExprBodyList) $3;
1284                 l.Insert (0, (QuantifiedExprBody) $1);
1285                 $$ = l;
1286         }
1287         ;
1288
1289 SingleQuantifiedExprBody // returns QuantifiedExprBody
1290         : DOLLAR {
1291                 tokenizer.State = ParseState.VarName;
1292           } VarName {
1293                 tokenizer.State = ParseState.Operator;
1294           } OptionalTypeDeclaration IN {
1295                 tokenizer.State = ParseState.Default;
1296           } ExprSingle
1297         {
1298                 $$ = new QuantifiedExprBody ((XmlQualifiedName) $3, (SequenceType) $5, (ExprSingle) $8);
1299         }
1300         ;
1301
1302 /* -------------------------------------
1303         TypeswitchExpr
1304 ------------------------------------- */
1305
1306 TypeswitchExpr // returns TypeswitchExpr
1307         : TYPESWITCH OPEN_PAREN {
1308                 tokenizer.PushState (ParseState.Operator);
1309                 tokenizer.State = ParseState.Default;
1310           } Expr CLOSE_PAREN {
1311                 tokenizer.State = ParseState.Operator;
1312           } RepeatedCaseClause DEFAULT OptionalVarSpec RETURN {
1313                 tokenizer.State = ParseState.Default;
1314           } ExprSingle
1315         {
1316                 if (!isXQueryMode)
1317                         throw new XmlQueryCompileException ("XPath2 does not support typeswitch.");
1318                 $$ = new TypeswitchExpr ((ExprSequence) $4, (CaseClauseList) $7, (XmlQualifiedName) $9, (ExprSingle) $12);
1319         }
1320         ;
1321
1322 RepeatedCaseClause // returns CaseClauseList
1323         : CaseClause
1324         {
1325                 CaseClauseList ccl = new CaseClauseList ();
1326                 ccl.Add ((CaseClause) $1);
1327                 $$ = ccl;
1328         }
1329         | CaseClause RepeatedCaseClause
1330         {
1331                 CaseClauseList l = (CaseClauseList) $2;
1332                 l.Add ((CaseClause) $1);
1333                 $$ = l;
1334         }
1335         ;
1336
1337 CaseClause // returns CaseClause
1338         : CASE {
1339                 tokenizer.State = ParseState.ItemType;
1340           } SequenceType RETURN {
1341                 tokenizer.State = ParseState.Default;
1342           } ExprSingle
1343         {
1344                 $$ = new CaseClause ((SequenceType) $3, (ExprSingle) $6, XmlQualifiedName.Empty);
1345         }
1346         | CASE {
1347                 tokenizer.State = ParseState.ItemType;
1348           } DOLLAR {
1349                 tokenizer.State = ParseState.VarName;
1350           } VarName {
1351                 tokenizer.State = ParseState.Operator;
1352           } AS {
1353                 tokenizer.State = ParseState.ItemType;
1354           } SequenceType RETURN {
1355                 tokenizer.State = ParseState.Default;
1356           } ExprSingle
1357         {
1358                 $$ = new CaseClause ((SequenceType) $9, (ExprSingle) $12, (XmlQualifiedName) $5);
1359         }
1360         ;
1361
1362 OptionalVarSpec // returns XmlQualifiedName
1363         : // empty
1364         {
1365                 $$ = XmlQualifiedName.Empty;
1366         }
1367         | DOLLAR VarName
1368         {
1369                 $$ = (XmlQualifiedName) $2;
1370         }
1371         ;
1372
1373 /* -------------------------------------
1374         IfExpr
1375 ------------------------------------- */
1376
1377 IfExpr
1378         : IF OPEN_PAREN Expr CLOSE_PAREN {
1379                 tokenizer.State = ParseState.Operator;
1380           } THEN {
1381                 tokenizer.State = ParseState.Default;
1382           } ExprSingle ELSE {
1383                 tokenizer.State = ParseState.Default;
1384           } ExprSingle
1385         {
1386                 $$ = new IfExpr ((ExprSequence) $3, (ExprSingle) $8, (ExprSingle) $11);
1387         }
1388         ;
1389
1390 /* -------------------------------------
1391         Logical Expressions
1392 ------------------------------------- */
1393
1394 OrExpr
1395         : AndExpr
1396         | AndExpr OR {
1397                 tokenizer.State = ParseState.Default;
1398           } OrExpr
1399         {
1400                 $$ = new OrExpr ((ExprSingle) $1, (ExprSingle) $4);
1401         }
1402         ;
1403
1404 AndExpr
1405         : InstanceOfExpr
1406         | InstanceOfExpr AND {
1407                 tokenizer.State = ParseState.Default;
1408           } AndExpr
1409         {
1410                 $$ = new AndExpr ((ExprSingle) $1, (ExprSingle) $4);
1411         }
1412         ;
1413
1414 /* -------------------------------------
1415         Typed Expressions
1416 ------------------------------------- */
1417
1418 InstanceOfExpr
1419         : TreatExpr
1420         | TreatExpr INSTANCE OF {
1421                 tokenizer.State = ParseState.ItemType;
1422           } SequenceType
1423         {
1424                 $$ = new InstanceOfExpr ((ExprSingle) $1, (SequenceType) $5);
1425         }
1426         ;
1427
1428 TreatExpr
1429         : CastableExpr
1430         | CastableExpr TREAT AS {
1431                 tokenizer.State = ParseState.ItemType;
1432           } SequenceType
1433         {
1434                 $$ = new TreatExpr ((ExprSingle) $1, (SequenceType) $5);
1435         }
1436         ;
1437
1438 CastableExpr
1439         : CastExpr
1440         | CastExpr CASTABLE AS {
1441                 tokenizer.State = ParseState.ItemType;
1442           } AtomicType OptionalQuestion
1443         {
1444                 $$ = new CastableExpr ((ExprSingle) $1, (XmlTypeCode) $5, (bool)$6);
1445         }
1446         ;
1447
1448 OptionalQuestion
1449         : // empty
1450         {
1451                 $$ = false;
1452         }
1453         | QUESTION
1454         {
1455                 $$ = true;
1456         }
1457         ;
1458
1459 CastExpr
1460         : ComparisonExpr
1461         | ComparisonExpr CAST AS {
1462                 tokenizer.State = ParseState.ItemType;
1463           } AtomicType OptionalQuestion
1464         {
1465                 $$ = new CastExpr ((ExprSingle) $1, (XmlTypeCode) $5, (bool) $6);
1466         }
1467         ;
1468
1469 /* -------------------------------------
1470         Comparison Expressions
1471 ------------------------------------- */
1472
1473 ComparisonExpr
1474         : RangeExpr
1475         | RangeExpr Comp {
1476                 tokenizer.State = ParseState.Default;
1477           } RangeExpr
1478         {
1479                 $$ = new ComparisonExpr ((ExprSingle) $1, (ExprSingle) $4, (ComparisonOperator) $2);
1480         }
1481         ;
1482
1483 Comp // returns ComparisonOperator
1484         : ValueComp
1485         | GeneralComp
1486         | NodeComp
1487         ;
1488
1489 ValueComp
1490         : EQ
1491         {
1492                 $$ = ComparisonOperator.ValueEQ;
1493         }
1494         | NE
1495         {
1496                 $$ = ComparisonOperator.ValueNE;
1497         }
1498         | LT
1499         {
1500                 $$ = ComparisonOperator.ValueLT;
1501         }
1502         | LE
1503         {
1504                 $$ = ComparisonOperator.ValueLE;
1505         }
1506         | GT
1507         {
1508                 $$ = ComparisonOperator.ValueGT;
1509         }
1510         | GE
1511         {
1512                 $$ = ComparisonOperator.ValueGE;
1513         }
1514         ;
1515
1516 GeneralComp
1517         : EQUAL
1518         {
1519                 $$ = ComparisonOperator.GeneralEQ;
1520         }
1521         | NOT_EQUAL
1522         {
1523                 $$ = ComparisonOperator.GeneralNE;
1524         }
1525         | LESSER
1526         {
1527                 $$ = ComparisonOperator.GeneralLT;
1528         }
1529         | LESSER_EQUAL
1530         {
1531                 $$ = ComparisonOperator.GeneralLE;
1532         }
1533         | GREATER
1534         {
1535                 $$ = ComparisonOperator.GeneralGT;
1536         }
1537         | GREATER_EQUAL
1538         {
1539                 $$ = ComparisonOperator.GeneralGE;
1540         }
1541         ;
1542
1543 NodeComp
1544         : IS
1545         {
1546                 $$ = ComparisonOperator.NodeIs;
1547         }
1548         | LESSER2
1549         {
1550                 $$ = ComparisonOperator.NodeFWD;
1551         }
1552         | GREATER2
1553         {
1554                 $$ = ComparisonOperator.NodeBWD;
1555         }
1556         ;
1557
1558 RangeExpr
1559         : AdditiveExpr
1560         | AdditiveExpr TO {
1561                 tokenizer.State = ParseState.Default;
1562           } AdditiveExpr
1563         {
1564                 $$ = new RangeExpr ((ExprSingle) $1, (ExprSingle)$4);
1565         }
1566         ;
1567
1568 /* -------------------------------------
1569         Arithmetic Expressions
1570 ------------------------------------- */
1571
1572 AdditiveExpr
1573         : MultiplicativeExpr
1574         | MultiplicativeExpr PLUS {
1575                 tokenizer.State = ParseState.Default;
1576           } AdditiveExpr
1577         {
1578                 $$ = new ArithmeticOperationExpr ((ExprSingle) $1, (ExprSingle) $4, ArithmeticOperator.Add);
1579         }
1580         | MultiplicativeExpr MINUS {
1581                 tokenizer.State = ParseState.Default;
1582           } AdditiveExpr
1583         {
1584                 $$ = new ArithmeticOperationExpr ((ExprSingle) $1, (ExprSingle) $4, ArithmeticOperator.Sub);
1585         }
1586         ;
1587
1588 MultiplicativeExpr
1589         : UnaryExpr
1590         | UnaryExpr ASTERISK {
1591                 tokenizer.State = ParseState.Default;
1592           } MultiplicativeExpr
1593         {
1594                 $$ = new ArithmeticOperationExpr ((ExprSingle) $1, (ExprSingle) $4, ArithmeticOperator.Mul);
1595         }
1596         | UnaryExpr DIV {
1597                 tokenizer.State = ParseState.Default;
1598           } MultiplicativeExpr
1599         {
1600                 $$ = new ArithmeticOperationExpr ((ExprSingle) $1, (ExprSingle) $4, ArithmeticOperator.Div);
1601         }
1602         | UnaryExpr IDIV {
1603                 tokenizer.State = ParseState.Default;
1604           } MultiplicativeExpr
1605         {
1606                 $$ = new ArithmeticOperationExpr ((ExprSingle) $1, (ExprSingle) $4, ArithmeticOperator.IDiv);
1607         }
1608         | UnaryExpr MOD {
1609                 tokenizer.State = ParseState.Default;
1610           } MultiplicativeExpr
1611         {
1612                 $$ = new ArithmeticOperationExpr ((ExprSingle) $1, (ExprSingle) $4, ArithmeticOperator.IMod);
1613         }
1614         ;
1615
1616 UnaryExpr
1617         : UnionExpr
1618         | MINUS UnionExpr
1619         {
1620                 $$ = new MinusExpr ((ExprSingle) $2);
1621         }
1622         | PLUS UnionExpr
1623         {
1624                 $$ = $2;
1625         }
1626         ;
1627
1628 UnionExpr
1629         : IntersectExceptExpr
1630         | IntersectExceptExpr UNION {
1631                 tokenizer.State = ParseState.Default;
1632           } UnionExpr
1633         {
1634                 $$ = new GroupExpr ((ExprSingle) $1, (ExprSingle) $4, AggregationType.Union);
1635         }
1636         | IntersectExceptExpr BAR {
1637                 tokenizer.State = ParseState.Default;
1638           } UnionExpr
1639         {
1640                 $$ = new GroupExpr ((ExprSingle) $1, (ExprSingle) $4, AggregationType.Union);
1641         }
1642         ;
1643
1644 IntersectExceptExpr
1645         : ValueExpr
1646         | ValueExpr INTERSECT {
1647                 tokenizer.State = ParseState.Default;
1648           } IntersectExceptExpr
1649         {
1650                 $$ = new GroupExpr ((ExprSingle) $1, (ExprSingle) $4, AggregationType.Intersect);
1651         }
1652         | ValueExpr EXCEPT {
1653                 tokenizer.State = ParseState.Default;
1654           } IntersectExceptExpr
1655         {
1656                 $$ = new GroupExpr ((ExprSingle) $1, (ExprSingle) $4, AggregationType.Except);
1657         }
1658         ;
1659
1660 ValueExpr
1661         : ValidateExpr
1662         | PathExpr
1663         | ExtensionExpr
1664         ;
1665
1666 /* -----------------
1667  Extension Expressions
1668 ----------------- */
1669
1670 ExtensionExpr
1671         : PragmaList OPEN_CURLY OptionalExpr CLOSE_CURLY
1672         {
1673                 if (!isXQueryMode)
1674                         throw new XmlQueryCompileException ("XPath2 does not suport extension expression.");
1675                 throw new NotImplementedException ();
1676         }
1677         ;
1678
1679 OptionalExpr
1680         :
1681         | Expr
1682         ;
1683
1684 PragmaList
1685         : Pragma
1686         {
1687                 throw new NotImplementedException ();
1688         }
1689         | Pragma PragmaList
1690         {
1691                 throw new NotImplementedException ();
1692         }
1693         ;
1694
1695 Pragma
1696         : PRAGMA_START QName PragmaContents PRAGMA_END
1697         {
1698                 throw new NotImplementedException ();
1699         }
1700         ;
1701
1702
1703 /* -----------------
1704  Validation Expressions
1705 ----------------- */
1706
1707 // FIXME: Here state transition is not well-tracked.
1708
1709 ValidateExpr // returns ValidateExpr
1710         : VALIDATE OptionalValidationMode OPEN_CURLY {
1711                 tokenizer.State = ParseState.Default;
1712                 tokenizer.PushState (ParseState.Operator);
1713           } Expr CloseCurly
1714         {
1715                 if (!isXQueryMode)
1716                         throw new XmlQueryCompileException ("XPath2 does not support validate expression.");
1717                 $$ = new ValidateExpr ((XmlSchemaContentProcessing) $2, (ExprSequence) $6);
1718         }
1719         ;
1720
1721 OptionalValidationMode // returns XmlSchemaContentProcessing
1722         : // empty
1723         {
1724                 $$ = XmlSchemaContentProcessing.Strict; // FIXME: confirm
1725         }
1726         | LAX
1727         {
1728                 $$ = XmlSchemaContentProcessing.Lax;
1729         }
1730         | STRICT
1731         {
1732                 $$ = XmlSchemaContentProcessing.Strict;
1733         }
1734         ;
1735
1736 /* -----------------
1737  Path Expressions
1738 ----------------- */
1739
1740 PathExpr // returns PathExpr
1741         : Slash
1742         {
1743                 $$ = new PathRootExpr ();
1744         }
1745         | Slash RelativePathExpr
1746         {
1747                 $$ = new PathSlashExpr (new PathRootExpr (), (ExprSingle) $2);
1748         }
1749         | Slash2 RelativePathExpr
1750         {
1751                 $$ = new PathSlash2Expr (new PathRootExpr (), (ExprSingle) $2);
1752         }
1753         | RelativePathExpr
1754         ;
1755
1756 RelativePathExpr // returns PathExpr
1757         : StepExpr
1758         | StepExpr Slash RelativePathExpr
1759         {
1760                 $$ = new PathSlashExpr ((ExprSingle) $1, (ExprSingle) $3);
1761         }
1762         | StepExpr Slash2 RelativePathExpr
1763         {
1764                 $$ = new PathSlash2Expr ((ExprSingle) $1, (ExprSingle) $3);
1765         }
1766         ;
1767
1768 StepExpr // returns ExprSingle
1769         : AxisStep
1770         | FilterStep
1771         ;
1772
1773 AxisStep // returns PathExpr
1774         : ForwardOrReverseStep
1775         | AxisStep Predicate
1776         {
1777                 $$ = new FilterStepExpr ((ExprSingle) $1, (ExprSequence) $2);
1778         }
1779         ;
1780
1781 ForwardOrReverseStep // returns ExprSingle
1782         : ForwardStep
1783         | ReverseStep
1784         ;
1785
1786 Predicate
1787         : OPEN_BRACKET Expr CLOSE_BRACKET {
1788                 tokenizer.State = ParseState.Operator;
1789           }
1790         {
1791                 $$ = $2;
1792         }
1793         ;
1794
1795 FilterStep // returns ExprSingle
1796         : PrimaryExpr
1797         | FilterStep Predicate
1798         {
1799                 $$ = new FilterStepExpr ((ExprSingle) $1, (ExprSequence) $2);
1800         }
1801         ;
1802
1803 ForwardStep // returns AxisStepExpr
1804         : ForwardAxis NodeTest
1805         {
1806                 $$ = new AxisStepExpr ((XPathAxis) $1, (XPath2NodeTest) $2);
1807         }
1808         | AbbrevForwardStep
1809         ;
1810
1811 ReverseStep // returns AxisStepExpr
1812         : ReverseAxis NodeTest
1813         {
1814                 $$ = new AxisStepExpr ((XPathAxis) $1, (XPath2NodeTest) $2);
1815         }
1816         | AbbrevReverseStep
1817         ;
1818
1819 ForwardAxis // returns XPathAxis
1820         : CHILD COLON2
1821         {
1822                 $$ = XPathAxis.Child;
1823         }
1824         | DESCENDANT COLON2
1825         {
1826                 $$ = XPathAxis.Descendant;
1827         }
1828         | ATTRIBUTE COLON2
1829         {
1830                 $$ = XPathAxis.Attribute;
1831         }
1832         | SELF COLON2
1833         {
1834                 $$ = XPathAxis.Self;
1835         }
1836         | DESCENDANT_OR_SELF COLON2
1837         {
1838                 $$ = XPathAxis.DescendantOrSelf;
1839         }
1840         | FOLLOWING_SIBLING COLON2
1841         {
1842                 $$ = XPathAxis.FollowingSibling;
1843         }
1844         | FOLLOWING COLON2
1845         {
1846                 $$ = XPathAxis.Following;
1847         }
1848         | NAMESPACE COLON2
1849         {
1850                 if (isXQueryMode)
1851                         throw new XmlQueryCompileException ("XQuery does not support namespace axis.");
1852                 $$ = XPathAxis.NamespaceAxis;
1853         }
1854         ;
1855
1856 ReverseAxis // returns XPathAxis
1857         : PARENT COLON2
1858         {
1859                 $$ = XPathAxis.Parent;
1860         }
1861         | ANCESTOR COLON2
1862         {
1863                 $$ = XPathAxis.Ancestor;
1864         }
1865         | PRECEDING_SIBLING COLON2
1866         {
1867                 $$ = XPathAxis.PrecedingSibling;
1868         }
1869         | PRECEDING COLON2
1870         {
1871                 $$ = XPathAxis.Preceding;
1872         }
1873         | ANCESTOR_OR_SELF COLON2
1874         {
1875                 $$ = XPathAxis.AncestorOrSelf;
1876         }
1877         ;
1878
1879 // LAMESPEC: in the XQuery spec, it is "@? NodeTest", but NodeKindTest
1880 // should not appear after AT. (imagine @processing-instruction::(name)).
1881 AbbrevForwardStep // returns NodeTestExpr
1882         : NodeTest
1883         {
1884                 $$ = new AxisStepExpr (XPathAxis.Child, (XPath2NodeTest) $1);
1885         }
1886         | AT NameTest
1887         {
1888                 $$ = new AxisStepExpr (XPathAxis.Attribute, new XPath2NodeTest ((XmlQualifiedName) $2));
1889         }
1890         ;
1891
1892 AbbrevReverseStep // returns AxisStepExpr
1893         : DOT2
1894         {
1895                 $$ = new AxisStepExpr (XPathAxis.Parent, null);
1896         }
1897         ;
1898
1899 NodeTest // returns NodeTest
1900         : KindTest
1901         {
1902                 $$ = new XPath2NodeTest ((KindTest) $1);
1903         }
1904         | NameTest
1905         {
1906                 $$ = new XPath2NodeTest ((XmlQualifiedName) $1);
1907         }
1908         ;
1909
1910 NameTest // returns XmlQualifiedName
1911         : QName
1912         | Wildcard {
1913                 tokenizer.State = ParseState.Operator;
1914           }
1915         ;
1916
1917 Wildcard // returns XmlQualifiedName  /*ws:explicit*/
1918         : ASTERISK
1919         {
1920                 $$ = new XmlQualifiedName ("*", "*");
1921         }
1922         | WILD_LOCALNAME
1923         {
1924                 $$ = (XmlQualifiedName) $1;
1925         }
1926         | WILD_PREFIX
1927         {
1928                 $$ = (XmlQualifiedName) $1;
1929         }
1930         ;
1931
1932 AtomicType // returns XmlTypeCode
1933         : QName
1934         {
1935                 $$ = GetAtomicTypeCode ((XmlQualifiedName) $1);
1936         }
1937         ;
1938
1939 ItemType // returns ItemType
1940         : AtomicType {
1941                 tokenizer.State = ParseState.OccurenceIndicator;
1942           }
1943         {
1944                 $$ = new ItemType ((XmlTypeCode) $1);
1945         }
1946         | KindTest
1947         | ITEM OPEN_PAREN CLOSE_PAREN {
1948                 tokenizer.State = ParseState.OccurenceIndicator;
1949           }
1950         {
1951                 $$ = new ItemType (XmlTypeCode.Item);
1952         }
1953         ;
1954
1955 KindTest // returns KindTest
1956         : DocumentTest
1957         | ElementTest
1958         | AttributeTest
1959         | PITest
1960         | CommentTest
1961         | TextTest
1962         | AnyKindTest
1963         ;
1964
1965 PITest
1966         : PROCESSING_INSTRUCTION OPEN_PAREN {
1967                 // LAMESPEC: push state is described as Operator, but should
1968                 // be OccurenceIndicator (as any KindTest could be followed by
1969                 // '?' '+' or '*')
1970                 tokenizer.PushState (ParseState.OccurenceIndicator);
1971                 tokenizer.State = ParseState.KindTestForPI;
1972           } PITestContent CLOSE_PAREN {
1973                 tokenizer.PopState ();
1974           }
1975         {
1976                 $$ = $4;
1977         }
1978         ;
1979
1980 PITestContent // returns KindTest
1981         : // empty
1982         {
1983                 $$ = new KindTest (XmlTypeCode.ProcessingInstruction);
1984         }
1985         | NCName
1986         {
1987                 $$ = new XmlPITest ((string) $1);
1988         }
1989         | STRING_LITERAL
1990         {
1991                 $$ = new XmlPITest ((string) $1);
1992         }
1993         ;
1994
1995 CommentTest
1996         : COMMENT OPEN_PAREN {
1997                 tokenizer.PushState (ParseState.OccurenceIndicator);
1998                 tokenizer.State = ParseState.KindTest;
1999           } CLOSE_PAREN {
2000                 tokenizer.PopState ();
2001           }
2002         {
2003                 $$ = new KindTest (XmlTypeCode.Comment);
2004         }
2005         ;
2006
2007 TextTest
2008         : TEXT OPEN_PAREN {
2009                 tokenizer.PushState (ParseState.OccurenceIndicator);
2010                 tokenizer.State = ParseState.KindTest;
2011           } CLOSE_PAREN {
2012                 tokenizer.PopState ();
2013           }
2014         {
2015                 $$ = new KindTest (XmlTypeCode.Text);
2016         }
2017         ;
2018
2019 AnyKindTest
2020         : NODE OPEN_PAREN {
2021                 tokenizer.PushState (ParseState.OccurenceIndicator);
2022                 tokenizer.State = ParseState.KindTest;
2023           } CLOSE_PAREN {
2024                 tokenizer.PopState ();
2025           }
2026         {
2027                 $$ = new KindTest (XmlTypeCode.Node);
2028         }
2029         ;
2030
2031 DocumentTest // returns DocumentTest
2032         : DOCUMENT_NODE OPEN_PAREN {
2033                 tokenizer.PushState (ParseState.OccurenceIndicator);
2034                 tokenizer.State = ParseState.KindTest;
2035           } DocumentTestContent CLOSE_PAREN {
2036                 tokenizer.PopState ();
2037           }
2038         {
2039                 $$ = $4;
2040         }
2041         ;
2042
2043 DocumentTestContent // returns DocumentTest
2044         : // empty
2045         {
2046                 $$ = new KindTest (XmlTypeCode.Document);
2047         }
2048         | ElementTest
2049         {
2050                 $$ = new DocumentTest ((ElementTest) $1);
2051         }
2052         ;
2053
2054 ElementTest // returns ElementTest
2055         : ELEMENT OPEN_PAREN {
2056                 tokenizer.PushState (ParseState.OccurenceIndicator);
2057                 tokenizer.State = ParseState.KindTest;
2058           } ElementTestContent CLOSE_PAREN {
2059                 tokenizer.PopState ();
2060           }
2061         {
2062                 $$ = $4;
2063         }
2064         ;
2065
2066 ElementTestContent // returns ElementTest
2067         : // empty
2068         {
2069                 $$ = new KindTest (XmlTypeCode.Element);
2070         }
2071         | ElementNameOrWildcard
2072         {
2073                 $$ = new ElementTest ((XmlQualifiedName) $1);
2074         }
2075         | ElementNameOrWildcard COMMA TypeName OptionalQuestion
2076         {
2077                 $$ = new ElementTest ((XmlQualifiedName) $1, (XmlQualifiedName) $3, (bool) $4);
2078         }
2079         ;
2080
2081 OptionalQuestion // returns bool
2082         : // empty
2083         {
2084                 $$ = false;
2085         }
2086         | QUESTION
2087         {
2088                 $$ = true;
2089         }
2090         ;
2091
2092 AttributeTest // returns AttributeTest
2093         : ATTRIBUTE OPEN_PAREN {
2094                 tokenizer.PushState (ParseState.OccurenceIndicator);
2095                 tokenizer.State = ParseState.KindTest;
2096           } AttributeTestContent CLOSE_PAREN {
2097                 tokenizer.PopState ();
2098           }
2099         {
2100                 $$ = $4;
2101         }
2102         ;
2103
2104 AttributeTestContent // returns AttributeTest
2105         : // empty
2106         {
2107                 $$ = AttributeTest.AnyAttribute;
2108         }
2109         | AttributeNameOrWildcard
2110         {
2111                 $$ = new AttributeTest ((XmlQualifiedName) $1);
2112         }
2113         | AttributeNameOrWildcard COMMA TypeNameOrWildcard
2114         {
2115                 $$ = new AttributeTest ((XmlQualifiedName) $1, (XmlQualifiedName) $3);
2116         }
2117         ;
2118
2119 ElementName
2120         : QName
2121         ;
2122
2123 AttributeName
2124         : QName
2125         ;
2126
2127 TypeName
2128         : QName
2129         ;
2130
2131 ElementNameOrWildcard // returns XmlQualifiedName
2132         : ElementName
2133         | ASTERISK
2134         {
2135                 $$ = new XmlQualifiedName ("*", "*");
2136         }
2137         ;
2138
2139 AttributeNameOrWildcard // returns XmlQualifiedName
2140         : AttributeName
2141         | ASTERISK
2142         {
2143                 $$ = new XmlQualifiedName ("*", "*");
2144         }
2145         ;
2146
2147 TypeNameOrWildcard // returns XmlQualifiedName
2148         : TypeName
2149         | ASTERISK
2150         {
2151                 $$ = new XmlQualifiedName ("*", "*");
2152         }
2153         ;
2154
2155 /* ----------------
2156  Primary Expressions
2157 ---------------- */
2158
2159 PrimaryExpr // returns ExprSingle
2160         : Literal {
2161                 tokenizer.State = ParseState.Operator;
2162           }
2163         | VarRef
2164         | ParenthesizedExpr
2165         | ContextItemExpr
2166         | FunctionCall
2167         | Constructor
2168         {
2169                 if (!isXQueryMode)
2170                         throw new XmlQueryCompileException ("XPath2 does not support constructor expression.");
2171                 $$ = $1;
2172         }
2173         | OrderedExpr
2174         {
2175                 if (!isXQueryMode)
2176                         throw new XmlQueryCompileException ("XPath2 does not support ordered expression.");
2177                 $$ = $1;
2178         }
2179         | UnorderedExpr
2180         {
2181                 if (!isXQueryMode)
2182                         throw new XmlQueryCompileException ("XPath2 does not support unordered expression.");
2183                 $$ = $1;
2184         }
2185         ;
2186
2187 Literal
2188         : DECIMAL_LITERAL
2189         {
2190                 $$ = new DecimalLiteralExpr ((decimal) $1);
2191         }
2192         | DOUBLE_LITERAL
2193         {
2194                 $$ = new DoubleLiteralExpr ((double) $1);
2195         }
2196         | STRING_LITERAL
2197         {
2198                 $$ = new StringLiteralExpr ((string) $1);
2199         }
2200         ;
2201
2202 /*
2203 NUMERIC_LITERAL
2204         : IntegerLiteral
2205         | DecimalLiteral
2206         | DoubleLiteral
2207         ;
2208
2209 IntegerLiteral
2210         : Digits
2211         ;
2212
2213 DecimalLiteral
2214         : DOT Digits
2215         | Digits DOT OptDigits
2216         ;
2217
2218 DoubleLiteral
2219         : DoubleDecimalPartSpec ExponentSpec
2220         ;
2221
2222 DoubleDecimalPartSpec
2223         : DOT Digits
2224         | Digits
2225         | Digits DOT OptDigits
2226
2227 ExponentSpec
2228         : // empty/*
2229         | ExponentAlpha Digits
2230         | ExponentAlpha PLUS Digits
2231         | ExponentAlpha MINUS Digits
2232         ;
2233
2234 ExponentAlpha
2235         : LARGE_E
2236         | SMALL_E
2237         ;
2238
2239 OptDigits
2240         : // empty/*
2241         | Digits
2242         ;
2243
2244 Digits
2245         : ZERO_TO_NINE_SEQ
2246         ;
2247
2248 STRING_LITERAL
2249         : QUOT STRING_LITERALContentQuot
2250         | APOS STRING_LITERALContentApos
2251         ;
2252
2253 STRING_LITERALContentQuot
2254         : PREDEFINED_ENTITY_REF
2255         | CHAR_REF
2256         | QUOT2
2257         | REMAINING_LITERAL
2258         ;
2259
2260 STRING_LITERALContentApos
2261         : PREDEFINED_ENTITY_REF
2262         | CHAR_REF
2263         | APOS2
2264         | REMAINING_LITERAL
2265         ;
2266 */
2267
2268 VarRef // returns VariableReferenceExpr
2269         : DOLLAR {
2270                 tokenizer.State = ParseState.VarName;
2271           } VarName
2272         {
2273                 $$ = new VariableReferenceExpr ((XmlQualifiedName) $3);
2274         }
2275         ;
2276
2277 VarName // returns XmlQualifiedName
2278         : QName {
2279                 tokenizer.State = ParseState.Operator;
2280           }
2281         {
2282                 $$ = $1;
2283         }
2284         ;
2285
2286 ParenthesizedExpr // returns ParenthesizedExpr
2287         : OPEN_PAREN OptionalExpr CLOSE_PAREN {
2288                 tokenizer.State = ParseState.Operator;
2289           }
2290         {
2291                 $$ = new ParenthesizedExpr ((ExprSequence) $2);
2292         }
2293         ;
2294
2295 OptionalExpr
2296         : // empty
2297         {
2298                 $$ = new ExprSequence ();
2299         }
2300         | Expr
2301         ;
2302
2303 ContextItemExpr // returns ContextItemExpr
2304         : DOT {
2305                 tokenizer.State = ParseState.Operator;
2306           }
2307         {
2308                 $$ = new ContextItemExpr ();
2309         }
2310         ;
2311
2312 FunctionCall
2313         : QName OPEN_PAREN {
2314                 tokenizer.State = ParseState.Default;
2315           } OptionalExpr CLOSE_PAREN {
2316                 tokenizer.State = ParseState.Operator;
2317           }
2318         {
2319                 XmlQualifiedName name = (XmlQualifiedName) $1;
2320                 if (name.Namespace == "")
2321                         name = new XmlQualifiedName (name.Name, tokenizer.DefaultFunctionNamespace);
2322                 if (name.Namespace != ""
2323                                 && name.Namespace != InternalPool.XdtNamespace
2324                                 && reservedFunctionNames [name.Name] != null)
2325                         throw new XmlQueryCompileException (String.Format ("'{0}' is reserved and cannot be used as a function name.", name.Name));
2326
2327                 $$ = new FunctionCallExpr (name, (ExprSequence) $4);
2328         }
2329         ;
2330
2331 OrderedExpr
2332         : ORDERED OPEN_BRACKET Expr CLOSE_BRACKET
2333         {
2334                 $$ = new OrderSpecifiedExpr ((ExprSequence) $3, true);
2335         }
2336         ;
2337
2338 UnorderedExpr
2339         : UNORDERED OPEN_BRACKET {
2340                 tokenizer.PushState (ParseState.Operator);
2341                 tokenizer.State = ParseState.Default;
2342           } Expr CLOSE_BRACKET {
2343                 tokenizer.PopState ();
2344           }
2345         {
2346                 $$ = new OrderSpecifiedExpr ((ExprSequence) $4, false);
2347         }
2348         ;
2349
2350
2351 /* -----------------
2352  Constructors
2353 ----------------- */
2354
2355
2356 Constructor // returns ExprSingle
2357         : DirElemConstructor
2358         | ComputedConstructor
2359         | XmlComment
2360         | XmlPI
2361         | XmlCData
2362         ;
2363
2364 DirElemConstructor // returns XmlElemConstructor
2365         : LESSER {
2366                 if (tokenizer.State == ParseState.ElementContent)
2367                         tokenizer.PushState (tokenizer.State);
2368 //              if (tokenizer.State == ParseState.Default)
2369                 else // considering <foo></foo><bar></bar> there after </foo> state is Operator.
2370                         tokenizer.PushState (ParseState.Operator);
2371                 tokenizer.State = ParseState.StartTag;
2372                 // FIXME: tokenizer.Space = WhitespaceHandling.Significant;
2373           } QName AttributeList FollowDirElemConstructor {
2374                 tokenizer.PopState ();
2375           }
2376         {
2377                 ExprSequence expr = new ExprSequence ();
2378                 expr.AddRange ((ICollection) $4);
2379                 expr.AddRange ((ICollection) $5);
2380                 $$ = new XmlElemConstructor ((XmlQualifiedName) $3, expr);
2381         }
2382         ;
2383
2384 FollowDirElemConstructor // returns ExprSequence
2385         : EMPTY_TAG_CLOSE
2386         {
2387                 $$ = new ExprSequence ();
2388         }
2389         | GREATER {
2390                 tokenizer.State = ParseState.ElementContent;
2391           } ElementContentList END_TAG_START {
2392                 tokenizer.State = ParseState.EndTag;
2393           } QName {
2394 //              tokenizer.Space = WhitespaceHandling.Arbitrary;
2395           } GREATER
2396         {
2397                 $$ = $3;
2398         }
2399         ;
2400
2401 ElementContentList // returns ExprSequence
2402         : // empty
2403         {
2404                 $$ = new ExprSequence ();
2405         }
2406         | ElementContent ElementContentList
2407         {
2408                 ExprSequence el = (ExprSequence) $2;
2409                 el.Insert (0, (ExprSingle) $1);
2410                 $$ = el;
2411         }
2412         ;
2413
2414 AttributeList // returns XmlAttrConstructorList
2415         : // empty
2416         {
2417                 $$ = new XmlAttrConstructorList ();
2418         }
2419         | /* space */ Attribute AttributeList
2420         {
2421                 XmlAttrConstructorList al = (XmlAttrConstructorList) $2;
2422                 al.Insert (0, (XmlAttrConstructor) $1);
2423                 $$ = al;
2424         }
2425         ;
2426
2427 Attribute // returns XmlAttrConstructor
2428         : QName /* opt-space */ EQUAL /* opt-space */ AttributeValue
2429         {
2430                 $$ = new XmlAttrConstructor ((XmlQualifiedName) $1, (ExprSequence) $3);
2431         }
2432         ;
2433
2434 /*
2435 // FIXME: it should be more complex
2436 AttributeValue // returns ExprSequence
2437         : STRING_LITERAL
2438         {
2439                 ExprSequence es = new ExprSequence ();
2440                 es.Insert (0, new StringLiteralExpr ((string) $1));
2441                 $$ = es;
2442         }
2443         ;
2444 */
2445
2446 AttributeValue // returns ExprSequence
2447         : QUOT {
2448                 tokenizer.State = ParseState.QuotAttributeContent;
2449           } AttributeValueContentSequence QUOT {
2450                 tokenizer.State = ParseState.StartTag;
2451           }
2452         {
2453                 $$ = $3;
2454         }
2455         | APOS {
2456                 tokenizer.State = ParseState.AposAttributeContent;
2457           } AttributeValueContentSequence APOS {
2458                 tokenizer.State = ParseState.StartTag;
2459           }
2460         {
2461                 $$ = $3;
2462         }
2463         ;
2464
2465
2466 AttributeValueContentSequence // returns ExprSequence
2467         : // empty
2468         {
2469                 $$ = new ExprSequence ();
2470         }
2471         | AttributeValueContent AttributeValueContentSequence
2472         {
2473                 ExprSequence es = (ExprSequence) $2;
2474                 es.Insert (0, (ExprSingle) $1);
2475                 $$ = es;
2476         }
2477         ;
2478
2479 AttributeValueContent // returns ExprSingle
2480         : ATT_VALUE_LITERAL // including "{{", "}}" and char/predefined entities
2481         {
2482                 $$ = new StringLiteralExpr ((string) $1);
2483         }
2484         | EnclosedExpr
2485         ;
2486
2487 EnclosedExpr // returns EnclosedExpr
2488         // FIXME: check if this state transition is valid for ElementContent and AttributeValueContent
2489         : OPEN_CURLY {
2490                 switch (tokenizer.State) {
2491                 case ParseState.ElementContent:
2492                 case ParseState.QuotAttributeContent:
2493                 case ParseState.AposAttributeContent:
2494                         tokenizer.PushState (tokenizer.State);
2495                         break;
2496                 }
2497                 tokenizer.State = ParseState.Default;
2498           } Expr CloseCurly
2499         {
2500                 $$ = new EnclosedExpr ((ExprSequence) $3);
2501         }
2502         ;
2503
2504 ElementContent // returns ExprSingle
2505         : ELEM_CONTENT_LITERAL // including "{{", "}}" and char/predefined entities
2506         {
2507                 $$ = new XmlTextConstructor ((string) $1);
2508         }
2509         | DirElemConstructor
2510         | EnclosedExpr
2511         | XmlCData
2512         | XmlComment
2513         | XmlPI
2514         ;
2515
2516 XmlCData
2517         : XML_CDATA_START XML_CDATA_TO_END
2518         {
2519                 $$ = new XmlTextConstructor ((string) $2);
2520         }
2521         ;
2522
2523 XmlComment // returns XmlCommentConstructor
2524         : XML_COMMENT_START XML_COMMENT_TO_END
2525         {
2526                 $$ = new XmlCommentConstructor ((string) $2);
2527         }
2528         ;
2529
2530 XmlPI // returns XmlPIConstructor
2531         : XML_PI_START {
2532                 tokenizer.PushState (tokenizer.State);
2533                 tokenizer.State = ParseState.XmlPI;
2534           } PITarget {
2535                 tokenizer.State = ParseState.XmlPIContent;
2536           } XML_PI_TO_END {
2537                 tokenizer.PopState ();
2538           }
2539         {
2540                 string name = (string) $3;
2541                 $$ = new XmlPIConstructor (name, (string) $5);
2542         }
2543         ;
2544
2545 PITarget
2546         : NCName
2547         ;
2548
2549 ComputedConstructor // returns ExprSingle
2550         : CompElemConstructor
2551         | CompAttrConstructor
2552         | CompDocConstructor
2553         | CompTextConstructor
2554         | CompXmlPI
2555         | CompXmlComment
2556         | CompNSConstructor
2557         ;
2558
2559 CompElemConstructor
2560         : ELEMENT QName OPEN_CURLY Expr CloseCurly
2561         {
2562                 $$ = new XmlElemConstructor ((XmlQualifiedName) $2, (ExprSequence) $4);
2563         }
2564         | ELEMENT OPEN_CURLY Expr CloseCurly OPEN_CURLY Expr CloseCurly
2565         {
2566                 $$ = new XmlElemConstructor ((ExprSequence) $3, (ExprSequence) $6);
2567         }
2568         ;
2569
2570 CompAttrConstructor
2571         : ATTRIBUTE QName OPEN_CURLY Expr CloseCurly
2572         {
2573                 $$ = new XmlAttrConstructor ((XmlQualifiedName) $2, (ExprSequence) $4);
2574         }
2575         | ATTRIBUTE OPEN_CURLY Expr CloseCurly OPEN_CURLY Expr CloseCurly
2576         {
2577                 $$ = new XmlAttrConstructor ((ExprSequence) $3, (ExprSequence) $6);
2578         }
2579         ;
2580
2581 CompNSConstructor
2582         : NAMESPACE NCName OPEN_CURLY Expr CloseCurly
2583         {
2584                 $$ = new XmlNSConstructor ((string) $2, (ExprSequence) $4);
2585         }
2586         ;
2587
2588 CompDocConstructor
2589         : DOCUMENT OPEN_CURLY Expr CloseCurly
2590         {
2591                 $$ = new XmlDocConstructor ((ExprSequence) $3);
2592         }
2593         ;
2594
2595 CompTextConstructor
2596         : TEXT OPEN_CURLY Expr CloseCurly
2597         {
2598                 $$ = new XmlTextConstructor ((ExprSequence) $3);
2599         }
2600         ;
2601
2602 CompXmlComment
2603         : COMMENT OPEN_CURLY Expr CloseCurly
2604         {
2605                 $$ = new XmlCommentConstructor ((ExprSequence) $3);
2606         }
2607         ;
2608
2609 CompXmlPI
2610         : PROCESSING_INSTRUCTION NCName OPEN_CURLY Expr CloseCurly
2611         {
2612                 $$ = new XmlPIConstructor ((string) $2, (ExprSequence) $4);
2613         }
2614         | PROCESSING_INSTRUCTION OPEN_CURLY Expr CloseCurly OPEN_CURLY Expr CloseCurly
2615         {
2616                 $$ = new XmlPIConstructor ((ExprSequence) $3, (ExprSequence) $6);
2617         }
2618         ;
2619
2620 /* -----------------
2621  Terminal Wrappers
2622 ----------------- */
2623
2624
2625 NCName // returns string
2626         : NCNAME
2627         ;
2628
2629 QName // returns XmlQualifiedName. Note that this state is just a wrapper for state transition.
2630         : QNAME {
2631                 switch (tokenizer.State) {
2632                 case ParseState.Default:
2633                         tokenizer.State = ParseState.Operator;
2634                         break;
2635                 case ParseState.ItemType:
2636                         tokenizer.State = ParseState.OccurenceIndicator;
2637                         break;
2638                 case ParseState.KindTest:
2639                 case ParseState.SchemaContextStep:
2640                         tokenizer.State = ParseState.CloseKindTest;
2641                         break;
2642                 case ParseState.ExtKey:
2643                         tokenizer.State = ParseState.ExprComment;
2644                         break;
2645                 }
2646           }
2647         ;
2648
2649 Slash
2650         : SLASH {
2651                 switch (tokenizer.State) {
2652                 case ParseState.Operator:
2653                         tokenizer.State = ParseState.Default;
2654                         break;
2655                 case ParseState.KindTest:
2656                         tokenizer.State = ParseState.SchemaContextStep;
2657                         break;
2658                 }
2659           }
2660         ;
2661
2662 Slash2
2663         : SLASH2 {
2664                 if (tokenizer.State == ParseState.Operator)
2665                         tokenizer.State = ParseState.Default;
2666           }
2667         ;
2668
2669 CloseCurly
2670         : CLOSE_CURLY {
2671                 if (tokenizer.State == ParseState.Operator)
2672                         tokenizer.PopState ();
2673           }
2674         ;
2675
2676 %%
2677
2678 }
2679
2680 #endif