HOL-OCL
/
su4sml
1
0
Fork 0
Code Issues Pull Requests Releases Activity
su4sml/src/ocl_parser/ocl.grm.sml

4052 lines
164 KiB
Standard ML
Raw Blame History

functor OclParserLrValsFun(structure Token : TOKEN)
: sig structure ParserData : PARSER_DATA
structure Tokens : OclParser_TOKENS
end
=
struct
structure ParserData=
struct
structure Header =
struct
(*****************************************************************************
* su4sml --- an SML repository for managing (Secure)UML/OCL models
* http://projects.brucker.ch/su4sml/
*
* ocl.grm ---
* This file is part of su4sml.
*
* Copyright (c) 2005-2007, ETH Zurich, Switzerland
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* * Neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************)
(* $Id$ *)
(*
THIS POINTS HAVE TO BE NOTICED TO UNDERSTAND THE SEMANTICS OF:
- context_declarations.sml
- type_checker.sml
i.) 'AttributeCall' needs a path for the name of the attriubte.
But it is not possible to extract the hole name when 'AttributeCall' is constructed.
So, we only have a 'Path' with one element, the name of the attribute.
But the type still is 'Path' because of the types.
ii.) We cannot know if a 'propertycall_exp_cs' is a member of a Class or a Variable of the signature.
Therefore, all calls to Variables from signature are parsed as 'AttributeCall's
*)
open Rep_Core
open Rep_OclTerm
open Rep_OclType
open XMI_DataTypes
open Context
type Visibility = Rep_Core.Visibility
type Scope = XMI_DataTypes.ScopeKind
exception NotYetSupported of string
end
structure LrTable = Token.LrTable
structure Token = Token
local open LrTable in
val table=let val actionRows =
"\
\\001\000\001\000\000\000\000\000\
\\001\000\003\000\217\000\079\000\014\000\000\000\
\\001\000\007\000\069\000\027\000\068\000\039\000\067\000\045\000\066\000\
\\050\000\065\000\000\000\
\\001\000\007\000\091\000\079\000\014\000\000\000\
\\001\000\007\000\096\000\079\000\014\000\000\000\
\\001\000\007\000\098\000\079\000\014\000\000\000\
\\001\000\007\000\111\000\000\000\
\\001\000\007\000\111\000\045\000\066\000\000\000\
\\001\000\007\000\115\000\079\000\014\000\000\000\
\\001\000\007\000\117\000\000\000\
\\001\000\007\000\154\000\025\000\088\000\042\000\087\000\043\000\086\000\000\000\
\\001\000\007\000\155\000\000\000\
\\001\000\007\000\157\000\000\000\
\\001\000\007\000\171\000\000\000\
\\001\000\007\000\228\000\000\000\
\\001\000\007\000\229\000\000\000\
\\001\000\009\000\046\001\000\000\
\\001\000\010\000\224\000\000\000\
\\001\000\010\000\005\001\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\046\000\000\001\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\062\000\143\000\075\000\142\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\046\000\033\001\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\062\000\143\000\075\000\142\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\048\000\249\000\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\062\000\143\000\075\000\142\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\051\000\031\000\052\000\030\000\053\000\029\000\054\000\028\000\
\\055\000\027\000\056\000\026\000\057\000\025\000\058\000\024\000\
\\059\000\023\000\060\000\022\000\061\000\021\000\062\000\143\000\
\\075\000\142\000\076\000\141\000\077\000\140\000\078\000\139\000\
\\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\045\000\144\000\051\000\031\000\
\\052\000\030\000\053\000\029\000\054\000\028\000\055\000\027\000\
\\056\000\026\000\057\000\025\000\058\000\024\000\059\000\023\000\
\\060\000\022\000\061\000\021\000\062\000\143\000\075\000\142\000\
\\076\000\141\000\077\000\140\000\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\045\000\144\000\051\000\031\000\
\\052\000\030\000\053\000\029\000\054\000\028\000\055\000\027\000\
\\056\000\026\000\057\000\025\000\058\000\024\000\059\000\023\000\
\\060\000\022\000\061\000\021\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\079\000\014\000\000\000\
\\001\000\025\000\088\000\042\000\087\000\043\000\086\000\000\000\
\\001\000\026\000\046\000\031\000\045\000\000\000\
\\001\000\027\000\068\000\039\000\067\000\000\000\
\\001\000\028\000\168\000\038\000\167\000\000\000\
\\001\000\029\000\040\001\000\000\
\\001\000\030\000\050\001\000\000\
\\001\000\031\000\051\000\000\000\
\\001\000\034\000\032\000\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\079\000\014\000\000\000\
\\001\000\034\000\032\000\051\000\237\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\079\000\014\000\000\000\
\\001\000\037\000\003\001\000\000\
\\001\000\041\000\008\000\080\000\007\000\000\000\
\\001\000\044\000\007\001\000\000\
\\001\000\045\000\113\000\000\000\
\\001\000\045\000\164\000\000\000\
\\001\000\045\000\014\001\000\000\
\\001\000\045\000\015\001\000\000\
\\001\000\045\000\016\001\000\000\
\\001\000\046\000\094\000\079\000\014\000\000\000\
\\001\000\046\000\150\000\000\000\
\\001\000\046\000\230\000\000\000\
\\001\000\046\000\001\001\000\000\
\\001\000\046\000\009\001\000\000\
\\001\000\046\000\024\001\000\000\
\\001\000\046\000\042\001\000\000\
\\001\000\046\000\044\001\000\000\
\\001\000\046\000\048\001\000\000\
\\001\000\046\000\052\001\000\000\
\\001\000\047\000\204\000\000\000\
\\001\000\048\000\020\001\000\000\
\\001\000\049\000\043\001\000\000\
\\001\000\049\000\049\001\000\000\
\\001\000\079\000\014\000\000\000\
\\001\000\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\001\000\085\000\033\000\000\000\
\\001\000\087\000\036\000\000\000\
\\054\001\000\000\
\\055\001\080\000\007\000\000\000\
\\056\001\041\000\008\000\000\000\
\\057\001\000\000\
\\058\001\000\000\
\\059\001\041\000\008\000\000\000\
\\060\001\000\000\
\\061\001\000\000\
\\062\001\000\000\
\\063\001\026\000\046\000\000\000\
\\064\001\000\000\
\\065\001\000\000\
\\066\001\000\000\
\\067\001\000\000\
\\068\001\000\000\
\\069\001\000\000\
\\070\001\000\000\
\\071\001\000\000\
\\072\001\000\000\
\\073\001\000\000\
\\074\001\028\000\168\000\038\000\167\000\000\000\
\\075\001\000\000\
\\076\001\027\000\068\000\039\000\067\000\000\000\
\\077\001\000\000\
\\078\001\025\000\088\000\042\000\087\000\043\000\086\000\000\000\
\\079\001\000\000\
\\080\001\050\000\065\000\000\000\
\\081\001\000\000\
\\082\001\000\000\
\\083\001\000\000\
\\084\001\000\000\
\\085\001\000\000\
\\086\001\000\000\
\\087\001\000\000\
\\088\001\000\000\
\\089\001\000\000\
\\090\001\000\000\
\\091\001\000\000\
\\092\001\000\000\
\\093\001\000\000\
\\094\001\000\000\
\\095\001\000\000\
\\096\001\000\000\
\\097\001\007\000\154\000\000\000\
\\098\001\000\000\
\\099\001\007\000\154\000\000\000\
\\100\001\000\000\
\\101\001\000\000\
\\102\001\000\000\
\\103\001\000\000\
\\104\001\000\000\
\\105\001\000\000\
\\106\001\000\000\
\\107\001\003\000\019\001\000\000\
\\108\001\000\000\
\\109\001\000\000\
\\110\001\000\000\
\\111\001\006\000\017\001\000\000\
\\112\001\000\000\
\\113\001\000\000\
\\114\001\000\000\
\\115\001\000\000\
\\116\001\000\000\
\\117\001\000\000\
\\118\001\000\000\
\\119\001\000\000\
\\120\001\000\000\
\\121\001\000\000\
\\122\001\000\000\
\\123\001\000\000\
\\124\001\000\000\
\\125\001\000\000\
\\126\001\000\000\
\\127\001\000\000\
\\128\001\000\000\
\\129\001\000\000\
\\130\001\000\000\
\\131\001\000\000\
\\132\001\000\000\
\\133\001\000\000\
\\134\001\000\000\
\\135\001\000\000\
\\136\001\008\000\037\000\000\000\
\\137\001\008\000\049\000\000\000\
\\138\001\000\000\
\\138\001\007\000\111\000\000\000\
\\139\001\000\000\
\\140\001\000\000\
\\141\001\000\000\
\\142\001\000\000\
\\143\001\000\000\
\\144\001\000\000\
\\145\001\000\000\
\\146\001\000\000\
\\147\001\000\000\
\\148\001\000\000\
\\149\001\000\000\
\\150\001\000\000\
\\151\001\000\000\
\\152\001\000\000\
\\153\001\000\000\
\\154\001\000\000\
\\155\001\000\000\
\\156\001\071\000\203\000\072\000\202\000\073\000\201\000\074\000\200\000\000\000\
\\157\001\000\000\
\\158\001\071\000\203\000\072\000\202\000\073\000\201\000\074\000\200\000\000\000\
\\159\001\000\000\
\\160\001\000\000\
\\161\001\000\000\
\\162\001\000\000\
\\163\001\000\000\
\\164\001\000\000\
\\165\001\010\000\196\000\066\000\195\000\067\000\194\000\068\000\193\000\
\\069\000\192\000\070\000\191\000\000\000\
\\166\001\000\000\
\\167\001\000\000\
\\168\001\000\000\
\\169\001\000\000\
\\170\001\000\000\
\\171\001\000\000\
\\172\001\000\000\
\\173\001\000\000\
\\174\001\062\000\188\000\065\000\187\000\000\000\
\\175\001\000\000\
\\176\001\062\000\188\000\065\000\187\000\000\000\
\\177\001\000\000\
\\178\001\000\000\
\\179\001\000\000\
\\180\001\000\000\
\\181\001\063\000\183\000\064\000\182\000\000\000\
\\182\001\000\000\
\\183\001\063\000\183\000\064\000\182\000\000\000\
\\184\001\000\000\
\\185\001\000\000\
\\186\001\000\000\
\\187\001\000\000\
\\188\001\000\000\
\\189\001\000\000\
\\190\001\000\000\
\\191\001\000\000\
\\192\001\004\000\177\000\005\000\176\000\000\000\
\\193\001\000\000\
\\194\001\000\000\
\\195\001\000\000\
\\196\001\000\000\
\\197\001\000\000\
\\198\001\000\000\
\\199\001\004\000\177\000\005\000\176\000\000\000\
\\200\001\000\000\
\\201\001\000\000\
\\202\001\000\000\
\\203\001\013\000\209\000\045\000\208\000\000\000\
\\204\001\045\000\208\000\000\000\
\\205\001\000\000\
\\206\001\000\000\
\\207\001\000\000\
\\208\001\000\000\
\\209\001\000\000\
\\210\001\000\000\
\\211\001\000\000\
\\212\001\000\000\
\\213\001\000\000\
\\215\001\000\000\
\\216\001\000\000\
\\217\001\003\000\023\001\000\000\
\\218\001\000\000\
\\219\001\003\000\023\001\000\000\
\\220\001\000\000\
\\221\001\000\000\
\\222\001\000\000\
\\223\001\000\000\
\\224\001\003\000\152\000\000\000\
\\225\001\000\000\
\\226\001\000\000\
\\227\001\000\000\
\\228\001\000\000\
\\229\001\000\000\
\\230\001\000\000\
\\231\001\000\000\
\\232\001\000\000\
\\233\001\000\000\
\\234\001\003\000\217\000\000\000\
\\235\001\000\000\
\\236\001\000\000\
\\237\001\000\000\
\\239\001\000\000\
\\243\001\000\000\
\\244\001\000\000\
\\245\001\087\000\036\000\000\000\
\\246\001\000\000\
\\247\001\000\000\
\\248\001\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\249\001\000\000\
\\250\001\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\251\001\000\000\
\\252\001\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\253\001\000\000\
\\254\001\000\000\
\\255\001\079\000\014\000\000\000\
\\000\002\000\000\
\\001\002\000\000\
\\002\002\000\000\
\\003\002\000\000\
\\004\002\079\000\014\000\000\000\
\\005\002\000\000\
\\006\002\000\000\
\\007\002\000\000\
\\008\002\000\000\
\"
val actionRowNumbers =
"\036\000\063\000\066\000\062\000\
\\061\000\057\000\033\000\065\000\
\\067\000\064\000\059\000\060\000\
\\077\000\149\000\148\000\143\000\
\\145\000\033\000\027\000\142\000\
\\140\000\141\000\139\000\138\000\
\\136\000\137\000\134\000\133\000\
\\132\000\147\000\135\000\246\000\
\\248\000\247\000\057\000\150\000\
\\144\000\075\000\074\000\073\000\
\\072\000\070\000\032\000\068\000\
\\033\000\249\000\058\000\151\000\
\\071\000\069\000\002\000\255\000\
\\253\000\251\000\250\000\028\000\
\\057\000\057\000\087\000\080\000\
\\026\000\083\000\078\000\003\000\
\\043\000\004\000\005\000\025\000\
\\000\001\254\000\252\000\010\001\
\\011\001\006\001\007\001\009\001\
\\006\000\001\001\002\001\038\000\
\\088\000\008\000\085\000\079\000\
\\110\000\109\000\111\000\084\000\
\\009\000\022\000\044\000\231\000\
\\104\000\011\000\022\000\012\000\
\\057\000\236\000\237\000\039\000\
\\238\000\029\000\121\000\125\000\
\\123\000\124\000\122\000\008\001\
\\234\000\025\000\003\001\057\000\
\\013\000\022\000\086\000\022\000\
\\204\000\200\000\197\000\024\000\
\\189\000\182\000\173\000\164\000\
\\128\000\157\000\156\000\155\000\
\\154\000\152\000\153\000\202\000\
\\129\000\097\000\205\000\053\000\
\\211\000\160\000\159\000\158\000\
\\199\000\198\000\022\000\001\000\
\\023\000\161\000\163\000\162\000\
\\106\000\232\000\057\000\105\000\
\\025\000\022\000\091\000\057\000\
\\102\000\101\000\100\000\017\000\
\\093\000\007\000\025\000\081\000\
\\076\000\014\000\015\000\235\000\
\\045\000\022\000\095\000\098\000\
\\207\000\201\000\033\000\034\000\
\\196\000\023\000\191\000\190\000\
\\195\000\194\000\023\000\183\000\
\\184\000\187\000\188\000\023\000\
\\174\000\180\000\179\000\178\000\
\\177\000\181\000\176\000\165\000\
\\023\000\166\000\172\000\171\000\
\\170\000\169\000\021\000\213\000\
\\126\000\212\000\019\000\127\000\
\\131\000\046\000\241\000\240\000\
\\239\000\035\000\018\000\057\000\
\\037\000\107\000\233\000\108\000\
\\092\000\094\000\022\000\103\000\
\\047\000\082\000\022\000\022\000\
\\010\000\096\000\208\000\209\000\
\\210\000\040\000\041\000\042\000\
\\193\000\192\000\186\000\185\000\
\\175\000\168\000\167\000\118\000\
\\117\000\114\000\054\000\112\000\
\\214\000\224\000\048\000\229\000\
\\230\000\146\000\223\000\203\000\
\\242\000\022\000\244\000\022\000\
\\243\000\022\000\099\000\120\000\
\\089\000\090\000\026\000\004\001\
\\022\000\020\000\057\000\022\000\
\\115\000\022\000\113\000\225\000\
\\226\000\022\000\222\000\130\000\
\\245\000\030\000\005\001\022\000\
\\049\000\055\000\050\000\217\000\
\\057\000\016\000\119\000\116\000\
\\227\000\228\000\022\000\051\000\
\\215\000\221\000\218\000\056\000\
\\220\000\031\000\216\000\022\000\
\\206\000\052\000\219\000\000\000"
val gotoT =
"\
\\001\000\051\001\009\000\004\000\010\000\003\000\011\000\002\000\
\\119\000\001\000\000\000\
\\010\000\007\000\011\000\002\000\000\000\
\\010\000\008\000\011\000\002\000\000\000\
\\119\000\009\000\000\000\
\\000\000\
\\033\000\011\000\120\000\010\000\000\000\
\\012\000\018\000\013\000\017\000\033\000\016\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\121\000\033\000\122\000\032\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\033\000\016\000\060\000\036\000\061\000\014\000\062\000\013\000\000\000\
\\014\000\042\000\015\000\041\000\016\000\040\000\017\000\039\000\
\\018\000\038\000\019\000\037\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\121\000\045\000\122\000\032\000\000\000\
\\000\000\
\\033\000\046\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\014\000\048\000\015\000\041\000\016\000\040\000\017\000\039\000\
\\018\000\038\000\019\000\037\000\000\000\
\\000\000\
\\000\000\
\\012\000\050\000\013\000\017\000\033\000\016\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\000\000\
\\000\000\
\\123\000\054\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\023\000\062\000\024\000\061\000\025\000\060\000\028\000\059\000\
\\029\000\058\000\000\000\
\\123\000\068\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\123\000\069\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\123\000\070\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\000\000\
\\023\000\072\000\024\000\061\000\131\000\071\000\000\000\
\\033\000\076\000\038\000\075\000\128\000\074\000\129\000\073\000\000\000\
\\033\000\079\000\125\000\078\000\126\000\077\000\000\000\
\\028\000\080\000\029\000\058\000\000\000\
\\000\000\
\\026\000\083\000\027\000\082\000\032\000\081\000\000\000\
\\023\000\087\000\024\000\061\000\000\000\
\\000\000\
\\033\000\088\000\000\000\
\\033\000\076\000\038\000\091\000\039\000\090\000\000\000\
\\033\000\093\000\000\000\
\\033\000\095\000\000\000\
\\020\000\101\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\033\000\076\000\038\000\075\000\128\000\074\000\129\000\107\000\000\000\
\\000\000\
\\108\000\108\000\000\000\
\\000\000\
\\033\000\079\000\125\000\078\000\126\000\110\000\000\000\
\\000\000\
\\000\000\
\\033\000\112\000\000\000\
\\026\000\114\000\027\000\082\000\032\000\081\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\133\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\040\000\149\000\000\000\
\\041\000\151\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\154\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\033\000\161\000\034\000\160\000\035\000\159\000\036\000\158\000\
\\037\000\157\000\038\000\156\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\021\000\164\000\022\000\163\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\020\000\167\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\000\000\
\\033\000\076\000\038\000\091\000\039\000\168\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\170\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\171\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\093\000\173\000\094\000\172\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\092\000\176\000\
\\095\000\117\000\096\000\116\000\000\000\
\\086\000\179\000\087\000\178\000\090\000\177\000\000\000\
\\082\000\184\000\083\000\183\000\088\000\182\000\000\000\
\\079\000\188\000\084\000\187\000\000\000\
\\076\000\197\000\080\000\196\000\116\000\195\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\050\000\205\000\051\000\204\000\100\000\203\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\209\000\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\033\000\076\000\038\000\214\000\074\000\213\000\103\000\212\000\
\\110\000\211\000\111\000\210\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\216\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\041\000\217\000\000\000\
\\000\000\
\\033\000\076\000\038\000\091\000\039\000\218\000\000\000\
\\000\000\
\\020\000\219\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\220\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\033\000\161\000\034\000\221\000\035\000\159\000\036\000\158\000\
\\037\000\157\000\038\000\156\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\025\000\223\000\108\000\108\000\000\000\
\\020\000\224\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\021\000\225\000\022\000\163\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\229\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\093\000\230\000\094\000\172\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\096\000\231\000\000\000\
\\033\000\234\000\061\000\233\000\097\000\232\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\089\000\236\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\086\000\237\000\087\000\178\000\090\000\177\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\085\000\238\000\
\\089\000\120\000\091\000\119\000\092\000\118\000\095\000\117\000\
\\096\000\116\000\000\000\
\\000\000\
\\082\000\184\000\083\000\239\000\088\000\182\000\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\081\000\240\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\077\000\241\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\076\000\197\000\080\000\196\000\116\000\242\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\044\000\246\000\045\000\245\000\047\000\244\000\048\000\243\000\
\\052\000\134\000\055\000\208\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\100\000\248\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\252\000\
\\043\000\135\000\048\000\251\000\052\000\134\000\055\000\208\000\
\\056\000\132\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\124\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\
\\104\000\250\000\107\000\249\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\110\000\000\001\111\000\210\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\112\000\002\001\000\000\
\\033\000\076\000\038\000\214\000\103\000\004\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\006\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\008\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\009\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\026\000\011\001\027\000\082\000\032\000\081\000\041\000\010\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\046\000\016\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\105\000\020\001\106\000\019\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\108\000\108\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\023\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\024\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\025\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\026\000\026\001\027\000\082\000\032\000\081\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\091\000\
\\039\000\029\001\043\000\135\000\048\000\028\001\052\000\134\000\
\\055\000\208\000\056\000\132\000\060\000\015\000\061\000\014\000\
\\062\000\013\000\063\000\131\000\064\000\130\000\066\000\129\000\
\\067\000\128\000\068\000\127\000\069\000\126\000\070\000\125\000\
\\075\000\124\000\077\000\123\000\081\000\122\000\085\000\121\000\
\\089\000\120\000\091\000\119\000\092\000\118\000\095\000\117\000\
\\096\000\116\000\109\000\027\001\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\252\000\
\\043\000\135\000\048\000\251\000\052\000\134\000\055\000\208\000\
\\056\000\132\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\124\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\
\\104\000\030\001\107\000\249\000\000\000\
\\033\000\076\000\038\000\091\000\039\000\033\001\102\000\032\001\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\034\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\044\000\035\001\045\000\245\000\047\000\244\000\048\000\243\000\
\\052\000\134\000\055\000\208\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\105\000\020\001\106\000\036\001\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\252\000\
\\043\000\135\000\048\000\251\000\052\000\134\000\055\000\208\000\
\\056\000\132\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\124\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\
\\104\000\037\001\107\000\249\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\039\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\033\000\076\000\038\000\214\000\103\000\043\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\045\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\049\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\"
val numstates = 308
val numrules = 211
val s = ref "" and index = ref 0
val string_to_int = fn () =>
let val i = !index
in index := i+2; Char.ord(String.sub(!s,i)) + Char.ord(String.sub(!s,i+1)) * 256
end
val string_to_list = fn s' =>
let val len = String.size s'
fun f () =
if !index < len then string_to_int() :: f()
else nil
in index := 0; s := s'; f ()
end
val string_to_pairlist = fn (conv_key,conv_entry) =>
let fun f () =
case string_to_int()
of 0 => EMPTY
| n => PAIR(conv_key (n-1),conv_entry (string_to_int()),f())
in f
end
val string_to_pairlist_default = fn (conv_key,conv_entry) =>
let val conv_row = string_to_pairlist(conv_key,conv_entry)
in fn () =>
let val default = conv_entry(string_to_int())
val row = conv_row()
in (row,default)
end
end
val string_to_table = fn (convert_row,s') =>
let val len = String.size s'
fun f ()=
if !index < len then convert_row() :: f()
else nil
in (s := s'; index := 0; f ())
end
local
val memo = Array.array(numstates+numrules,ERROR)
val _ =let fun g i=(Array.update(memo,i,REDUCE(i-numstates)); g(i+1))
fun f i =
if i=numstates then g i
else (Array.update(memo,i,SHIFT (STATE i)); f (i+1))
in f 0 handle Subscript => ()
end
in
val entry_to_action = fn 0 => ACCEPT | 1 => ERROR | j => Array.sub(memo,(j-2))
end
val gotoT=Array.fromList(string_to_table(string_to_pairlist(NT,STATE),gotoT))
val actionRows=string_to_table(string_to_pairlist_default(T,entry_to_action),actionRows)
val actionRowNumbers = string_to_list actionRowNumbers
val actionT = let val actionRowLookUp=
let val a=Array.fromList(actionRows) in fn i=>Array.sub(a,i) end
in Array.fromList(map actionRowLookUp actionRowNumbers)
end
in LrTable.mkLrTable {actions=actionT,gotos=gotoT,numRules=numrules,
numStates=numstates,initialState=STATE 0}
end
end
local open Header in
type pos = ( int * int * int )
type arg = unit
structure MlyValue =
struct
datatype svalue = VOID | ntVOID of unit -> unit
| CLASS of unit -> (string) | CONSTRAINTS of unit -> (string)
| END of unit -> (string) | BETWEEN of unit -> (string)
| ASSOCIATIONS of unit -> (string) | ATTRIBUTES of unit -> (string)
| OPERATIONS of unit -> (string) | MODEL of unit -> (string)
| SIMPLE_NAME of unit -> (string)
| STRING_LITERAL of unit -> (string)
| REAL_LITERAL of unit -> (string)
| INTEGER_LITERAL of unit -> (string) | NOT of unit -> (string)
| LOG_IMPL of unit -> (string) | LOG_XOR of unit -> (string)
| LOG_OR of unit -> (string) | LOG_AND of unit -> (string)
| REL_LTE of unit -> (string) | REL_GTE of unit -> (string)
| REL_LT of unit -> (string) | REL_GT of unit -> (string)
| REL_NOTEQUAL of unit -> (string) | PLUS of unit -> (string)
| SLASH of unit -> (string) | STAR of unit -> (string)
| MINUS of unit -> (string) | OCLASTYPE of unit -> (string)
| OCLISKINDOF of unit -> (string) | OCLISTYPEOF of unit -> (string)
| ISUNIQUE of unit -> (string) | ONE of unit -> (string)
| EXISTS of unit -> (string) | ANY of unit -> (string)
| COLLECT of unit -> (string) | REJECT of unit -> (string)
| SELECT of unit -> (string) | ITERATE of unit -> (string)
| GUARD of unit -> (string) | VERTICAL_BAR of unit -> (string)
| BRACE_CLOSE of unit -> (string) | BRACE_OPEN of unit -> (string)
| PAREN_CLOSE of unit -> (string) | PAREN_OPEN of unit -> (string)
| THEN of unit -> (string)
| POST of unit -> (Context.ConditionType)
| PRE of unit -> (Context.ConditionType)
| PACKAGE of unit -> (string) | LET of unit -> (string)
| INV of unit -> (string) | INIT of unit -> (Context.AttrOrAssoc)
| IN of unit -> (string) | IF of unit -> (string)
| TRUE of unit -> (string) | FORALL of unit -> (string)
| NULL of unit -> (string) | FALSE of unit -> (string)
| ENDPACKAGE of unit -> (string) | ENDIF of unit -> (string)
| ELSE of unit -> (string)
| DERIVE of unit -> (Context.AttrOrAssoc) | DEF of unit -> (string)
| CONTEXT of unit -> (string)
| BODY of unit -> (Context.ConditionType)
| DBL_CARAT of unit -> (string) | CARAT of unit -> (string)
| BRACKET_CLOSE of unit -> (string)
| BRACKET_OPEN of unit -> (string) | TUPLE_TYPE of unit -> (string)
| TUPLE of unit -> (string) | SET of unit -> (string)
| ORDERED_SET of unit -> (string) | SEQUENCE of unit -> (string)
| COLLECTION of unit -> (string) | BAG of unit -> (string)
| AT_PRE of unit -> (string) | HASH of unit -> (string)
| QUESTION_MARK of unit -> (string) | EQUALS of unit -> (string)
| SEMI_COLON of unit -> (string) | DBL_COLON of unit -> (string)
| COLON of unit -> (string) | DBL_DOT of unit -> (string)
| DOT of unit -> (string) | ARROW_RIGHT of unit -> (string)
| COMMA of unit -> (string) | TICK of unit -> (string)
| model_cons_def_tail_cs_p of unit -> ( ( string option * OclTerm ) list)
| model_cons_spec_cs of unit -> (Classifier)
| model_att_value_def_tail_cs_p of unit -> (attribute list)
| model_att_value_def_cs of unit -> (attribute)
| model_atts_spec_cs of unit -> (Classifier)
| model_op_def_tail_cs_p of unit -> (operation list)
| model_op_def_cs of unit -> (operation)
| model_ops_spec_cs of unit -> (Classifier)
| model_component_def_cs of unit -> ( ( Classifier list ) )
| model_class_def_cs of unit -> ( ( Path * Classifier ) )
| model_class_def_tail_cs_p of unit -> ( ( Path * Classifier ) list)
| model_def_cs of unit -> (Classifier list)
| model_spec_cs of unit -> (Classifier list)
| logical_exp_tail_cs_p of unit -> ( ( string * OclTerm ) )
| variable_declaration_list_tail_cs of unit -> ( ( string*OclType ) list)
| variable_declaration_list_cs of unit -> ( ( string*OclType ) list)
| variable_declaration_cs of unit -> ( ( string*OclType ) )
| variable_initializer of unit -> (OclTerm)
| initialized_variable_list_tail_cs of unit -> ( ( string * OclType * OclTerm ) )
| initialized_variable_list_tail_cs_p of unit -> ( ( string * OclType * OclTerm ) list)
| iterator_vars_cs of unit -> ( ( string*OclType ) list)
| formal_parameter_type_specifier of unit -> (OclType)
| actual_parameter_list_element_cs of unit -> ( ( OclTerm * OclType ) )
| actual_parameter_list_tail_cs_p of unit -> ( ( OclTerm * OclType ) list)
| actual_parameter_list_tail_cs of unit -> ( ( OclTerm * OclType ) list)
| actual_parameter_list_cs of unit -> ( ( OclTerm * OclType ) list)
| initialized_variable_cs of unit -> ( ( string * OclType * OclTerm ) )
| iterate_vars_cs of unit -> ( ( string * OclType ) list)
| qualifiers of unit -> (CollectionPart list)
| property_call_parameters_cs of unit -> ( ( OclTerm * OclType ) list)
| msg_operator_cs of unit -> (OclTerm)
| signal_spec_exp_cs of unit -> (OclTerm)
| arrow_property_call_exp_cs of unit -> (OclTerm)
| property_call_exp_cs of unit -> (OclTerm)
| primary_exp_cs of unit -> (OclTerm)
| postfix_exp_tail_cs of unit -> (OclTerm)
| postfix_exp_tail_cs_p of unit -> (OclTerm list)
| postfix_exp_cs of unit -> (OclTerm)
| unary_op of unit -> (string) | mult_op of unit -> (string)
| unary_exp_cs of unit -> (OclTerm) | add_op of unit -> (string)
| multiplicative_exp_tail_cs of unit -> ( ( string*OclTerm ) )
| multiplicative_exp_tail_cs_p of unit -> ( ( string*OclTerm ) )
| multiplicative_exp_cs of unit -> (OclTerm)
| rel_op of unit -> (string)
| additive_exp_tail_cs_p of unit -> ( ( string*OclTerm ) )
| additive_exp_tail_cs of unit -> ( ( string*OclTerm ) )
| additive_exp_cs of unit -> (OclTerm)
| logic_op of unit -> (string)
| relational_exp_tail_cs of unit -> ( ( string*OclTerm ) )
| relational_exp_tail_cs_p of unit -> ( ( string*OclTerm ) )
| relational_exp_cs of unit -> (OclTerm)
| logical_exp_tail_cs of unit -> ( ( string*OclTerm ) )
| logical_exp_cs of unit -> (OclTerm)
| initialized_variable_list_cs of unit -> ( ( string * OclType * OclTerm ) list)
| string_literal of unit -> (OclTerm)
| real_literal of unit -> (OclTerm)
| integer_literal of unit -> (OclTerm)
| invalid_literal_exp_cs of unit -> (OclTerm)
| boolean_literal_exp_cs of unit -> (OclTerm)
| string_literal_exp_cs of unit -> (OclTerm)
| numeric_literal_exp_cs of unit -> (OclTerm)
| primitive_literal_exp_cs of unit -> (OclTerm)
| tuple_literal_exp_cs of unit -> (OclTerm)
| collection_literal_exp_cs of unit -> (OclTerm)
| literal_exp_cs of unit -> (OclTerm)
| ocl_op_name of unit -> (string)
| iterator_name_cs of unit -> (string)
| identifier_cs of unit -> (string)
| let_exp_cs of unit -> (OclTerm)
| ocl_expression_cs of unit -> (OclTerm)
| tuple_type_specifier_cs of unit -> (OclType)
| simple_type_specifier_cs of unit -> (OclType)
| if_exp_cs of unit -> (OclTerm)
| is_marked_pre_cs of unit -> (string)
| time_exp_cs of unit -> (string)
| collection_type_specifier_cs of unit -> (OclType)
| expression of unit -> (OclTerm)
| collection_range_cs of unit -> (CollectionPart)
| collection_literal_parts_tail_cs of unit -> (CollectionPart list)
| collection_literal_part_cs of unit -> (CollectionPart)
| collection_literal_parts_cs of unit -> (CollectionPart list)
| collection_type_identifier_cs of unit -> (string)
| collection_literal_exp of unit -> (OclTerm)
| operation_return_type_specifier_cs of unit -> (OclType)
| formal_parameter_list_tail_cs of unit -> ( ( string * OclType ) list)
| formal_parameter_list_cs of unit -> ( ( string * OclType ) list)
| formal_parameter_cs of unit -> ( ( string * OclType ) )
| ocl_operation_defined_entity_decl_cs of unit -> (string* ( (string * OclType) list ) )
| ocl_attribute_defined_entity_decl_cs of unit -> ( ( string * OclType ) )
| defined_entity_decl_cs of unit -> (OclTerm)
| definition_constraint_cs of unit -> (OclTerm)
| simple_name of unit -> (string)
| op_constraint_stereotype_cs of unit -> (Context.ConditionType)
| definition_cs of unit -> (OclTerm)
| invariant_cs of unit -> (OclTerm)
| guard_constraint_cs of unit -> ( ( string option*OclTerm ) )
| guard_constraint_cs_p of unit -> ( ( string option*OclTerm ) list)
| operation_constraint_cs of unit -> ( ( Context.ConditionType*string option*OclTerm ) )
| operation_constraint_cs_p of unit -> ( ( Context.ConditionType*string option*OclTerm ) list)
| operation_signature_cs of unit -> ( ( string * OclType ) list)
| classifier_constraint_cs of unit -> ( ( string option*OclTerm ) )
| classifier_constraint_cs_p of unit -> ( ( string option*OclTerm ) list)
| init_or_der_value_cs of unit -> ( ( AttrOrAssoc*OclTerm ) )
| init_or_der_value_cs_p of unit -> ( ( AttrOrAssoc*OclTerm ) list)
| type_specifier of unit -> (OclType)
| guard_context_declaration_cs of unit -> (context list)
| operation_context_declaration_cs of unit -> (context list)
| classifier_context_declaration_cs of unit -> (context list)
| attr_or_assoc_cs of unit -> (context list)
| context_declaration_cs of unit -> (context list)
| context_declaration_list_cs of unit -> (context list)
| path_name_head_cs of unit -> (Path)
| path_name_cs of unit -> (Path)
| package_constraint_list_cs of unit -> (context list)
| package_constraint_list_cs_p of unit -> (context list)
| ocl_file of unit -> ( ( context list * Classifier list ) )
| RealLiteralExp of unit -> (Rep_OclTerm.OclTerm)
| StringLiteralExp of unit -> (Rep_OclTerm.OclTerm)
| BooleanLiteralExp of unit -> (Rep_OclTerm.OclTerm)
| IntegerLiteralExp of unit -> (Rep_OclTerm.OclTerm)
| PrimitiveLiteralExp of unit -> (Rep_OclTerm.OclTerm)
| LiteralExp of unit -> (OclTerm)
| OclExpression of unit -> (Rep_OclTerm.OclTerm)
| START of unit -> ( ( context list * Classifier list ) )
end
type svalue = MlyValue.svalue
type result = ( context list * Classifier list )
end
structure EC=
struct
open LrTable
infix 5 $$
fun x $$ y = y::x
val is_keyword =
fn _ => false
val preferred_change : (term list * term list) list =
nil
val noShift =
fn (T 0) => true | _ => false
val showTerminal =
fn (T 0) => "EOF"
| (T 1) => "TICK"
| (T 2) => "COMMA"
| (T 3) => "ARROW_RIGHT"
| (T 4) => "DOT"
| (T 5) => "DBL_DOT"
| (T 6) => "COLON"
| (T 7) => "DBL_COLON"
| (T 8) => "SEMI_COLON"
| (T 9) => "EQUALS"
| (T 10) => "QUESTION_MARK"
| (T 11) => "HASH"
| (T 12) => "AT_PRE"
| (T 13) => "BAG"
| (T 14) => "COLLECTION"
| (T 15) => "SEQUENCE"
| (T 16) => "ORDERED_SET"
| (T 17) => "SET"
| (T 18) => "TUPLE"
| (T 19) => "TUPLE_TYPE"
| (T 20) => "BRACKET_OPEN"
| (T 21) => "BRACKET_CLOSE"
| (T 22) => "CARAT"
| (T 23) => "DBL_CARAT"
| (T 24) => "BODY"
| (T 25) => "CONTEXT"
| (T 26) => "DEF"
| (T 27) => "DERIVE"
| (T 28) => "ELSE"
| (T 29) => "ENDIF"
| (T 30) => "ENDPACKAGE"
| (T 31) => "FALSE"
| (T 32) => "NULL"
| (T 33) => "FORALL"
| (T 34) => "TRUE"
| (T 35) => "IF"
| (T 36) => "IN"
| (T 37) => "INIT"
| (T 38) => "INV"
| (T 39) => "LET"
| (T 40) => "PACKAGE"
| (T 41) => "PRE"
| (T 42) => "POST"
| (T 43) => "THEN"
| (T 44) => "PAREN_OPEN"
| (T 45) => "PAREN_CLOSE"
| (T 46) => "BRACE_OPEN"
| (T 47) => "BRACE_CLOSE"
| (T 48) => "VERTICAL_BAR"
| (T 49) => "GUARD"
| (T 50) => "ITERATE"
| (T 51) => "SELECT"
| (T 52) => "REJECT"
| (T 53) => "COLLECT"
| (T 54) => "ANY"
| (T 55) => "EXISTS"
| (T 56) => "ONE"
| (T 57) => "ISUNIQUE"
| (T 58) => "OCLISTYPEOF"
| (T 59) => "OCLISKINDOF"
| (T 60) => "OCLASTYPE"
| (T 61) => "MINUS"
| (T 62) => "STAR"
| (T 63) => "SLASH"
| (T 64) => "PLUS"
| (T 65) => "REL_NOTEQUAL"
| (T 66) => "REL_GT"
| (T 67) => "REL_LT"
| (T 68) => "REL_GTE"
| (T 69) => "REL_LTE"
| (T 70) => "LOG_AND"
| (T 71) => "LOG_OR"
| (T 72) => "LOG_XOR"
| (T 73) => "LOG_IMPL"
| (T 74) => "NOT"
| (T 75) => "INTEGER_LITERAL"
| (T 76) => "REAL_LITERAL"
| (T 77) => "STRING_LITERAL"
| (T 78) => "SIMPLE_NAME"
| (T 79) => "MODEL"
| (T 80) => "OPERATIONS"
| (T 81) => "ATTRIBUTES"
| (T 82) => "ASSOCIATIONS"
| (T 83) => "BETWEEN"
| (T 84) => "END"
| (T 85) => "CONSTRAINTS"
| (T 86) => "CLASS"
| _ => "bogus-term"
local open Header in
val errtermvalue=
fn _ => MlyValue.VOID
end
val terms : term list = nil
$$ (T 0)end
structure Actions =
struct
type int = Int.int
exception mlyAction of int
local open Header in
val actions =
fn (i392:int,defaultPos,stack,
(()):arg) =>
case (i392,stack)
of ( 0, ( ( _, ( MlyValue.ocl_file ocl_file1, ocl_file1left,
ocl_file1right)) :: rest671)) => let val result = MlyValue.START (fn
_ => let val (ocl_file as ocl_file1) = ocl_file1 ()
in (ocl_file)
end)
in ( LrTable.NT 0, ( result, ocl_file1left, ocl_file1right), rest671)
end
| ( 1, ( ( _, ( MlyValue.package_constraint_list_cs_p
package_constraint_list_cs_p1, package_constraint_list_cs_p1left,
package_constraint_list_cs_p1right)) :: rest671)) => let val result =
MlyValue.ocl_file (fn _ => let val (package_constraint_list_cs_p as
package_constraint_list_cs_p1) = package_constraint_list_cs_p1 ()
in (package_constraint_list_cs_p,[])
end)
in ( LrTable.NT 8, ( result, package_constraint_list_cs_p1left,
package_constraint_list_cs_p1right), rest671)
end
| ( 2, ( ( _, ( MlyValue.model_spec_cs model_spec_cs1,
model_spec_cs1left, model_spec_cs1right)) :: rest671)) => let val
result = MlyValue.ocl_file (fn _ => let val (model_spec_cs as
model_spec_cs1) = model_spec_cs1 ()
in ([],model_spec_cs)
end)
in ( LrTable.NT 8, ( result, model_spec_cs1left, model_spec_cs1right)
, rest671)
end
| ( 3, ( ( _, ( MlyValue.model_spec_cs model_spec_cs1, _,
model_spec_cs1right)) :: ( _, ( MlyValue.package_constraint_list_cs_p
package_constraint_list_cs_p1, package_constraint_list_cs_p1left, _))
:: rest671)) => let val result = MlyValue.ocl_file (fn _ => let val
(package_constraint_list_cs_p as package_constraint_list_cs_p1) =
package_constraint_list_cs_p1 ()
val (model_spec_cs as model_spec_cs1) = model_spec_cs1 ()
in (package_constraint_list_cs_p,model_spec_cs)
end)
in ( LrTable.NT 8, ( result, package_constraint_list_cs_p1left,
model_spec_cs1right), rest671)
end
| ( 4, ( ( _, ( MlyValue.package_constraint_list_cs_p
package_constraint_list_cs_p1, _, package_constraint_list_cs_p1right))
:: ( _, ( MlyValue.model_spec_cs model_spec_cs1, model_spec_cs1left,
_)) :: rest671)) => let val result = MlyValue.ocl_file (fn _ => let
val (model_spec_cs as model_spec_cs1) = model_spec_cs1 ()
val (package_constraint_list_cs_p as package_constraint_list_cs_p1)
= package_constraint_list_cs_p1 ()
in (package_constraint_list_cs_p,model_spec_cs)
end)
in ( LrTable.NT 8, ( result, model_spec_cs1left,
package_constraint_list_cs_p1right), rest671)
end
| ( 5, ( ( _, ( MlyValue.package_constraint_list_cs
package_constraint_list_cs1, package_constraint_list_cs1left,
package_constraint_list_cs1right)) :: rest671)) => let val result =
MlyValue.package_constraint_list_cs_p (fn _ => let val (
package_constraint_list_cs as package_constraint_list_cs1) =
package_constraint_list_cs1 ()
in (package_constraint_list_cs)
end)
in ( LrTable.NT 9, ( result, package_constraint_list_cs1left,
package_constraint_list_cs1right), rest671)
end
| ( 6, ( ( _, ( MlyValue.package_constraint_list_cs_p
package_constraint_list_cs_p1, _, package_constraint_list_cs_p1right))
:: ( _, ( MlyValue.package_constraint_list_cs
package_constraint_list_cs1, package_constraint_list_cs1left, _)) ::
rest671)) => let val result = MlyValue.package_constraint_list_cs_p
(fn _ => let val (package_constraint_list_cs as
package_constraint_list_cs1) = package_constraint_list_cs1 ()
val (package_constraint_list_cs_p as package_constraint_list_cs_p1)
= package_constraint_list_cs_p1 ()
in (package_constraint_list_cs@package_constraint_list_cs_p)
end)
in ( LrTable.NT 9, ( result, package_constraint_list_cs1left,
package_constraint_list_cs_p1right), rest671)
end
| ( 7, ( ( _, ( MlyValue.ENDPACKAGE ENDPACKAGE1, _, ENDPACKAGE1right)
) :: ( _, ( MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, (
MlyValue.PACKAGE PACKAGE1, PACKAGE1left, _)) :: rest671)) => let val
result = MlyValue.package_constraint_list_cs (fn _ => let val
PACKAGE1 = PACKAGE1 ()
val path_name_cs1 = path_name_cs1 ()
val ENDPACKAGE1 = ENDPACKAGE1 ()
in (
Logger.debug3 ("Starts creatind empty package ... " ^ "\n"); ([Empty_context ("this is an empty context", Literal ("empty",OclVoid))])
)
end)
in ( LrTable.NT 10, ( result, PACKAGE1left, ENDPACKAGE1right),
rest671)
end
| ( 8, ( ( _, ( MlyValue.ENDPACKAGE ENDPACKAGE1, _, ENDPACKAGE1right)
) :: ( _, ( MlyValue.context_declaration_list_cs
context_declaration_list_cs1, _, _)) :: ( _, ( MlyValue.path_name_cs
path_name_cs1, _, _)) :: ( _, ( MlyValue.PACKAGE PACKAGE1,
PACKAGE1left, _)) :: rest671)) => let val result =
MlyValue.package_constraint_list_cs (fn _ => let val PACKAGE1 =
PACKAGE1 ()
val (path_name_cs as path_name_cs1) = path_name_cs1 ()
val (context_declaration_list_cs as context_declaration_list_cs1) =
context_declaration_list_cs1 ()
val ENDPACKAGE1 = ENDPACKAGE1 ()
in (
Logger.debug3 ("Starts creating contextes ..." ^ "\n"); (list_extend_path path_name_cs context_declaration_list_cs)
)
end)
in ( LrTable.NT 10, ( result, PACKAGE1left, ENDPACKAGE1right),
rest671)
end
| ( 9, ( ( _, ( MlyValue.context_declaration_cs
context_declaration_cs1, context_declaration_cs1left,
context_declaration_cs1right)) :: rest671)) => let val result =
MlyValue.context_declaration_list_cs (fn _ => let val (
context_declaration_cs as context_declaration_cs1) =
context_declaration_cs1 ()
in (context_declaration_cs)
end)
in ( LrTable.NT 13, ( result, context_declaration_cs1left,
context_declaration_cs1right), rest671)
end
| ( 10, ( ( _, ( MlyValue.context_declaration_list_cs
context_declaration_list_cs1, _, context_declaration_list_cs1right))
:: ( _, ( MlyValue.context_declaration_cs context_declaration_cs1,
context_declaration_cs1left, _)) :: rest671)) => let val result =
MlyValue.context_declaration_list_cs (fn _ => let val (
context_declaration_cs as context_declaration_cs1) =
context_declaration_cs1 ()
val (context_declaration_list_cs as context_declaration_list_cs1) =
context_declaration_list_cs1 ()
in (context_declaration_cs@context_declaration_list_cs)
end)
in ( LrTable.NT 13, ( result, context_declaration_cs1left,
context_declaration_list_cs1right), rest671)
end
| ( 11, ( ( _, ( MlyValue.attr_or_assoc_cs attr_or_assoc_cs1,
attr_or_assoc_cs1left, attr_or_assoc_cs1right)) :: rest671)) => let
val result = MlyValue.context_declaration_cs (fn _ => let val (
attr_or_assoc_cs as attr_or_assoc_cs1) = attr_or_assoc_cs1 ()
in (attr_or_assoc_cs)
end)
in ( LrTable.NT 14, ( result, attr_or_assoc_cs1left,
attr_or_assoc_cs1right), rest671)
end
| ( 12, ( ( _, ( MlyValue.classifier_context_declaration_cs
classifier_context_declaration_cs1,
classifier_context_declaration_cs1left,
classifier_context_declaration_cs1right)) :: rest671)) => let val
result = MlyValue.context_declaration_cs (fn _ => let val (
classifier_context_declaration_cs as
classifier_context_declaration_cs1) =
classifier_context_declaration_cs1 ()
in (classifier_context_declaration_cs)
end)
in ( LrTable.NT 14, ( result, classifier_context_declaration_cs1left,
classifier_context_declaration_cs1right), rest671)
end
| ( 13, ( ( _, ( MlyValue.operation_context_declaration_cs
operation_context_declaration_cs1,
operation_context_declaration_cs1left,
operation_context_declaration_cs1right)) :: rest671)) => let val
result = MlyValue.context_declaration_cs (fn _ => let val (
operation_context_declaration_cs as operation_context_declaration_cs1)
= operation_context_declaration_cs1 ()
in (operation_context_declaration_cs)
end)
in ( LrTable.NT 14, ( result, operation_context_declaration_cs1left,
operation_context_declaration_cs1right), rest671)
end
| ( 14, ( ( _, ( MlyValue.guard_context_declaration_cs
guard_context_declaration_cs1, guard_context_declaration_cs1left,
guard_context_declaration_cs1right)) :: rest671)) => let val result =
MlyValue.context_declaration_cs (fn _ => let val (
guard_context_declaration_cs as guard_context_declaration_cs1) =
guard_context_declaration_cs1 ()
in (guard_context_declaration_cs)
end)
in ( LrTable.NT 14, ( result, guard_context_declaration_cs1left,
guard_context_declaration_cs1right), rest671)
end
| ( 15, ( ( _, ( MlyValue.init_or_der_value_cs_p
init_or_der_value_cs_p1, _, init_or_der_value_cs_p1right)) :: ( _, (
MlyValue.type_specifier type_specifier1, _, _)) :: ( _, (
MlyValue.COLON COLON1, _, _)) :: ( _, ( MlyValue.path_name_cs
path_name_cs1, _, _)) :: ( _, ( MlyValue.CONTEXT CONTEXT1,
CONTEXT1left, _)) :: rest671)) => let val result =
MlyValue.attr_or_assoc_cs (fn _ => let val CONTEXT1 = CONTEXT1 ()
val (path_name_cs as path_name_cs1) = path_name_cs1 ()
val COLON1 = COLON1 ()
val (type_specifier as type_specifier1) = type_specifier1 ()
val (init_or_der_value_cs_p as init_or_der_value_cs_p1) =
init_or_der_value_cs_p1 ()
in (attr_list (path_name_cs, type_specifier, init_or_der_value_cs_p))
end)
in ( LrTable.NT 15, ( result, CONTEXT1left,
init_or_der_value_cs_p1right), rest671)
end
| ( 16, ( ( _, ( MlyValue.SIMPLE_NAME SIMPLE_NAME1, SIMPLE_NAME1left,
SIMPLE_NAME1right)) :: rest671)) => let val result =
MlyValue.simple_name (fn _ => let val (SIMPLE_NAME as SIMPLE_NAME1) =
SIMPLE_NAME1 ()
in (Logger.debug3 ("simple_name..." ^ "\n");SIMPLE_NAME)
end)
in ( LrTable.NT 32, ( result, SIMPLE_NAME1left, SIMPLE_NAME1right),
rest671)
end
| ( 17, ( ( _, ( MlyValue.classifier_constraint_cs_p
classifier_constraint_cs_p1, _, classifier_constraint_cs_p1right)) ::
( _, ( MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, (
MlyValue.CONTEXT CONTEXT1, CONTEXT1left, _)) :: rest671)) => let val
result = MlyValue.classifier_context_declaration_cs (fn _ => let val
CONTEXT1 = CONTEXT1 ()
val (path_name_cs as path_name_cs1) = path_name_cs1 ()
val (classifier_constraint_cs_p as classifier_constraint_cs_p1) =
classifier_constraint_cs_p1 ()
in (inv_list (path_name_cs, classifier_constraint_cs_p))
end)
in ( LrTable.NT 16, ( result, CONTEXT1left,
classifier_constraint_cs_p1right), rest671)
end
| ( 18, ( ( _, ( MlyValue.operation_constraint_cs_p
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
_, ( MlyValue.operation_signature_cs operation_signature_cs1, _, _))
:: ( _, ( MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, (
MlyValue.CONTEXT CONTEXT1, CONTEXT1left, _)) :: rest671)) => let val
result = MlyValue.operation_context_declaration_cs (fn _ => let val
CONTEXT1 = CONTEXT1 ()
val (path_name_cs as path_name_cs1) = path_name_cs1 ()
val (operation_signature_cs as operation_signature_cs1) =
operation_signature_cs1 ()
val (operation_constraint_cs_p as operation_constraint_cs_p1) =
operation_constraint_cs_p1 ()
in (
cond_list (path_name_cs, operation_signature_cs, operation_constraint_cs_p)
)
end)
in ( LrTable.NT 17, ( result, CONTEXT1left,
operation_constraint_cs_p1right), rest671)
end
| ( 19, ( ( _, ( MlyValue.guard_constraint_cs_p
guard_constraint_cs_p1, _, guard_constraint_cs_p1right)) :: ( _, (
MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, ( MlyValue.CONTEXT
CONTEXT1, CONTEXT1left, _)) :: rest671)) => let val result =
MlyValue.guard_context_declaration_cs (fn _ => let val CONTEXT1 =
CONTEXT1 ()
val (path_name_cs as path_name_cs1) = path_name_cs1 ()
val (guard_constraint_cs_p as guard_constraint_cs_p1) =
guard_constraint_cs_p1 ()
in (guard_list (real_path (path_name_cs), guard_constraint_cs_p))
end
)
in ( LrTable.NT 18, ( result, CONTEXT1left,
guard_constraint_cs_p1right), rest671)
end
| ( 20, ( ( _, ( MlyValue.init_or_der_value_cs init_or_der_value_cs1,
init_or_der_value_cs1left, init_or_der_value_cs1right)) :: rest671))
=> let val result = MlyValue.init_or_der_value_cs_p (fn _ => let
val (init_or_der_value_cs as init_or_der_value_cs1) =
init_or_der_value_cs1 ()
in ([init_or_der_value_cs])
end)
in ( LrTable.NT 20, ( result, init_or_der_value_cs1left,
init_or_der_value_cs1right), rest671)
end
| ( 21, ( ( _, ( MlyValue.init_or_der_value_cs_p
init_or_der_value_cs_p1, _, init_or_der_value_cs_p1right)) :: ( _, (
MlyValue.init_or_der_value_cs init_or_der_value_cs1,
init_or_der_value_cs1left, _)) :: rest671)) => let val result =
MlyValue.init_or_der_value_cs_p (fn _ => let val (
init_or_der_value_cs as init_or_der_value_cs1) = init_or_der_value_cs1
()
val (init_or_der_value_cs_p as init_or_der_value_cs_p1) =
init_or_der_value_cs_p1 ()
in ([init_or_der_value_cs]@init_or_der_value_cs_p)
end)
in ( LrTable.NT 20, ( result, init_or_der_value_cs1left,
init_or_der_value_cs_p1right), rest671)
end
| ( 22, ( ( _, ( MlyValue.classifier_constraint_cs
classifier_constraint_cs1, classifier_constraint_cs1left,
classifier_constraint_cs1right)) :: rest671)) => let val result =
MlyValue.classifier_constraint_cs_p (fn _ => let val (
classifier_constraint_cs as classifier_constraint_cs1) =
classifier_constraint_cs1 ()
in ([classifier_constraint_cs])
end)
in ( LrTable.NT 22, ( result, classifier_constraint_cs1left,
classifier_constraint_cs1right), rest671)
end
| ( 23, ( ( _, ( MlyValue.classifier_constraint_cs_p
classifier_constraint_cs_p1, _, classifier_constraint_cs_p1right)) ::
( _, ( MlyValue.classifier_constraint_cs classifier_constraint_cs1,
classifier_constraint_cs1left, _)) :: rest671)) => let val result =
MlyValue.classifier_constraint_cs_p (fn _ => let val (
classifier_constraint_cs as classifier_constraint_cs1) =
classifier_constraint_cs1 ()
val (classifier_constraint_cs_p as classifier_constraint_cs_p1) =
classifier_constraint_cs_p1 ()
in ([classifier_constraint_cs]@classifier_constraint_cs_p)
end)
in ( LrTable.NT 22, ( result, classifier_constraint_cs1left,
classifier_constraint_cs_p1right), rest671)
end
| ( 24, ( ( _, ( MlyValue.operation_constraint_cs
operation_constraint_cs1, operation_constraint_cs1left,
operation_constraint_cs1right)) :: rest671)) => let val result =
MlyValue.operation_constraint_cs_p (fn _ => let val (
operation_constraint_cs as operation_constraint_cs1) =
operation_constraint_cs1 ()
in ([operation_constraint_cs])
end)
in ( LrTable.NT 25, ( result, operation_constraint_cs1left,
operation_constraint_cs1right), rest671)
end
| ( 25, ( ( _, ( MlyValue.operation_constraint_cs_p
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
_, ( MlyValue.operation_constraint_cs operation_constraint_cs1,
operation_constraint_cs1left, _)) :: rest671)) => let val result =
MlyValue.operation_constraint_cs_p (fn _ => let val (
operation_constraint_cs as operation_constraint_cs1) =
operation_constraint_cs1 ()
val (operation_constraint_cs_p as operation_constraint_cs_p1) =
operation_constraint_cs_p1 ()
in ([operation_constraint_cs]@operation_constraint_cs_p)
end)
in ( LrTable.NT 25, ( result, operation_constraint_cs1left,
operation_constraint_cs_p1right), rest671)
end
| ( 26, ( ( _, ( MlyValue.guard_constraint_cs guard_constraint_cs1,
guard_constraint_cs1left, guard_constraint_cs1right)) :: rest671)) =>
let val result = MlyValue.guard_constraint_cs_p (fn _ => let val (
guard_constraint_cs as guard_constraint_cs1) = guard_constraint_cs1 ()
in ([guard_constraint_cs])
end)
in ( LrTable.NT 27, ( result, guard_constraint_cs1left,
guard_constraint_cs1right), rest671)
end
| ( 27, ( ( _, ( MlyValue.guard_constraint_cs_p
guard_constraint_cs_p1, _, guard_constraint_cs_p1right)) :: ( _, (
MlyValue.guard_constraint_cs guard_constraint_cs1,
guard_constraint_cs1left, _)) :: rest671)) => let val result =
MlyValue.guard_constraint_cs_p (fn _ => let val (guard_constraint_cs
as guard_constraint_cs1) = guard_constraint_cs1 ()
val (guard_constraint_cs_p as guard_constraint_cs_p1) =
guard_constraint_cs_p1 ()
in ([guard_constraint_cs]@guard_constraint_cs_p)
end)
in ( LrTable.NT 27, ( result, guard_constraint_cs1left,
guard_constraint_cs_p1right), rest671)
end
| ( 28, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.INIT INIT1, INIT1left, _)) :: rest671)) => let val
result = MlyValue.init_or_der_value_cs (fn _ => let val (INIT as
INIT1) = INIT1 ()
val COLON1 = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (INIT, ocl_expression_cs)
end)
in ( LrTable.NT 21, ( result, INIT1left, ocl_expression_cs1right),
rest671)
end
| ( 29, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.DERIVE DERIVE1, DERIVE1left, _)) :: rest671)) => let
val result = MlyValue.init_or_der_value_cs (fn _ => let val (DERIVE
as DERIVE1) = DERIVE1 ()
val COLON1 = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (DERIVE, ocl_expression_cs)
end)
in ( LrTable.NT 21, ( result, DERIVE1left, ocl_expression_cs1right),
rest671)
end
| ( 30, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.INV INV1, INV1left, _)) :: rest671)) => let val result
= MlyValue.classifier_constraint_cs (fn _ => let val (INV as INV1) =
INV1 ()
val (COLON as COLON1) = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (
Logger.debug3 ("INV COLON ocl_expression_cs ..." ^ "\n"); (NONE,ocl_expression_cs)
)
end)
in ( LrTable.NT 23, ( result, INV1left, ocl_expression_cs1right),
rest671)
end
| ( 31, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.simple_name simple_name1, _, _)) :: ( _, ( MlyValue.INV
INV1, INV1left, _)) :: rest671)) => let val result =
MlyValue.classifier_constraint_cs (fn _ => let val (INV as INV1) =
INV1 ()
val (simple_name as simple_name1) = simple_name1 ()
val (COLON as COLON1) = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (
Logger.debug3 ("INV simple_name COLON ocl_expression_cs ..." ^ "\n");(SOME(simple_name),ocl_expression_cs)
)
end)
in ( LrTable.NT 23, ( result, INV1left, ocl_expression_cs1right),
rest671)
end
| ( 32, ( ( _, ( MlyValue.definition_constraint_cs
definition_constraint_cs1, _, definition_constraint_cs1right)) :: ( _,
( MlyValue.COLON COLON1, _, _)) :: ( _, ( MlyValue.DEF DEF1, DEF1left
, _)) :: rest671)) => let val result =
MlyValue.classifier_constraint_cs (fn _ => let val DEF1 = DEF1 ()
val COLON1 = COLON1 ()
val (definition_constraint_cs as definition_constraint_cs1) =
definition_constraint_cs1 ()
in (NONE,definition_constraint_cs)
end)
in ( LrTable.NT 23, ( result, DEF1left,
definition_constraint_cs1right), rest671)
end
| ( 33, ( ( _, ( MlyValue.definition_constraint_cs
definition_constraint_cs1, _, definition_constraint_cs1right)) :: ( _,
( MlyValue.COLON COLON1, _, _)) :: ( _, ( MlyValue.simple_name
simple_name1, _, _)) :: ( _, ( MlyValue.DEF DEF1, DEF1left, _)) ::
rest671)) => let val result = MlyValue.classifier_constraint_cs (fn _
=> let val DEF1 = DEF1 ()
val (simple_name as simple_name1) = simple_name1 ()
val COLON1 = COLON1 ()
val (definition_constraint_cs as definition_constraint_cs1) =
definition_constraint_cs1 ()
in (SOME(simple_name),definition_constraint_cs)
end)
in ( LrTable.NT 23, ( result, DEF1left,
definition_constraint_cs1right), rest671)
end
| ( 34, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.op_constraint_stereotype_cs
op_constraint_stereotype_cs1, op_constraint_stereotype_cs1left, _)) ::
rest671)) => let val result = MlyValue.operation_constraint_cs (fn _
=> let val (op_constraint_stereotype_cs as
op_constraint_stereotype_cs1) = op_constraint_stereotype_cs1 ()
val COLON1 = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (
Logger.debug3 ("operation_constraint_cs 1..." ^ "\n"); (op_constraint_stereotype_cs,NONE,ocl_expression_cs)
)
end)
in ( LrTable.NT 26, ( result, op_constraint_stereotype_cs1left,
ocl_expression_cs1right), rest671)
end
| ( 35, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.simple_name simple_name1, _, _)) :: ( _, (
MlyValue.op_constraint_stereotype_cs op_constraint_stereotype_cs1,
op_constraint_stereotype_cs1left, _)) :: rest671)) => let val result
= MlyValue.operation_constraint_cs (fn _ => let val (
op_constraint_stereotype_cs as op_constraint_stereotype_cs1) =
op_constraint_stereotype_cs1 ()
val (simple_name as simple_name1) = simple_name1 ()
val COLON1 = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (
Logger.debug3 ("operation_constraint_cs 23454..." ^ "\n"); (op_constraint_stereotype_cs,SOME(simple_name),ocl_expression_cs)
)
end)
in ( LrTable.NT 26, ( result, op_constraint_stereotype_cs1left,
ocl_expression_cs1right), rest671)
end
| ( 36, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.GUARD GUARD1, GUARD1left, _)) :: rest671)) => let val
result = MlyValue.guard_constraint_cs (fn _ => let val GUARD1 =
GUARD1 ()
val COLON1 = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (NONE,ocl_expression_cs)
end)
in ( LrTable.NT 28, ( result, GUARD1left, ocl_expression_cs1right),
rest671)
end
| ( 37, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
_, ( MlyValue.simple_name simple_name1, _, _)) :: ( _, (
MlyValue.GUARD GUARD1, GUARD1left, _)) :: rest671)) => let val result
= MlyValue.guard_constraint_cs (fn _ => let val GUARD1 = GUARD1 ()
val (simple_name as simple_name1) = simple_name1 ()
val COLON1 = COLON1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (SOME(simple_name),ocl_expression_cs)
end)
in ( LrTable.NT 28, ( result, GUARD1left, ocl_expression_cs1right),
rest671)
end
| ( 38, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.EQUALS EQUALS1, _, _)) ::
( _, ( MlyValue.defined_entity_decl_cs defined_entity_decl_cs1,
defined_entity_decl_cs1left, _)) :: rest671)) => let val result =
MlyValue.definition_constraint_cs (fn _ => let val (
defined_entity_decl_cs as defined_entity_decl_cs1) =
defined_entity_decl_cs1 ()
val (EQUALS as EQUALS1) = EQUALS1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (
OperationCall (defined_entity_decl_cs,DummyT,[OclLibPackage,"DummyT",EQUALS],[(ocl_expression_cs,DummyT)],DummyT)
)
end)
in ( LrTable.NT 33, ( result, defined_entity_decl_cs1left,
ocl_expression_cs1right), rest671)
end
| ( 39, ( ( _, ( MlyValue.ocl_attribute_defined_entity_decl_cs
ocl_attribute_defined_entity_decl_cs1,
ocl_attribute_defined_entity_decl_cs1left,
ocl_attribute_defined_entity_decl_cs1right)) :: rest671)) => let val
result = MlyValue.defined_entity_decl_cs (fn _ => let val (
ocl_attribute_defined_entity_decl_cs as
ocl_attribute_defined_entity_decl_cs1) =
ocl_attribute_defined_entity_decl_cs1 ()
in (
Logger.debug3 ("AttributeCall 1 ..." ^ "\n");AttributeCall (Literal ("self2",DummyT),DummyT,[#1(ocl_attribute_defined_entity_decl_cs)],#2(ocl_attribute_defined_entity_decl_cs))
)
end)
in ( LrTable.NT 34, ( result,
ocl_attribute_defined_entity_decl_cs1left,
ocl_attribute_defined_entity_decl_cs1right), rest671)
end
| ( 40, ( ( _, ( MlyValue.ocl_operation_defined_entity_decl_cs
ocl_operation_defined_entity_decl_cs1,
ocl_operation_defined_entity_decl_cs1left,
ocl_operation_defined_entity_decl_cs1right)) :: rest671)) => let val
result = MlyValue.defined_entity_decl_cs (fn _ => let val (
ocl_operation_defined_entity_decl_cs as
ocl_operation_defined_entity_decl_cs1) =
ocl_operation_defined_entity_decl_cs1 ()
in (
OperationCall (Literal ("self2",DummyT),DummyT,[#1(ocl_operation_defined_entity_decl_cs)],List.map gen_literal_term (real_signature (#2(ocl_operation_defined_entity_decl_cs))),#2(List.last (#2(ocl_operation_defined_entity_decl_cs))))
)
end)
in ( LrTable.NT 34, ( result,
ocl_operation_defined_entity_decl_cs1left,
ocl_operation_defined_entity_decl_cs1right), rest671)
end
| ( 41, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1,
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
let val result = MlyValue.ocl_attribute_defined_entity_decl_cs (fn _
=> let val (formal_parameter_cs as formal_parameter_cs1) =
formal_parameter_cs1 ()
in (formal_parameter_cs)
end)
in ( LrTable.NT 35, ( result, formal_parameter_cs1left,
formal_parameter_cs1right), rest671)
end
| ( 42, ( ( _, ( MlyValue.operation_signature_cs
operation_signature_cs1, _, operation_signature_cs1right)) :: ( _, (
MlyValue.simple_name simple_name1, simple_name1left, _)) :: rest671))
=> let val result = MlyValue.ocl_operation_defined_entity_decl_cs
(fn _ => let val (simple_name as simple_name1) = simple_name1 ()
val (operation_signature_cs as operation_signature_cs1) =
operation_signature_cs1 ()
in (simple_name,operation_signature_cs)
end)
in ( LrTable.NT 36, ( result, simple_name1left,
operation_signature_cs1right), rest671)
end
| ( 43, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1,
PAREN_OPEN1left, _)) :: rest671)) => let val result =
MlyValue.operation_signature_cs (fn _ => let val PAREN_OPEN1 =
PAREN_OPEN1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (
Logger.debug3 ("operation_signature_cs ..." ^ "\n");[("",OclVoid)])
end)
in ( LrTable.NT 24, ( result, PAREN_OPEN1left, PAREN_CLOSE1right),
rest671)
end
| ( 44, ( ( _, ( MlyValue.operation_return_type_specifier_cs
operation_return_type_specifier_cs1, _,
operation_return_type_specifier_cs1right)) :: ( _, (
MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, (
MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)) :: rest671)) =>
let val result = MlyValue.operation_signature_cs (fn _ => let val
PAREN_OPEN1 = PAREN_OPEN1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
val (operation_return_type_specifier_cs as
operation_return_type_specifier_cs1) =
operation_return_type_specifier_cs1 ()
in (
Logger.debug3 ("operation_signature_cs ..." ^ "\n");[("",operation_return_type_specifier_cs)]
)
end)
in ( LrTable.NT 24, ( result, PAREN_OPEN1left,
operation_return_type_specifier_cs1right), rest671)
end
| ( 45, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.formal_parameter_list_cs
formal_parameter_list_cs1, _, _)) :: ( _, ( MlyValue.PAREN_OPEN
PAREN_OPEN1, PAREN_OPEN1left, _)) :: rest671)) => let val result =
MlyValue.operation_signature_cs (fn _ => let val PAREN_OPEN1 =
PAREN_OPEN1 ()
val (formal_parameter_list_cs as formal_parameter_list_cs1) =
formal_parameter_list_cs1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (
Logger.debug3 ("operation_signature_cs ..." ^ "\n");formal_parameter_list_cs@[("",OclVoid)]
)
end)
in ( LrTable.NT 24, ( result, PAREN_OPEN1left, PAREN_CLOSE1right),
rest671)
end
| ( 46, ( ( _, ( MlyValue.operation_return_type_specifier_cs
operation_return_type_specifier_cs1, _,
operation_return_type_specifier_cs1right)) :: ( _, (
MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, (
MlyValue.formal_parameter_list_cs formal_parameter_list_cs1, _, _)) ::
( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)) ::
rest671)) => let val result = MlyValue.operation_signature_cs (fn _
=> let val PAREN_OPEN1 = PAREN_OPEN1 ()
val (formal_parameter_list_cs as formal_parameter_list_cs1) =
formal_parameter_list_cs1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
val (operation_return_type_specifier_cs as
operation_return_type_specifier_cs1) =
operation_return_type_specifier_cs1 ()
in (
Logger.debug3 ("operation_signature_cs ..." ^ "\n");formal_parameter_list_cs@[("",operation_return_type_specifier_cs)]
)
end)
in ( LrTable.NT 24, ( result, PAREN_OPEN1left,
operation_return_type_specifier_cs1right), rest671)
end
| ( 47, ( ( _, ( MlyValue.type_specifier type_specifier1, _,
type_specifier1right)) :: ( _, ( MlyValue.COLON COLON1, COLON1left, _)
) :: rest671)) => let val result =
MlyValue.operation_return_type_specifier_cs (fn _ => let val COLON1 =
COLON1 ()
val (type_specifier as type_specifier1) = type_specifier1 ()
in (
Logger.debug3 ("Contextes created form list of Attributes ..." ^ "\n");type_specifier
)
end)
in ( LrTable.NT 40, ( result, COLON1left, type_specifier1right),
rest671)
end
| ( 48, ( ( _, ( MlyValue.PRE PRE1, PRE1left, PRE1right)) :: rest671)
) => let val result = MlyValue.op_constraint_stereotype_cs (fn _ =>
let val (PRE as PRE1) = PRE1 ()
in (PRE)
end)
in ( LrTable.NT 31, ( result, PRE1left, PRE1right), rest671)
end
| ( 49, ( ( _, ( MlyValue.POST POST1, POST1left, POST1right)) ::
rest671)) => let val result = MlyValue.op_constraint_stereotype_cs
(fn _ => let val (POST as POST1) = POST1 ()
in (POST)
end)
in ( LrTable.NT 31, ( result, POST1left, POST1right), rest671)
end
| ( 50, ( ( _, ( MlyValue.BODY BODY1, BODY1left, BODY1right)) ::
rest671)) => let val result = MlyValue.op_constraint_stereotype_cs
(fn _ => let val (BODY as BODY1) = BODY1 ()
in (BODY)
end)
in ( LrTable.NT 31, ( result, BODY1left, BODY1right), rest671)
end
| ( 51, ( ( _, ( MlyValue.BRACE_CLOSE BRACE_CLOSE1, _,
BRACE_CLOSE1right)) :: ( _, ( MlyValue.BRACE_OPEN BRACE_OPEN1, _, _))
:: ( _, ( MlyValue.collection_type_identifier_cs
collection_type_identifier_cs1, collection_type_identifier_cs1left, _)
) :: rest671)) => let val result = MlyValue.collection_literal_exp_cs
(fn _ => let val (collection_type_identifier_cs as
collection_type_identifier_cs1) = collection_type_identifier_cs1 ()
val BRACE_OPEN1 = BRACE_OPEN1 ()
val BRACE_CLOSE1 = BRACE_CLOSE1 ()
in (
CollectionLiteral ([],create_set (collection_type_identifier_cs,DummyT))
)
end)
in ( LrTable.NT 63, ( result, collection_type_identifier_cs1left,
BRACE_CLOSE1right), rest671)
end
| ( 52, ( ( _, ( MlyValue.BRACE_CLOSE BRACE_CLOSE1, _,
BRACE_CLOSE1right)) :: ( _, ( MlyValue.collection_literal_parts_cs
collection_literal_parts_cs1, _, _)) :: ( _, ( MlyValue.BRACE_OPEN
BRACE_OPEN1, _, _)) :: ( _, ( MlyValue.collection_type_identifier_cs
collection_type_identifier_cs1, collection_type_identifier_cs1left, _)
) :: rest671)) => let val result = MlyValue.collection_literal_exp_cs
(fn _ => let val (collection_type_identifier_cs as
collection_type_identifier_cs1) = collection_type_identifier_cs1 ()
val BRACE_OPEN1 = BRACE_OPEN1 ()
val (collection_literal_parts_cs as collection_literal_parts_cs1) =
collection_literal_parts_cs1 ()
val BRACE_CLOSE1 = BRACE_CLOSE1 ()
in (
CollectionLiteral (collection_literal_parts_cs,create_set(collection_type_identifier_cs,DummyT))
)
end)
in ( LrTable.NT 63, ( result, collection_type_identifier_cs1left,
BRACE_CLOSE1right), rest671)
end
| ( 53, ( ( _, ( MlyValue.collection_literal_part_cs
collection_literal_part_cs1, collection_literal_part_cs1left,
collection_literal_part_cs1right)) :: rest671)) => let val result =
MlyValue.collection_literal_parts_cs (fn _ => let val (
collection_literal_part_cs as collection_literal_part_cs1) =
collection_literal_part_cs1 ()
in ([collection_literal_part_cs])
end)
in ( LrTable.NT 43, ( result, collection_literal_part_cs1left,
collection_literal_part_cs1right), rest671)
end
| ( 54, ( ( _, ( MlyValue.collection_literal_parts_tail_cs
collection_literal_parts_tail_cs1, _,
collection_literal_parts_tail_cs1right)) :: ( _, (
MlyValue.collection_literal_part_cs collection_literal_part_cs1,
collection_literal_part_cs1left, _)) :: rest671)) => let val result =
MlyValue.collection_literal_parts_cs (fn _ => let val (
collection_literal_part_cs as collection_literal_part_cs1) =
collection_literal_part_cs1 ()
val (collection_literal_parts_tail_cs as
collection_literal_parts_tail_cs1) = collection_literal_parts_tail_cs1
()
in ([collection_literal_part_cs]@collection_literal_parts_tail_cs)
end)
in ( LrTable.NT 43, ( result, collection_literal_part_cs1left,
collection_literal_parts_tail_cs1right), rest671)
end
| ( 55, ( ( _, ( MlyValue.collection_literal_parts_cs
collection_literal_parts_cs1, _, collection_literal_parts_cs1right))
:: ( _, ( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let
val result = MlyValue.collection_literal_parts_tail_cs (fn _ => let
val COMMA1 = COMMA1 ()
val (collection_literal_parts_cs as collection_literal_parts_cs1) =
collection_literal_parts_cs1 ()
in (collection_literal_parts_cs)
end)
in ( LrTable.NT 45, ( result, COMMA1left,
collection_literal_parts_cs1right), rest671)
end
| ( 56, ( ( _, ( MlyValue.collection_range_cs collection_range_cs1,
collection_range_cs1left, collection_range_cs1right)) :: rest671)) =>
let val result = MlyValue.collection_literal_part_cs (fn _ => let
val (collection_range_cs as collection_range_cs1) =
collection_range_cs1 ()
in (collection_range_cs)
end)
in ( LrTable.NT 44, ( result, collection_range_cs1left,
collection_range_cs1right), rest671)
end
| ( 57, ( ( _, ( MlyValue.expression expression1, expression1left,
expression1right)) :: rest671)) => let val result =
MlyValue.collection_literal_part_cs (fn _ => let val (expression as
expression1) = expression1 ()
in (CollectionItem (expression,DummyT))
end)
in ( LrTable.NT 44, ( result, expression1left, expression1right),
rest671)
end
| ( 58, ( ( _, ( MlyValue.expression expression2, _, expression2right
)) :: ( _, ( MlyValue.DBL_DOT DBL_DOT1, _, _)) :: ( _, (
MlyValue.expression expression1, expression1left, _)) :: rest671)) =>
let val result = MlyValue.collection_range_cs (fn _ => let val
expression1 = expression1 ()
val DBL_DOT1 = DBL_DOT1 ()
val expression2 = expression2 ()
in (CollectionRange (expression1,expression2,DummyT))
end)
in ( LrTable.NT 46, ( result, expression1left, expression2right),
rest671)
end
| ( 59, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.type_specifier type_specifier1,
_, _)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, (
MlyValue.collection_type_identifier_cs collection_type_identifier_cs1,
collection_type_identifier_cs1left, _)) :: rest671)) => let val
result = MlyValue.collection_type_specifier_cs (fn _ => let val (
collection_type_identifier_cs as collection_type_identifier_cs1) =
collection_type_identifier_cs1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (type_specifier as type_specifier1) = type_specifier1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (create_set (collection_type_identifier_cs,type_specifier))
end)
in ( LrTable.NT 48, ( result, collection_type_identifier_cs1left,
PAREN_CLOSE1right), rest671)
end
| ( 60, ( ( _, ( MlyValue.SET SET1, SET1left, SET1right)) :: rest671)
) => let val result = MlyValue.collection_type_identifier_cs (fn _ =>
let val (SET as SET1) = SET1 ()
in (SET)
end)
in ( LrTable.NT 42, ( result, SET1left, SET1right), rest671)
end
| ( 61, ( ( _, ( MlyValue.BAG BAG1, BAG1left, BAG1right)) :: rest671)
) => let val result = MlyValue.collection_type_identifier_cs (fn _ =>
let val (BAG as BAG1) = BAG1 ()
in (BAG)
end)
in ( LrTable.NT 42, ( result, BAG1left, BAG1right), rest671)
end
| ( 62, ( ( _, ( MlyValue.SEQUENCE SEQUENCE1, SEQUENCE1left,
SEQUENCE1right)) :: rest671)) => let val result =
MlyValue.collection_type_identifier_cs (fn _ => let val (SEQUENCE as
SEQUENCE1) = SEQUENCE1 ()
in (SEQUENCE)
end)
in ( LrTable.NT 42, ( result, SEQUENCE1left, SEQUENCE1right), rest671
)
end
| ( 63, ( ( _, ( MlyValue.COLLECTION COLLECTION1, COLLECTION1left,
COLLECTION1right)) :: rest671)) => let val result =
MlyValue.collection_type_identifier_cs (fn _ => let val (COLLECTION
as COLLECTION1) = COLLECTION1 ()
in (COLLECTION)
end)
in ( LrTable.NT 42, ( result, COLLECTION1left, COLLECTION1right),
rest671)
end
| ( 64, ( ( _, ( MlyValue.ORDERED_SET ORDERED_SET1, ORDERED_SET1left,
ORDERED_SET1right)) :: rest671)) => let val result =
MlyValue.collection_type_identifier_cs (fn _ => let val (ORDERED_SET
as ORDERED_SET1) = ORDERED_SET1 ()
in (ORDERED_SET)
end)
in ( LrTable.NT 42, ( result, ORDERED_SET1left, ORDERED_SET1right),
rest671)
end
| ( 65, ( ( _, ( MlyValue.is_marked_pre_cs is_marked_pre_cs1,
is_marked_pre_cs1left, is_marked_pre_cs1right)) :: rest671)) => let
val result = MlyValue.time_exp_cs (fn _ => let val (
is_marked_pre_cs as is_marked_pre_cs1) = is_marked_pre_cs1 ()
in (is_marked_pre_cs)
end)
in ( LrTable.NT 49, ( result, is_marked_pre_cs1left,
is_marked_pre_cs1right), rest671)
end
| ( 66, ( ( _, ( MlyValue.AT_PRE AT_PRE1, AT_PRE1left, AT_PRE1right))
:: rest671)) => let val result = MlyValue.is_marked_pre_cs (fn _ =>
let val (AT_PRE as AT_PRE1) = AT_PRE1 ()
in (AT_PRE)
end)
in ( LrTable.NT 50, ( result, AT_PRE1left, AT_PRE1right), rest671)
end
| ( 67, ( ( _, ( MlyValue.logical_exp_cs logical_exp_cs1,
logical_exp_cs1left, logical_exp_cs1right)) :: rest671)) => let val
result = MlyValue.ocl_expression_cs (fn _ => let val (logical_exp_cs
as logical_exp_cs1) = logical_exp_cs1 ()
in (Logger.debug3 ("ocl_expression_cs..." ^ "\n");logical_exp_cs)
end
)
in ( LrTable.NT 54, ( result, logical_exp_cs1left,
logical_exp_cs1right), rest671)
end
| ( 68, ( ( _, ( MlyValue.let_exp_cs let_exp_cs1, let_exp_cs1left,
let_exp_cs1right)) :: rest671)) => let val result =
MlyValue.ocl_expression_cs (fn _ => let val (let_exp_cs as
let_exp_cs1) = let_exp_cs1 ()
in (Logger.debug3 ("ocl_expression_cs..." ^ "\n");let_exp_cs)
end)
in ( LrTable.NT 54, ( result, let_exp_cs1left, let_exp_cs1right),
rest671)
end
| ( 69, ( ( _, ( MlyValue.expression expression1, _, expression1right
)) :: ( _, ( MlyValue.IN IN1, _, _)) :: ( _, (
MlyValue.initialized_variable_list_cs initialized_variable_list_cs1, _
, _)) :: ( _, ( MlyValue.LET LET1, LET1left, _)) :: rest671)) => let
val result = MlyValue.let_exp_cs (fn _ => let val LET1 = LET1 ()
val (initialized_variable_list_cs as initialized_variable_list_cs1)
= initialized_variable_list_cs1 ()
val IN1 = IN1 ()
val (expression as expression1) = expression1 ()
in (gen_let_term initialized_variable_list_cs expression)
end)
in ( LrTable.NT 55, ( result, LET1left, expression1right), rest671)
end
| ( 70, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1,
ocl_expression_cs1left, ocl_expression_cs1right)) :: rest671)) => let
val result = MlyValue.expression (fn _ => let val (
ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1 ()
in (ocl_expression_cs)
end)
in ( LrTable.NT 47, ( result, ocl_expression_cs1left,
ocl_expression_cs1right), rest671)
end
| ( 71, ( ( _, ( MlyValue.SELECT SELECT1, SELECT1left, SELECT1right))
:: rest671)) => let val result = MlyValue.iterator_name_cs (fn _ =>
let val (SELECT as SELECT1) = SELECT1 ()
in (SELECT)
end)
in ( LrTable.NT 60, ( result, SELECT1left, SELECT1right), rest671)
end
| ( 72, ( ( _, ( MlyValue.REJECT REJECT1, REJECT1left, REJECT1right))
:: rest671)) => let val result = MlyValue.iterator_name_cs (fn _ =>
let val (REJECT as REJECT1) = REJECT1 ()
in (REJECT)
end)
in ( LrTable.NT 60, ( result, REJECT1left, REJECT1right), rest671)
end
| ( 73, ( ( _, ( MlyValue.COLLECT COLLECT1, COLLECT1left,
COLLECT1right)) :: rest671)) => let val result =
MlyValue.iterator_name_cs (fn _ => let val (COLLECT as COLLECT1) =
COLLECT1 ()
in (COLLECT)
end)
in ( LrTable.NT 60, ( result, COLLECT1left, COLLECT1right), rest671)
end
| ( 74, ( ( _, ( MlyValue.FORALL FORALL1, FORALL1left, FORALL1right))
:: rest671)) => let val result = MlyValue.iterator_name_cs (fn _ =>
let val (FORALL as FORALL1) = FORALL1 ()
in (FORALL)
end)
in ( LrTable.NT 60, ( result, FORALL1left, FORALL1right), rest671)
end
| ( 75, ( ( _, ( MlyValue.EXISTS EXISTS1, EXISTS1left, EXISTS1right))
:: rest671)) => let val result = MlyValue.iterator_name_cs (fn _ =>
let val (EXISTS as EXISTS1) = EXISTS1 ()
in (EXISTS)
end)
in ( LrTable.NT 60, ( result, EXISTS1left, EXISTS1right), rest671)
end
| ( 76, ( ( _, ( MlyValue.ANY ANY1, ANY1left, ANY1right)) :: rest671)
) => let val result = MlyValue.iterator_name_cs (fn _ => let val (
ANY as ANY1) = ANY1 ()
in (ANY)
end)
in ( LrTable.NT 60, ( result, ANY1left, ANY1right), rest671)
end
| ( 77, ( ( _, ( MlyValue.ONE ONE1, ONE1left, ONE1right)) :: rest671)
) => let val result = MlyValue.iterator_name_cs (fn _ => let val (
ONE as ONE1) = ONE1 ()
in (ONE)
end)
in ( LrTable.NT 60, ( result, ONE1left, ONE1right), rest671)
end
| ( 78, ( ( _, ( MlyValue.ISUNIQUE ISUNIQUE1, ISUNIQUE1left,
ISUNIQUE1right)) :: rest671)) => let val result =
MlyValue.iterator_name_cs (fn _ => let val (ISUNIQUE as ISUNIQUE1) =
ISUNIQUE1 ()
in (ISUNIQUE)
end)
in ( LrTable.NT 60, ( result, ISUNIQUE1left, ISUNIQUE1right), rest671
)
end
| ( 79, ( ( _, ( MlyValue.OCLISKINDOF OCLISKINDOF1, OCLISKINDOF1left,
OCLISKINDOF1right)) :: rest671)) => let val result =
MlyValue.ocl_op_name (fn _ => let val (OCLISKINDOF as OCLISKINDOF1) =
OCLISKINDOF1 ()
in (OCLISKINDOF)
end)
in ( LrTable.NT 61, ( result, OCLISKINDOF1left, OCLISKINDOF1right),
rest671)
end
| ( 80, ( ( _, ( MlyValue.OCLISTYPEOF OCLISTYPEOF1, OCLISTYPEOF1left,
OCLISTYPEOF1right)) :: rest671)) => let val result =
MlyValue.ocl_op_name (fn _ => let val (OCLISTYPEOF as OCLISTYPEOF1) =
OCLISTYPEOF1 ()
in (OCLISTYPEOF)
end)
in ( LrTable.NT 61, ( result, OCLISTYPEOF1left, OCLISTYPEOF1right),
rest671)
end
| ( 81, ( ( _, ( MlyValue.OCLASTYPE OCLASTYPE1, OCLASTYPE1left,
OCLASTYPE1right)) :: rest671)) => let val result =
MlyValue.ocl_op_name (fn _ => let val (OCLASTYPE as OCLASTYPE1) =
OCLASTYPE1 ()
in (OCLASTYPE)
end)
in ( LrTable.NT 61, ( result, OCLASTYPE1left, OCLASTYPE1right),
rest671)
end
| ( 82, ( ( _, ( MlyValue.identifier_cs identifier_cs1,
identifier_cs1left, identifier_cs1right)) :: rest671)) => let val
result = MlyValue.path_name_cs (fn _ => let val (identifier_cs as
identifier_cs1) = identifier_cs1 ()
in (Logger.debug3 ("path_name finished..." ^ "\n");[identifier_cs])
end)
in ( LrTable.NT 11, ( result, identifier_cs1left, identifier_cs1right
), rest671)
end
| ( 83, ( ( _, ( MlyValue.identifier_cs identifier_cs1, _,
identifier_cs1right)) :: ( _, ( MlyValue.path_name_head_cs
path_name_head_cs1, path_name_head_cs1left, _)) :: rest671)) => let
val result = MlyValue.path_name_cs (fn _ => let val (
path_name_head_cs as path_name_head_cs1) = path_name_head_cs1 ()
val (identifier_cs as identifier_cs1) = identifier_cs1 ()
in (
Logger.debug3 ("path_name generation ..." ^ "\n");path_name_head_cs@[identifier_cs]
)
end)
in ( LrTable.NT 11, ( result, path_name_head_cs1left,
identifier_cs1right), rest671)
end
| ( 84, ( ( _, ( MlyValue.simple_name simple_name1, simple_name1left,
simple_name1right)) :: rest671)) => let val result =
MlyValue.identifier_cs (fn _ => let val (simple_name as simple_name1)
= simple_name1 ()
in (Logger.debug3 ("path_name generation..." ^ "\n");simple_name)
end
)
in ( LrTable.NT 59, ( result, simple_name1left, simple_name1right),
rest671)
end
| ( 85, ( ( _, ( MlyValue.ITERATE ITERATE1, ITERATE1left,
ITERATE1right)) :: rest671)) => let val result =
MlyValue.identifier_cs (fn _ => let val (ITERATE as ITERATE1) =
ITERATE1 ()
in (ITERATE)
end)
in ( LrTable.NT 59, ( result, ITERATE1left, ITERATE1right), rest671)
end
| ( 86, ( ( _, ( MlyValue.iterator_name_cs iterator_name_cs1,
iterator_name_cs1left, iterator_name_cs1right)) :: rest671)) => let
val result = MlyValue.identifier_cs (fn _ => let val (
iterator_name_cs as iterator_name_cs1) = iterator_name_cs1 ()
in (iterator_name_cs)
end)
in ( LrTable.NT 59, ( result, iterator_name_cs1left,
iterator_name_cs1right), rest671)
end
| ( 87, ( ( _, ( MlyValue.ocl_op_name ocl_op_name1, ocl_op_name1left,
ocl_op_name1right)) :: rest671)) => let val result =
MlyValue.identifier_cs (fn _ => let val (ocl_op_name as ocl_op_name1)
= ocl_op_name1 ()
in (ocl_op_name)
end)
in ( LrTable.NT 59, ( result, ocl_op_name1left, ocl_op_name1right),
rest671)
end
| ( 88, ( ( _, ( MlyValue.DBL_COLON DBL_COLON1, _, DBL_COLON1right))
:: ( _, ( MlyValue.identifier_cs identifier_cs1, identifier_cs1left,
_)) :: rest671)) => let val result = MlyValue.path_name_head_cs (fn
_ => let val (identifier_cs as identifier_cs1) = identifier_cs1 ()
val DBL_COLON1 = DBL_COLON1 ()
in (Logger.debug3 ("path_name generation..." ^ "\n");[identifier_cs])
end)
in ( LrTable.NT 12, ( result, identifier_cs1left, DBL_COLON1right),
rest671)
end
| ( 89, ( ( _, ( MlyValue.DBL_COLON DBL_COLON1, _, DBL_COLON1right))
:: ( _, ( MlyValue.identifier_cs identifier_cs1, _, _)) :: ( _, (
MlyValue.path_name_head_cs path_name_head_cs1, path_name_head_cs1left,
_)) :: rest671)) => let val result = MlyValue.path_name_head_cs (fn
_ => let val (path_name_head_cs as path_name_head_cs1) =
path_name_head_cs1 ()
val (identifier_cs as identifier_cs1) = identifier_cs1 ()
val DBL_COLON1 = DBL_COLON1 ()
in (
Logger.debug3 ("path_name generation..." ^ "\n");path_name_head_cs@[identifier_cs]
)
end)
in ( LrTable.NT 12, ( result, path_name_head_cs1left, DBL_COLON1right
), rest671)
end
| ( 90, ( ( _, ( MlyValue.primitive_literal_exp_cs
primitive_literal_exp_cs1, primitive_literal_exp_cs1left,
primitive_literal_exp_cs1right)) :: rest671)) => let val result =
MlyValue.literal_exp_cs (fn _ => let val (primitive_literal_exp_cs
as primitive_literal_exp_cs1) = primitive_literal_exp_cs1 ()
in (
Logger.debug3 ("primitive_literal_exp_cs..." ^ "\n");primitive_literal_exp_cs
)
end)
in ( LrTable.NT 62, ( result, primitive_literal_exp_cs1left,
primitive_literal_exp_cs1right), rest671)
end
| ( 91, ( ( _, ( MlyValue.collection_literal_exp_cs
collection_literal_exp_cs1, collection_literal_exp_cs1left,
collection_literal_exp_cs1right)) :: rest671)) => let val result =
MlyValue.literal_exp_cs (fn _ => let val (collection_literal_exp_cs
as collection_literal_exp_cs1) = collection_literal_exp_cs1 ()
in (collection_literal_exp_cs)
end)
in ( LrTable.NT 62, ( result, collection_literal_exp_cs1left,
collection_literal_exp_cs1right), rest671)
end
| ( 92, ( ( _, ( MlyValue.numeric_literal_exp_cs
numeric_literal_exp_cs1, numeric_literal_exp_cs1left,
numeric_literal_exp_cs1right)) :: rest671)) => let val result =
MlyValue.primitive_literal_exp_cs (fn _ => let val (
numeric_literal_exp_cs as numeric_literal_exp_cs1) =
numeric_literal_exp_cs1 ()
in (
Logger.debug3 ("numeric_literal_exp_cs..." ^ "\n");numeric_literal_exp_cs
)
end)
in ( LrTable.NT 65, ( result, numeric_literal_exp_cs1left,
numeric_literal_exp_cs1right), rest671)
end
| ( 93, ( ( _, ( MlyValue.string_literal_exp_cs
string_literal_exp_cs1, string_literal_exp_cs1left,
string_literal_exp_cs1right)) :: rest671)) => let val result =
MlyValue.primitive_literal_exp_cs (fn _ => let val (
string_literal_exp_cs as string_literal_exp_cs1) =
string_literal_exp_cs1 ()
in (
Logger.debug3 ("string_literal_exp_cs..." ^ "\n");string_literal_exp_cs
)
end)
in ( LrTable.NT 65, ( result, string_literal_exp_cs1left,
string_literal_exp_cs1right), rest671)
end
| ( 94, ( ( _, ( MlyValue.boolean_literal_exp_cs
boolean_literal_exp_cs1, boolean_literal_exp_cs1left,
boolean_literal_exp_cs1right)) :: rest671)) => let val result =
MlyValue.primitive_literal_exp_cs (fn _ => let val (
boolean_literal_exp_cs as boolean_literal_exp_cs1) =
boolean_literal_exp_cs1 ()
in (boolean_literal_exp_cs)
end)
in ( LrTable.NT 65, ( result, boolean_literal_exp_cs1left,
boolean_literal_exp_cs1right), rest671)
end
| ( 95, ( ( _, ( MlyValue.invalid_literal_exp_cs
invalid_literal_exp_cs1, invalid_literal_exp_cs1left,
invalid_literal_exp_cs1right)) :: rest671)) => let val result =
MlyValue.primitive_literal_exp_cs (fn _ => let val (
invalid_literal_exp_cs as invalid_literal_exp_cs1) =
invalid_literal_exp_cs1 ()
in (invalid_literal_exp_cs)
end)
in ( LrTable.NT 65, ( result, invalid_literal_exp_cs1left,
invalid_literal_exp_cs1right), rest671)
end
| ( 96, ( ( _, ( MlyValue.INTEGER_LITERAL INTEGER_LITERAL1,
INTEGER_LITERAL1left, INTEGER_LITERAL1right)) :: rest671)) => let val
result = MlyValue.numeric_literal_exp_cs (fn _ => let val (
INTEGER_LITERAL as INTEGER_LITERAL1) = INTEGER_LITERAL1 ()
in (
Logger.debug3 ("INTEGER_LITERAL..." ^ "\n");Literal (INTEGER_LITERAL,Integer)
)
end)
in ( LrTable.NT 66, ( result, INTEGER_LITERAL1left,
INTEGER_LITERAL1right), rest671)
end
| ( 97, ( ( _, ( MlyValue.REAL_LITERAL REAL_LITERAL1,
REAL_LITERAL1left, REAL_LITERAL1right)) :: rest671)) => let val
result = MlyValue.numeric_literal_exp_cs (fn _ => let val (
REAL_LITERAL as REAL_LITERAL1) = REAL_LITERAL1 ()
in (Literal (REAL_LITERAL,Real))
end)
in ( LrTable.NT 66, ( result, REAL_LITERAL1left, REAL_LITERAL1right),
rest671)
end
| ( 98, ( ( _, ( MlyValue.STRING_LITERAL STRING_LITERAL1,
STRING_LITERAL1left, STRING_LITERAL1right)) :: rest671)) => let val
result = MlyValue.string_literal_exp_cs (fn _ => let val (
STRING_LITERAL as STRING_LITERAL1) = STRING_LITERAL1 ()
in (Literal (STRING_LITERAL,String))
end)
in ( LrTable.NT 67, ( result, STRING_LITERAL1left,
STRING_LITERAL1right), rest671)
end
| ( 99, ( ( _, ( MlyValue.TRUE TRUE1, TRUE1left, TRUE1right)) ::
rest671)) => let val result = MlyValue.boolean_literal_exp_cs (fn _
=> let val TRUE1 = TRUE1 ()
in (Literal ("true",Boolean))
end)
in ( LrTable.NT 68, ( result, TRUE1left, TRUE1right), rest671)
end
| ( 100, ( ( _, ( MlyValue.FALSE FALSE1, FALSE1left, FALSE1right)) ::
rest671)) => let val result = MlyValue.boolean_literal_exp_cs (fn _
=> let val FALSE1 = FALSE1 ()
in (Literal ("false",Boolean))
end)
in ( LrTable.NT 68, ( result, FALSE1left, FALSE1right), rest671)
end
| ( 101, ( ( _, ( MlyValue.NULL NULL1, NULL1left, NULL1right)) ::
rest671)) => let val result = MlyValue.invalid_literal_exp_cs (fn _
=> let val NULL1 = NULL1 ()
in (Literal ("null",DummyT))
end)
in ( LrTable.NT 69, ( result, NULL1left, NULL1right), rest671)
end
| ( 102, ( ( _, ( MlyValue.relational_exp_cs relational_exp_cs1,
relational_exp_cs1left, relational_exp_cs1right)) :: rest671)) => let
val result = MlyValue.logical_exp_cs (fn _ => let val (
relational_exp_cs as relational_exp_cs1) = relational_exp_cs1 ()
in (Logger.debug3 ("logical_exp_cs..." ^ "\n");relational_exp_cs)
end
)
in ( LrTable.NT 74, ( result, relational_exp_cs1left,
relational_exp_cs1right), rest671)
end
| ( 103, ( ( _, ( MlyValue.logical_exp_tail_cs_p
logical_exp_tail_cs_p1, _, logical_exp_tail_cs_p1right)) :: ( _, (
MlyValue.relational_exp_cs relational_exp_cs1, relational_exp_cs1left,
_)) :: rest671)) => let val result = MlyValue.logical_exp_cs (fn _
=> let val (relational_exp_cs as relational_exp_cs1) =
relational_exp_cs1 ()
val (logical_exp_tail_cs_p as logical_exp_tail_cs_p1) =
logical_exp_tail_cs_p1 ()
in (
Logger.debug3 ("logical_exp_cs..." ^ "\n");OperationCall(relational_exp_cs,Boolean,[OclLibPackage,"Boolean",#1(logical_exp_tail_cs_p)],[(#2(logical_exp_tail_cs_p),Boolean)],Boolean)
)
end)
in ( LrTable.NT 74, ( result, relational_exp_cs1left,
logical_exp_tail_cs_p1right), rest671)
end
| ( 104, ( ( _, ( MlyValue.logical_exp_tail_cs logical_exp_tail_cs1,
logical_exp_tail_cs1left, logical_exp_tail_cs1right)) :: rest671)) =>
let val result = MlyValue.logical_exp_tail_cs_p (fn _ => let val (
logical_exp_tail_cs as logical_exp_tail_cs1) = logical_exp_tail_cs1 ()
in (logical_exp_tail_cs)
end)
in ( LrTable.NT 115, ( result, logical_exp_tail_cs1left,
logical_exp_tail_cs1right), rest671)
end
| ( 105, ( ( _, ( MlyValue.logical_exp_tail_cs_p
logical_exp_tail_cs_p1, _, logical_exp_tail_cs_p1right)) :: ( _, (
MlyValue.logical_exp_tail_cs logical_exp_tail_cs1,
logical_exp_tail_cs1left, _)) :: rest671)) => let val result =
MlyValue.logical_exp_tail_cs_p (fn _ => let val (logical_exp_tail_cs
as logical_exp_tail_cs1) = logical_exp_tail_cs1 ()
val (logical_exp_tail_cs_p as logical_exp_tail_cs_p1) =
logical_exp_tail_cs_p1 ()
in (
(#1(logical_exp_tail_cs),OperationCall(#2(logical_exp_tail_cs),Boolean,[OclLibPackage,"Boolean",#1(logical_exp_tail_cs_p)],[(#2(logical_exp_tail_cs_p),Boolean)],Boolean))
)
end)
in ( LrTable.NT 115, ( result, logical_exp_tail_cs1left,
logical_exp_tail_cs_p1right), rest671)
end
| ( 106, ( ( _, ( MlyValue.relational_exp_cs relational_exp_cs1, _,
relational_exp_cs1right)) :: ( _, ( MlyValue.logic_op logic_op1,
logic_op1left, _)) :: rest671)) => let val result =
MlyValue.logical_exp_tail_cs (fn _ => let val (logic_op as logic_op1)
= logic_op1 ()
val (relational_exp_cs as relational_exp_cs1) = relational_exp_cs1
()
in (logic_op,relational_exp_cs)
end)
in ( LrTable.NT 75, ( result, logic_op1left, relational_exp_cs1right)
, rest671)
end
| ( 107, ( ( _, ( MlyValue.LOG_AND LOG_AND1, LOG_AND1left,
LOG_AND1right)) :: rest671)) => let val result = MlyValue.logic_op
(fn _ => let val (LOG_AND as LOG_AND1) = LOG_AND1 ()
in (LOG_AND)
end)
in ( LrTable.NT 79, ( result, LOG_AND1left, LOG_AND1right), rest671)
end
| ( 108, ( ( _, ( MlyValue.LOG_OR LOG_OR1, LOG_OR1left, LOG_OR1right)
) :: rest671)) => let val result = MlyValue.logic_op (fn _ => let
val (LOG_OR as LOG_OR1) = LOG_OR1 ()
in (LOG_OR)
end)
in ( LrTable.NT 79, ( result, LOG_OR1left, LOG_OR1right), rest671)
end
| ( 109, ( ( _, ( MlyValue.LOG_XOR LOG_XOR1, LOG_XOR1left,
LOG_XOR1right)) :: rest671)) => let val result = MlyValue.logic_op
(fn _ => let val (LOG_XOR as LOG_XOR1) = LOG_XOR1 ()
in (LOG_XOR)
end)
in ( LrTable.NT 79, ( result, LOG_XOR1left, LOG_XOR1right), rest671)
end
| ( 110, ( ( _, ( MlyValue.LOG_IMPL LOG_IMPL1, LOG_IMPL1left,
LOG_IMPL1right)) :: rest671)) => let val result = MlyValue.logic_op
(fn _ => let val (LOG_IMPL as LOG_IMPL1) = LOG_IMPL1 ()
in (LOG_IMPL)
end)
in ( LrTable.NT 79, ( result, LOG_IMPL1left, LOG_IMPL1right), rest671
)
end
| ( 111, ( ( _, ( MlyValue.additive_exp_cs additive_exp_cs1,
additive_exp_cs1left, additive_exp_cs1right)) :: rest671)) => let val
result = MlyValue.relational_exp_cs (fn _ => let val (
additive_exp_cs as additive_exp_cs1) = additive_exp_cs1 ()
in (Logger.debug3 ("additive_exp_cs..." ^ "\n");additive_exp_cs)
end)
in ( LrTable.NT 76, ( result, additive_exp_cs1left,
additive_exp_cs1right), rest671)
end
| ( 112, ( ( _, ( MlyValue.relational_exp_tail_cs
relational_exp_tail_cs1, _, relational_exp_tail_cs1right)) :: ( _, (
MlyValue.additive_exp_cs additive_exp_cs1, additive_exp_cs1left, _))
:: rest671)) => let val result = MlyValue.relational_exp_cs (fn _ =>
let val (additive_exp_cs as additive_exp_cs1) = additive_exp_cs1 ()
val (relational_exp_tail_cs as relational_exp_tail_cs1) =
relational_exp_tail_cs1 ()
in (
Logger.debug3 ("additive_exp_cs relational_exp_tail_cs ..." ^ "\n");OperationCall(additive_exp_cs,DummyT,[OclLibPackage,"DummyT",#1(relational_exp_tail_cs)],[(#2(relational_exp_tail_cs),DummyT)],Boolean)
)
end)
in ( LrTable.NT 76, ( result, additive_exp_cs1left,
relational_exp_tail_cs1right), rest671)
end
| ( 113, ( ( _, ( MlyValue.additive_exp_cs additive_exp_cs1, _,
additive_exp_cs1right)) :: ( _, ( MlyValue.rel_op rel_op1, rel_op1left
, _)) :: rest671)) => let val result =
MlyValue.relational_exp_tail_cs (fn _ => let val (rel_op as rel_op1)
= rel_op1 ()
val (additive_exp_cs as additive_exp_cs1) = additive_exp_cs1 ()
in (
Logger.debug3 ("relational_exp_tail_cs..." ^ "\n");(rel_op, additive_exp_cs)
)
end)
in ( LrTable.NT 78, ( result, rel_op1left, additive_exp_cs1right),
rest671)
end
| ( 114, ( ( _, ( MlyValue.EQUALS EQUALS1, EQUALS1left, EQUALS1right)
) :: rest671)) => let val result = MlyValue.rel_op (fn _ => let val
(EQUALS as EQUALS1) = EQUALS1 ()
in (EQUALS)
end)
in ( LrTable.NT 83, ( result, EQUALS1left, EQUALS1right), rest671)
end
| ( 115, ( ( _, ( MlyValue.REL_GT REL_GT1, REL_GT1left, REL_GT1right)
) :: rest671)) => let val result = MlyValue.rel_op (fn _ => let val
(REL_GT as REL_GT1) = REL_GT1 ()
in (Logger.debug3 (">..." ^ "\n");REL_GT)
end)
in ( LrTable.NT 83, ( result, REL_GT1left, REL_GT1right), rest671)
end
| ( 116, ( ( _, ( MlyValue.REL_LT REL_LT1, REL_LT1left, REL_LT1right)
) :: rest671)) => let val result = MlyValue.rel_op (fn _ => let val
(REL_LT as REL_LT1) = REL_LT1 ()
in (Logger.debug3 ("<..." ^ "\n");REL_LT)
end)
in ( LrTable.NT 83, ( result, REL_LT1left, REL_LT1right), rest671)
end
| ( 117, ( ( _, ( MlyValue.REL_GTE REL_GTE1, REL_GTE1left,
REL_GTE1right)) :: rest671)) => let val result = MlyValue.rel_op (fn
_ => let val (REL_GTE as REL_GTE1) = REL_GTE1 ()
in (REL_GTE)
end)
in ( LrTable.NT 83, ( result, REL_GTE1left, REL_GTE1right), rest671)
end
| ( 118, ( ( _, ( MlyValue.REL_LTE REL_LTE1, REL_LTE1left,
REL_LTE1right)) :: rest671)) => let val result = MlyValue.rel_op (fn
_ => let val (REL_LTE as REL_LTE1) = REL_LTE1 ()
in (REL_LTE)
end)
in ( LrTable.NT 83, ( result, REL_LTE1left, REL_LTE1right), rest671)
end
| ( 119, ( ( _, ( MlyValue.REL_NOTEQUAL REL_NOTEQUAL1,
REL_NOTEQUAL1left, REL_NOTEQUAL1right)) :: rest671)) => let val
result = MlyValue.rel_op (fn _ => let val (REL_NOTEQUAL as
REL_NOTEQUAL1) = REL_NOTEQUAL1 ()
in (REL_NOTEQUAL)
end)
in ( LrTable.NT 83, ( result, REL_NOTEQUAL1left, REL_NOTEQUAL1right),
rest671)
end
| ( 120, ( ( _, ( MlyValue.multiplicative_exp_cs
multiplicative_exp_cs1, multiplicative_exp_cs1left,
multiplicative_exp_cs1right)) :: rest671)) => let val result =
MlyValue.additive_exp_cs (fn _ => let val (multiplicative_exp_cs as
multiplicative_exp_cs1) = multiplicative_exp_cs1 ()
in (
Logger.debug3 ("multiplicative_exp_cs..." ^ "\n");multiplicative_exp_cs
)
end)
in ( LrTable.NT 80, ( result, multiplicative_exp_cs1left,
multiplicative_exp_cs1right), rest671)
end
| ( 121, ( ( _, ( MlyValue.additive_exp_tail_cs_p
additive_exp_tail_cs_p1, _, additive_exp_tail_cs_p1right)) :: ( _, (
MlyValue.multiplicative_exp_cs multiplicative_exp_cs1,
multiplicative_exp_cs1left, _)) :: rest671)) => let val result =
MlyValue.additive_exp_cs (fn _ => let val (multiplicative_exp_cs as
multiplicative_exp_cs1) = multiplicative_exp_cs1 ()
val (additive_exp_tail_cs_p as additive_exp_tail_cs_p1) =
additive_exp_tail_cs_p1 ()
in (
Logger.debug3 ("multiplicative_exp_cs additive_exp_tail_cs_p..." ^ "\n");OperationCall (multiplicative_exp_cs,DummyT,[OclLibPackage,"DummyT",#1(additive_exp_tail_cs_p)],[(#2(additive_exp_tail_cs_p),DummyT)],DummyT)
)
end)
in ( LrTable.NT 80, ( result, multiplicative_exp_cs1left,
additive_exp_tail_cs_p1right), rest671)
end
| ( 122, ( ( _, ( MlyValue.additive_exp_tail_cs additive_exp_tail_cs1
, additive_exp_tail_cs1left, additive_exp_tail_cs1right)) :: rest671))
=> let val result = MlyValue.additive_exp_tail_cs_p (fn _ => let
val (additive_exp_tail_cs as additive_exp_tail_cs1) =
additive_exp_tail_cs1 ()
in (additive_exp_tail_cs)
end)
in ( LrTable.NT 82, ( result, additive_exp_tail_cs1left,
additive_exp_tail_cs1right), rest671)
end
| ( 123, ( ( _, ( MlyValue.additive_exp_tail_cs_p
additive_exp_tail_cs_p1, _, additive_exp_tail_cs_p1right)) :: ( _, (
MlyValue.additive_exp_tail_cs additive_exp_tail_cs1,
additive_exp_tail_cs1left, _)) :: rest671)) => let val result =
MlyValue.additive_exp_tail_cs_p (fn _ => let val (
additive_exp_tail_cs as additive_exp_tail_cs1) = additive_exp_tail_cs1
()
val (additive_exp_tail_cs_p as additive_exp_tail_cs_p1) =
additive_exp_tail_cs_p1 ()
in (
#1(additive_exp_tail_cs),OperationCall (#2(additive_exp_tail_cs),DummyT,[OclLibPackage,"DummyT",#1(additive_exp_tail_cs_p)],[(#2(additive_exp_tail_cs_p),DummyT)],DummyT)
)
end)
in ( LrTable.NT 82, ( result, additive_exp_tail_cs1left,
additive_exp_tail_cs_p1right), rest671)
end
| ( 124, ( ( _, ( MlyValue.multiplicative_exp_cs
multiplicative_exp_cs1, _, multiplicative_exp_cs1right)) :: ( _, (
MlyValue.add_op add_op1, add_op1left, _)) :: rest671)) => let val
result = MlyValue.additive_exp_tail_cs (fn _ => let val (add_op as
add_op1) = add_op1 ()
val (multiplicative_exp_cs as multiplicative_exp_cs1) =
multiplicative_exp_cs1 ()
in (add_op, multiplicative_exp_cs)
end)
in ( LrTable.NT 81, ( result, add_op1left,
multiplicative_exp_cs1right), rest671)
end
| ( 125, ( ( _, ( MlyValue.PLUS PLUS1, PLUS1left, PLUS1right)) ::
rest671)) => let val result = MlyValue.add_op (fn _ => let val (PLUS
as PLUS1) = PLUS1 ()
in (PLUS)
end)
in ( LrTable.NT 87, ( result, PLUS1left, PLUS1right), rest671)
end
| ( 126, ( ( _, ( MlyValue.MINUS MINUS1, MINUS1left, MINUS1right)) ::
rest671)) => let val result = MlyValue.add_op (fn _ => let val (
MINUS as MINUS1) = MINUS1 ()
in (MINUS)
end)
in ( LrTable.NT 87, ( result, MINUS1left, MINUS1right), rest671)
end
| ( 127, ( ( _, ( MlyValue.unary_exp_cs unary_exp_cs1,
unary_exp_cs1left, unary_exp_cs1right)) :: rest671)) => let val
result = MlyValue.multiplicative_exp_cs (fn _ => let val (
unary_exp_cs as unary_exp_cs1) = unary_exp_cs1 ()
in (Logger.debug3 ("unary_exp_cs ..." ^ "\n");unary_exp_cs)
end)
in ( LrTable.NT 84, ( result, unary_exp_cs1left, unary_exp_cs1right),
rest671)
end
| ( 128, ( ( _, ( MlyValue.multiplicative_exp_tail_cs_p
multiplicative_exp_tail_cs_p1, _, multiplicative_exp_tail_cs_p1right))
:: ( _, ( MlyValue.unary_exp_cs unary_exp_cs1, unary_exp_cs1left, _))
:: rest671)) => let val result = MlyValue.multiplicative_exp_cs (fn
_ => let val (unary_exp_cs as unary_exp_cs1) = unary_exp_cs1 ()
val (multiplicative_exp_tail_cs_p as multiplicative_exp_tail_cs_p1)
= multiplicative_exp_tail_cs_p1 ()
in (
OperationCall (unary_exp_cs,DummyT,[OclLibPackage,"DummyT",#1(multiplicative_exp_tail_cs_p)],[(#2(multiplicative_exp_tail_cs_p),DummyT)],DummyT)
)
end)
in ( LrTable.NT 84, ( result, unary_exp_cs1left,
multiplicative_exp_tail_cs_p1right), rest671)
end
| ( 129, ( ( _, ( MlyValue.multiplicative_exp_tail_cs
multiplicative_exp_tail_cs1, multiplicative_exp_tail_cs1left,
multiplicative_exp_tail_cs1right)) :: rest671)) => let val result =
MlyValue.multiplicative_exp_tail_cs_p (fn _ => let val (
multiplicative_exp_tail_cs as multiplicative_exp_tail_cs1) =
multiplicative_exp_tail_cs1 ()
in (multiplicative_exp_tail_cs)
end)
in ( LrTable.NT 85, ( result, multiplicative_exp_tail_cs1left,
multiplicative_exp_tail_cs1right), rest671)
end
| ( 130, ( ( _, ( MlyValue.multiplicative_exp_tail_cs_p
multiplicative_exp_tail_cs_p1, _, multiplicative_exp_tail_cs_p1right))
:: ( _, ( MlyValue.multiplicative_exp_tail_cs
multiplicative_exp_tail_cs1, multiplicative_exp_tail_cs1left, _)) ::
rest671)) => let val result = MlyValue.multiplicative_exp_tail_cs_p
(fn _ => let val (multiplicative_exp_tail_cs as
multiplicative_exp_tail_cs1) = multiplicative_exp_tail_cs1 ()
val (multiplicative_exp_tail_cs_p as multiplicative_exp_tail_cs_p1)
= multiplicative_exp_tail_cs_p1 ()
in (
#1(multiplicative_exp_tail_cs),OperationCall (#2(multiplicative_exp_tail_cs),DummyT,[OclLibPackage,"DummyT",#1(multiplicative_exp_tail_cs_p)],[(#2(multiplicative_exp_tail_cs_p),DummyT)],DummyT)
)
end)
in ( LrTable.NT 85, ( result, multiplicative_exp_tail_cs1left,
multiplicative_exp_tail_cs_p1right), rest671)
end
| ( 131, ( ( _, ( MlyValue.unary_exp_cs unary_exp_cs1, _,
unary_exp_cs1right)) :: ( _, ( MlyValue.mult_op mult_op1, mult_op1left
, _)) :: rest671)) => let val result =
MlyValue.multiplicative_exp_tail_cs (fn _ => let val (mult_op as
mult_op1) = mult_op1 ()
val (unary_exp_cs as unary_exp_cs1) = unary_exp_cs1 ()
in (mult_op, unary_exp_cs)
end)
in ( LrTable.NT 86, ( result, mult_op1left, unary_exp_cs1right),
rest671)
end
| ( 132, ( ( _, ( MlyValue.STAR STAR1, STAR1left, STAR1right)) ::
rest671)) => let val result = MlyValue.mult_op (fn _ => let val (
STAR as STAR1) = STAR1 ()
in (STAR)
end)
in ( LrTable.NT 89, ( result, STAR1left, STAR1right), rest671)
end
| ( 133, ( ( _, ( MlyValue.SLASH SLASH1, SLASH1left, SLASH1right)) ::
rest671)) => let val result = MlyValue.mult_op (fn _ => let val (
SLASH as SLASH1) = SLASH1 ()
in (SLASH)
end)
in ( LrTable.NT 89, ( result, SLASH1left, SLASH1right), rest671)
end
| ( 134, ( ( _, ( MlyValue.postfix_exp_cs postfix_exp_cs1, _,
postfix_exp_cs1right)) :: ( _, ( MlyValue.unary_op unary_op1,
unary_op1left, _)) :: rest671)) => let val result =
MlyValue.unary_exp_cs (fn _ => let val (unary_op as unary_op1) =
unary_op1 ()
val (postfix_exp_cs as postfix_exp_cs1) = postfix_exp_cs1 ()
in (
OperationCall (postfix_exp_cs,DummyT,[OclLibPackage,"DummyT",unary_op],[],DummyT)
)
end)
in ( LrTable.NT 88, ( result, unary_op1left, postfix_exp_cs1right),
rest671)
end
| ( 135, ( ( _, ( MlyValue.postfix_exp_cs postfix_exp_cs1,
postfix_exp_cs1left, postfix_exp_cs1right)) :: rest671)) => let val
result = MlyValue.unary_exp_cs (fn _ => let val (postfix_exp_cs as
postfix_exp_cs1) = postfix_exp_cs1 ()
in (postfix_exp_cs)
end)
in ( LrTable.NT 88, ( result, postfix_exp_cs1left,
postfix_exp_cs1right), rest671)
end
| ( 136, ( ( _, ( MlyValue.MINUS MINUS1, MINUS1left, MINUS1right)) ::
rest671)) => let val result = MlyValue.unary_op (fn _ => let val (
MINUS as MINUS1) = MINUS1 ()
in (MINUS)
end)
in ( LrTable.NT 90, ( result, MINUS1left, MINUS1right), rest671)
end
| ( 137, ( ( _, ( MlyValue.NOT NOT1, NOT1left, NOT1right)) :: rest671
)) => let val result = MlyValue.unary_op (fn _ => let val (NOT as
NOT1) = NOT1 ()
in (NOT)
end)
in ( LrTable.NT 90, ( result, NOT1left, NOT1right), rest671)
end
| ( 138, ( ( _, ( MlyValue.primary_exp_cs primary_exp_cs1,
primary_exp_cs1left, primary_exp_cs1right)) :: rest671)) => let val
result = MlyValue.postfix_exp_cs (fn _ => let val (primary_exp_cs as
primary_exp_cs1) = primary_exp_cs1 ()
in (primary_exp_cs)
end)
in ( LrTable.NT 91, ( result, primary_exp_cs1left,
primary_exp_cs1right), rest671)
end
| ( 139, ( ( _, ( MlyValue.postfix_exp_tail_cs_p
postfix_exp_tail_cs_p1, _, postfix_exp_tail_cs_p1right)) :: ( _, (
MlyValue.primary_exp_cs primary_exp_cs1, primary_exp_cs1left, _)) ::
rest671)) => let val result = MlyValue.postfix_exp_cs (fn _ => let
val (primary_exp_cs as primary_exp_cs1) = primary_exp_cs1 ()
val (postfix_exp_tail_cs_p as postfix_exp_tail_cs_p1) =
postfix_exp_tail_cs_p1 ()
in (
Logger.debug3 ("literal_call_exp_cs..." ^ "\n");nest_source ([primary_exp_cs]@postfix_exp_tail_cs_p)
)
end)
in ( LrTable.NT 91, ( result, primary_exp_cs1left,
postfix_exp_tail_cs_p1right), rest671)
end
| ( 140, ( ( _, ( MlyValue.literal_exp_cs literal_exp_cs1,
literal_exp_cs1left, literal_exp_cs1right)) :: rest671)) => let val
result = MlyValue.primary_exp_cs (fn _ => let val (literal_exp_cs as
literal_exp_cs1) = literal_exp_cs1 ()
in (Logger.debug3 ("literal_call_exp_cs..." ^ "\n");literal_exp_cs)
end)
in ( LrTable.NT 94, ( result, literal_exp_cs1left,
literal_exp_cs1right), rest671)
end
| ( 141, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
:: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)) ::
rest671)) => let val result = MlyValue.primary_exp_cs (fn _ => let
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (expression as expression1) = expression1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (expression)
end)
in ( LrTable.NT 94, ( result, PAREN_OPEN1left, PAREN_CLOSE1right),
rest671)
end
| ( 142, ( ( _, ( MlyValue.property_call_exp_cs property_call_exp_cs1
, property_call_exp_cs1left, property_call_exp_cs1right)) :: rest671))
=> let val result = MlyValue.primary_exp_cs (fn _ => let val (
property_call_exp_cs as property_call_exp_cs1) = property_call_exp_cs1
()
in (
Logger.debug3 ("property_call_exp_cs..." ^ "\n");property_call_exp_cs)
end)
in ( LrTable.NT 94, ( result, property_call_exp_cs1left,
property_call_exp_cs1right), rest671)
end
| ( 143, ( ( _, ( MlyValue.if_exp_cs if_exp_cs1, if_exp_cs1left,
if_exp_cs1right)) :: rest671)) => let val result =
MlyValue.primary_exp_cs (fn _ => let val (if_exp_cs as if_exp_cs1) =
if_exp_cs1 ()
in (if_exp_cs)
end)
in ( LrTable.NT 94, ( result, if_exp_cs1left, if_exp_cs1right),
rest671)
end
| ( 144, ( ( _, ( MlyValue.ENDIF ENDIF1, _, ENDIF1right)) :: ( _, (
MlyValue.ocl_expression_cs ocl_expression_cs2, _, _)) :: ( _, (
MlyValue.ELSE ELSE1, _, _)) :: ( _, ( MlyValue.ocl_expression_cs
ocl_expression_cs1, _, _)) :: ( _, ( MlyValue.THEN THEN1, _, _)) :: (
_, ( MlyValue.logical_exp_cs logical_exp_cs1, _, _)) :: ( _, (
MlyValue.IF IF1, IF1left, _)) :: rest671)) => let val result =
MlyValue.if_exp_cs (fn _ => let val IF1 = IF1 ()
val (logical_exp_cs as logical_exp_cs1) = logical_exp_cs1 ()
val THEN1 = THEN1 ()
val ocl_expression_cs1 = ocl_expression_cs1 ()
val ELSE1 = ELSE1 ()
val ocl_expression_cs2 = ocl_expression_cs2 ()
val ENDIF1 = ENDIF1 ()
in (
If (logical_exp_cs,DummyT,ocl_expression_cs1,DummyT,ocl_expression_cs2,DummyT,DummyT)
)
end)
in ( LrTable.NT 51, ( result, IF1left, ENDIF1right), rest671)
end
| ( 145, ( ( _, ( MlyValue.postfix_exp_tail_cs postfix_exp_tail_cs1,
postfix_exp_tail_cs1left, postfix_exp_tail_cs1right)) :: rest671)) =>
let val result = MlyValue.postfix_exp_tail_cs_p (fn _ => let val (
postfix_exp_tail_cs as postfix_exp_tail_cs1) = postfix_exp_tail_cs1 ()
in (
Logger.debug3 ("end of recursion..." ^ Ocl2String.ocl2string false postfix_exp_tail_cs ^ "\n");[postfix_exp_tail_cs]
)
end)
in ( LrTable.NT 92, ( result, postfix_exp_tail_cs1left,
postfix_exp_tail_cs1right), rest671)
end
| ( 146, ( ( _, ( MlyValue.postfix_exp_tail_cs_p
postfix_exp_tail_cs_p1, _, postfix_exp_tail_cs_p1right)) :: ( _, (
MlyValue.postfix_exp_tail_cs postfix_exp_tail_cs1,
postfix_exp_tail_cs1left, _)) :: rest671)) => let val result =
MlyValue.postfix_exp_tail_cs_p (fn _ => let val (postfix_exp_tail_cs
as postfix_exp_tail_cs1) = postfix_exp_tail_cs1 ()
val (postfix_exp_tail_cs_p as postfix_exp_tail_cs_p1) =
postfix_exp_tail_cs_p1 ()
in (
Logger.debug3 ("add_source ..." ^ "\n" ^ "done");([postfix_exp_tail_cs]@postfix_exp_tail_cs_p)
)
end)
in ( LrTable.NT 92, ( result, postfix_exp_tail_cs1left,
postfix_exp_tail_cs_p1right), rest671)
end
| ( 147, ( ( _, ( MlyValue.property_call_exp_cs property_call_exp_cs1
, _, property_call_exp_cs1right)) :: ( _, ( MlyValue.DOT DOT1,
DOT1left, _)) :: rest671)) => let val result =
MlyValue.postfix_exp_tail_cs (fn _ => let val DOT1 = DOT1 ()
val (property_call_exp_cs as property_call_exp_cs1) =
property_call_exp_cs1 ()
in (property_call_exp_cs)
end)
in ( LrTable.NT 93, ( result, DOT1left, property_call_exp_cs1right),
rest671)
end
| ( 148, ( ( _, ( MlyValue.arrow_property_call_exp_cs
arrow_property_call_exp_cs1, _, arrow_property_call_exp_cs1right)) ::
( _, ( MlyValue.ARROW_RIGHT ARROW_RIGHT1, ARROW_RIGHT1left, _)) ::
rest671)) => let val result = MlyValue.postfix_exp_tail_cs (fn _ =>
let val ARROW_RIGHT1 = ARROW_RIGHT1 ()
val (arrow_property_call_exp_cs as arrow_property_call_exp_cs1) =
arrow_property_call_exp_cs1 ()
in (arrow_property_call_exp_cs)
end)
in ( LrTable.NT 93, ( result, ARROW_RIGHT1left,
arrow_property_call_exp_cs1right), rest671)
end
| ( 149, ( ( _, ( MlyValue.path_name_cs path_name_cs1,
path_name_cs1left, path_name_cs1right)) :: rest671)) => let val
result = MlyValue.property_call_exp_cs (fn _ => let val (path_name_cs
as path_name_cs1) = path_name_cs1 ()
in (
AttributeCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs, DummyT)
)
end)
in ( LrTable.NT 95, ( result, path_name_cs1left, path_name_cs1right),
rest671)
end
| ( 150, ( ( _, ( MlyValue.time_exp_cs time_exp_cs1, _,
time_exp_cs1right)) :: ( _, ( MlyValue.path_name_cs path_name_cs1,
path_name_cs1left, _)) :: rest671)) => let val result =
MlyValue.property_call_exp_cs (fn _ => let val (path_name_cs as
path_name_cs1) = path_name_cs1 ()
val time_exp_cs1 = time_exp_cs1 ()
in (
AttributeCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs@["atPre"],DummyT)
)
end)
in ( LrTable.NT 95, ( result, path_name_cs1left, time_exp_cs1right),
rest671)
end
| ( 151, ( ( _, ( MlyValue.property_call_parameters_cs
property_call_parameters_cs1, _, property_call_parameters_cs1right))
:: ( _, ( MlyValue.path_name_cs path_name_cs1, path_name_cs1left, _))
:: rest671)) => let val result = MlyValue.property_call_exp_cs (fn _
=> let val (path_name_cs as path_name_cs1) = path_name_cs1 ()
val (property_call_parameters_cs as property_call_parameters_cs1) =
property_call_parameters_cs1 ()
in (
OperationCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs , property_call_parameters_cs,DummyT)
)
end)
in ( LrTable.NT 95, ( result, path_name_cs1left,
property_call_parameters_cs1right), rest671)
end
| ( 152, ( ( _, ( MlyValue.property_call_parameters_cs
property_call_parameters_cs1, _, property_call_parameters_cs1right))
:: ( _, ( MlyValue.time_exp_cs time_exp_cs1, _, _)) :: ( _, (
MlyValue.path_name_cs path_name_cs1, path_name_cs1left, _)) :: rest671
)) => let val result = MlyValue.property_call_exp_cs (fn _ => let
val (path_name_cs as path_name_cs1) = path_name_cs1 ()
val time_exp_cs1 = time_exp_cs1 ()
val (property_call_parameters_cs as property_call_parameters_cs1) =
property_call_parameters_cs1 ()
in (
OperationCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs@["atPre"],property_call_parameters_cs,DummyT)
)
end)
in ( LrTable.NT 95, ( result, path_name_cs1left,
property_call_parameters_cs1right), rest671)
end
| ( 153, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
:: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, (
MlyValue.iterator_name_cs iterator_name_cs1, iterator_name_cs1left, _)
) :: rest671)) => let val result =
MlyValue.arrow_property_call_exp_cs (fn _ => let val (
iterator_name_cs as iterator_name_cs1) = iterator_name_cs1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (expression as expression1) = expression1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (
Iterator (iterator_name_cs,[],Variable("dummy_source",DummyT),DummyT,expression,DummyT,DummyT)
)
end)
in ( LrTable.NT 96, ( result, iterator_name_cs1left,
PAREN_CLOSE1right), rest671)
end
| ( 154, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
:: ( _, ( MlyValue.iterator_vars_cs iterator_vars_cs1, _, _)) :: ( _,
( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, (
MlyValue.iterator_name_cs iterator_name_cs1, iterator_name_cs1left, _)
) :: rest671)) => let val result =
MlyValue.arrow_property_call_exp_cs (fn _ => let val (
iterator_name_cs as iterator_name_cs1) = iterator_name_cs1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (iterator_vars_cs as iterator_vars_cs1) = iterator_vars_cs1 ()
val (expression as expression1) = expression1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (
Logger.debug3 ("arrow_property_call_cs: iterator with vars..." ^ "\n");Iterator (iterator_name_cs,iterator_vars_cs,Variable("dummy_source",DummyT),DummyT,expression,DummyT,DummyT)
)
end)
in ( LrTable.NT 96, ( result, iterator_name_cs1left,
PAREN_CLOSE1right), rest671)
end
| ( 155, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _))
:: ( _, ( MlyValue.simple_name simple_name1, simple_name1left, _)) ::
rest671)) => let val result = MlyValue.arrow_property_call_exp_cs
(fn _ => let val (simple_name as simple_name1) = simple_name1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (
Logger.debug3 ("arrow_property_call_exp_cs..." ^ "\n");OperationCall (Variable ("dummy_source",DummyT),DummyT,(["arrow"]@[simple_name]),[],DummyT)
)
end)
in ( LrTable.NT 96, ( result, simple_name1left, PAREN_CLOSE1right),
rest671)
end
| ( 156, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.actual_parameter_list_cs
actual_parameter_list_cs1, _, _)) :: ( _, ( MlyValue.PAREN_OPEN
PAREN_OPEN1, _, _)) :: ( _, ( MlyValue.simple_name simple_name1,
simple_name1left, _)) :: rest671)) => let val result =
MlyValue.arrow_property_call_exp_cs (fn _ => let val (simple_name as
simple_name1) = simple_name1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (actual_parameter_list_cs as actual_parameter_list_cs1) =
actual_parameter_list_cs1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (
OperationCall (Variable ("dummy_source",DummyT),DummyT,(["arrow"]@[simple_name]),actual_parameter_list_cs,DummyT)
)
end)
in ( LrTable.NT 96, ( result, simple_name1left, PAREN_CLOSE1right),
rest671)
end
| ( 157, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
:: ( _, ( MlyValue.VERTICAL_BAR VERTICAL_BAR1, _, _)) :: ( _, (
MlyValue.initialized_variable_cs initialized_variable_cs1, _, _)) :: (
_, ( MlyValue.iterate_vars_cs iterate_vars_cs1, _, _)) :: ( _, (
MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( MlyValue.ITERATE
ITERATE1, ITERATE1left, _)) :: rest671)) => let val result =
MlyValue.arrow_property_call_exp_cs (fn _ => let val ITERATE1 =
ITERATE1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (iterate_vars_cs as iterate_vars_cs1) = iterate_vars_cs1 ()
val (initialized_variable_cs as initialized_variable_cs1) =
initialized_variable_cs1 ()
val VERTICAL_BAR1 = VERTICAL_BAR1 ()
val (expression as expression1) = expression1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (
Iterate (iterate_vars_cs,(#1 (initialized_variable_cs)),(#2 (initialized_variable_cs)),(#3 (initialized_variable_cs)),Variable ("dummy_source",DummyT),DummyT,expression,DummyT,DummyT)
)
end)
in ( LrTable.NT 96, ( result, ITERATE1left, PAREN_CLOSE1right),
rest671)
end
| ( 158, ( ( _, ( MlyValue.SEMI_COLON SEMI_COLON1, _,
SEMI_COLON1right)) :: ( _, ( MlyValue.formal_parameter_list_cs
formal_parameter_list_cs1, formal_parameter_list_cs1left, _)) ::
rest671)) => let val result = MlyValue.iterate_vars_cs (fn _ => let
val (formal_parameter_list_cs as formal_parameter_list_cs1) =
formal_parameter_list_cs1 ()
val SEMI_COLON1 = SEMI_COLON1 ()
in (formal_parameter_list_cs)
end)
in ( LrTable.NT 101, ( result, formal_parameter_list_cs1left,
SEMI_COLON1right), rest671)
end
| ( 159, ( ( _, ( MlyValue.VERTICAL_BAR VERTICAL_BAR1, _,
VERTICAL_BAR1right)) :: ( _, ( MlyValue.formal_parameter_list_cs
formal_parameter_list_cs1, formal_parameter_list_cs1left, _)) ::
rest671)) => let val result = MlyValue.iterator_vars_cs (fn _ => let
val (formal_parameter_list_cs as formal_parameter_list_cs1) =
formal_parameter_list_cs1 ()
val VERTICAL_BAR1 = VERTICAL_BAR1 ()
in (formal_parameter_list_cs)
end)
in ( LrTable.NT 108, ( result, formal_parameter_list_cs1left,
VERTICAL_BAR1right), rest671)
end
| ( 160, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.type_specifier type_specifier1,
_, _)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)
) :: rest671)) => let val result = MlyValue.ntVOID (fn _ => ( let
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (type_specifier as type_specifier1) = type_specifier1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (type_specifier)
end; ()))
in ( LrTable.NT 116, ( result, PAREN_OPEN1left, PAREN_CLOSE1right),
rest671)
end
| ( 161, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.actual_parameter_list_cs
actual_parameter_list_cs1, _, _)) :: ( _, ( MlyValue.PAREN_OPEN
PAREN_OPEN1, PAREN_OPEN1left, _)) :: rest671)) => let val result =
MlyValue.property_call_parameters_cs (fn _ => let val PAREN_OPEN1 =
PAREN_OPEN1 ()
val (actual_parameter_list_cs as actual_parameter_list_cs1) =
actual_parameter_list_cs1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in (actual_parameter_list_cs)
end)
in ( LrTable.NT 99, ( result, PAREN_OPEN1left, PAREN_CLOSE1right),
rest671)
end
| ( 162, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _,
PAREN_CLOSE1right)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1,
PAREN_OPEN1left, _)) :: rest671)) => let val result =
MlyValue.property_call_parameters_cs (fn _ => let val PAREN_OPEN1 =
PAREN_OPEN1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
in ([])
end)
in ( LrTable.NT 99, ( result, PAREN_OPEN1left, PAREN_CLOSE1right),
rest671)
end
| ( 163, ( ( _, ( MlyValue.actual_parameter_list_element_cs
actual_parameter_list_element_cs1,
actual_parameter_list_element_cs1left,
actual_parameter_list_element_cs1right)) :: rest671)) => let val
result = MlyValue.actual_parameter_list_cs (fn _ => let val (
actual_parameter_list_element_cs as actual_parameter_list_element_cs1)
= actual_parameter_list_element_cs1 ()
in ([actual_parameter_list_element_cs])
end)
in ( LrTable.NT 103, ( result, actual_parameter_list_element_cs1left,
actual_parameter_list_element_cs1right), rest671)
end
| ( 164, ( ( _, ( MlyValue.actual_parameter_list_tail_cs_p
actual_parameter_list_tail_cs_p1, _,
actual_parameter_list_tail_cs_p1right)) :: ( _, (
MlyValue.actual_parameter_list_element_cs
actual_parameter_list_element_cs1,
actual_parameter_list_element_cs1left, _)) :: rest671)) => let val
result = MlyValue.actual_parameter_list_cs (fn _ => let val (
actual_parameter_list_element_cs as actual_parameter_list_element_cs1)
= actual_parameter_list_element_cs1 ()
val (actual_parameter_list_tail_cs_p as
actual_parameter_list_tail_cs_p1) = actual_parameter_list_tail_cs_p1
()
in (
[actual_parameter_list_element_cs]@actual_parameter_list_tail_cs_p)
end)
in ( LrTable.NT 103, ( result, actual_parameter_list_element_cs1left,
actual_parameter_list_tail_cs_p1right), rest671)
end
| ( 165, ( ( _, ( MlyValue.actual_parameter_list_tail_cs
actual_parameter_list_tail_cs1, actual_parameter_list_tail_cs1left,
actual_parameter_list_tail_cs1right)) :: rest671)) => let val result
= MlyValue.actual_parameter_list_tail_cs_p (fn _ => let val (
actual_parameter_list_tail_cs as actual_parameter_list_tail_cs1) =
actual_parameter_list_tail_cs1 ()
in (actual_parameter_list_tail_cs)
end)
in ( LrTable.NT 105, ( result, actual_parameter_list_tail_cs1left,
actual_parameter_list_tail_cs1right), rest671)
end
| ( 166, ( ( _, ( MlyValue.actual_parameter_list_tail_cs_p
actual_parameter_list_tail_cs_p1, _,
actual_parameter_list_tail_cs_p1right)) :: ( _, (
MlyValue.actual_parameter_list_tail_cs actual_parameter_list_tail_cs1,
actual_parameter_list_tail_cs1left, _)) :: rest671)) => let val
result = MlyValue.actual_parameter_list_tail_cs_p (fn _ => let val (
actual_parameter_list_tail_cs as actual_parameter_list_tail_cs1) =
actual_parameter_list_tail_cs1 ()
val (actual_parameter_list_tail_cs_p as
actual_parameter_list_tail_cs_p1) = actual_parameter_list_tail_cs_p1
()
in (actual_parameter_list_tail_cs@actual_parameter_list_tail_cs_p)
end)
in ( LrTable.NT 105, ( result, actual_parameter_list_tail_cs1left,
actual_parameter_list_tail_cs_p1right), rest671)
end
| ( 167, ( ( _, ( MlyValue.actual_parameter_list_cs
actual_parameter_list_cs1, _, actual_parameter_list_cs1right)) :: ( _,
( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let val
result = MlyValue.actual_parameter_list_tail_cs (fn _ => let val
COMMA1 = COMMA1 ()
val (actual_parameter_list_cs as actual_parameter_list_cs1) =
actual_parameter_list_cs1 ()
in (actual_parameter_list_cs)
end)
in ( LrTable.NT 104, ( result, COMMA1left,
actual_parameter_list_cs1right), rest671)
end
| ( 168, ( ( _, ( MlyValue.expression expression1, expression1left,
expression1right)) :: rest671)) => let val result =
MlyValue.actual_parameter_list_element_cs (fn _ => let val (
expression as expression1) = expression1 ()
in (expression,DummyT)
end)
in ( LrTable.NT 106, ( result, expression1left, expression1right),
rest671)
end
| ( 169, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1,
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
let val result = MlyValue.actual_parameter_list_element_cs (fn _ =>
let val (formal_parameter_cs as formal_parameter_cs1) =
formal_parameter_cs1 ()
in (
Variable (#1(formal_parameter_cs),#2(formal_parameter_cs)),#2(formal_parameter_cs)
)
end)
in ( LrTable.NT 106, ( result, formal_parameter_cs1left,
formal_parameter_cs1right), rest671)
end
| ( 170, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1,
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
let val result = MlyValue.formal_parameter_list_cs (fn _ => let val
(formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1
()
in ([formal_parameter_cs])
end)
in ( LrTable.NT 38, ( result, formal_parameter_cs1left,
formal_parameter_cs1right), rest671)
end
| ( 171, ( ( _, ( MlyValue.formal_parameter_list_tail_cs
formal_parameter_list_tail_cs1, _, formal_parameter_list_tail_cs1right
)) :: ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1,
formal_parameter_cs1left, _)) :: rest671)) => let val result =
MlyValue.formal_parameter_list_cs (fn _ => let val (
formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1 ()
val (formal_parameter_list_tail_cs as formal_parameter_list_tail_cs1
) = formal_parameter_list_tail_cs1 ()
in ([formal_parameter_cs]@formal_parameter_list_tail_cs)
end)
in ( LrTable.NT 38, ( result, formal_parameter_cs1left,
formal_parameter_list_tail_cs1right), rest671)
end
| ( 172, ( ( _, ( MlyValue.formal_parameter_list_cs
formal_parameter_list_cs1, _, formal_parameter_list_cs1right)) :: ( _,
( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let val
result = MlyValue.formal_parameter_list_tail_cs (fn _ => let val
COMMA1 = COMMA1 ()
val (formal_parameter_list_cs as formal_parameter_list_cs1) =
formal_parameter_list_cs1 ()
in (formal_parameter_list_cs)
end)
in ( LrTable.NT 39, ( result, COMMA1left,
formal_parameter_list_cs1right), rest671)
end
| ( 173, ( ( _, ( MlyValue.formal_parameter_type_specifier
formal_parameter_type_specifier1, _,
formal_parameter_type_specifier1right)) :: ( _, ( MlyValue.simple_name
simple_name1, simple_name1left, _)) :: rest671)) => let val result =
MlyValue.formal_parameter_cs (fn _ => let val (simple_name as
simple_name1) = simple_name1 ()
val (formal_parameter_type_specifier as
formal_parameter_type_specifier1) = formal_parameter_type_specifier1
()
in (simple_name,formal_parameter_type_specifier)
end)
in ( LrTable.NT 37, ( result, simple_name1left,
formal_parameter_type_specifier1right), rest671)
end
| ( 174, ( ( _, ( MlyValue.type_specifier type_specifier1, _,
type_specifier1right)) :: ( _, ( MlyValue.COLON COLON1, COLON1left, _)
) :: rest671)) => let val result =
MlyValue.formal_parameter_type_specifier (fn _ => let val COLON1 =
COLON1 ()
val (type_specifier as type_specifier1) = type_specifier1 ()
in (type_specifier)
end)
in ( LrTable.NT 107, ( result, COLON1left, type_specifier1right),
rest671)
end
| ( 175, ( ( _, ( MlyValue.simple_type_specifier_cs
simple_type_specifier_cs1, simple_type_specifier_cs1left,
simple_type_specifier_cs1right)) :: rest671)) => let val result =
MlyValue.type_specifier (fn _ => let val (simple_type_specifier_cs
as simple_type_specifier_cs1) = simple_type_specifier_cs1 ()
in (
Logger.debug3 ("type_specifier ..." ^ "\n");simple_type_specifier_cs)
end)
in ( LrTable.NT 19, ( result, simple_type_specifier_cs1left,
simple_type_specifier_cs1right), rest671)
end
| ( 176, ( ( _, ( MlyValue.collection_type_specifier_cs
collection_type_specifier_cs1, collection_type_specifier_cs1left,
collection_type_specifier_cs1right)) :: rest671)) => let val result =
MlyValue.type_specifier (fn _ => let val (
collection_type_specifier_cs as collection_type_specifier_cs1) =
collection_type_specifier_cs1 ()
in (collection_type_specifier_cs)
end)
in ( LrTable.NT 19, ( result, collection_type_specifier_cs1left,
collection_type_specifier_cs1right), rest671)
end
| ( 177, ( ( _, ( MlyValue.simple_name simple_name1, simple_name1left
, simple_name1right)) :: rest671)) => let val result =
MlyValue.simple_type_specifier_cs (fn _ => let val (simple_name as
simple_name1) = simple_name1 ()
in (
Logger.debug3 ("simple_type_name_specifier_cs : " ^ simple_name ^ "\n");string_to_type simple_name
)
end)
in ( LrTable.NT 52, ( result, simple_name1left, simple_name1right),
rest671)
end
| ( 178, ( ( _, ( MlyValue.initialized_variable_cs
initialized_variable_cs1, initialized_variable_cs1left,
initialized_variable_cs1right)) :: rest671)) => let val result =
MlyValue.initialized_variable_list_cs (fn _ => let val (
initialized_variable_cs as initialized_variable_cs1) =
initialized_variable_cs1 ()
in ([initialized_variable_cs])
end)
in ( LrTable.NT 73, ( result, initialized_variable_cs1left,
initialized_variable_cs1right), rest671)
end
| ( 179, ( ( _, ( MlyValue.initialized_variable_list_tail_cs_p
initialized_variable_list_tail_cs_p1,
initialized_variable_list_tail_cs_p1left,
initialized_variable_list_tail_cs_p1right)) :: rest671)) => let val
result = MlyValue.initialized_variable_list_cs (fn _ => let val (
initialized_variable_list_tail_cs_p as
initialized_variable_list_tail_cs_p1) =
initialized_variable_list_tail_cs_p1 ()
in (initialized_variable_list_tail_cs_p)
end)
in ( LrTable.NT 73, ( result,
initialized_variable_list_tail_cs_p1left,
initialized_variable_list_tail_cs_p1right), rest671)
end
| ( 180, ( ( _, ( MlyValue.initialized_variable_list_tail_cs
initialized_variable_list_tail_cs1,
initialized_variable_list_tail_cs1left,
initialized_variable_list_tail_cs1right)) :: rest671)) => let val
result = MlyValue.initialized_variable_list_tail_cs_p (fn _ => let
val (initialized_variable_list_tail_cs as
initialized_variable_list_tail_cs1) =
initialized_variable_list_tail_cs1 ()
in ([initialized_variable_list_tail_cs])
end)
in ( LrTable.NT 109, ( result, initialized_variable_list_tail_cs1left
, initialized_variable_list_tail_cs1right), rest671)
end
| ( 181, ( ( _, ( MlyValue.initialized_variable_list_tail_cs_p
initialized_variable_list_tail_cs_p1, _,
initialized_variable_list_tail_cs_p1right)) :: ( _, (
MlyValue.initialized_variable_list_tail_cs
initialized_variable_list_tail_cs1,
initialized_variable_list_tail_cs1left, _)) :: rest671)) => let val
result = MlyValue.initialized_variable_list_tail_cs_p (fn _ => let
val (initialized_variable_list_tail_cs as
initialized_variable_list_tail_cs1) =
initialized_variable_list_tail_cs1 ()
val (initialized_variable_list_tail_cs_p as
initialized_variable_list_tail_cs_p1) =
initialized_variable_list_tail_cs_p1 ()
in (
[initialized_variable_list_tail_cs]@(initialized_variable_list_tail_cs_p)
)
end)
in ( LrTable.NT 109, ( result, initialized_variable_list_tail_cs1left
, initialized_variable_list_tail_cs_p1right), rest671)
end
| ( 182, ( ( _, ( MlyValue.initialized_variable_cs
initialized_variable_cs1, _, initialized_variable_cs1right)) :: ( _, (
MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let val
result = MlyValue.initialized_variable_list_tail_cs (fn _ => let val
COMMA1 = COMMA1 ()
val (initialized_variable_cs as initialized_variable_cs1) =
initialized_variable_cs1 ()
in (initialized_variable_cs)
end)
in ( LrTable.NT 110, ( result, COMMA1left,
initialized_variable_cs1right), rest671)
end
| ( 183, ( ( _, ( MlyValue.variable_initializer variable_initializer1
, _, variable_initializer1right)) :: ( _, (
MlyValue.formal_parameter_cs formal_parameter_cs1,
formal_parameter_cs1left, _)) :: rest671)) => let val result =
MlyValue.initialized_variable_cs (fn _ => let val (
formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1 ()
val (variable_initializer as variable_initializer1) =
variable_initializer1 ()
in (
(#1 formal_parameter_cs),(#2 formal_parameter_cs),variable_initializer
)
end)
in ( LrTable.NT 102, ( result, formal_parameter_cs1left,
variable_initializer1right), rest671)
end
| ( 184, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1,
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
let val result = MlyValue.variable_declaration_cs (fn _ => let val
(formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1
()
in (formal_parameter_cs)
end)
in ( LrTable.NT 112, ( result, formal_parameter_cs1left,
formal_parameter_cs1right), rest671)
end
| ( 185, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _,
ocl_expression_cs1right)) :: ( _, ( MlyValue.EQUALS EQUALS1,
EQUALS1left, _)) :: rest671)) => let val result =
MlyValue.variable_initializer (fn _ => let val EQUALS1 = EQUALS1 ()
val (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
()
in (ocl_expression_cs)
end)
in ( LrTable.NT 111, ( result, EQUALS1left, ocl_expression_cs1right),
rest671)
end
| ( 186, ( ( _, ( MlyValue.variable_declaration_cs
variable_declaration_cs1, variable_declaration_cs1left,
variable_declaration_cs1right)) :: rest671)) => let val result =
MlyValue.variable_declaration_list_cs (fn _ => let val (
variable_declaration_cs as variable_declaration_cs1) =
variable_declaration_cs1 ()
in ([variable_declaration_cs])
end)
in ( LrTable.NT 113, ( result, variable_declaration_cs1left,
variable_declaration_cs1right), rest671)
end
| ( 187, ( ( _, ( MlyValue.variable_declaration_list_tail_cs
variable_declaration_list_tail_cs1, _,
variable_declaration_list_tail_cs1right)) :: ( _, (
MlyValue.variable_declaration_cs variable_declaration_cs1,
variable_declaration_cs1left, _)) :: rest671)) => let val result =
MlyValue.variable_declaration_list_cs (fn _ => let val (
variable_declaration_cs as variable_declaration_cs1) =
variable_declaration_cs1 ()
val (variable_declaration_list_tail_cs as
variable_declaration_list_tail_cs1) =
variable_declaration_list_tail_cs1 ()
in ([variable_declaration_cs]@variable_declaration_list_tail_cs)
end)
in ( LrTable.NT 113, ( result, variable_declaration_cs1left,
variable_declaration_list_tail_cs1right), rest671)
end
| ( 188, ( ( _, ( MlyValue.variable_declaration_list_cs
variable_declaration_list_cs1, _, variable_declaration_list_cs1right))
:: ( _, ( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let
val result = MlyValue.variable_declaration_list_tail_cs (fn _ => let
val COMMA1 = COMMA1 ()
val (variable_declaration_list_cs as variable_declaration_list_cs1)
= variable_declaration_list_cs1 ()
in (variable_declaration_list_cs)
end)
in ( LrTable.NT 114, ( result, COMMA1left,
variable_declaration_list_cs1right), rest671)
end
| ( 189, ( ( _, ( MlyValue.END END1, _, END1right)) :: ( _, (
MlyValue.model_def_cs model_def_cs1, _, _)) :: ( _, ( MlyValue.MODEL
MODEL1, MODEL1left, _)) :: rest671)) => let val result =
MlyValue.model_spec_cs (fn _ => let val MODEL1 = MODEL1 ()
val (model_def_cs as model_def_cs1) = model_def_cs1 ()
val END1 = END1 ()
in (model_def_cs)
end)
in ( LrTable.NT 118, ( result, MODEL1left, END1right), rest671)
end
| ( 190, ( ( _, ( MlyValue.model_class_def_tail_cs_p
model_class_def_tail_cs_p1, _, model_class_def_tail_cs_p1right)) :: (
_, ( MlyValue.simple_name simple_name1, simple_name1left, _)) ::
rest671)) => let val result = MlyValue.model_def_cs (fn _ => let val
(simple_name as simple_name1) = simple_name1 ()
val (model_class_def_tail_cs_p as model_class_def_tail_cs_p1) =
model_class_def_tail_cs_p1 ()
in (
List.map (fn (a,b) => rename_classifier ([simple_name]@a) b) model_class_def_tail_cs_p
)
end)
in ( LrTable.NT 119, ( result, simple_name1left,
model_class_def_tail_cs_p1right), rest671)
end
| ( 191, ( ( _, ( MlyValue.model_class_def_cs model_class_def_cs1,
model_class_def_cs1left, model_class_def_cs1right)) :: rest671)) =>
let val result = MlyValue.model_class_def_tail_cs_p (fn _ => let
val (model_class_def_cs as model_class_def_cs1) =
model_class_def_cs1 ()
in ([model_class_def_cs])
end)
in ( LrTable.NT 120, ( result, model_class_def_cs1left,
model_class_def_cs1right), rest671)
end
| ( 192, ( ( _, ( MlyValue.model_class_def_tail_cs_p
model_class_def_tail_cs_p1, _, model_class_def_tail_cs_p1right)) :: (
_, ( MlyValue.model_class_def_cs model_class_def_cs1,
model_class_def_cs1left, _)) :: rest671)) => let val result =
MlyValue.model_class_def_tail_cs_p (fn _ => let val (
model_class_def_cs as model_class_def_cs1) = model_class_def_cs1 ()
val (model_class_def_tail_cs_p as model_class_def_tail_cs_p1) =
model_class_def_tail_cs_p1 ()
in ([model_class_def_cs]@(model_class_def_tail_cs_p))
end)
in ( LrTable.NT 120, ( result, model_class_def_cs1left,
model_class_def_tail_cs_p1right), rest671)
end
| ( 193, ( ( _, ( MlyValue.model_component_def_cs
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, (
MlyValue.simple_name simple_name1, _, _)) :: ( _, ( MlyValue.CLASS
CLASS1, CLASS1left, _)) :: rest671)) => let val result =
MlyValue.model_class_def_cs (fn _ => let val CLASS1 = CLASS1 ()
val (simple_name as simple_name1) = simple_name1 ()
val (model_component_def_cs as model_component_def_cs1) =
model_component_def_cs1 ()
in ([simple_name],merge_classifiers (model_component_def_cs))
end)
in ( LrTable.NT 121, ( result, CLASS1left,
model_component_def_cs1right), rest671)
end
| ( 194, ( ( _, ( MlyValue.model_ops_spec_cs model_ops_spec_cs1,
model_ops_spec_cs1left, model_ops_spec_cs1right)) :: rest671)) => let
val result = MlyValue.model_component_def_cs (fn _ => let val (
model_ops_spec_cs as model_ops_spec_cs1) = model_ops_spec_cs1 ()
in ([model_ops_spec_cs])
end)
in ( LrTable.NT 122, ( result, model_ops_spec_cs1left,
model_ops_spec_cs1right), rest671)
end
| ( 195, ( ( _, ( MlyValue.model_component_def_cs
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, (
MlyValue.model_ops_spec_cs model_ops_spec_cs1, model_ops_spec_cs1left,
_)) :: rest671)) => let val result = MlyValue.model_component_def_cs
(fn _ => let val (model_ops_spec_cs as model_ops_spec_cs1) =
model_ops_spec_cs1 ()
val (model_component_def_cs as model_component_def_cs1) =
model_component_def_cs1 ()
in ([model_ops_spec_cs]@(model_component_def_cs))
end)
in ( LrTable.NT 122, ( result, model_ops_spec_cs1left,
model_component_def_cs1right), rest671)
end
| ( 196, ( ( _, ( MlyValue.model_atts_spec_cs model_atts_spec_cs1,
model_atts_spec_cs1left, model_atts_spec_cs1right)) :: rest671)) =>
let val result = MlyValue.model_component_def_cs (fn _ => let val (
model_atts_spec_cs as model_atts_spec_cs1) = model_atts_spec_cs1 ()
in ([model_atts_spec_cs])
end)
in ( LrTable.NT 122, ( result, model_atts_spec_cs1left,
model_atts_spec_cs1right), rest671)
end
| ( 197, ( ( _, ( MlyValue.model_component_def_cs
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, (
MlyValue.model_atts_spec_cs model_atts_spec_cs1,
model_atts_spec_cs1left, _)) :: rest671)) => let val result =
MlyValue.model_component_def_cs (fn _ => let val (model_atts_spec_cs
as model_atts_spec_cs1) = model_atts_spec_cs1 ()
val (model_component_def_cs as model_component_def_cs1) =
model_component_def_cs1 ()
in ([model_atts_spec_cs]@(model_component_def_cs))
end)
in ( LrTable.NT 122, ( result, model_atts_spec_cs1left,
model_component_def_cs1right), rest671)
end
| ( 198, ( ( _, ( MlyValue.model_cons_spec_cs model_cons_spec_cs1,
model_cons_spec_cs1left, model_cons_spec_cs1right)) :: rest671)) =>
let val result = MlyValue.model_component_def_cs (fn _ => let val (
model_cons_spec_cs as model_cons_spec_cs1) = model_cons_spec_cs1 ()
in ([model_cons_spec_cs])
end)
in ( LrTable.NT 122, ( result, model_cons_spec_cs1left,
model_cons_spec_cs1right), rest671)
end
| ( 199, ( ( _, ( MlyValue.model_component_def_cs
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, (
MlyValue.model_cons_spec_cs model_cons_spec_cs1,
model_cons_spec_cs1left, _)) :: rest671)) => let val result =
MlyValue.model_component_def_cs (fn _ => let val (model_cons_spec_cs
as model_cons_spec_cs1) = model_cons_spec_cs1 ()
val (model_component_def_cs as model_component_def_cs1) =
model_component_def_cs1 ()
in ([model_cons_spec_cs]@(model_component_def_cs))
end)
in ( LrTable.NT 122, ( result, model_cons_spec_cs1left,
model_component_def_cs1right), rest671)
end
| ( 200, ( ( _, ( MlyValue.model_op_def_tail_cs_p
model_op_def_tail_cs_p1, _, model_op_def_tail_cs_p1right)) :: ( _, (
MlyValue.OPERATIONS OPERATIONS1, OPERATIONS1left, _)) :: rest671)) =>
let val result = MlyValue.model_ops_spec_cs (fn _ => let val
OPERATIONS1 = OPERATIONS1 ()
val (model_op_def_tail_cs_p as model_op_def_tail_cs_p1) =
model_op_def_tail_cs_p1 ()
in (operations_to_classifier model_op_def_tail_cs_p)
end)
in ( LrTable.NT 123, ( result, OPERATIONS1left,
model_op_def_tail_cs_p1right), rest671)
end
| ( 201, ( ( _, ( MlyValue.model_op_def_cs model_op_def_cs1,
model_op_def_cs1left, model_op_def_cs1right)) :: rest671)) => let val
result = MlyValue.model_op_def_tail_cs_p (fn _ => let val (
model_op_def_cs as model_op_def_cs1) = model_op_def_cs1 ()
in ([model_op_def_cs])
end)
in ( LrTable.NT 125, ( result, model_op_def_cs1left,
model_op_def_cs1right), rest671)
end
| ( 202, ( ( _, ( MlyValue.model_op_def_tail_cs_p
model_op_def_tail_cs_p1, _, model_op_def_tail_cs_p1right)) :: ( _, (
MlyValue.model_op_def_cs model_op_def_cs1, model_op_def_cs1left, _))
:: rest671)) => let val result = MlyValue.model_op_def_tail_cs_p (fn
_ => let val (model_op_def_cs as model_op_def_cs1) =
model_op_def_cs1 ()
val (model_op_def_tail_cs_p as model_op_def_tail_cs_p1) =
model_op_def_tail_cs_p1 ()
in ([model_op_def_cs]@(model_op_def_tail_cs_p))
end)
in ( LrTable.NT 125, ( result, model_op_def_cs1left,
model_op_def_tail_cs_p1right), rest671)
end
| ( 203, ( ( _, ( MlyValue.operation_constraint_cs_p
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
_, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, (
MlyValue.formal_parameter_list_cs formal_parameter_list_cs1, _, _)) ::
( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, (
MlyValue.simple_name simple_name1, simple_name1left, _)) :: rest671))
=> let val result = MlyValue.model_op_def_cs (fn _ => let val (
simple_name as simple_name1) = simple_name1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (formal_parameter_list_cs as formal_parameter_list_cs1) =
formal_parameter_list_cs1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
val (operation_constraint_cs_p as operation_constraint_cs_p1) =
operation_constraint_cs_p1 ()
in (
{name=simple_name,
precondition=(dispatch_pre_or_post pre operation_constraint_cs_p),
postcondition=(dispatch_pre_or_post post operation_constraint_cs_p),
body=[],arguments=formal_parameter_list_cs,
result=OclVoid,
isQuery=false,
scope=ClassifierScope:Rep_Core.Scope,
stereotypes=[],
visibility=public:Rep_Core.Visibility}:operation
)
end)
in ( LrTable.NT 124, ( result, simple_name1left,
operation_constraint_cs_p1right), rest671)
end
| ( 204, ( ( _, ( MlyValue.operation_constraint_cs_p
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
_, ( MlyValue.operation_return_type_specifier_cs
operation_return_type_specifier_cs1, _, _)) :: ( _, (
MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, (
MlyValue.formal_parameter_list_cs formal_parameter_list_cs1, _, _)) ::
( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, (
MlyValue.simple_name simple_name1, simple_name1left, _)) :: rest671))
=> let val result = MlyValue.model_op_def_cs (fn _ => let val (
simple_name as simple_name1) = simple_name1 ()
val PAREN_OPEN1 = PAREN_OPEN1 ()
val (formal_parameter_list_cs as formal_parameter_list_cs1) =
formal_parameter_list_cs1 ()
val PAREN_CLOSE1 = PAREN_CLOSE1 ()
val (operation_return_type_specifier_cs as
operation_return_type_specifier_cs1) =
operation_return_type_specifier_cs1 ()
val (operation_constraint_cs_p as operation_constraint_cs_p1) =
operation_constraint_cs_p1 ()
in (
{name=simple_name,
precondition=(dispatch_pre_or_post pre operation_constraint_cs_p),
postcondition=(dispatch_pre_or_post post operation_constraint_cs_p),
body=[],
arguments=formal_parameter_list_cs,
result=operation_return_type_specifier_cs,
isQuery=false,
scope=ClassifierScope:Rep_Core.Scope,
stereotypes=[],
visibility=public:Rep_Core.Visibility}:operation
)
end)
in ( LrTable.NT 124, ( result, simple_name1left,
operation_constraint_cs_p1right), rest671)
end
| ( 205, ( ( _, ( MlyValue.model_att_value_def_tail_cs_p
model_att_value_def_tail_cs_p1, _, model_att_value_def_tail_cs_p1right
)) :: ( _, ( MlyValue.ATTRIBUTES ATTRIBUTES1, ATTRIBUTES1left, _)) ::
rest671)) => let val result = MlyValue.model_atts_spec_cs (fn _ =>
let val ATTRIBUTES1 = ATTRIBUTES1 ()
val (model_att_value_def_tail_cs_p as model_att_value_def_tail_cs_p1
) = model_att_value_def_tail_cs_p1 ()
in (attributes_to_classifier model_att_value_def_tail_cs_p)
end)
in ( LrTable.NT 126, ( result, ATTRIBUTES1left,
model_att_value_def_tail_cs_p1right), rest671)
end
| ( 206, ( ( _, ( MlyValue.model_att_value_def_cs
model_att_value_def_cs1, model_att_value_def_cs1left,
model_att_value_def_cs1right)) :: rest671)) => let val result =
MlyValue.model_att_value_def_tail_cs_p (fn _ => let val (
model_att_value_def_cs as model_att_value_def_cs1) =
model_att_value_def_cs1 ()
in ([model_att_value_def_cs])
end)
in ( LrTable.NT 128, ( result, model_att_value_def_cs1left,
model_att_value_def_cs1right), rest671)
end
| ( 207, ( ( _, ( MlyValue.model_att_value_def_tail_cs_p
model_att_value_def_tail_cs_p1, _, model_att_value_def_tail_cs_p1right
)) :: ( _, ( MlyValue.model_att_value_def_cs model_att_value_def_cs1,
model_att_value_def_cs1left, _)) :: rest671)) => let val result =
MlyValue.model_att_value_def_tail_cs_p (fn _ => let val (
model_att_value_def_cs as model_att_value_def_cs1) =
model_att_value_def_cs1 ()
val (model_att_value_def_tail_cs_p as model_att_value_def_tail_cs_p1
) = model_att_value_def_tail_cs_p1 ()
in ([model_att_value_def_cs]@(model_att_value_def_tail_cs_p))
end)
in ( LrTable.NT 128, ( result, model_att_value_def_cs1left,
model_att_value_def_tail_cs_p1right), rest671)
end
| ( 208, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1,
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
let val result = MlyValue.model_att_value_def_cs (fn _ => let val (
formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1 ()
in (
{name=(#1 formal_parameter_cs),attr_type=(#2 formal_parameter_cs),visibility=public,scope=ClassifierScope,stereotypes=[],init=NONE}
)
end)
in ( LrTable.NT 127, ( result, formal_parameter_cs1left,
formal_parameter_cs1right), rest671)
end
| ( 209, ( ( _, ( MlyValue.model_cons_def_tail_cs_p
model_cons_def_tail_cs_p1, _, model_cons_def_tail_cs_p1right)) :: ( _,
( MlyValue.CONSTRAINTS CONSTRAINTS1, CONSTRAINTS1left, _)) :: rest671
)) => let val result = MlyValue.model_cons_spec_cs (fn _ => let val
CONSTRAINTS1 = CONSTRAINTS1 ()
val (model_cons_def_tail_cs_p as model_cons_def_tail_cs_p1) =
model_cons_def_tail_cs_p1 ()
in (constraints_to_classifier model_cons_def_tail_cs_p)
end)
in ( LrTable.NT 129, ( result, CONSTRAINTS1left,
model_cons_def_tail_cs_p1right), rest671)
end
| ( 210, ( ( _, ( MlyValue.classifier_constraint_cs_p
classifier_constraint_cs_p1, classifier_constraint_cs_p1left,
classifier_constraint_cs_p1right)) :: rest671)) => let val result =
MlyValue.model_cons_def_tail_cs_p (fn _ => let val (
classifier_constraint_cs_p as classifier_constraint_cs_p1) =
classifier_constraint_cs_p1 ()
in (classifier_constraint_cs_p)
end)
in ( LrTable.NT 130, ( result, classifier_constraint_cs_p1left,
classifier_constraint_cs_p1right), rest671)
end
| _ => raise (mlyAction i392)
end
val void = MlyValue.VOID
val extract = fn a => (fn MlyValue.START x => x
| _ => let exception ParseInternal
in raise ParseInternal end) a ()
end
end
structure Tokens : OclParser_TOKENS =
struct
type svalue = ParserData.svalue
type ('a,'b) token = ('a,'b) Token.token
fun EOF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 0,(
ParserData.MlyValue.VOID,p1,p2))
fun TICK (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 1,(
ParserData.MlyValue.TICK (fn () => i),p1,p2))
fun COMMA (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 2,(
ParserData.MlyValue.COMMA (fn () => i),p1,p2))
fun ARROW_RIGHT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 3,(
ParserData.MlyValue.ARROW_RIGHT (fn () => i),p1,p2))
fun DOT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 4,(
ParserData.MlyValue.DOT (fn () => i),p1,p2))
fun DBL_DOT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 5,(
ParserData.MlyValue.DBL_DOT (fn () => i),p1,p2))
fun COLON (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 6,(
ParserData.MlyValue.COLON (fn () => i),p1,p2))
fun DBL_COLON (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 7,(
ParserData.MlyValue.DBL_COLON (fn () => i),p1,p2))
fun SEMI_COLON (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 8,(
ParserData.MlyValue.SEMI_COLON (fn () => i),p1,p2))
fun EQUALS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 9,(
ParserData.MlyValue.EQUALS (fn () => i),p1,p2))
fun QUESTION_MARK (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 10,(
ParserData.MlyValue.QUESTION_MARK (fn () => i),p1,p2))
fun HASH (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 11,(
ParserData.MlyValue.HASH (fn () => i),p1,p2))
fun AT_PRE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 12,(
ParserData.MlyValue.AT_PRE (fn () => i),p1,p2))
fun BAG (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 13,(
ParserData.MlyValue.BAG (fn () => i),p1,p2))
fun COLLECTION (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 14,(
ParserData.MlyValue.COLLECTION (fn () => i),p1,p2))
fun SEQUENCE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 15,(
ParserData.MlyValue.SEQUENCE (fn () => i),p1,p2))
fun ORDERED_SET (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 16,(
ParserData.MlyValue.ORDERED_SET (fn () => i),p1,p2))
fun SET (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 17,(
ParserData.MlyValue.SET (fn () => i),p1,p2))
fun TUPLE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 18,(
ParserData.MlyValue.TUPLE (fn () => i),p1,p2))
fun TUPLE_TYPE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 19,(
ParserData.MlyValue.TUPLE_TYPE (fn () => i),p1,p2))
fun BRACKET_OPEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 20,(
ParserData.MlyValue.BRACKET_OPEN (fn () => i),p1,p2))
fun BRACKET_CLOSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 21,(
ParserData.MlyValue.BRACKET_CLOSE (fn () => i),p1,p2))
fun CARAT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 22,(
ParserData.MlyValue.CARAT (fn () => i),p1,p2))
fun DBL_CARAT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 23,(
ParserData.MlyValue.DBL_CARAT (fn () => i),p1,p2))
fun BODY (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 24,(
ParserData.MlyValue.BODY (fn () => i),p1,p2))
fun CONTEXT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 25,(
ParserData.MlyValue.CONTEXT (fn () => i),p1,p2))
fun DEF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 26,(
ParserData.MlyValue.DEF (fn () => i),p1,p2))
fun DERIVE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 27,(
ParserData.MlyValue.DERIVE (fn () => i),p1,p2))
fun ELSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 28,(
ParserData.MlyValue.ELSE (fn () => i),p1,p2))
fun ENDIF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 29,(
ParserData.MlyValue.ENDIF (fn () => i),p1,p2))
fun ENDPACKAGE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 30,(
ParserData.MlyValue.ENDPACKAGE (fn () => i),p1,p2))
fun FALSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 31,(
ParserData.MlyValue.FALSE (fn () => i),p1,p2))
fun NULL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 32,(
ParserData.MlyValue.NULL (fn () => i),p1,p2))
fun FORALL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 33,(
ParserData.MlyValue.FORALL (fn () => i),p1,p2))
fun TRUE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 34,(
ParserData.MlyValue.TRUE (fn () => i),p1,p2))
fun IF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 35,(
ParserData.MlyValue.IF (fn () => i),p1,p2))
fun IN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 36,(
ParserData.MlyValue.IN (fn () => i),p1,p2))
fun INIT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 37,(
ParserData.MlyValue.INIT (fn () => i),p1,p2))
fun INV (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 38,(
ParserData.MlyValue.INV (fn () => i),p1,p2))
fun LET (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 39,(
ParserData.MlyValue.LET (fn () => i),p1,p2))
fun PACKAGE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 40,(
ParserData.MlyValue.PACKAGE (fn () => i),p1,p2))
fun PRE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 41,(
ParserData.MlyValue.PRE (fn () => i),p1,p2))
fun POST (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 42,(
ParserData.MlyValue.POST (fn () => i),p1,p2))
fun THEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 43,(
ParserData.MlyValue.THEN (fn () => i),p1,p2))
fun PAREN_OPEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 44,(
ParserData.MlyValue.PAREN_OPEN (fn () => i),p1,p2))
fun PAREN_CLOSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 45,(
ParserData.MlyValue.PAREN_CLOSE (fn () => i),p1,p2))
fun BRACE_OPEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 46,(
ParserData.MlyValue.BRACE_OPEN (fn () => i),p1,p2))
fun BRACE_CLOSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 47,(
ParserData.MlyValue.BRACE_CLOSE (fn () => i),p1,p2))
fun VERTICAL_BAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 48,(
ParserData.MlyValue.VERTICAL_BAR (fn () => i),p1,p2))
fun GUARD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 49,(
ParserData.MlyValue.GUARD (fn () => i),p1,p2))
fun ITERATE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 50,(
ParserData.MlyValue.ITERATE (fn () => i),p1,p2))
fun SELECT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 51,(
ParserData.MlyValue.SELECT (fn () => i),p1,p2))
fun REJECT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 52,(
ParserData.MlyValue.REJECT (fn () => i),p1,p2))
fun COLLECT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 53,(
ParserData.MlyValue.COLLECT (fn () => i),p1,p2))
fun ANY (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 54,(
ParserData.MlyValue.ANY (fn () => i),p1,p2))
fun EXISTS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 55,(
ParserData.MlyValue.EXISTS (fn () => i),p1,p2))
fun ONE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 56,(
ParserData.MlyValue.ONE (fn () => i),p1,p2))
fun ISUNIQUE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 57,(
ParserData.MlyValue.ISUNIQUE (fn () => i),p1,p2))
fun OCLISTYPEOF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 58,(
ParserData.MlyValue.OCLISTYPEOF (fn () => i),p1,p2))
fun OCLISKINDOF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 59,(
ParserData.MlyValue.OCLISKINDOF (fn () => i),p1,p2))
fun OCLASTYPE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 60,(
ParserData.MlyValue.OCLASTYPE (fn () => i),p1,p2))
fun MINUS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 61,(
ParserData.MlyValue.MINUS (fn () => i),p1,p2))
fun STAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 62,(
ParserData.MlyValue.STAR (fn () => i),p1,p2))
fun SLASH (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 63,(
ParserData.MlyValue.SLASH (fn () => i),p1,p2))
fun PLUS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 64,(
ParserData.MlyValue.PLUS (fn () => i),p1,p2))
fun REL_NOTEQUAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 65,(
ParserData.MlyValue.REL_NOTEQUAL (fn () => i),p1,p2))
fun REL_GT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 66,(
ParserData.MlyValue.REL_GT (fn () => i),p1,p2))
fun REL_LT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 67,(
ParserData.MlyValue.REL_LT (fn () => i),p1,p2))
fun REL_GTE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 68,(
ParserData.MlyValue.REL_GTE (fn () => i),p1,p2))
fun REL_LTE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 69,(
ParserData.MlyValue.REL_LTE (fn () => i),p1,p2))
fun LOG_AND (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 70,(
ParserData.MlyValue.LOG_AND (fn () => i),p1,p2))
fun LOG_OR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 71,(
ParserData.MlyValue.LOG_OR (fn () => i),p1,p2))
fun LOG_XOR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 72,(
ParserData.MlyValue.LOG_XOR (fn () => i),p1,p2))
fun LOG_IMPL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 73,(
ParserData.MlyValue.LOG_IMPL (fn () => i),p1,p2))
fun NOT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 74,(
ParserData.MlyValue.NOT (fn () => i),p1,p2))
fun INTEGER_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 75,(
ParserData.MlyValue.INTEGER_LITERAL (fn () => i),p1,p2))
fun REAL_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 76,(
ParserData.MlyValue.REAL_LITERAL (fn () => i),p1,p2))
fun STRING_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 77,(
ParserData.MlyValue.STRING_LITERAL (fn () => i),p1,p2))
fun SIMPLE_NAME (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 78,(
ParserData.MlyValue.SIMPLE_NAME (fn () => i),p1,p2))
fun MODEL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 79,(
ParserData.MlyValue.MODEL (fn () => i),p1,p2))
fun OPERATIONS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 80,(
ParserData.MlyValue.OPERATIONS (fn () => i),p1,p2))
fun ATTRIBUTES (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 81,(
ParserData.MlyValue.ATTRIBUTES (fn () => i),p1,p2))
fun ASSOCIATIONS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 82,(
ParserData.MlyValue.ASSOCIATIONS (fn () => i),p1,p2))
fun BETWEEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 83,(
ParserData.MlyValue.BETWEEN (fn () => i),p1,p2))
fun END (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 84,(
ParserData.MlyValue.END (fn () => i),p1,p2))
fun CONSTRAINTS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 85,(
ParserData.MlyValue.CONSTRAINTS (fn () => i),p1,p2))
fun CLASS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 86,(
ParserData.MlyValue.CLASS (fn () => i),p1,p2))
end
end
Reference in New Issue View Git Blame Copy Permalink