commit-gnue
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

gnue/appserver/src/_featuretest thekitchensink....


From: Daniel E. Baumann
Subject: gnue/appserver/src/_featuretest thekitchensink....
Date: Thu, 19 Dec 2002 00:58:05 -0500

CVSROOT:        /cvsroot/gnue
Module name:    gnue
Changes by:     Daniel E. Baumann <address@hidden>      02/12/19 00:58:05

Modified files:
        appserver/src/_featuretest: thekitchensink.godl 

Log message:
        Changed markup to be more "flat", logical, and to correspond to the
        metadata api in the ODMG standard.

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/gnue/gnue/appserver/src/_featuretest/thekitchensink.godl.diff?tr1=1.8&tr2=1.9&r1=text&r2=text

Patches:
Index: gnue/appserver/src/_featuretest/thekitchensink.godl
diff -c gnue/appserver/src/_featuretest/thekitchensink.godl:1.8 
gnue/appserver/src/_featuretest/thekitchensink.godl:1.9
*** gnue/appserver/src/_featuretest/thekitchensink.godl:1.8     Mon Sep 16 
00:44:03 2002
--- gnue/appserver/src/_featuretest/thekitchensink.godl Thu Dec 19 00:58:05 2002
***************
*** 12,1429 ****
  -->
  <odl_specification>
    <odl_definition>
!     <typedef>
!       <type_spec>float</type_spec>
!       <declarators>
!         <declarator>FloatType</declarator>
!       </declarators>
      </typedef>
  
      <typedef>
!       <type_spec>
!         <array><type_spec>float</type_spec></array>
!       </type_spec>
!       <declarators>
!         <declarator>FloatArrayType</declarator>
!       </declarators>
      </typedef>
  
      <typedef>
!       <type_spec>
!         <sequence><type_spec>float</type_spec></sequence>
!       </type_spec>
!       <declarators>
!         <declarator>FloatSequenceType</declarator>
!       </declarators>
      </typedef>
  
!     <typedef>
!       <type_spec>string</type_spec>
!       <declarators>
!         <declarator>StringType</declarator>
!       </declarators>
      </typedef>
  
!     <typedef>
!       <type_spec>
!         <scoped_name>GNUe::Sadist</scoped_name>
!       </type_spec>
!       <declarators>
!         <declarator>Masta</declarator>
!       </declarators>
      </typedef>
  
!     <struct id="Bar">
        <members>
!         <member>
!           <type_spec>string</type_spec>
!           <declarators>
!             <declarator>barname</declarator>
!           </declarators>
!         </member>
!         <member>
!           <type_spec>float</type_spec>
!           <declarators>
!             <declarator>barprice</declarator>
!           </declarators>
!         </member>
!         <member>
!           <type_spec>short</type_spec>
!           <declarators>
!             <declarator>barz</declarator>
!           </declarators>
!         </member>
!         <member>
!           <type_spec>unsigned long</type_spec>
!           <declarators>
!             <declarator>fubar</declarator>
!           </declarators>
!         </member>
!         <member>
!           <type_spec>unsigned short</type_spec>
!           <declarators>
!             <declarator>fbar</declarator>
!           </declarators>
!         </member>
!         <member>
!           <type_spec>long long</type_spec>
!           <declarators>
!             <declarator>bars</declarator>
!           </declarators>
!         </member>
        </members>
      </struct>
  
!     <union id="Trout">
!       <switch>
!         <type_spec>boolean</type_spec>
!         <case>
!           <boolean>TRUE</boolean>
!           <type_spec>string</type_spec>
!           <declarator>brown_trout</declarator>
!         </case>
!         <case>
!           <boolean>FLASE</boolean>
!           <type_spec>string</type_spec>
!           <declarator>rainbow_trout</declarator>
!         </case>
!         <default>
!           <type_spec>string</type_spec>
!           <declarator>trout</declarator>
!         </default>
        </switch>
      </union>
  
!     <enum id="TroutType">
!       <enumerator>brown</enumerator>
!       <enumerator>rainbow</enumerator>
!       <enumerator>lake</enumerator>
      </enum>
  
!     <typedef>
!       <type_spec><struct>Bar</struct></type_spec>
!       <declarators>
!         <declarator>bar</declarator>
!       </declarators>
      </typedef>
  
!     <typedef>
!       <type_spec><union>Trout</union></type_spec>
!       <declarators>
!         <declarator>trout_t</declarator>
!       </declarators>
      </typedef>
  
!     <typedef>
!       <type_spec><enum>TroutType</enum></type_spec>
!       <declarators>
!         <declarator>trout_type</declarator>
!       </declarators>
      </typedef>
  
      <typedef>
!       <type_spec>
!         <dictionary>
!           <key>
!             <type_spec>float</type_spec>
!           </key>
!           <value>
!             <type_spec>float</type_spec>
!           </value>
!         </dictionary>
!       </type_spec>
!       <declarators>
!         <declarator>DictionaryType</declarator>
!       </declarators>
      </typedef>
  
      <typedef>
!       <type_spec>
!         <set><type_spec>float</type_spec></set>
!       </type_spec>
!       <declarators>
!         <declarator>SetType</declarator>
!       </declarators>
      </typedef>
  
      <typedef>
!       <type_spec>
!         <list><type_spec>float</type_spec></list>
!       </type_spec>
!       <declarators>
!         <declarator>ListType</declarator>
!       </declarators>
      </typedef>
  
      <typedef>
!       <type_spec>
!         <bag><type_spec>float</type_spec></bag>
!       </type_spec>
!       <declarators>
!         <declarator>BagType</declarator>
!       </declarators>
      </typedef>
  
      <!-- Forward declarations -->
!     <interface id="GNUe::Sadist"/>
!     <class id="GNUe::Goats::Chillywilly"/>
  
!     <const id="BIGINT">
!       <type_spec>
!         <unsigned_long>10000L</unsigned_long>
!       </type_spec>
!     </const>
  
!     <exception id="NoModuleError">
        <members>
!         <member>
!           <type_spec>string</type_spec>
!           <declarators>
!             <declarator>what</declarator>
!           </declarators>
!         </member>
!         <member>
!           <type_spec>short</type_spec>
!           <declarators>
!             <declarator>line</declarator>
!           </declarators>
!         </member>
        </members>
      </exception>
  
!     <exception id="FubarError"/>
! 
!     <interface id="KungFu">
!       <operation id="Kick"/>
! 
!       <operation id="Punch"/>
  
      </interface>
  
!     <class id="Dragon">
        <inherits>
!         <interface>KungFu</interface>
        </inherits>
! 
!       <attribute>
!         <type_spec>string</type_spec>
!         <name>sensai</name>
!       </attribute>
! 
!       <operation id="dragonKick"/>
! 
!       <operation id="dragonPunch"/>
      </class>
  
!     <module id="GNUe">
        <odl_specification>
          <odl_definition>
  
!           <!-- Tyep declarations -->
!    
!           <!-- base types -->
!           <typedef>
!             <type_spec>float</type_spec>
!             <declarators>
!               <declarator>Float</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>double</type_spec>
!             <declarators>
!               <declarator>Double</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>long</type_spec>
!             <declarators>
!               <declarator>Long</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>long long</type_spec>
!             <declarators>
!               <declarator>Long Long</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>short</type_spec>
!             <declarators>
!               <declarator>Short</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>unsigned long</type_spec>
!             <declarators>
!               <declarator>Unsigned Long</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>unsigned short</type_spec>
!             <declarators>
!               <declarator>Unsigned Short</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>char</type_spec>
!             <declarators>
!               <declarator>Char</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>boolean</type_spec>
!             <declarators>
!               <declarator>Bool</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>octet</type_spec>
!             <declarators>
!               <declarator>Octet</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>date</type_spec>
!             <declarators>
!               <declarator>Date</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>time</type_spec>
!             <declarators>
!               <declarator>Time</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>interval</type_spec>
!             <declarators>
!               <declarator>Interval</declarator>
!             </declarators>
            </typedef>
  
!           <typedef>
!             <type_spec>timestamp</type_spec>
!             <declarators>
!               <declarator>Timestamp</declarator>
!             </declarators>
            </typedef>
  
            <!-- array types -->
            <typedef>
!             <type_spec>
!               <array><type_spec>float</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>FloatArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>float</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>FloatArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>double</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>DoubleArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>long long</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>LongLongArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>long</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>LongArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>short</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>ShortArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>unsigned long</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>UnsignedLongArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>unsigned short</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>UnsignedShortArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>char</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>CharArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>boolean</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>BooleanArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>octet</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>OctetArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>date</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>DateArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>time</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>TimeArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>interval</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>IntervalArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <array><type_spec>timestamp</type_spec></array>
!             </type_spec>
!             <declarators>
!               <declarator>TimestampArray</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <sequence><type_spec>float</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>FloatSequence</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <sequence><type_spec>double</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>DoubleSequence</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <sequence><type_spec>long long</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>LongLongSequence</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <sequence><type_spec>long</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>LongSequence</declarator>
!             </declarators>
            </typedef>
  
            <typedef>
!             <type_spec>
!               <sequence><type_spec>short</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>ShortSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>unsigned long</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>UnsignedLongSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>unsigned short</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>UnsignedShortSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>char</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>CharSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>boolean</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>BooleanSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>octet</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>OctetSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>date</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>DateSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>time</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>TimeSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>interval</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>IntervalSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <sequence><type_spec>timestamp</type_spec></sequence>
!             </type_spec>
!             <declarators>
!               <declarator>IntervalSequence</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <type_spec>string</type_spec>
!             </type_spec>
!             <declarators>
!               <declarator>String</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               <type_spec size="2">string</type_spec>
!             </type_spec>
!             <declarators>
!               <declarator>StringArray</declarator>
!             </declarators>
            </typedef>
  
!            <typedef>
!             <type_spec>
!               
<type_spec><scoped_name>GNUe::Goats::Goat</scoped_name></type_spec>
!             </type_spec>
!             <declarators>
!               <declarator>Hacker</declarator>
!             </declarators>
            </typedef>
  
!           <struct id="Foo">
              <members>
!               <member>
!                 <type_spec>short</type_spec>
!                 <declarators>
!                   <declarator>fubar</declarator>
!                 </declarators>
!               </member>
!               <member>
!                 <type_spec>long</type_spec>
!                 <declarators>
!                   <declarator>foobar</declarator>
!                 </declarators>
!               </member>
!               <member>
!                 
<type_spec><array><type_spec>long</type_spec></array></type_spec>
!                 <declarators>
!                   <declarator>fubarz</declarator>
!                 </declarators>
                </member>
              </members>
            </struct>
  
!           <union id="MyUnion">
!             <switch>
!               <type_spec>long</type_spec>
!               <case>
!                 <long>1</long>
!                 <type_spec>string</type_spec>
!                 <declarator>s</declarator>
!               </case>
!               <default>
!                 <type_spec>long</type_spec>
!                 <declarator>x</declarator>
!               </default>
              </switch>
            </union>
  
!           <enum id="FooType">
!             <enumerator>bar</enumerator>
!             <enumerator>biz</enumerator>
!             <enumerator>bazz</enumerator>
            </enum>
  
!           <typedef>
!             <type_spec><struct>Foo</struct></type_spec>
!             <declarators>
!               <declarator>foo</declarator>
!             </declarators>
!           </typedef>
! 
!          <typedef>
!            <type_spec><union>MyUnion</union></type_spec>
!            <declarators>
!              <declarator>my_union</declarator>
!            </declarators>
!          </typedef>
! 
!          <typedef>
!            <type_spec><enum>FooType</enum></type_spec>
!            <declarators>
!              <declarator>foo_type</declarator>
!            </declarators>
!          </typedef>
! 
!          <typedef>
!            <type_spec>
!              <dictionary>
!                <key>
!                  <type_spec>float</type_spec>
!                </key>
!                <value>
!                  <type_spec>float</type_spec>
!                </value>
!              </dictionary>
!            </type_spec>
!            <declarators>
!              <declarator>Dictionary</declarator>
!            </declarators>
!          </typedef>
! 
!          <typedef>
!            <type_spec><set><type_spec>float</type_spec></set></type_spec>
!            <declarators>
!              <declarator>Set</declarator>
!            </declarators>
!          </typedef>
! 
!          <typedef>
!            <type_spec><list><type_spec>float</type_spec></list></type_spec>
!            <declarators>
!              <declarator>Set</declarator>
!            </declarators>
!          </typedef>
! 
!          <typedef>
!            <type_spec><bag><type_spec>float</type_spec></bag></type_spec>
!            <declarators>
!              <declarator>Bag</declarator>
!            </declarators>
!          </typedef>
! 
!          <!-- Forward declarations -->
!          <interface id="CodeSlave"/>
!          <class id="Goats::Goat"/>
! 
!          <const id="MADGOATS">
!            <type_spec>
!              <boolean>TRUE</boolean>
!            </type_spec>
!          </const>
! 
!          <!-- Exception declarations -->
!          <exception id="FooError"/>
! 
!          <exception id="BarError">
!            <members>
!              <member>
!                <type_spec>string</type_spec>
!                <declarators>
!                  <declarator>biz</declarator>
!                </declarators>
!              </member>
!              <member>
!                <type_spec>char</type_spec>
!                <declarators>
!                  <declarator>bar</declarator>
!                </declarators>
!              </member>
!              <member>
!                <type_spec>float</type_spec>
!                <declarators>
!                  <declarator>baz</declarator>
!                </declarators>
!              </member>
!            </members>
!          </exception>
! 
!          <interface id="Sadist">
! 
!            <operation id="torture"/>
! 
!          </interface>
! 
!          <interface id="Masochist">
!            <operation id="suffer"/>
!          </interface>
! 
!          <interface id="DaMasta">
!            <inherits>
!              <interface>Sadist</interface>
!            </inherits>
! 
!            <enum id="BeatingType">
!              <enumeration>mild</enumeration>
!              <enumeration>profuse</enumeration>
!            </enum>
! 
!            <typedef>
!              <type_spec><enum>BeatingType</enum></type_spec>
!              <declarators>
!                <declarator>beating_t</declarator>
!              </declarators>
!            </typedef>
! 
!            <const id="FAVCOLOR">
!              <type_spec><string>red</string></type_spec>
!            </const>
! 
!            <exception id="CodeSlaveAway"/>
! 
!            <exception id="NoTicketsAssigned"/>
! 
!            <attribute readonly="1">
!              <type_spec>string</type_spec>
!              <name>favoriteColor</name>
!            </attribute>
!             
!            <attribute>
!              <type_spec>unsigned short</type_spec>
!              <name>bugReports</name>
!            </attribute>
! 
!            <attribute>
!              <type_spec>beating_t</type_spec>
!              <name>beating</name>
!            </attribute>
! 
!            <relationship id="beats">
!              <target>
!                <type_spec><set>CodeSlave</set></type_spec>
!              </target>
!              <inverse>
!                <scoped_name>CodeSlave::isBeaten</scoped_name>
!              </inverse>
!            </relationship>
! 
!            <relationship id="assignsTicket">
!              <target>
!                <type_spec><scoped_name>Hacker</scoped_name></type_spec>
!              </target>
!              <inverse>
!                <scoped_name>Hacker::isAssignedTicketBy</scoped_name>
!              </inverse>
!            </relationship>
! 
!            <operation oneway="1" id="speakInIRCChannel"/>
! 
!            <operation id="isWatching">
!              <returns>
!                <type_spec>boolean</type_spec>
!              </returns>
!              <parameters>
!                <parameter mode="in">
!                  <type_spec><scoped_name>CodeSlave</scoped_name></type_spec>
!                  <declarator>cslave</declarator>
!                </parameter>
!              </parameters>
!            </operation>
! 
!            <operation id="beatCodeSlave">
!              <parameters>
!                <parameter mode="in">
!                  <type_spec><scoped_name>CodeSlave</scoped_name></type_spec>
!                  <declarator>cslave</declarator>
!                </parameter>
!                <parameter mode="inout">
!                  <type_spec>beating_t</type_spec>
!                  <declarator>severity</declarator>
!                </parameter>
!              </parameters>
!              <raises>
!                <exception>CodeSlaveAway</exception>
!              </raises>
!            </operation>
! 
!            <operation id="getTickets">
!              <returns>
!                <type_spec>boolean</type_spec>
!              </returns>
!              <parameters>
!                <parameter mode="in">
!                  <type_spec><scoped_name>Hacker</scoped_name></type_spec>
!                  <declarator>goat</declarator>
!                </parameter>
!                <parameter mode="out">
!                  <type_spec>unsigned short</type_spec>
!                  <declarator>tickets</declarator>
!                </parameter>
!              </parameters>
!              <raises>
!                <exception>NoTickestAssigned</exception>
!              </raises>
!            </operation>
! 
!          </interface>
! 
!          <interface id="CodeSlave">
!            <inherits>
!              <interface>Masochist</interface>
!            </inherits>
! 
!            <enum id="HackType">
!              <enumeration>common</enumeration>
!              <enumeration>forms</enumeration>
!              <enumeration>appserver</enumeration>
!              <enumeration>designer</enumeration>
!              <enumeration>reports</enumeration>
!              <enumeration>navigator</enumeration>
!              <enumeration>phpforms</enumeration>
!            </enum>
! 
!            <typedef>
!              <type_spec><enum>HackType</enum></type_spec>
!              <declarators>
!                <declarator>hack_t</declarator>
!              </declarators>
!            </typedef>
! 
!            <exception id="WhoSaidYouCouldStopCoding">
!              <members>
!                <member>
!                  <type_spec>string</type_spec>
!                  <declarators>
!                    <declarator>cslave_name</declarator>
!                  </declarators>
!                </member>
!                <member>
!                  <type_spec>boolean</type_spec>
!                  <declarators>
!                    <declarator>beating</declarator>
!                  </declarators>
!                </member>
!              </members>
!            </exception>
! 
!            <exception id="CVSPermissionDenied">
!              <members>
!                <member>
!                  <type_spec>string</type_spec>
!                  <declarators>
!                    <declarator>why</declarator>
!                  </declarators>
!                </member>
!              </members>
!            </exception>
! 
!            <relationship id="isBeaten">
!              <target>
!                <type_spec><scoped_name>GNUe::DaMasta</scoped_name></type_spec>
!              </target>
!              <inverse>
!                <scoped_name>GNUe::DaMasta::beats</scoped_name>
!              </inverse>
!            </relationship>
! 
!            <operation id="stopCoding">
!              <raises>
!                <exception>WhoSaidYouCouldStopCoding</exception>
!              </raises>
!            </operation>
! 
!            <operation id="commitCode">
!              <returns>
!                <type_spec>boolean</type_spec>
!              </returns>
!              <parameters>
!                <parameter mode="in">
!                  <type_spec>string</type_spec>
!                  <declarator>code</declarator>
!                </parameter>
!                <parameter mode="in">
!                  <type_spec>hack_t</type_spec>
!                  <declarator>hackingOn</declarator>
!                </parameter>
!              </parameters>
!              <raises>
!                <exception>CVSPermissionDenied</exception>
!              </raises>
!            </operation>
!          </interface> 
! 
!            <!--
!            This is the fun module :). It is also used to test nesting of
!            modules and as an example to help determine how xml for nesting 
modules
!            should be done.
!            -->
!            <module id="Goats">
!              <odl_specification>
!                <odl_definition>
! 
!                  <class>
!                    <id>Goat</id>
!                    <inherits>
!                      <interface>GNUe::CodeSlave</interface>
!                    </inherits>
! 
!                    <attribute>
!                      <type_spec>boolean</type_spec>
!                      <name>madGoatRaped</name>
!                    </attribute>
  
!                    <attribute>
!                      <type_spec>string</type_spec>
!                      <name>name</name>
!                    </attribute>
  
!                    <attribute>
!                      <type_spec>boolean</type_spec>
!                      <name>FSFCopyrightAssignment</name>
!                    </attribute>
  
!                    <relationship id="isAssignedTicketBy">
!                      <target>
!                        
<type_spec><scoped_name>GNUe::DaMasta</scoped_name></type_spec>
!                      </target>
!                      <inverse>
!                        <scoped_name>GNUe::DaMasta::assignsTicket</scoped_name>
!                      </inverse>
!                    </relationship>
!                  </class>
  
!                  <class id="Derek">
!                    <extends>
!                      <class>Goat</class>
!                    </extends>
!                    <inherits>
!                      <interface>GNUe::DaMasta</interface>
!                    </inherits>
!                    <extent>goats</extent>
  
!                    <exception id="BurnRoofOfMouth"/>
  
!                    <exception id="NeedsReheating"/>
  
!                    <exception id="OutofTopping">
!                      <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>topping</declarator>
!                          </declarators>
!                        </member>
!                      </members>
!                    </exception>
  
!                    <struct id="PizzaType">
!                      <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>kind</declarator>
!                          </declarators>
!                        </member>
!                        <member>
!                          
<type_spec><bag><type_spec>string</type_spec></bag></type_spec>
!                          <declarators>
!                            <declarator>toppings</declarator>
!                          </declarators>
!                          <!-- allows duplicate toppings ("extra" toppings) -->
!                        </member>
!                      </members>
!                    </struct>
  
!                    <typedef>
!                      <type_spec><struct>PizzaType</struct></type_spec>
!                      <declarators>
!                        <declarator>pizza_t</declarator>
!                      </declarators>
!                    </typedef>
  
!                    <attribute>
!                      <type_spec>boolean</type_spec>
!                      <name>orderPizza</name>
!                    </attribute>
  
!                    <attribute>
!                      <type_spec>float</type_spec>
!                      <name>temperature</name>
!                    </attribute>
  
!                    <attribute>
!                      
<type_spec><set><type_spec>pizza_t</type_spec></set></type_spec>
!                      <name>pizzas</name>
!                    </attribute>
  
!                    <operation id="orderPizza">
!                      <returns>
!                        <type_spec>boolean</type_spec>
!                      </returns>
!                      <parameters>
!                        <parameter mode="in">
!                          <type_spec><set>pizza_t</set></type_spec>
!                          <declarator>pizzaPies</declarator>
!                        </parameter>
!                      </parameters>
!                      <raises>
!                        <exception>OutofTopping</exception>
!                      </raises>
!                    </operation>
  
!                    <operation id="eatPizza">
!                      <parameters>
!                        <parameter mode="in">
!                          <type_spec>pizza_t</type_spec>
!                          <declarator>pizza</declarator>
!                        </parameter>
!                      </parameters>
!                      <raises>
!                        <exception>BurnRoofofMouth</exception>
!                        <exception>NeedsReheating</exception>
!                      </raises>
!                    </operation>
!                  </class>
  
!                  <class id="Chillywilly">
!                    <extends>
!                      <class>Goat</class>
!                    </extends>
!                    <extent>goats</extent>
!  
!                    <exception id="OutofStock">
!                      <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>why</declarator>
!                          </declarators>
!                        </member>
!                      </members>
!                    </exception>
  
!                    <exception id="GoatDucked"/>
  
!                    <exception id="ExceededTroutLimit">
!                      <members>
!                        <member>
!                          <type_spec>unsigned short</type_spec>
!                          <declarators>
!                            <declarator>limit</declarator>
!                          </declarators>
!                        </member>
!                      </members>
!                    </exception>
  
!                    <enum id="TroutType">
!                      <enumeration>brown</enumeration>
!                      <enumeration>rainbow</enumeration>
!                      <enumeration>lake</enumeration>
                     </enum>
  
!                    <typedef>
!                      <type_spec><enum>TroutType</enum></type_spec>
!                      <declarators>
!                        <declarator>trout_t</declarator>
!                      </declarators>
                     </typedef>
  
!                    <const id="preferredTrout">
!                      <type_spec>
!                        <trout_t>rainbow</trout_t>
!                      </type_spec>
!                    </const>
! 
!                    <attribute>
!                      <type_spec>boolean</type_spec>
!                      <name>troutslap</name>
!                    </attribute>
  
!                    <attribute>
!                      
<type_spec><bag><type_spec>trout_t</type_spec></bag></type_spec>
!                      <name>trout</name>
                     </attribute>
  
!                    <relationship id="favoriteSlapee">
!                      <target>
!                        
<type_spec><scoped_name>Jcater</scoped_name></type_spec>
!                      </target>
!                      <inverse>
!                        <scoped_name>Jcater::isTroutSlappedBy</scoped_name>
!                      </inverse>
                     </relationship>
  
!                    <operation id="addTrout">
!                      <returns>
!                        <type_spec>boolean</type_spec>
!                      </returns>
                       <parameters>
!                        <parameter mode="in">
!                          <type_spec>trout_t</type_spec>
!                          <declarator>trout</declarator>
!                        </parameter>
!                        <parameter mode="out">
!                          <type_spec>unsigned short</type_spec>
!                          <declarator>inStock</declarator>
!                        </parameter>
                       </parameters>
                       <raises>
!                        <exception>ExceededTroutLimit</exception>
                       </raises>
                     </operation>
  
!                    <operation id="troutSlap">
                       <parameters>
!                        <parameter mode="in">
!                          
<type_spec><scoped_name>Goat</scoped_name></type_spec>
!                          <declarator>slapee</declarator>
!                        </parameter>
!                        <parameter mode="in">
!                          <type_spec>trout_t</type_spec>
!                          <declarator>trout</declarator>
!                        </parameter>
                       </parameters>
                       <raises>
!                        <exception>OutOfStock</exception>
!                        <exception>GoatDucked</exception>
                       </raises>
                     </operation>
                   </class>
  
!                  <class id="Jcater">
                     <extends>
!                      <class>Goat</class>
                     </extends>
                     <extent>goats</extent>
  
!                    <exception id="InvalidDonutType">
                       <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>what</declarator>
!                          </declarators>
!                        </member>
                       </members>
                     </exception>
  
!                    <exception id="NotEnoughMoney"/>
  
!                    <enum id="DonutType">
!                      <enumeration>glazed</enumeration>
!                      <enumeration>krispy_kreme</enumeration>
!                      <enumeration>jelly</enumeration>
!                      <enumeration>powedered</enumeration>
                     </enum>
  
!                    <struct id="Currency">
                       <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>type</declarator>
!                          </declarators>
!                        </member>
!                        <member>
!                          <type_spec>float</type_spec>
!                          <declarators>
!                            <declarator>amount</declarator>
!                          </declarators>
!                        </member>
                       </members>
                     </struct>
  
!                    <typedef>
!                      <type_spec><struct>DonutType</struct></type_spec>
!                      <declarators>
!                        <declarator>donut_t</declarator>
!                      </declarators>
                     </typedef>
  
!                    <const id="preferredDonut">
!                      <type_spec><donut_t>krispy_kreme</donut_t></type_spec>
!                    </const>
! 
!                    <attribute>
!                      
<type_spec><bag><type_spec>donut_t</type_spec></bag></type_spec>
!                      <name>donuts</name>
                     </attribute>
  
!                    <operation id="consumeDonuts">
                       <parameters>
!                        <parameter mode="in">
!                          <type_spec>donut_t</type_spec>
!                          <declarator>donut</declarator>
!                        </parameter>
                       </parameters>
                       <raises>
!                        <exception>InvalidDonutType</exception>
                       </raises>
                     </operation>
  
!                    <operation id="purchaseDonuts">
!                      <returns>
!                        <type_spec>boolean</type_spec>
!                      </returns>
                       <parameters>
!                        <parameter mode="in">
!                          <type_spec><struct>Currency</struct></type_spec>
!                          <declarator>money</declarator>
!                        </parameter>
!                        <parameter mode="out">
!                          
<type_spec><bag><type_spec>donut_t</type_spec></bag></type_spec>
!                          <declarator>donuts</declarator>
                         </parameter>
                       </parameters>
                       <raises>
!                        <exception>NotEnoughMoney</exception>
                       </raises>
                     </operation>
- 
                   </class>
  
!                  <class id="Jamest">
                     <extends>
!                      <class>Goat</class>
                     </extends>
                     <extent>goats</extent>
  
!                    <exception id="CrackLevelsTooLow">
                       <members>
!                        <member>
!                          <type_spec>unsigned short</type_spec>
!                          <declarators>
!                            <declarator>level</declarator>
!                          </declarators>
!                        </member>
                       </members>
                     </exception>
  
!                    <struct id="AtmosphericCrack">
                       <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>kind</declarator>
!                          </declarators>
!                        </member>
!                        <member>
!                          <type_spec>unsigned long</type_spec>
!                          <declarators>
!                            <declarator>weight</declarator>
!                          </declarators>
!                        </member>
!                        <member>
!                          <type_spec>float</type_spec>
!                          <declarators>
!                            <declarator>percentage</declarator>
!                          </declarators>
!                        </member>
                       </members>
                     </struct>
  
!                    <typedef>
!                      <type_spec><struct>AtmosphericCrack</struct></type_spec>
!                      <declarators>
!                        <declarator>atmoscrack_t</declarator>
!                      </declarators>
                     </typedef>
  
!                    <attribute>
!                      
<type_spec><bag><type_spec>atmoscrack_t</type_spec></bag></type_spec>
!                      <name>crackReserves</name>
                     </attribute>
  
!                    <operation id="inhaleAtmosphericCrack">
                       <parameters>
!                        <parameter mode="in">
!                          
<type_spec><struct>AtmosphericCrack</struct></type_spec>
!                          <declarator>crack</declarator>
!                        </parameter>
                       </parameters>
                       <raises>
!                        <exception>CrackLevelsTooLow</exception>
                       </raises>
                     </operation>
                   </class>
  
!                  <class id="Reinhard">
                     <extends>
!                      <class>Goat</class>
                     </extends>
                     <extent>goats</extent>
  
!                    <exception id="FileDoesNotExist">
                       <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>filename</declarator>
!                          </declarators>
!                        </member>
                       </members>
                     </exception>
  
!                    <exception id="FileIsEmpty">
                       <members>
!                        <member>
!                          <type_spec>string</type_spec>
!                          <declarators>
!                            <declarator>filename</declarator>
!                          </declarators>
!                        </member>
                       </members>
                     </exception>
  
!                    <attribute>
!                      
<type_spec><list><type_spec>string</type_spec></list></type_spec>
!                      <name>quitMessages</name>
                     </attribute>
  
!                    <attribute>
!                      <type_spec>string</type_spec>
!                      <name>filename</name>
!                    </attribute>
  
!                    <operation id="loadQuitMessage">
!                      <returns>
!                        <type_spec>boolean</type_spec>
!                      </returns>
                       <parameters>
!                        <parameter mode="in">
!                          <type_spec>string</type_spec>
!                          <declarator>filename</declarator>
!                        </parameter>
                       </parameters>
                       <raises>
!                        <exception>FileDoesNotExist</exception>
!                        <exception>FileIsEmpty</exception>
                       </raises>
                     </operation>
  
!                    <operation id="loadQuitMessage">
!                      <returns>
!                        <type_spec>string</type_spec>
!                      </returns>
                     </operation>
                   </class>
  
--- 12,850 ----
  -->
  <odl_specification>
    <odl_definition>
! 
!     <typedef type="float">
!       <alias>FloatType</alias>
      </typedef>
  
      <typedef>
!       <array>float</array>
!       <alias>FloatArrayType</alias>
      </typedef>
  
      <typedef>
!       <sequence>float</sequence>
!       <alias>FloatSequenceType</alias>
      </typedef>
  
!     <typedef type="string">
!       <alias>StringType</alias>
      </typedef>
  
!     <typedef type="GNUe::Sadist">
!       <alias>Masta</alias>
      </typedef>
  
!     <struct name="Bar">
        <members>
!         <member name="barname">string</member>
!         <member name="barprice">float"</member>
!         <member name="barz">short</member>
!         <member name="fubar"/>unsigned long</member>
!         <member name="fbar">unsigned short</member>
!         <member name="bars">long long</member>
        </members>
      </struct>
  
!     <union name="Trout">
!       <switch type="boolean">
!         <case label="TRUE" name="brown_trout">string</case>
!         <case label="FALSE" name="rainbow_trout">string</case>
!         <default name="trout">string</default>
        </switch>
      </union>
  
!     <enum name="TroutType">
!       <element>brown</element>
!       <element>rainbow</element>
!       <element>lake</element>
      </enum>
  
!     <typedef type="Bar">
!       <alias>bar</alias>
      </typedef>
  
!     <typedef type="Trout">
!       <alias>trout_t</alias>
      </typedef>
  
!     <typedef type="TroutType">
!       <alias>trout_type</alias>
      </typedef>
  
      <typedef>
!       <dictionary>
!         <key>float</key>
!         <value>float</value>
!       </dictionary>
!       <alias>DictionaryType</alias>
      </typedef>
  
      <typedef>
!       <set>float</set>
!       <alias>SetType</alias>
      </typedef>
  
      <typedef>
!       <list>float</list>
!       <alias>ListType</alias>
      </typedef>
  
      <typedef>
!       <bag>float</bag>
!       <alias>BagType</alias>
      </typedef>
  
      <!-- Forward declarations -->
!     <interface name="GNUe::Sadist"/>
!     <class name="GNUe::Goats::Chillywilly"/>
  
!     <const name="BIGINT" type="unsigned long">10000L</const>
  
!     <exception name="NoModuleError">
        <members>
!         <member name="what">string</member>
!         <member name="line">short</member>
        </members>
      </exception>
  
!     <exception name="FubarError"/>
  
+     <interface name="KungFu">
+       <operation name="Kick"/>
+       <operation name="Punch"/>
      </interface>
  
!     <class name="Dragon">
        <inherits>
!         <interface name="KungFu"/>
        </inherits>
!       <attribute name="sensai">string</attribute>
!       <operation name="dragonKick"/>
!       <operation name="dragonPunch"/>
      </class>
  
!     <module name="GNUe">
        <odl_specification>
          <odl_definition>
  
!           <!-- Type declarations -->
!         
!           <!-- primitive types -->
!           <typedef type="float">
!             <alias>Float</alias>
            </typedef>
  
!           <typedef type="double">
!             <alias>Double</alias>
            </typedef>
  
!           <typedef type="long">
!             <alias>Long</alias>
            </typedef>
  
!           <typedef type="long long">
!             <alias>Long Long</alias>
            </typedef>
  
!           <typedef type="short">
!             <alias>Short</alias>
            </typedef>
  
!           <typedef type="unsigned long">
!             <alias>Unsigned Long</alias>
            </typedef>
  
!           <typedef type="unsigned short">
!             <alias>Unsigned Short</alias>
            </typedef>
  
!           <typedef type="char">
!             <alias>Char</alias>
            </typedef>
  
!           <typedef type="boolean">
!             <alias>Bool</alias>
            </typedef>
  
!           <typedef type="octet">
!             <alias>Octet</declarator>
            </typedef>
  
!           <typedef type="date"
!             <alias>Date</alias>
            </typedef>
  
!           <typedef type="time">
!             <alias>Time</alias>
            </typedef>
  
!           <typedef type="interval">
!             <alias>Interval</alias>
            </typedef>
  
!           <typedef type="timestamp>
!             <alias>Timestamp</alias>
            </typedef>
  
            <!-- array types -->
            <typedef>
!             <array>float</array>
!             <alias>FloatArray</alias>
            </typedef>
  
            <typedef>
!             <array>float</array>
!             <alias>FloatArray</alias>
            </typedef>
  
            <typedef>
!             <array>double</array>
!             <alias>DoubleArray</alias>
            </typedef>
  
            <typedef>
!             <array>long long</array>
!             <alias>LongLongArray</alias>
            </typedef>
  
            <typedef>
!             <array>long</array>
!             <alias>LongArray</alias>
            </typedef>
  
            <typedef>
!             <array>short</array>
!             <alias>ShortArray</alias>
            </typedef>
  
            <typedef>
!             <array>unsigned long</array>
!             <alias>UnsignedLongArray</alias>
            </typedef>
  
            <typedef>
!             <array>unsigned short</array>
!             <alias>UnsignedShortArray</alias>
            </typedef>
  
            <typedef>
!             <array>char</array>
!             <alias>CharArray</alias>
            </typedef>
  
            <typedef>
!             <array>boolean</array>
!             <alias>BooleanArray</alias>
            </typedef>
  
            <typedef>
!             <array>octet</array>
!             <alias>OctetArray</alias>
            </typedef>
  
            <typedef>
!             <array>date</array>
!             <alias>DateArray</alias>
            </typedef>
  
            <typedef>
!             <array>time</array>
!             <alias>TimeArray</alias>
            </typedef>
  
            <typedef>
!             <array>interval</array>
!             <alias>IntervalArray</alias>
            </typedef>
  
            <typedef>
!             <array>timestamp</array>
!             <alias>TimestampArray</alias>
            </typedef>
  
            <typedef>
!             <sequence>float</sequence>
!             <alias>FloatSequence</alias>
            </typedef>
  
            <typedef>
!             <sequence>double</sequence>
!             <alias>DoubleSequence</alias>
            </typedef>
  
            <typedef>
!             <sequence>long long</sequence>
!             <alias>LongLongSequence</alias>
            </typedef>
  
            <typedef>
!             <sequence>long</sequence>
!             <alias>LongSequence</alias>
            </typedef>
  
            <typedef>
!             <sequence>short</sequence>
!             <alias>ShortSequence</alias>
            </typedef>
  
!         <typedef>
!             <sequence>unsigned long</sequence>
!             <alias>UnsignedLongSequence</alias>
            </typedef>
  
!         <typedef>
!             <sequence>unsigned short</sequence>
!             <alias>UnsignedShortSequence</alias>
            </typedef>
  
!         <typedef>
!             <sequence>char</sequence>
!             <alias>CharSeq0uence</alias>
            </typedef>
  
!         <typedef>
!             <sequence>boolean</sequence>
!             <alias>BooleanSequence</alias>
            </typedef>
  
!         <typedef>
!             <sequence>octet</sequence>
!             <alias>OctetSequence</alias>
            </typedef>
  
!         <typedef>
!             <sequence>date</sequence>
!             <alias>DateSequence</alias>
            </typedef>
  
!           <typedef>
!             <sequence>time</sequence>
!             <alias>TimeSequence</alias>
            </typedef>
  
!           <typedef>
!             <sequence>interval</sequence>
!             <alias>IntervalSequence</alias>
            </typedef>
  
!           <typedef>
!             <sequence>timestamp</sequence>
!             <alias>IntervalSequence</alias>
            </typedef>
  
!           <typedef type="string">
!             <alias>String</alias>
            </typedef>
  
!           <typedef>
!             <string size="2"/>
!             <alias>StringArray</alias>
            </typedef>
  
!           <typedef type="GNUe::Goats::Goat">
!             <alias>Hacker</alias>
            </typedef>
  
!           <struct name="Foo">
              <members>
!               <member name="fubar">short</member>
!               <member name="foobar">long</member>
!               <member name="fubarz">
!                 <array>long</array>
                </member>
              </members>
            </struct>
  
!           <union name="MyUnion">
!             <switch type="long">
!               <case label="1" name="s">string</case>
!               <default name="x">long</default>
              </switch>
            </union>
  
!           <enum name="FooType">
!             <element>bar</element>
!             <element>biz</element>
!             <element>bazz</element>
            </enum>
  
!           <typedef type="Foo">
!             <alias>foo</alias>
!           </typedef>
  
!         <typedef type="MyUnion">
!             <alias>my_union</alias>
!         </typedef>
  
!         <typedef type="FooType">
!             <alias>foo_type</alias>
!           </typedef>
  
!         <typedef>
!           <dictionary>
!               <key>float</key>
!               <value>float</value>
!             </dictionary>
!           <alias>Dictionary</alias>
!         </typedef>
  
!           <typedef>
!             <set>float</set>
!             <alias>Set</alias>
!           </typedef>
  
!         <typedef>
!           <list>float</list>
!           <alias>List</alias>
!         </typedef>
  
!         <typedef>
!           <bag>float</bag>
!           <alias>Bag</alias>
!         </typedef>
  
!         <!-- Forward declarations -->
!         <interface name="CodeSlave"/>
!         <class name="Goats::Goat"/>
  
!         <const name="MADGOATS" type="boolean">TRUE</const>
  
!         <!-- Exception declarations -->
!         <exception name="FooError"/>
  
!         <exception name="BarError">
!           <members>
!             <member name="biz">string</member>
!             <member name="bar">char</member>
!             <member name="baz">float</member>
!           </members>
!         </exception>
  
!         <interface name="Sadist">
!           <operation name="torture"/>
!         </interface>
  
!         <interface name="Masochist">
!           <operation name="suffer"/>
!         </interface>
  
!         <interface name="DaMasta">
!           <inherits>
!             <interface name="Sadist"/>
!           </inherits>
  
!           <enum name="BeatingType">
!             <element>mild</element>
!             <element>profuse</element>
!           </enum>
  
!           <typedef type="BeatingType">
!               <alias>beating_t</alias>
!           </typedef>
  
!           <const name="FAVCOLOR" type="string">red</const>
  
!           <exception name="CodeSlaveAway"/>
  
!           <exception name="NoTicketsAssigned"/>
! 
!           <attribute readonly="1" name="favoriteColor">string</attribute>
!             
!           <attribute name="bugReports">unsigned short</attribute>
! 
!           <attribute name="beating">beating_t</attribute>
! 
!           <relationship name="beats">
!             <target>
!               <set>CodeSlave</set>
!             </target>
!             <inverse>CodeSlave::isBeaten</inverse>
!           </relationship>
! 
!           <relationship name="assignsTicket">
!             <target>Hacker</target>
!             <inverse>Hacker::isAssignedTicketBy</inverse>
!           </relationship>
! 
!           <operation oneway="1" name="speakInIRCChannel"/>
! 
!           <operation name="isWatching">
!             <returns>boolean</returns>
!             <parameters>
!               <parameter mode="in" name="cslave">CodeSlave</parameter>
!             </parameters>
!           </operation>
! 
!           <operation name="beatCodeSlave">
!             <parameters>
!               <parameter mode="in" name="cslave">CodeSlave</parameter>
!               <parameter mode="inout" name="severity">beating_t</parameter>
!             </parameters>
!             <raises>
!               <exception name="CodeSlaveAway"/>
!             </raises>
!           </operation>
! 
!           <operation name="getTickets">
!             <returns>boolean</returns>
!             <parameters>
!               <parameter mode="in" name="goat">Hacker</parameter>
!               <parameter mode="out" name="tickets">unsigned short</parameter>
!             </parameters>
!             <raises>
!               <exception name="NoTickestAssigned"/>
!             </raises>
!           </operation>
!         </interface>
! 
!         <interface name="CodeSlave">
!           <inherits>
!             <interface name="Masochist"/>
!           </inherits>
! 
!           <enum name="HackType">
!             <element>common</element>
!             <element>forms</element>
!             <element>appserver</element>
!             <element>designer</element>
!             <element>reports</element>
!             <element>navigator</element>
!             <element>phpforms</element>
!           </enum>
! 
!           <typedef type="HackType">
!               <alias>hack_t</alias>
!           </typedef>
! 
!           <exception name="WhoSaidYouCouldStopCoding">
!             <members>
!               <member name="cslave_name">string</member>
!               <member name="beating">boolean</member>
!             </members>
!           </exception>
! 
!           <exception name="CVSPermissionDenied">
!             <members>
!               <member name="why">string</member>
!             </members>
!           </exception>
! 
!           <relationship name="isBeaten">
!             <target>GNUe::DaMasta</target>
!             <inverse>GNUe::DaMasta::beats</inverse>
!           </relationship>
! 
!           <operation name="stopCoding">
!             <raises>
!               <exception name="WhoSaidYouCouldStopCoding"/>
!             </raises>
!           </operation>
! 
!           <operation name="commitCode">
!             <returns>boolean</returns>
!             <parameters>
!               <parameter mode="in" name="code">string</parameter>
!               <parameter mode="in" name="hackinOn">hack_t</parameter>
!             </parameters>
!             <raises>
!               <exception name="CVSPermissionDenied"/>
!             </raises>
!           </operation>
!         </interface> 
! 
!         <!--
!         This is the fun module :). It is also used to test nesting of
!         modules and as an example to help determine how xml for nesting 
modules
!         should be done.
!         -->
!         <module name="Goats">
!           <odl_specification>
!             <odl_definition>
! 
!               <class name="Goat">
!                 <inherits>
!                   <interface name="GNUe::CodeSlave"/>
!                 </inherits>
! 
!                 <attribute name="madGoatRaped">boolean</attribute>
! 
!                 <attribute name="name">string</attribute>
! 
!                 <attribute name="FSFCopyrightAssignment">boolean</attribute>
! 
!                 <relationship name="isAssignedTicketBy">
!                   <target>GNUe::DaMasta</target>
!                   <inverse>GNUe::DaMasta::assignsTicket</inverse>
!                 </relationship>
!               </class>
! 
!               <class name="Derek">
!                 <extends>
!                   <class name="Goat"/>
!                 </extends>
!                 <inherits>
!                   <interface name="GNUe::DaMasta"/>
!                 </inherits>
!                 <extent>goats</extent>
! 
!                 <exception name="BurnRoofOfMouth"/>
! 
!                 <exception name="NeedsReheating"/>
! 
!                 <exception name="OutofTopping">
!                   <members>
!                     <member name="topping">string</member>
!                   </members>
!                 </exception>
! 
!                 <struct name="PizzaType">
!                   <members>
!                     <member name="kind">string</member>
!                     <member name="topping">
!                       <bag>string</bag>
!                       <!-- allows duplicate toppings ("extra" toppings) -->
!                     </member>
!                   </members>
!                 </struct>
! 
!                 <typedef type="PizaType"
!                     <alias>pizza_t</alias>
!                 </typedef>
! 
!                 <attribute name="orderPizza">boolean</attribute>
! 
!                 <attribute name="temperature">float</attribute>
! 
!                 <attribute name="pizzas">
!                     <set>pizza_t</set>
!                 </attribute>
! 
!                 <operation name="orderPizza">
!                   <returns>boolean</returns>
!                   <parameters>
!                     <parameter mode="in" name="pizzaPies">
!                       <set>pizza_t</set>
!                     </parameter>
!                   </parameters>
!                   <raises>
!                     <exception name="OutofTopping"/>
!                   </raises>
!                 </operation>
! 
!                 <operation name="eatPizza">
!                   <parameters>
!                     <parameter mode="in" name="pizza">pizza_t</parameter>
!                   </parameters>
!                   <raises>
!                     <exception name="BurnRoofofMouth"/>
!                     <exception name="NeedsReheating"/>
!                   </raises>
!                 </operation>
!               </class>
! 
!               <class name="Chillywilly">
!                 <extends>
!                   <class name="Goat"/>
!                 </extends>
!                 <extent>goats</extent>
!                 
!                 <exception name="OutofStock">
!                   <members>
!                     <member name="why">string</member>
!                   </members>
!                 </exception>
! 
!                 <exception name="GoatDucked"/>
! 
!                 <exception name="ExceededTroutLimit">
!                   <members>
!                     <member name="limit">unsigned short</member>
!                     </members>
!                   </exception>
! 
!                    <enum name="TroutType">
!                      <element>brown</element>
!                      <element>rainbow</element>
!                      <element>lake</element>
                     </enum>
  
!                    <typedef type="TroutType">
!                      <alias>trout_t</alias>
                     </typedef>
  
!                    <const name="preferredTrout" type="trout_t">rainbow</const>
! 
!                    <attribute name="troutslap">boolean</attribute>
  
!                    <attribute name="trout">
!                      <bag>trout_t</bag>
                     </attribute>
  
!                    <relationship name="favoriteSlapee">
!                      <target>Jcater</target>
!                      <inverse>Jcater::isTroutSlappedBy</inverse>
                     </relationship>
  
!                    <operation name="addTrout">
!                      <returns>boolean</returns>
                       <parameters>
!                        <parameter mode="in" name="trout">trout_t</parameter>
!                        <parameter mode="out" name="inStock">unsigned 
short</parameter>
                       </parameters>
                       <raises>
!                        <exception name="ExceededTroutLimit"/>
                       </raises>
                     </operation>
  
!                    <operation name="troutSlap">
                       <parameters>
!                        <parameter mode="in" name="slapee">Goat</parameter>
!                        <parameter mode="in" name="trout">trout_t</parameter>
                       </parameters>
                       <raises>
!                        <exception name="OutOfStock"/>
!                        <exception name="GoatDucked"/>
                       </raises>
                     </operation>
                   </class>
  
!                  <class name="Jcater">
                     <extends>
!                      <class name="Goat"/>
                     </extends>
                     <extent>goats</extent>
  
!                    <exception name="InvalidDonutType">
                       <members>
!                        <member name="what">string</member>
                       </members>
                     </exception>
  
!                    <exception name="NotEnoughMoney"/>
  
!                    <enum name="DonutType">
!                      <element>glazed</element>
!                      <element>krispy_kreme</element>
!                      <element>jelly</element>
!                      <element>powedered</element>
                     </enum>
  
!                    <struct name="Currency">
                       <members>
!                        <member name="type">string</member>
!                        <member name="amount">float</member>
                       </members>
                     </struct>
  
!                    <typedef type="DonutType">
!                      <alias>donut_t</alias>
                     </typedef>
  
!                    <const name="preferredDonut" 
type="donut_t">krispy_kreme</const>
! 
!                    <attribute name="donuts">
!                      <bag>donut_t</bag>
                     </attribute>
  
!                    <operation name="consumeDonuts">
                       <parameters>
!                        <parameter mode="in" name="donut">donut_t</parameter>
                       </parameters>
                       <raises>
!                        <exception name="InvalidDonutType"/>
                       </raises>
                     </operation>
  
!                    <operation name="purchaseDonuts">
!                      <returns>boolean</returns>
                       <parameters>
!                        <parameter mode="in" name="money">Currency</parameter>
!                        <parameter mode="out" name="donuts">
!                          <bag>donut_t</bag>
                         </parameter>
                       </parameters>
                       <raises>
!                        <exception name="NotEnoughMoney"/>
                       </raises>
                     </operation>
                   </class>
  
!                  <class name="Jamest">
                     <extends>
!                      <class name="Goat"/>
                     </extends>
                     <extent>goats</extent>
  
!                    <exception name="CrackLevelsTooLow">
                       <members>
!                        <member name="level">unsigned short</member>
                       </members>
                     </exception>
  
!                    <struct name="AtmosphericCrack">
                       <members>
!                        <member name="kind">string</member>
!                        <member name="weight">unsigned long</member>
!                        <member name="percentage">float</member>
                       </members>
                     </struct>
  
!                    <typedef type="AtmosphericCrack">
!                      <alias>atmoscrack_t</alias>
                     </typedef>
  
!                    <attribute name="crackReserves">
!                      <bag>atmoscrack_t</bag>
                     </attribute>
  
!                    <operation name="inhaleAtmosphericCrack">
                       <parameters>
!                        <parameter mode="in" 
name="crack">AtmosphericCrack</parameter>
                       </parameters>
                       <raises>
!                        <exception name="CrackLevelsTooLow"/>
                       </raises>
                     </operation>
                   </class>
  
!                  <class name="Reinhard">
                     <extends>
!                      <class name="Goat"/>
                     </extends>
                     <extent>goats</extent>
  
!                    <exception name="FileDoesNotExist">
                       <members>
!                        <member name="filename">string</member>
                       </members>
                     </exception>
  
!                    <exception name="FileIsEmpty">
                       <members>
!                        <member name="filename">string</member>
                       </members>
                     </exception>
  
!                    <attribute name="quitMessages">
!                      <list>string</list>
                     </attribute>
  
!                    <attribute name="filename">string</attribute>
  
!                    <operation name="loadQuitMessage">
!                      <returns>boolean</returns>
                       <parameters>
!                        <parameter mode="in" name="filename">string</parameter>
                       </parameters>
                       <raises>
!                        <exception name="FileDoesNotExist"/>
!                        <exception name="FileIsEmpty"/>
                       </raises>
                     </operation>
  
!                    <operation name="loadQuitMessage">
!                      <returns>string</returns>
                     </operation>
                   </class>
  



reply via email to

[Prev in Thread] Current Thread [Next in Thread]