hlvm/hlvm/Reader/HLVM.rng

<?xml version="1.0" encoding="UTF-8"?>
<!--=========================================================================-->
<!-- Copyright (C) 2006 Reid Spencer. All Rights Reserved.                   -->
<!--                                                                         -->
<!-- This software is free software; you can redistribute it and/or modify it-->
<!-- under the terms of the GNU Lesser General Public License as published by-->
<!-- the Free Software Foundation; either version 2.1 of the License, or (at -->
<!-- your option) any later version.                                         -->
<!--                                                                         -->
<!-- This software is distributed in the hope that it will be useful, but    -->
<!-- WITHOUT ANY WARRANTY; without even the implied warranty of              -->
<!-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser-->
<!-- General Public License for more details.                                -->
<!--                                                                         -->
<!-- You should have received a copy of the GNU Lesser General Public License-->
<!-- along with this library in the file named LICENSE.txt; if not, write to -->
<!-- the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,    -->
<!-- Boston, MA 02110-1301 USA                                               -->
<!--                                                                         -->
<!--=========================================================================-->
<!-- @file hlvm/Reader/HLVM.rng                                              -->
<!-- @author Reid Spencer <rspencer@reidspencer.com> (original author)       -->
<!-- @date 2006/05/13                                                        -->
<!-- @since 0.1.0                                                            -->
<!-- @brief Defines the core XPL language via Relax/NG Schema                -->
<!--=========================================================================-->
<!-- HLVM AST Schema                                                         -->
<!--                                                                         -->
<!-- This file contains the Relax/NG schema for construction of the HLVM AST -->
<!-- via an XML syntax. The schema aims to be simple and closely match the   -->
<!-- construction of an HLVM AST.                                            -->
<!--                                                                         -->
<!-- For full commentary on this schema, see http://hlvm.org/docs/XML.html   -->
<!--                                                                         -->
<!--=========================================================================-->

<grammar 
  datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"
  xmlns ="http://relaxng.org/ns/structure/1.0"
  xmlns:a="http://relaxng.org/ns/annotation/1.0"
  ns="http://hlvm.org/src/hlvm/Reader/XML/HLVM.rng">

  <start>
    <ref name="hlvm.elem"/>
  </start>

  <!-- PATTERN DEFINITIONS FOR DATA TYPES -->

  <define name="Identifier.type">
    <choice>
      <ref name="Unprefixed_Identifier.type"/>
      <ref name="Prefixed_Identifier.type"/>
    </choice>
  </define>

  <define name="Unprefixed_Identifier.type">
    <data type="string">
      <param name="pattern">[^:]+</param>
      <param name="maxLength">1024</param>
    </data>
  </define>

  <define name="Prefixed_Identifier.type">
    <data type="string">
      <param name="pattern">[^:]+:[^:]+</param>
      <param name="maxLength">1024</param>
    </data>
  </define>

  <define name="C_Identifier.type">
    <data type="string">
      <param name="pattern">[A-Za-z_][A-Za-z0-9_]*</param>
      <param name="maxLength">256</param>
    </data>
  </define>

  <define name="Boolean.type">
    <choice>
      <data type="boolean"/>
      <value>TRUE</value>
      <value>True</value>
      <value>true</value>
      <value>YES</value>
      <value>Yes</value>
      <value>yes</value>
      <value>1</value>
      <value>FALSE</value>
      <value>False</value>
      <value>false</value>
      <value>NO</value>
      <value>No</value>
      <value>no</value>
      <value>0</value>
    </choice>
  </define>

  <define name="Binary.type">
    <data type="string">
      <param name="minLength">1</param>
      <param name="maxLength">1024</param>
      <param name="pattern">[01]+</param>
    </data>
  </define>

  <define name="Octal.type" >
    <data type="string">
      <param name="minLength">1</param>
      <param name="maxLength">1024</param>
      <param name="pattern">[0-7]+</param>
    </data>
  </define>

  <define name="Decimal.type">
    <data type="string">
      <param name="minLength">1</param>
      <param name="maxLength">1024</param>
      <param name="pattern">[+\-]?\d+</param>
    </data>
  </define>

  <define name="Hexadecimal.type">
    <data type="string">
      <param name="minLength">1</param>
      <param name="maxLength">1024</param>
      <param name="pattern">([0-9A-Fa-f][0-9A-Fa-f])+</param>
    </data>
  </define>

  <define name="Integer.type">
    <choice>
      <ref name="Binary.type"/>
      <ref name="Octal.type"/>
      <ref name="Decimal.type"/>
      <ref name="Hexadecimal.type"/>
    </choice>
  </define>

  <define name="Real.type">
    <data type="string">
      <param name="minLength">1</param>
      <param name="maxLength">1024</param>
      <param name="pattern">ninf|pinf|nan|signan|zero|nzero|[+\-]?0x[0-9A-Fa-f](\.[0-9A-Fa-f]+)?p[-+][0-9]+|#[0-9A-Fa-f]{16}|#[0-9a-fA-F]{8}|[+\-]?\d+\.\d*([Ee][+\-]?\d+)?</param>
    </data>
  </define>

  <define name="Encoding.type">
    <choice>
      <value>utf-8</value>
      <value>utf-16</value>
      <value>ucs</value>
    </choice>
  </define>

  <define name="Character.type">
    <choice>
      <data type="string">
        <param name="length">1</param>
      </data>
      <data type="string">
        <param name="length">5</param>
        <param name="pattern">[#][0-9A-Fa-f]{4,4}</param>
      </data>
    </choice>
  </define>

  <define name="Octet.type">
    <data type="unsignedByte"/>
  </define>

  <!-- DOCUMENTATION OF HLVM AST PROGRAMS -->

  <define name="Documentation.pat">
    <optional>
      <element name="doc">
        <zeroOrMore>
          <choice>
            <text/>
            <ref name="Any.pat"/> <!-- should really be XHTML elements -->
          </choice>
        </zeroOrMore>
      </element>
    </optional>
  </define>

  <define name="Any.pat">
    <element>
      <anyName/>
      <zeroOrMore>
        <choice>
          <attribute>
            <anyName/>
          </attribute>
          <text/>
          <ref name="Any.pat"/>
        </choice>
      </zeroOrMore>
    </element>
  </define>

  <!-- PATTERNS THAT DEFINE name AND type ATTRIBUTES -->

  <define name="Named_Element.pat">
    <attribute name="id">
      <ref name="Identifier.type"/>
    </attribute>
  </define>

  <define name="Typed_Element.pat">
    <attribute name="type">
      <ref name="Identifier.type"/>
    </attribute>
  </define>

  <define name="Named_Typed_Element.pat">
    <attribute name="id">
      <ref name="Identifier.type"/>
    </attribute>
    <attribute name="type">
      <ref name="Identifier.type"/>
    </attribute>
  </define>

  <!-- HLVM PATTERN -->
  <define name="hlvm.elem">
    <element name="hlvm">
      <attribute name="pubid"><data type="anyURI"/></attribute>
      <ref name="Documentation.pat"/>
      <oneOrMore>
        <ref name="bundle.elem"/>
      </oneOrMore>
    </element>
  </define>

  <!--BUNDLES PATTERN -->

  <define name="bundle.elem">
    <element name="bundle">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
      <zeroOrMore>
        <ref name="import.elem"/>
      </zeroOrMore>
      <oneOrMore>
        <choice>
          <ref name="any.elem"/>
          <ref name="array.elem"/>
          <ref name="boolean.elem"/>
          <ref name="buffer.elem"/>
          <ref name="character.elem"/>
          <ref name="constant.elem"/>
          <ref name="enumeration.elem"/>
          <ref name="function.elem"/>
          <ref name="opaque.elem"/>
          <ref name="pointer.elem"/>
          <ref name="program.elem"/>
          <ref name="range.elem"/>
          <ref name="real.elem"/>
          <ref name="signature.elem"/>
          <ref name="signed.elem"/>
          <ref name="stream.elem"/>
          <ref name="string.elem"/>
          <ref name="structure.elem"/>
          <ref name="text.elem"/>
          <ref name="unsigned.elem"/>
          <ref name="variable.elem"/>
          <ref name="vector.elem"/>
        </choice>
      </oneOrMore>
    </element>
  </define>

  <define name="import.elem">
    <element name="import">
      <attribute name="prefix">
        <ref name="Identifier.type"/>
      </attribute>
      <attribute name="pubid">
        <data type="anyURI"/>
      </attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <!--PATTERNS FOR DEFINING TYPES -->

  <define name="any.elem">
    <element name="any">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="array.elem">
    <element name="array">
      <ref name="Named_Element.pat"/>
      <attribute name="length"><data type="nonNegativeInteger"/></attribute>
      <attribute name="of"><ref name="Identifier.type"/></attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="boolean.elem">
    <element name="boolean">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="buffer.elem">
    <element name="buffer">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="character.elem">
    <element name="character">
      <ref name="Named_Element.pat"/>
      <attribute name="encoding">
        <ref name="Encoding.type"/>
      </attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="enumeration.elem">
    <element name="enumeration">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
      <oneOrMore>
        <element name="enumerator">
          <attribute name="id">
            <ref name="Unprefixed_Identifier.type"/>
          </attribute>
        </element>
      </oneOrMore>
    </element>
  </define>

  <define name="opaque.elem">
    <element name="opaque">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="pointer.elem">
    <element name="pointer">
      <ref name="Named_Element.pat"/>
      <attribute name="to"><ref name="Identifier.type"/></attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="range.elem">
    <element name="range">
      <ref name="Named_Element.pat"/>
      <attribute name="min">
        <ref name="Integer.type"/>
      </attribute>
      <attribute name="max">
        <ref name="Integer.type"/>
      </attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="real.elem">
    <element name="real">
      <ref name="Named_Element.pat"/>
      <attribute name="mantissa">
        <ref name="Integer.type"/>
      </attribute>
      <attribute name="exponent">
        <ref name="Integer.type"/>
      </attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="signed.elem">
    <element name="signed">
      <ref name="Named_Element.pat"/>
      <optional>
        <attribute name="bits">
          <ref name="Integer.type"/>
        </attribute>
      </optional>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="stream.elem">
    <element name="stream">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="string.elem">
    <element name="string">
      <ref name="Named_Element.pat"/>
      <attribute name="encoding">
        <ref name="Encoding.type"/>
      </attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="structure.elem">
    <element name="structure">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
      <zeroOrMore>
        <element name="field">
          <ref name="Named_Typed_Element.pat"/>
          <ref name="Documentation.pat"/>
        </element>
      </zeroOrMore>
    </element>
  </define>

  <define name="signature.elem">
    <element name="signature">
      <ref name="Named_Element.pat"/>
      <attribute name="result"><ref name="Identifier.type"/></attribute>
      <optional>
        <attribute name="varargs"><ref name="Boolean.type"/></attribute>
      </optional>
      <ref name="Documentation.pat"/>
      <zeroOrMore>
        <element name="arg">
          <ref name="Named_Typed_Element.pat"/>
          <ref name="Documentation.pat"/>
        </element>
      </zeroOrMore>
    </element>
  </define>

  <define name="text.elem">
    <element name="text">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="unsigned.elem">
    <element name="unsigned">
      <ref name="Named_Element.pat"/>
      <optional>
        <attribute name="bits">
          <ref name="Integer.type"/>
        </attribute>
      </optional>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="vector.elem">
    <element name="vector">
      <ref name="Named_Element.pat"/>
      <attribute name="of"><ref name="Identifier.type"/></attribute>
      <attribute name="length"><data type="nonNegativeInteger"/></attribute>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <!-- PATTERNS FOR CONSTANTS -->

  <define name="constant.elem">
    <element name="constant">
      <ref name="Named_Typed_Element.pat"/>
      <ref name="Documentation.pat"/>
      <ref name="Literal.pat"/>
    </element>
  </define>

  <!-- PATTERNS FOR LITERAL CONSTANTS -->

  <define name="Typed_Literal.pat">
    <optional>
      <attribute name="type">
        <ref name="Identifier.type"/>
      </attribute>
    </optional>
  </define>

  <define name="Literal.pat">
    <choice>
      <ref name="Boolean_Literal.pat"/>
      <ref name="Integer_Literal.pat"/>
      <ref name="Real_Literal.pat"/>
      <ref name="char.elem"/>
      <ref name="octet.elem"/>
      <ref name="enum.elem"/>
      <ref name="str.elem"/>
      <ref name="null.elem"/>
      <ref name="ptr.elem"/>
      <ref name="arr.elem"/>
      <ref name="vect.elem"/>
      <ref name="struct.elem"/>
      <ref name="cont.elem"/>
      <ref name="get.elem"/>
    </choice>
  </define>

  <define name="Boolean_Literal.pat">
    <choice>
      <element name="true">
        <empty/>
      </element>
      <element name="false">
        <empty/>
      </element>
      <element name="bool">
        <ref name="Typed_Literal.pat"/>
        <ref name="Boolean.type"/>
      </element>
    </choice>
  </define>


  <define name="Integer_Literal.pat">
    <choice>
      <element name="bin">
        <ref name="Typed_Literal.pat"/>
        <ref name="Binary.type"/>
      </element>
      <element name="oct">
        <ref name="Typed_Literal.pat"/>
        <ref name="Octal.type"/>
      </element>
      <element name="dec">
        <ref name="Typed_Literal.pat"/>
        <ref name="Decimal.type"/>
      </element>
      <element name="hex">
        <ref name="Typed_Literal.pat"/>
        <ref name="Hexadecimal.type"/>
      </element>
    </choice>
  </define>

  <define name="Real_Literal.pat">
    <choice>
      <element name="flt">
        <ref name="Real.type"/>
      </element>
      <element name="dbl">
        <ref name="Real.type"/>
      </element>
      <element name="real">
        <ref name="Typed_Literal.pat"/>
        <ref name="Real.type"/>
      </element>
    </choice>
  </define>

  <define name="char.elem">
    <element name="char">
      <ref name="Typed_Literal.pat"/>
      <ref name="Character.type"/>
    </element>
  </define>

  <define name="octet.elem">
    <element name="octet">
      <ref name="Typed_Literal.pat"/>
      <ref name="Octet.type"/>
    </element>
  </define>

  <define name="enum.elem">
    <element name="enum">
      <ref name="Typed_Literal.pat"/>
      <ref name="Identifier.type"/>
    </element>
  </define>

  <define name="str.elem">
    <element name="str">
      <ref name="Typed_Literal.pat"/>
      <text/>
    </element>
  </define>

  <define name="null.elem">
    <element name="null">
      <ref name="Typed_Literal.pat"/>
      <empty/>
    </element>
  </define>

  <define name="ptr.elem">
    <element name="ptr">
      <ref name="Typed_Literal.pat"/>
      <attribute name="to">
        <ref name="Identifier.type"/>
      </attribute>
    </element>
  </define>

  <define name="arr.elem">
    <element name="arr">
      <ref name="Typed_Literal.pat"/>
      <oneOrMore>
        <ref name="Literal.pat"/>
      </oneOrMore>
    </element>
  </define>

  <define name="vect.elem">
    <element name="vect">
      <ref name="Typed_Literal.pat"/>
      <oneOrMore>
        <ref name="Literal.pat"/>
      </oneOrMore>
    </element>
  </define>

  <define name="struct.elem">
    <element name="struct">
      <ref name="Typed_Literal.pat"/>
      <oneOrMore>
        <ref name="Literal.pat"/>
      </oneOrMore>
    </element>
  </define>

  <define name="cont.elem">
    <element name="cont">
      <ref name="Typed_Literal.pat"/>
      <oneOrMore>
        <ref name="Literal.pat"/>
      </oneOrMore>
    </element>
  </define>

  <!-- PATTERNS FOR VARIABLES-->

  <define name="variable.elem">
    <element name="variable">
      <ref name="Named_Typed_Element.pat"/>
      <optional>
        <attribute name="const">
          <data type="boolean"/>
        </attribute>
      </optional>
      <optional>
        <attribute name="linkage">
          <ref name="Linkage.type"/>
        </attribute>
      </optional>
      <optional>
        <attribute name="init">
          <ref name="Identifier.type"/>
        </attribute>
      </optional>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="Linkage.type">
    <choice>
      <value>appending</value>
      <value>external</value>
      <value>internal</value>
      <value>linkonce</value>
      <value>weak</value>
    </choice>
  </define>

  <!--PATTERNS FOR FUNCTIONS -->

  <define name="function.elem">
    <element name="function">
      <ref name="Named_Typed_Element.pat"/>
      <optional>
        <attribute name="linkage"><ref name="Linkage.type"/></attribute>
      </optional>
      <ref name="Documentation.pat"/>
      <optional>
        <choice>
          <element name="as"><ref name="C_Identifier.type"/></element>
          <ref name="block.elem"/>
        </choice>
      </optional>
    </element>
  </define>

  <define name="program.elem">
    <element name="program">
      <ref name="Named_Element.pat"/>
      <optional>
        <attribute name="linkage"><ref name="Linkage.type"/></attribute>
      </optional>
      <ref name="Documentation.pat"/>
      <ref name="block.elem"/>
    </element>
  </define>


  <!-- PATTERNS FOR DEFINING CONSTANTS -->

  <define name="ConstantExpression.pat">
    <choice>
      <ref name="getfld.elem"/>
      <ref name="getidx.elem"/>
      <ref name="cast.elem"/>
      <ref name="select.elem"/>
      <ref name="sizeof.elem"/>
      <ref name="addrof.elem"/>
      <ref name="extract.elem"/>
      <ref name="insert.elem"/>
      <ref name="shuffle.elem"/>
      <ref name="BooleanOperators.pat"/>
      <ref name="UnaryArithmeticOperators.pat"/>
      <ref name="BinaryArithmeticOperators.pat"/>
      <ref name="UnaryRealMathOperators.pat"/>
      <ref name="BinaryRealMathOperators.pat"/>
    </choice>
  </define>

  <!-- PATTERNS FOR OPERATORS -->

  <define name="Operators.pat">
    <choice>
      <ref name="block.elem"/>
      <ref name="BooleanOperators.pat"/>
      <ref name="UnaryArithmeticOperators.pat"/>
      <ref name="BinaryArithmeticOperators.pat"/>
      <ref name="UnaryRealMathOperators.pat"/>
      <ref name="BinaryRealMathOperators.pat"/>
      <ref name="MemoryOps.pat"/>
      <ref name="InputOutputOps.pat"/>
      <ref name="StringOperators.pat"/>
      <ref name="ControlFlowOps.pat"/>
    </choice>
  </define>

  <define name="UnaryOperator.pat">
    <ref name="Documentation.pat"/>
    <ref name="Operators.pat"/>
  </define>

  <define name="BinaryOperator.pat">
    <ref name="Documentation.pat"/>
    <ref name="Operators.pat"/>
    <ref name="Operators.pat"/>
  </define>

  <define name="TernaryOperator.pat">
    <ref name="Documentation.pat"/>
    <ref name="Operators.pat"/>
    <ref name="Operators.pat"/>
    <ref name="Operators.pat"/>
  </define>

  <define name="Location.pat">
    <choice>
      <ref name="get.elem"/>
      <ref name="getfld.elem"/>
      <ref name="getidx.elem"/>
    </choice>
  </define>

  <define name="block.elem">
    <element name="block">
      <optional>
        <attribute name="label"><ref name="Identifier.type"/></attribute>
      </optional>
      <ref name="Documentation.pat"/>
      <oneOrMore>
        <choice>
          <ref name="Operators.pat"/>
          <ref name="result.elem"/>
        </choice>
      </oneOrMore>
    </element>
  </define>

  <define name="result.elem">
    <element name="result">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="cast.elem">
    <empty/>
  </define>

  <define name="sizeof.elem">
    <empty/>
  </define>

  <define name="addrof.elem">
    <ref name="Operators.pat"/>
  </define>

  <define name="extract.elem">
    <empty/>
  </define>

  <define name="insert.elem">
    <empty/>
  </define>

  <define name="shuffle.elem">
    <empty/>
  </define>

  <!-- MEMORY OPERATORS -->

  <define name="MemoryOps.pat">
    <choice>
      <ref name="load.elem"/>
      <ref name="store.elem"/>
      <ref name="getfld.elem"/>
      <ref name="getidx.elem"/>
      <ref name="length.elem"/>
      <ref name="autovar.elem"/>
      <ref name="get.elem"/>
    </choice>
  </define>

  <define name="get.elem">
    <element name="get">
      <ref name="Named_Element.pat"/>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="load.elem">
    <element name="load">
      <ref name="Documentation.pat"/>
      <ref name="Location.pat"/>
    </element>
  </define>

  <define name="store.elem">
    <element name="store">
      <ref name="Documentation.pat"/>
      <ref name="Location.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="getfld.elem">
    <element name="getfld">
      <attribute name="field">
        <ref name="Identifier.type"/>
      </attribute>
      <ref name="Documentation.pat"/>
      <ref name="Location.pat"/>
    </element>
  </define>

  <define name="getidx.elem">
    <element name="getidx">
      <ref name="Documentation.pat"/>
      <ref name="Location.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="length.elem">
    <element name="length">
      <ref name="Documentation.pat"/>
      <ref name="Location.pat"/>
    </element>
  </define>

  <define name="autovar.elem">
    <element name="autovar">
      <ref name="Named_Typed_Element.pat"/>
      <ref name="Documentation.pat"/>
      <optional>
        <ref name="Operators.pat"/>
      </optional>
    </element>
  </define>

  <!-- INPUT/OUTPUT OPERATORS -->

  <define name="InputOutputOps.pat">
    <choice>
      <ref name="open.elem"/>
      <ref name="close.elem"/>
      <ref name="write.elem"/>
      <!-- <ref name="read.elem"/>
      <ref name="seek.elem"/>
      <ref name="tell.elem"/>
      <ref name="info.elem"/> -->
    </choice>
  </define>

  <define name="open.elem">
    <element name="open">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="close.elem">
    <element name="close">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="write.elem">
    <element name="write">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="read.elem">
    <element name="read">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <!-- UNARY ARITHMETIC OPERATORS -->

  <define name="UnaryArithmeticOperators.pat">
    <choice>
      <ref name="neg.elem"/>
      <ref name="cmpl.elem"/>
      <ref name="preinc.elem"/>
      <ref name="predec.elem"/>
      <ref name="postinc.elem"/>
      <ref name="postdec.elem"/>
    </choice>
  </define>

  <define name="neg.elem">
    <element name="neg">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="cmpl.elem">
    <element name="cmpl">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="preinc.elem">
    <element name="preinc">
      <ref name="Location.pat"/>
    </element>
  </define>

  <define name="predec.elem">
    <element name="predec">
      <ref name="Location.pat"/>
    </element>
  </define>

  <define name="postinc.elem">
    <element name="postinc">
      <ref name="Location.pat"/>
    </element>
  </define>

  <define name="postdec.elem">
    <element name="postdec">
      <ref name="Location.pat"/>
    </element>
  </define>

  <!-- BINARY ARITHMETIC OPERATORS -->

  <define name="BinaryArithmeticOperators.pat">
    <choice>
      <ref name="add.elem"/>
      <ref name="sub.elem"/>
      <ref name="mul.elem"/>
      <ref name="div.elem"/>
      <ref name="mod.elem"/>
      <ref name="band.elem"/>
      <ref name="bor.elem"/>
      <ref name="bxor.elem"/>
      <ref name="bnor.elem"/>
      <ref name="convert.elem"/>
    </choice>
  </define>

  <define name="add.elem">
    <element name="add">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>
      
  <define name="sub.elem">
    <element name="sub">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="mul.elem">
    <element name="mul">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="div.elem">
    <element name="div">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="mod.elem">
    <element name="mod">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="bor.elem">
    <element name="bor">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="band.elem">
    <element name="band">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="bxor.elem">
    <element name="bxor">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="bnor.elem">
    <element name="bnor">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="convert.elem">
    <element name="convert">
      <ref name="Typed_Element.pat"/>
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <!-- Unary Real Math Operators -->
  <define name="UnaryRealMathOperators.pat">
    <choice>
      <ref name="ispinf.elem"/>
      <ref name="isninf.elem"/>
      <ref name="isnan.elem"/>
      <ref name="trunc.elem"/>
      <ref name="round.elem"/>
      <ref name="floor.elem"/>
      <ref name="ceiling.elem"/>
      <ref name="loge.elem"/>
      <ref name="log2.elem"/>
      <ref name="log10.elem"/>
      <ref name="squareroot.elem"/>
      <ref name="cuberoot.elem"/>
      <ref name="factorial.elem"/>
    </choice>
  </define>

  <define name="ispinf.elem">
    <element name="ispinf">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="isninf.elem">
    <element name="isninf">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="isnan.elem">
    <element name="isnan">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="trunc.elem">
    <element name="trunc">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="round.elem">
    <element name="round">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="floor.elem">
    <element name="floor">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="ceiling.elem">
    <element name="ceiling">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="loge.elem">
    <element name="loge">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="log2.elem">
    <element name="log2">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="log10.elem">
    <element name="log10">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="squareroot.elem">
    <element name="squareroot">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="cuberoot.elem">
    <element name="cuberoot">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="factorial.elem">
    <element name="factorial">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <!-- Binary Real Math Operators -->
  <define name="BinaryRealMathOperators.pat">
    <choice>
      <ref name="power.elem"/>
      <ref name="root.elem"/>
      <ref name="GCD.elem"/>
      <ref name="LCM.elem"/>
    </choice>
  </define>

  <define name="power.elem">
    <element name="power">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="root.elem">
    <element name="root">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="GCD.elem">
    <element name="GCD">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="LCM.elem">
    <element name="LCM">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <!-- Comparison Operators -->

  <define name="BooleanOperators.pat">
    <choice>
      <ref name="not.elem"/>
      <ref name="and.elem"/>
      <ref name="or.elem"/>
      <ref name="xor.elem"/>
      <ref name="nor.elem"/>
      <ref name="eq.elem"/>
      <ref name="ne.elem"/>
      <ref name="lt.elem"/>
      <ref name="gt.elem"/>
      <ref name="le.elem"/>
      <ref name="ge.elem"/>
    </choice>
  </define>

  <define name="not.elem">
    <element name="not">
      <ref name="UnaryOperator.pat"/>
    </element>
  </define>

  <define name="and.elem">
    <element name="and">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="or.elem">
    <element name="or">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="xor.elem">
    <element name="xor">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="nor.elem">
    <element name="nor">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="eq.elem">
    <element name="eq">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="ne.elem">
    <element name="ne">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="lt.elem">
    <element name="lt">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="gt.elem">
    <element name="gt">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="le.elem">
    <element name="le">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <define name="ge.elem">
    <element name="ge">
      <ref name="BinaryOperator.pat"/>
    </element>
  </define>

  <!-- String Operators -->
  <define name="StringOperators.pat">
    <choice>
      <ref name="sinsert.elem"/>
      <ref name="serase.elem"/>
      <ref name="sreplace.elem"/>
      <ref name="sconcat.elem"/>
    </choice>
  </define>

  <define name="sinsert.elem">
    <element name="sinsert">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="serase.elem">
    <element name="serase">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="sreplace.elem">
    <element name="sreplace">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="sconcat.elem">
    <element name="sconcat">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <!-- Control Flow Operators -->

  <define name="ControlFlowOps.pat">
    <choice>
      <ref name="select.elem"/>
      <ref name="switch.elem"/>
      <ref name="while.elem"/>
      <ref name="unless.elem"/>
      <ref name="until.elem"/>
      <ref name="loop.elem"/>
      <ref name="break.elem"/>
      <ref name="continue.elem"/>
      <ref name="ret.elem"/>
      <ref name="call.elem"/>
    </choice>
  </define>

  <define name="select.elem">
    <element name="select">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
      <ref name="Operators.pat"/>
    </element>
  </define>

  <define name="switch.elem">
    <element name="switch">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>       <!-- Control Expression -->
      <ref name="Operators.pat"/>   <!-- Default Case -->
      <zeroOrMore>
        <ref name="Operators.pat"/> <!-- Case Expression -->
        <ref name="Operators.pat"/> <!-- Case Block -->
      </zeroOrMore>
    </element>
  </define>

  <define name="while.elem">
    <element name="while">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>  <!-- Pre-Loop Test -->
      <ref name="Operators.pat"/>  <!-- Loop Body -->
    </element>
  </define>

  <define name="unless.elem">
    <element name="unless">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>  <!-- Pre-Loop Test -->
      <ref name="Operators.pat"/>  <!-- Loop Body -->
    </element>
  </define>

  <define name="until.elem">
    <element name="until">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>  <!-- Loop Body -->
      <ref name="Operators.pat"/>  <!-- Post-Loop Test -->
    </element>
  </define>

  <define name="loop.elem">
    <element name="loop">
      <ref name="Documentation.pat"/>
      <ref name="Operators.pat"/>  <!-- Pre-Loop Test -->
      <ref name="Operators.pat"/>  <!-- Loop Body -->
      <ref name="Operators.pat"/>  <!-- Post-Loop Test -->
    </element>
  </define>

  <define name="break.elem">
    <element name="break">
      <optional>
        <attribute name="id">
          <ref name="Identifier.type"/>
        </attribute>
      </optional>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="continue.elem">
    <element name="continue">
      <optional>
        <attribute name="id">
          <ref name="Identifier.type"/>
        </attribute>
      </optional>
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="ret.elem">
    <element name="ret">
      <ref name="Documentation.pat"/>
    </element>
  </define>

  <define name="call.elem">
    <element name="call">
      <oneOrMore>
        <ref name="Operators.pat"/>
      </oneOrMore>
    </element>
  </define>

</grammar>