-- File generated by the BNF Converter.
-- Parser definition for use with Happy.
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
{-# LANGUAGE PatternSynonyms #-}

module ParOCL
  ( happyError
  , myLexer
  , pOCLfile
  , pListOCLPackage
  , pOCLPackage
  , pPackageName
  , pOCLExpressions
  , pListConstrnt
  , pConstrnt
  , pListConstrBody
  , pConstrBody
  , pContextDeclaration
  , pClassifierContext
  , pOperationContext
  , pStereotype
  , pOperationName
  , pListFormalParameter
  , pFormalParameter
  , pTypeSpecifier
  , pCollectionType
  , pReturnType
  , pOCLExpression
  , pLetExpression
  , pListLetExpression
  , pIfExpression
  , pExpression
  , pExpression1
  , pExpression2
  , pExpression3
  , pExpression4
  , pExpression5
  , pExpression6
  , pExpression7
  , pExpression8
  , pMessageArg
  , pListMessageArg
  , pPropertyCall
  , pPathName
  , pPName
  , pListPName
  , pPossQualifiers
  , pQualifiers
  , pPossTimeExpression
  , pPossPropCallParam
  , pDeclarator
  , pDeclaratorVarList
  , pListIdent
  , pListExpression
  , pPropertyCallParameters
  , pPCPHelper
  , pListPCPHelper
  , pOCLLiteral
  , pSimpleTypeSpecifier
  , pLiteralCollection
  , pListCollectionItem
  , pCollectionItem
  , pOCLNumber
  , pLogicalOperator
  , pCollectionKind
  , pEqualityOperator
  , pRelationalOperator
  , pAddOperator
  , pMultiplyOperator
  , pUnaryOperator
  , pPostfixOperator
  ) where

import Prelude

import qualified AbsOCL
import LexOCL

}

%name pOCLfile OCLfile
%name pListOCLPackage ListOCLPackage
%name pOCLPackage OCLPackage
%name pPackageName PackageName
%name pOCLExpressions OCLExpressions
%name pListConstrnt ListConstrnt
%name pConstrnt Constrnt
%name pListConstrBody ListConstrBody
%name pConstrBody ConstrBody
%name pContextDeclaration ContextDeclaration
%name pClassifierContext ClassifierContext
%name pOperationContext OperationContext
%name pStereotype Stereotype
%name pOperationName OperationName
%name pListFormalParameter ListFormalParameter
%name pFormalParameter FormalParameter
%name pTypeSpecifier TypeSpecifier
%name pCollectionType CollectionType
%name pReturnType ReturnType
%name pOCLExpression OCLExpression
%name pLetExpression LetExpression
%name pListLetExpression ListLetExpression
%name pIfExpression IfExpression
%name pExpression Expression
%name pExpression1 Expression1
%name pExpression2 Expression2
%name pExpression3 Expression3
%name pExpression4 Expression4
%name pExpression5 Expression5
%name pExpression6 Expression6
%name pExpression7 Expression7
%name pExpression8 Expression8
%name pMessageArg MessageArg
%name pListMessageArg ListMessageArg
%name pPropertyCall PropertyCall
%name pPathName PathName
%name pPName PName
%name pListPName ListPName
%name pPossQualifiers PossQualifiers
%name pQualifiers Qualifiers
%name pPossTimeExpression PossTimeExpression
%name pPossPropCallParam PossPropCallParam
%name pDeclarator Declarator
%name pDeclaratorVarList DeclaratorVarList
%name pListIdent ListIdent
%name pListExpression ListExpression
%name pPropertyCallParameters PropertyCallParameters
%name pPCPHelper PCPHelper
%name pListPCPHelper ListPCPHelper
%name pOCLLiteral OCLLiteral
%name pSimpleTypeSpecifier SimpleTypeSpecifier
%name pLiteralCollection LiteralCollection
%name pListCollectionItem ListCollectionItem
%name pCollectionItem CollectionItem
%name pOCLNumber OCLNumber
%name pLogicalOperator LogicalOperator
%name pCollectionKind CollectionKind
%name pEqualityOperator EqualityOperator
%name pRelationalOperator RelationalOperator
%name pAddOperator AddOperator
%name pMultiplyOperator MultiplyOperator
%name pUnaryOperator UnaryOperator
%name pPostfixOperator PostfixOperator
%monad { Err } { (>>=) } { return }
%tokentype {Token}

%token
  '(' { PT _ (TS _ 1) }
  ')' { PT _ (TS _ 2) }
  '*' { PT _ (TS _ 3) }
  '+' { PT _ (TS _ 4) }
  ',' { PT _ (TS _ 5) }
  '-' { PT _ (TS _ 6) }
  '->' { PT _ (TS _ 7) }
  '.' { PT _ (TS _ 8) }
  '..' { PT _ (TS _ 9) }
  '/' { PT _ (TS _ 10) }
  ':' { PT _ (TS _ 11) }
  '::' { PT _ (TS _ 12) }
  ';' { PT _ (TS _ 13) }
  '<' { PT _ (TS _ 14) }
  '<=' { PT _ (TS _ 15) }
  '<>' { PT _ (TS _ 16) }
  '=' { PT _ (TS _ 17) }
  '>' { PT _ (TS _ 18) }
  '>=' { PT _ (TS _ 19) }
  '?' { PT _ (TS _ 20) }
  '@' { PT _ (TS _ 21) }
  'Bag' { PT _ (TS _ 22) }
  'Collection' { PT _ (TS _ 23) }
  'Sequence' { PT _ (TS _ 24) }
  'Set' { PT _ (TS _ 25) }
  '[' { PT _ (TS _ 26) }
  ']' { PT _ (TS _ 27) }
  '^' { PT _ (TS _ 28) }
  'and' { PT _ (TS _ 29) }
  'context' { PT _ (TS _ 30) }
  'def' { PT _ (TS _ 31) }
  'else' { PT _ (TS _ 32) }
  'endif' { PT _ (TS _ 33) }
  'endpackage' { PT _ (TS _ 34) }
  'false' { PT _ (TS _ 35) }
  'if' { PT _ (TS _ 36) }
  'implies' { PT _ (TS _ 37) }
  'in' { PT _ (TS _ 38) }
  'inv' { PT _ (TS _ 39) }
  'let' { PT _ (TS _ 40) }
  'not' { PT _ (TS _ 41) }
  'null' { PT _ (TS _ 42) }
  'or' { PT _ (TS _ 43) }
  'package' { PT _ (TS _ 44) }
  'post' { PT _ (TS _ 45) }
  'pre' { PT _ (TS _ 46) }
  'then' { PT _ (TS _ 47) }
  'true' { PT _ (TS _ 48) }
  'xor' { PT _ (TS _ 49) }
  '{' { PT _ (TS _ 50) }
  '|' { PT _ (TS _ 51) }
  '}' { PT _ (TS _ 52) }
  L_Ident { PT _ (TV $$) }
  L_doubl { PT _ (TD $$) }
  L_integ { PT _ (TI $$) }
  L_quoted { PT _ (TL $$) }

%%

Ident :: { AbsOCL.Ident }
Ident  : L_Ident { AbsOCL.Ident $1 }

Double :: { Double }
Double  : L_doubl  { (read $1 ) :: Double }

Integer :: { Integer }
Integer  : L_integ  { (read $1 ) :: Integer }

String :: { String }
String  : L_quoted { $1 }

OCLfile :: { AbsOCL.OCLfile }
OCLfile
  : ListOCLPackage { AbsOCL.OCLf $1 }

ListOCLPackage :: { [AbsOCL.OCLPackage] }
ListOCLPackage
  : OCLPackage { (:[]) $1 }
  | OCLPackage ListOCLPackage { (:) $1 $2 }

OCLPackage :: { AbsOCL.OCLPackage }
OCLPackage
  : 'package' PackageName OCLExpressions 'endpackage' { AbsOCL.Pack $2 $3 }

PackageName :: { AbsOCL.PackageName }
PackageName
  : PathName { AbsOCL.PackName $1 }

OCLExpressions :: { AbsOCL.OCLExpressions }
OCLExpressions
  : ListConstrnt { AbsOCL.Constraints $1 }

ListConstrnt :: { [AbsOCL.Constrnt] }
ListConstrnt
  : {- empty -} { [] }
  | Constrnt ListConstrnt { (:) $1 $2 }

Constrnt :: { AbsOCL.Constrnt }
Constrnt
  : ContextDeclaration ListConstrBody { AbsOCL.Constr $1 $2 }

ListConstrBody :: { [AbsOCL.ConstrBody] }
ListConstrBody
  : ConstrBody { (:[]) $1 }
  | ConstrBody ListConstrBody { (:) $1 $2 }

ConstrBody :: { AbsOCL.ConstrBody }
ConstrBody
  : 'def' ':' ListLetExpression { AbsOCL.CBDef $3 }
  | 'def' Ident ':' ListLetExpression { AbsOCL.CBDefNamed $2 $4 }
  | Stereotype ':' OCLExpression { AbsOCL.CB $1 $3 }
  | Stereotype Ident ':' OCLExpression { AbsOCL.CBNamed $1 $2 $4 }

ContextDeclaration :: { AbsOCL.ContextDeclaration }
ContextDeclaration
  : 'context' ClassifierContext { AbsOCL.CDClassif $2 }
  | 'context' OperationContext { AbsOCL.CDOper $2 }

ClassifierContext :: { AbsOCL.ClassifierContext }
ClassifierContext
  : Ident { AbsOCL.CC $1 }
  | Ident ':' Ident { AbsOCL.CCType $1 $3 }

OperationContext :: { AbsOCL.OperationContext }
OperationContext
  : Ident '::' OperationName '(' ListFormalParameter ')' { AbsOCL.OpC $1 $3 $5 }
  | Ident '::' OperationName '(' ListFormalParameter ')' ':' ReturnType { AbsOCL.OpCRT $1 $3 $5 $8 }

Stereotype :: { AbsOCL.Stereotype }
Stereotype
  : 'inv' { AbsOCL.Inv }
  | 'post' { AbsOCL.Post }
  | 'pre' { AbsOCL.Pre }

OperationName :: { AbsOCL.OperationName }
OperationName
  : '*' { AbsOCL.Mult }
  | '+' { AbsOCL.Add }
  | '-' { AbsOCL.Sub }
  | '/' { AbsOCL.Div }
  | '<' { AbsOCL.LST }
  | '<=' { AbsOCL.LSTE }
  | '<>' { AbsOCL.NEq }
  | '=' { AbsOCL.Eq }
  | '>' { AbsOCL.GRT }
  | '>=' { AbsOCL.GRTE }
  | 'and' { AbsOCL.And }
  | 'implies' { AbsOCL.Impl }
  | 'not' { AbsOCL.Not }
  | 'or' { AbsOCL.Or }
  | 'xor' { AbsOCL.Xor }
  | Ident { AbsOCL.OpName $1 }

ListFormalParameter :: { [AbsOCL.FormalParameter] }
ListFormalParameter
  : {- empty -} { [] }
  | FormalParameter { (:[]) $1 }
  | FormalParameter ',' ListFormalParameter { (:) $1 $3 }

FormalParameter :: { AbsOCL.FormalParameter }
FormalParameter
  : Ident ':' TypeSpecifier { AbsOCL.FP $1 $3 }

TypeSpecifier :: { AbsOCL.TypeSpecifier }
TypeSpecifier
  : CollectionType { AbsOCL.TScoll $1 }
  | SimpleTypeSpecifier { AbsOCL.TSsimple $1 }

CollectionType :: { AbsOCL.CollectionType }
CollectionType
  : CollectionKind '(' SimpleTypeSpecifier ')' { AbsOCL.CT $1 $3 }

ReturnType :: { AbsOCL.ReturnType }
ReturnType
  : TypeSpecifier { AbsOCL.RT $1 }

OCLExpression :: { AbsOCL.OCLExpression }
OCLExpression
  : Expression { AbsOCL.OCLExp $1 }
  | ListLetExpression 'in' Expression { AbsOCL.OCLExpLet $1 $3 }

LetExpression :: { AbsOCL.LetExpression }
LetExpression
  : 'let' Ident '(' ListFormalParameter ')' ':' TypeSpecifier '=' Expression { AbsOCL.LEType $2 $4 $7 $9 }
  | 'let' Ident '(' ListFormalParameter ')' '=' Expression { AbsOCL.LE $2 $4 $7 }
  | 'let' Ident ':' TypeSpecifier '=' Expression { AbsOCL.LENoParamType $2 $4 $6 }
  | 'let' Ident '=' Expression { AbsOCL.LENoParam $2 $4 }

ListLetExpression :: { [AbsOCL.LetExpression] }
ListLetExpression
  : LetExpression { (:[]) $1 }
  | LetExpression ListLetExpression { (:) $1 $2 }

IfExpression :: { AbsOCL.IfExpression }
IfExpression
  : 'if' Expression 'then' Expression 'else' Expression 'endif' { AbsOCL.IfExp $2 $4 $6 }

Expression :: { AbsOCL.Expression }
Expression
  : Expression 'implies' Expression1 { AbsOCL.EOpImpl $1 $3 }
  | Expression1 { $1 }

Expression1 :: { AbsOCL.Expression }
Expression1
  : Expression1 LogicalOperator Expression2 { AbsOCL.EOpLog $1 $2 $3 }
  | Expression2 { $1 }

Expression2 :: { AbsOCL.Expression }
Expression2
  : Expression2 EqualityOperator Expression3 { AbsOCL.EOpEq $1 $2 $3 }
  | Expression3 { $1 }

Expression3 :: { AbsOCL.Expression }
Expression3
  : Expression3 RelationalOperator Expression4 { AbsOCL.EOpRel $1 $2 $3 }
  | Expression4 { $1 }

Expression4 :: { AbsOCL.Expression }
Expression4
  : Expression4 AddOperator Expression5 { AbsOCL.EOpAdd $1 $2 $3 }
  | Expression5 { $1 }

Expression5 :: { AbsOCL.Expression }
Expression5
  : Expression5 MultiplyOperator Expression6 { AbsOCL.EOpMul $1 $2 $3 }
  | Expression6 { $1 }

Expression6 :: { AbsOCL.Expression }
Expression6
  : UnaryOperator Expression7 { AbsOCL.EOpUn $1 $2 }
  | Expression7 { $1 }

Expression7 :: { AbsOCL.Expression }
Expression7
  : Expression7 '^' PathName '(' ListMessageArg ')' { AbsOCL.EMessage $1 $3 $5 }
  | Expression7 PostfixOperator PropertyCall { AbsOCL.EExplPropCall $1 $2 $3 }
  | Expression8 { $1 }

Expression8 :: { AbsOCL.Expression }
Expression8
  : '(' Expression ')' { $2 }
  | 'null' { AbsOCL.ENull }
  | IfExpression { AbsOCL.EIfExp $1 }
  | LiteralCollection { AbsOCL.ELitColl $1 }
  | OCLLiteral { AbsOCL.ELit $1 }
  | PropertyCall { AbsOCL.EImplPropCall $1 }

MessageArg :: { AbsOCL.MessageArg }
MessageArg
  : '?' { AbsOCL.MAUnspec }
  | '?' ':' TypeSpecifier { AbsOCL.MAUnspecTyped $3 }
  | Expression { AbsOCL.MAExpr $1 }

ListMessageArg :: { [AbsOCL.MessageArg] }
ListMessageArg
  : {- empty -} { [] }
  | MessageArg { (:[]) $1 }
  | MessageArg ',' ListMessageArg { (:) $1 $3 }

PropertyCall :: { AbsOCL.PropertyCall }
PropertyCall
  : PathName PossTimeExpression PossQualifiers PossPropCallParam { AbsOCL.PCall $1 $2 $3 $4 }

PathName :: { AbsOCL.PathName }
PathName
  : ListPName { AbsOCL.PathN $1 }

PName :: { AbsOCL.PName }
PName
  : Ident { AbsOCL.PN $1 }

ListPName :: { [AbsOCL.PName] }
ListPName
  : PName { (:[]) $1 }
  | PName '::' ListPName { (:) $1 $3 }

PossQualifiers :: { AbsOCL.PossQualifiers }
PossQualifiers
  : {- empty -} { AbsOCL.NoQual }
  | Qualifiers { AbsOCL.Qual $1 }

Qualifiers :: { AbsOCL.Qualifiers }
Qualifiers
  : '[' ListExpression ']' { AbsOCL.Quals $2 }

PossTimeExpression :: { AbsOCL.PossTimeExpression }
PossTimeExpression
  : {- empty -} { AbsOCL.NoTE }
  | '@' 'pre' { AbsOCL.AtPre }

PossPropCallParam :: { AbsOCL.PossPropCallParam }
PossPropCallParam
  : {- empty -} { AbsOCL.NoPCP }
  | PropertyCallParameters { AbsOCL.PCPs $1 }

Declarator :: { AbsOCL.Declarator }
Declarator
  : DeclaratorVarList ';' Ident ':' TypeSpecifier '=' Expression '|' { AbsOCL.DeclAcc $1 $3 $5 $7 }
  | DeclaratorVarList '|' { AbsOCL.Decl $1 }

DeclaratorVarList :: { AbsOCL.DeclaratorVarList }
DeclaratorVarList
  : ListIdent { AbsOCL.DVL $1 }
  | ListIdent ':' SimpleTypeSpecifier { AbsOCL.DVLType $1 $3 }

ListIdent :: { [AbsOCL.Ident] }
ListIdent
  : Ident { (:[]) $1 }
  | Ident ',' ListIdent { (:) $1 $3 }

ListExpression :: { [AbsOCL.Expression] }
ListExpression
  : {- empty -} { [] }
  | Expression { (:[]) $1 }
  | Expression ',' ListExpression { (:) $1 $3 }

PropertyCallParameters :: { AbsOCL.PropertyCallParameters }
PropertyCallParameters
  : '(' ')' { AbsOCL.PCPNoDeclNoParam }
  | '(' Expression ListPCPHelper ')' { AbsOCL.PCPConcrete $2 $3 }

PCPHelper :: { AbsOCL.PCPHelper }
PCPHelper
  : ',' Expression { AbsOCL.PCPComma $2 }
  | ':' SimpleTypeSpecifier { AbsOCL.PCPColon $2 }
  | ';' Ident ':' TypeSpecifier '=' Expression { AbsOCL.PCPIterate $2 $4 $6 }
  | '|' Expression { AbsOCL.PCPBar $2 }

ListPCPHelper :: { [AbsOCL.PCPHelper] }
ListPCPHelper
  : {- empty -} { [] }
  | PCPHelper ListPCPHelper { (:) $1 $2 }

OCLLiteral :: { AbsOCL.OCLLiteral }
OCLLiteral
  : 'false' { AbsOCL.LitBoolFalse }
  | 'true' { AbsOCL.LitBoolTrue }
  | String { AbsOCL.LitStr $1 }
  | OCLNumber { AbsOCL.LitNum $1 }

SimpleTypeSpecifier :: { AbsOCL.SimpleTypeSpecifier }
SimpleTypeSpecifier
  : PathName { AbsOCL.STSpec $1 }

LiteralCollection :: { AbsOCL.LiteralCollection }
LiteralCollection
  : CollectionKind '{' '}' { AbsOCL.LCollectionEmpty $1 }
  | CollectionKind '{' ListCollectionItem '}' { AbsOCL.LCollection $1 $3 }

ListCollectionItem :: { [AbsOCL.CollectionItem] }
ListCollectionItem
  : CollectionItem { (:[]) $1 }
  | CollectionItem ',' ListCollectionItem { (:) $1 $3 }

CollectionItem :: { AbsOCL.CollectionItem }
CollectionItem
  : Expression { AbsOCL.CI $1 }
  | Expression '..' Expression { AbsOCL.CIRange $1 $3 }

OCLNumber :: { AbsOCL.OCLNumber }
OCLNumber
  : Double { AbsOCL.NumDouble $1 }
  | Integer { AbsOCL.NumInt $1 }

LogicalOperator :: { AbsOCL.LogicalOperator }
LogicalOperator
  : 'and' { AbsOCL.LAnd }
  | 'or' { AbsOCL.LOr }
  | 'xor' { AbsOCL.LXor }

CollectionKind :: { AbsOCL.CollectionKind }
CollectionKind
  : 'Bag' { AbsOCL.Bag }
  | 'Collection' { AbsOCL.Collection }
  | 'Sequence' { AbsOCL.Sequence }
  | 'Set' { AbsOCL.Set }

EqualityOperator :: { AbsOCL.EqualityOperator }
EqualityOperator
  : '<>' { AbsOCL.ENEq }
  | '=' { AbsOCL.EEq }

RelationalOperator :: { AbsOCL.RelationalOperator }
RelationalOperator
  : '<' { AbsOCL.RLT }
  | '<=' { AbsOCL.RLTE }
  | '>' { AbsOCL.RGT }
  | '>=' { AbsOCL.RGTE }

AddOperator :: { AbsOCL.AddOperator }
AddOperator
  : '+' { AbsOCL.AAdd }
  | '-' { AbsOCL.ASub }

MultiplyOperator :: { AbsOCL.MultiplyOperator }
MultiplyOperator
  : '*' { AbsOCL.MMult }
  | '/' { AbsOCL.MDiv }

UnaryOperator :: { AbsOCL.UnaryOperator }
UnaryOperator
  : '-' { AbsOCL.UMin }
  | 'not' { AbsOCL.UNot }

PostfixOperator :: { AbsOCL.PostfixOperator }
PostfixOperator
  : '->' { AbsOCL.PArrow }
  | '.' { AbsOCL.PDot }

{

type Err = Either String

happyError :: [Token] -> Err a
happyError ts = Left $
  "syntax error at " ++ tokenPos ts ++ 
  case ts of
    []      -> []
    [Err _] -> " due to lexer error"
    t:_     -> " before `" ++ (prToken t) ++ "'"

myLexer :: String -> [Token]
myLexer = tokens

}