clafer-0.5.8: src/Language/Clafer/Front/ParClafer.y
-- This Happy file was machine-generated by the BNF converter
{
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
module Language.Clafer.Front.ParClafer where
import Language.Clafer.Front.AbsClafer
import Language.Clafer.Front.LexClafer
import Language.Clafer.Front.ErrM
}
%name pModule Module
%name pClafer Clafer
%name pConstraint Constraint
%name pAssertion Assertion
%name pGoal Goal
-- no lexer declaration
%monad { Err } { thenM } { returnM }
%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) }
'..' { PT _ (TS _ 22) }
'/' { PT _ (TS _ 23) }
':' { PT _ (TS _ 24) }
':=' { PT _ (TS _ 25) }
':>' { PT _ (TS _ 26) }
';' { PT _ (TS _ 27) }
L_sep { PT _ (TS _ 101) }
'<' { PT _ (TS _ 28) }
'<:' { PT _ (TS _ 29) }
'<<' { PT _ (TS _ 30) }
'<=' { PT _ (TS _ 31) }
'<=>' { PT _ (TS _ 32) }
'=' { PT _ (TS _ 33) }
'=>' { PT _ (TS _ 34) }
'>' { PT _ (TS _ 35) }
'>=' { PT _ (TS _ 36) }
'>>' { PT _ (TS _ 37) }
'?' { PT _ (TS _ 38) }
'F' { PT _ (TS _ 39) }
'G' { PT _ (TS _ 40) }
'U' { PT _ (TS _ 41) }
'W' { PT _ (TS _ 42) }
'X' { PT _ (TS _ 43) }
'[' { PT _ (TS _ 44) }
'\\' { PT _ (TS _ 45) }
']' { PT _ (TS _ 46) }
']->' { PT _ (TS _ 47) }
']->>' { PT _ (TS _ 48) }
'`' { PT _ (TS _ 49) }
'abstract' { PT _ (TS _ 50) }
'after' { PT _ (TS _ 51) }
'all' { PT _ (TS _ 52) }
'always' { PT _ (TS _ 53) }
'and' { PT _ (TS _ 54) }
'assert' { PT _ (TS _ 55) }
'before' { PT _ (TS _ 56) }
'between' { PT _ (TS _ 57) }
'disj' { PT _ (TS _ 58) }
'else' { PT _ (TS _ 59) }
'enum' { PT _ (TS _ 60) }
'eventually' { PT _ (TS _ 61) }
'final' { PT _ (TS _ 62) }
'finally' { PT _ (TS _ 63) }
'finalref' { PT _ (TS _ 64) }
'finaltarget' { PT _ (TS _ 65) }
'follow' { PT _ (TS _ 66) }
'globally' { PT _ (TS _ 67) }
'if' { PT _ (TS _ 68) }
'in' { PT _ (TS _ 69) }
'initial' { PT _ (TS _ 70) }
'initially' { PT _ (TS _ 71) }
'let' { PT _ (TS _ 72) }
'lonce' { PT _ (TS _ 73) }
'lone' { PT _ (TS _ 74) }
'max' { PT _ (TS _ 75) }
'maximize' { PT _ (TS _ 76) }
'min' { PT _ (TS _ 77) }
'minimize' { PT _ (TS _ 78) }
'must' { PT _ (TS _ 79) }
'mux' { PT _ (TS _ 80) }
'never' { PT _ (TS _ 81) }
'next' { PT _ (TS _ 82) }
'no' { PT _ (TS _ 83) }
'not' { PT _ (TS _ 84) }
'one' { PT _ (TS _ 85) }
'opt' { PT _ (TS _ 86) }
'or' { PT _ (TS _ 87) }
'precede' { PT _ (TS _ 88) }
'product' { PT _ (TS _ 89) }
'some' { PT _ (TS _ 90) }
'sometime' { PT _ (TS _ 91) }
'sum' { PT _ (TS _ 92) }
'then' { PT _ (TS _ 93) }
'until' { PT _ (TS _ 94) }
'weakuntil' { PT _ (TS _ 95) }
'xor' { PT _ (TS _ 96) }
'{' { PT _ (TS _ 97) }
'|' { PT _ (TS _ 98) }
'||' { PT _ (TS _ 99) }
'}' { PT _ (TS _ 100) }
L_PosInteger { PT _ (T_PosInteger _) }
L_PosDouble { PT _ (T_PosDouble _) }
L_PosReal { PT _ (T_PosReal _) }
L_PosString { PT _ (T_PosString _) }
L_PosIdent { PT _ (T_PosIdent _) }
L_PosLineComment { PT _ (T_PosLineComment _) }
L_PosBlockComment { PT _ (T_PosBlockComment _) }
L_PosAlloy { PT _ (T_PosAlloy _) }
L_PosChoco { PT _ (T_PosChoco _) }
%%
PosInteger :: { PosInteger} : L_PosInteger { PosInteger (mkPosToken $1)}
PosDouble :: { PosDouble} : L_PosDouble { PosDouble (mkPosToken $1)}
PosReal :: { PosReal} : L_PosReal { PosReal (mkPosToken $1)}
PosString :: { PosString} : L_PosString { PosString (mkPosToken $1)}
PosIdent :: { PosIdent} : L_PosIdent { PosIdent (mkPosToken $1)}
PosLineComment :: { PosLineComment} : L_PosLineComment { PosLineComment (mkPosToken $1)}
PosBlockComment :: { PosBlockComment} : L_PosBlockComment { PosBlockComment (mkPosToken $1)}
PosAlloy :: { PosAlloy} : L_PosAlloy { PosAlloy (mkPosToken $1)}
PosChoco :: { PosChoco} : L_PosChoco { PosChoco (mkPosToken $1)}
Module :: { Module }
Module : ListDeclaration { Language.Clafer.Front.AbsClafer.Module ((mkCatSpan $1)) (reverse $1) }
Declaration :: { Declaration }
Declaration : 'enum' PosIdent '=' ListEnumId { Language.Clafer.Front.AbsClafer.EnumDecl ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
| Element { Language.Clafer.Front.AbsClafer.ElementDecl ((mkCatSpan $1)) $1 }
Clafer :: { Clafer }
Clafer : Abstract ListTempModifier GCard PosIdent Super Reference Card Init Transition Elements { Language.Clafer.Front.AbsClafer.Clafer ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3) >- (mkCatSpan $4) >- (mkCatSpan $5) >- (mkCatSpan $6) >- (mkCatSpan $7) >- (mkCatSpan $8) >- (mkCatSpan $9) >- (mkCatSpan $10)) $1 (reverse $2) $3 $4 $5 $6 $7 $8 $9 $10 }
Constraint :: { Constraint }
Constraint : '[' ListExp ']' { Language.Clafer.Front.AbsClafer.Constraint ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) }
Assertion :: { Assertion }
Assertion : 'assert' '[' ListExp ']' { Language.Clafer.Front.AbsClafer.Assertion ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
Goal :: { Goal }
Goal : '<<' 'min' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMinDeprecated ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
| '<<' 'max' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMaxDeprecated ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
| '<<' 'minimize' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMinimize ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
| '<<' 'maximize' ListExp '>>' { Language.Clafer.Front.AbsClafer.GoalMaximize ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4)) (reverse $3) }
TempModifier :: { TempModifier }
TempModifier : 'initial' { Language.Clafer.Front.AbsClafer.Initial ((mkTokenSpan $1)) }
| 'final' { Language.Clafer.Front.AbsClafer.Final ((mkTokenSpan $1)) }
| 'finalref' { Language.Clafer.Front.AbsClafer.FinalRef ((mkTokenSpan $1)) }
| 'finaltarget' { Language.Clafer.Front.AbsClafer.FinalTarget ((mkTokenSpan $1)) }
Transition :: { Transition }
Transition : {- empty -} { Language.Clafer.Front.AbsClafer.TransitionEmpty noSpan }
| TransArrow Exp { Language.Clafer.Front.AbsClafer.Transition ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
Abstract :: { Abstract }
Abstract : {- empty -} { Language.Clafer.Front.AbsClafer.AbstractEmpty noSpan }
| 'abstract' { Language.Clafer.Front.AbsClafer.Abstract ((mkTokenSpan $1)) }
Elements :: { Elements }
Elements : {- empty -} { Language.Clafer.Front.AbsClafer.ElementsEmpty noSpan }
| '{' ListElement '}' { Language.Clafer.Front.AbsClafer.ElementsList ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) }
Element :: { Element }
Element : Clafer { Language.Clafer.Front.AbsClafer.Subclafer ((mkCatSpan $1)) $1 }
| '`' Name Card Elements { Language.Clafer.Front.AbsClafer.ClaferUse ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3) >- (mkCatSpan $4)) $2 $3 $4 }
| Constraint { Language.Clafer.Front.AbsClafer.Subconstraint ((mkCatSpan $1)) $1 }
| Goal { Language.Clafer.Front.AbsClafer.Subgoal ((mkCatSpan $1)) $1 }
| Assertion { Language.Clafer.Front.AbsClafer.SubAssertion ((mkCatSpan $1)) $1 }
Super :: { Super }
Super : {- empty -} { Language.Clafer.Front.AbsClafer.SuperEmpty noSpan }
| ':' Exp26 { Language.Clafer.Front.AbsClafer.SuperSome ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
Reference :: { Reference }
Reference : {- empty -} { Language.Clafer.Front.AbsClafer.ReferenceEmpty noSpan }
| '->' Exp23 { Language.Clafer.Front.AbsClafer.ReferenceSet ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| '->>' Exp23 { Language.Clafer.Front.AbsClafer.ReferenceBag ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
Init :: { Init }
Init : {- empty -} { Language.Clafer.Front.AbsClafer.InitEmpty noSpan }
| InitHow Exp { Language.Clafer.Front.AbsClafer.InitSome ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
InitHow :: { InitHow }
InitHow : '=' { Language.Clafer.Front.AbsClafer.InitConstant ((mkTokenSpan $1)) }
| ':=' { Language.Clafer.Front.AbsClafer.InitDefault ((mkTokenSpan $1)) }
GCard :: { GCard }
GCard : {- empty -} { Language.Clafer.Front.AbsClafer.GCardEmpty noSpan }
| 'xor' { Language.Clafer.Front.AbsClafer.GCardXor ((mkTokenSpan $1)) }
| 'or' { Language.Clafer.Front.AbsClafer.GCardOr ((mkTokenSpan $1)) }
| 'mux' { Language.Clafer.Front.AbsClafer.GCardMux ((mkTokenSpan $1)) }
| 'opt' { Language.Clafer.Front.AbsClafer.GCardOpt ((mkTokenSpan $1)) }
| NCard { Language.Clafer.Front.AbsClafer.GCardInterval ((mkCatSpan $1)) $1 }
Card :: { Card }
Card : {- empty -} { Language.Clafer.Front.AbsClafer.CardEmpty noSpan }
| '?' { Language.Clafer.Front.AbsClafer.CardLone ((mkTokenSpan $1)) }
| '+' { Language.Clafer.Front.AbsClafer.CardSome ((mkTokenSpan $1)) }
| '*' { Language.Clafer.Front.AbsClafer.CardAny ((mkTokenSpan $1)) }
| PosInteger { Language.Clafer.Front.AbsClafer.CardNum ((mkCatSpan $1)) $1 }
| NCard { Language.Clafer.Front.AbsClafer.CardInterval ((mkCatSpan $1)) $1 }
NCard :: { NCard }
NCard : PosInteger '..' ExInteger { Language.Clafer.Front.AbsClafer.NCard ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
ExInteger :: { ExInteger }
ExInteger : '*' { Language.Clafer.Front.AbsClafer.ExIntegerAst ((mkTokenSpan $1)) }
| PosInteger { Language.Clafer.Front.AbsClafer.ExIntegerNum ((mkCatSpan $1)) $1 }
Name :: { Name }
Name : ListModId { Language.Clafer.Front.AbsClafer.Path ((mkCatSpan $1)) $1 }
Exp :: { Exp }
Exp : Exp1 TransArrow Exp { Language.Clafer.Front.AbsClafer.TransitionExp ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $1 $2 $3 }
| Exp1 { $1 }
Exp1 :: { Exp }
Exp1 : 'all' 'disj' Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclAllDisj ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4) >- (mkCatSpan $5)) $3 $5 }
| 'all' Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclAll ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
| Quant 'disj' Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclQuantDisj ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4) >- (mkCatSpan $5)) $1 $3 $5 }
| Quant Decl '|' Exp1 { Language.Clafer.Front.AbsClafer.EDeclQuant ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $1 $2 $4 }
| 'if' Exp1 'then' Exp1 'else' Exp1 { Language.Clafer.Front.AbsClafer.EImpliesElse ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4) >- (mkTokenSpan $5) >- (mkCatSpan $6)) $2 $4 $6 }
| 'let' VarBinding 'in' Exp1 { Language.Clafer.Front.AbsClafer.LetExp ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
| Exp2 { $1 }
Exp2 :: { Exp }
Exp2 : 'never' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatNever ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
| 'sometime' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatSometime ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
| 'lonce' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatLessOrOnce ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
| 'always' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatAlways ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3)) $2 $3 }
| Exp3 'must' 'precede' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatPrecede ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4) >- (mkCatSpan $5)) $1 $4 $5 }
| Exp3 'must' 'follow' Exp3 PatternScope { Language.Clafer.Front.AbsClafer.TmpPatFollow ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4) >- (mkCatSpan $5)) $1 $4 $5 }
| 'initially' Exp3 { Language.Clafer.Front.AbsClafer.TmpInitially ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'finally' Exp3 { Language.Clafer.Front.AbsClafer.TmpFinally ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| Exp3 { $1 }
Exp3 :: { Exp }
Exp3 : Exp3 '<=>' Exp4 { Language.Clafer.Front.AbsClafer.EIff ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp4 { $1 }
Exp4 :: { Exp }
Exp4 : Exp4 '=>' Exp5 { Language.Clafer.Front.AbsClafer.EImplies ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp5 { $1 }
Exp5 :: { Exp }
Exp5 : Exp5 '||' Exp6 { Language.Clafer.Front.AbsClafer.EOr ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp6 { $1 }
Exp6 :: { Exp }
Exp6 : Exp6 'xor' Exp7 { Language.Clafer.Front.AbsClafer.EXor ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp7 { $1 }
Exp7 :: { Exp }
Exp7 : Exp7 '&&' Exp8 { Language.Clafer.Front.AbsClafer.EAnd ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp8 { $1 }
Exp8 :: { Exp }
Exp8 : Exp8 'U' Exp9 { Language.Clafer.Front.AbsClafer.LtlU ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp8 'until' Exp9 { Language.Clafer.Front.AbsClafer.TmpUntil ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp9 { $1 }
Exp9 :: { Exp }
Exp9 : Exp9 'W' Exp10 { Language.Clafer.Front.AbsClafer.LtlW ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp9 'weakuntil' Exp10 { Language.Clafer.Front.AbsClafer.TmpWUntil ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp10 { $1 }
Exp10 :: { Exp }
Exp10 : 'F' Exp10 { Language.Clafer.Front.AbsClafer.LtlF ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'eventually' Exp10 { Language.Clafer.Front.AbsClafer.TmpEventually ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'G' Exp10 { Language.Clafer.Front.AbsClafer.LtlG ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'globally' Exp10 { Language.Clafer.Front.AbsClafer.TmpGlobally ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'X' Exp10 { Language.Clafer.Front.AbsClafer.LtlX ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'next' Exp10 { Language.Clafer.Front.AbsClafer.TmpNext ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| Exp11 { $1 }
Exp11 :: { Exp }
Exp11 : '!' Exp11 { Language.Clafer.Front.AbsClafer.ENeg ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| Exp12 { $1 }
Exp15 :: { Exp }
Exp15 : Exp15 '<' Exp16 { Language.Clafer.Front.AbsClafer.ELt ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp15 '>' Exp16 { Language.Clafer.Front.AbsClafer.EGt ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp15 '=' Exp16 { Language.Clafer.Front.AbsClafer.EEq ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp15 '<=' Exp16 { Language.Clafer.Front.AbsClafer.ELte ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp15 '>=' Exp16 { Language.Clafer.Front.AbsClafer.EGte ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp15 '!=' Exp16 { Language.Clafer.Front.AbsClafer.ENeq ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp15 'in' Exp16 { Language.Clafer.Front.AbsClafer.EIn ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp15 'not' 'in' Exp16 { Language.Clafer.Front.AbsClafer.ENin ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $1 $4 }
| Exp16 { $1 }
Exp16 :: { Exp }
Exp16 : Quant Exp20 { Language.Clafer.Front.AbsClafer.EQuantExp ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
| Exp17 { $1 }
Exp17 :: { Exp }
Exp17 : Exp17 '+' Exp18 { Language.Clafer.Front.AbsClafer.EAdd ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp17 '-' Exp18 { Language.Clafer.Front.AbsClafer.ESub ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp18 { $1 }
Exp18 :: { Exp }
Exp18 : Exp18 '*' Exp19 { Language.Clafer.Front.AbsClafer.EMul ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp18 '/' Exp19 { Language.Clafer.Front.AbsClafer.EDiv ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp18 '%' Exp19 { Language.Clafer.Front.AbsClafer.ERem ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp19 { $1 }
Exp19 :: { Exp }
Exp19 : 'max' Exp20 { Language.Clafer.Front.AbsClafer.EGMax ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'min' Exp20 { Language.Clafer.Front.AbsClafer.EGMin ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| Exp20 { $1 }
Exp20 :: { Exp }
Exp20 : 'sum' Exp21 { Language.Clafer.Front.AbsClafer.ESum ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'product' Exp21 { Language.Clafer.Front.AbsClafer.EProd ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| '#' Exp21 { Language.Clafer.Front.AbsClafer.ECard ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| '-' Exp21 { Language.Clafer.Front.AbsClafer.EMinExp ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| Exp21 { $1 }
Exp21 :: { Exp }
Exp21 : Exp21 '<:' Exp22 { Language.Clafer.Front.AbsClafer.EDomain ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp22 { $1 }
Exp22 :: { Exp }
Exp22 : Exp22 ':>' Exp23 { Language.Clafer.Front.AbsClafer.ERange ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp23 { $1 }
Exp23 :: { Exp }
Exp23 : Exp23 '++' Exp24 { Language.Clafer.Front.AbsClafer.EUnion ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp23 ',' Exp24 { Language.Clafer.Front.AbsClafer.EUnionCom ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp24 { $1 }
Exp24 :: { Exp }
Exp24 : Exp24 '--' Exp25 { Language.Clafer.Front.AbsClafer.EDifference ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp25 { $1 }
Exp25 :: { Exp }
Exp25 : Exp25 '**' Exp26 { Language.Clafer.Front.AbsClafer.EIntersection ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp26 { $1 }
Exp26 :: { Exp }
Exp26 : Exp26 '&' Exp27 { Language.Clafer.Front.AbsClafer.EIntersectionDeprecated ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp26 '.' Exp27 { Language.Clafer.Front.AbsClafer.EJoin ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
| Exp27 { $1 }
Exp27 :: { Exp }
Exp27 : Name { Language.Clafer.Front.AbsClafer.ClaferId ((mkCatSpan $1)) $1 }
| PosInteger { Language.Clafer.Front.AbsClafer.EInt ((mkCatSpan $1)) $1 }
| PosDouble { Language.Clafer.Front.AbsClafer.EDouble ((mkCatSpan $1)) $1 }
| PosReal { Language.Clafer.Front.AbsClafer.EReal ((mkCatSpan $1)) $1 }
| PosString { Language.Clafer.Front.AbsClafer.EStr ((mkCatSpan $1)) $1 }
| '(' Exp ')' { $2 }
TransGuard :: { TransGuard }
TransGuard : Exp1 { Language.Clafer.Front.AbsClafer.TransGuard ((mkCatSpan $1)) $1 }
TransArrow :: { TransArrow }
TransArrow : '-->>' { Language.Clafer.Front.AbsClafer.SyncTransArrow ((mkTokenSpan $1)) }
| '-[' TransGuard ']->>' { Language.Clafer.Front.AbsClafer.GuardedSyncTransArrow ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) $2 }
| '-->' { Language.Clafer.Front.AbsClafer.NextTransArrow ((mkTokenSpan $1)) }
| '-[' TransGuard ']->' { Language.Clafer.Front.AbsClafer.GuardedNextTransArrow ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) $2 }
PatternScope :: { PatternScope }
PatternScope : 'before' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeBefore ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'after' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeAfter ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
| 'between' Exp11 'and' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeBetweenAnd ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
| 'after' Exp11 'until' Exp11 { Language.Clafer.Front.AbsClafer.PatScopeAfterUntil ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
| {- empty -} { Language.Clafer.Front.AbsClafer.PatScopeEmpty noSpan }
Decl :: { Decl }
Decl : ListLocId ':' Exp21 { Language.Clafer.Front.AbsClafer.Decl ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
VarBinding :: { VarBinding }
VarBinding : LocId '=' Exp16 { Language.Clafer.Front.AbsClafer.VarBinding ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
Quant :: { Quant }
Quant : 'no' { Language.Clafer.Front.AbsClafer.QuantNo ((mkTokenSpan $1)) }
| 'not' { Language.Clafer.Front.AbsClafer.QuantNot ((mkTokenSpan $1)) }
| 'lone' { Language.Clafer.Front.AbsClafer.QuantLone ((mkTokenSpan $1)) }
| 'one' { Language.Clafer.Front.AbsClafer.QuantOne ((mkTokenSpan $1)) }
| 'some' { Language.Clafer.Front.AbsClafer.QuantSome ((mkTokenSpan $1)) }
EnumId :: { EnumId }
EnumId : PosIdent { Language.Clafer.Front.AbsClafer.EnumIdIdent ((mkCatSpan $1)) $1 }
ModId :: { ModId }
ModId : PosIdent { Language.Clafer.Front.AbsClafer.ModIdIdent ((mkCatSpan $1)) $1 }
LocId :: { LocId }
LocId : PosIdent { Language.Clafer.Front.AbsClafer.LocIdIdent ((mkCatSpan $1)) $1 }
ListDeclaration :: { [Declaration] }
ListDeclaration : {- empty -} { [] }
| ListDeclaration Declaration { flip (:) $1 $2 }
| ListDeclaration L_sep { $1 }
ListEnumId :: { [EnumId] }
ListEnumId : EnumId { (:[]) $1 }
| EnumId '|' ListEnumId { (:) $1 $3 }
ListElement :: { [Element] }
ListElement : {- empty -} { [] }
| ListElement Element { flip (:) $1 $2 }
| ListElement L_sep { $1 }
ListExp :: { [Exp] }
ListExp : {- empty -} { [] } | ListExp Exp { flip (:) $1 $2 }
ListTempModifier :: { [TempModifier] }
ListTempModifier : {- empty -} { [] }
| ListTempModifier TempModifier { flip (:) $1 $2 }
ListLocId :: { [LocId] }
ListLocId : LocId { (:[]) $1 }
| LocId ';' ListLocId { (:) $1 $3 }
ListModId :: { [ModId] }
ListModId : ModId { (:[]) $1 }
| ModId '\\' ListModId { (:) $1 $3 }
Exp12 :: { Exp }
Exp12 : Exp13 { $1 }
Exp13 :: { Exp }
Exp13 : Exp14 { $1 }
Exp14 :: { Exp }
Exp14 : Exp15 { $1 }
{
returnM :: a -> Err a
returnM = return
thenM :: Err a -> (a -> Err b) -> Err b
thenM = (>>=)
happyError :: [Token] -> Err a
-- | The separator of sibling lines, which the layout resolver inserts, e.g., in @a ; 2..3 b@,
-- so that a group cardinality at the start of a line is not the cardinality of the clafer on
-- the line before. It is not a reserved symbol, so a model cannot contain it.
layoutSeparator :: Token
layoutSeparator = PT (Pn 0 0 0) (TS "" 101)
isLayoutSeparator :: Token -> Bool
isLayoutSeparator (PT _ (TS _ 101)) = True
isLayoutSeparator _ = False
happyError ts' =
-- the position is reported with the error; in a model of several files, the line of the
-- token is a line of the complete model. The separators inserted by the layout resolver
-- are not shown.
let ts = filter (not . isLayoutSeparator) ts' in
Bad (pp ts) $ "syntax error" ++
case ts of
[] -> " at end of file"
[Err _] -> " due to lexer error"
_ -> " before " ++ unwords (map (id . prToken) (take 4 ts))
myLexer = tokens
gp x@(PT (Pn _ l c) _) = Span (Pos (toInteger l) (toInteger c)) (Pos (toInteger l) (toInteger c + toInteger (length $ prToken x)))
pp (PT (Pn _ l c) _ :_) = Pos (toInteger l) (toInteger c)
pp (Err (Pn _ l c) :_) = Pos (toInteger l) (toInteger c)
pp _ = error "EOF"
mkCatSpan :: (Spannable c) => c -> Span
mkCatSpan = getSpan
mkTokenSpan :: Token -> Span
mkTokenSpan = gp
}