Rakarake/churf
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Added the src/Grammar folder to the gitingore.

Browse source
This commit is contained in:
Samuel Hammersberg 2023-02-04 15:12:32 +01:00
parent 66fb77c84e
commit d779605814
23 changed files with 1 additions and 2322 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -2,3 +2,4 @@ dist-newstyle
*.y *.y
*.x *.x
*.bak *.bak
src/Grammar/*

BIN
src/Grammar/Abs.hi
View file

Binary file not shown.

30
src/Grammar/Abs.hs
View file

@ -1,30 +0,0 @@
-- File generated by the BNF Converter (bnfc 2.9.4.1).
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-- | The abstract syntax of language Grammar.
module Grammar.Abs where
import Prelude (Integer, String)
import qualified Prelude as C (Eq, Ord, Show, Read)
import qualified Data.String
data Program = Program Exp
deriving (C.Eq, C.Ord, C.Show, C.Read)
data Exp
= EId Ident
| EInt Integer
| EApp Exp Exp
| EAdd Exp Exp
| ESub Exp Exp
| EMul Exp Exp
| EDiv Exp Exp
| EMod Exp Exp
| EAbs Ident Exp
deriving (C.Eq, C.Ord, C.Show, C.Read)
newtype Ident = Ident String
deriving (C.Eq, C.Ord, C.Show, C.Read, Data.String.IsString)

BIN
src/Grammar/Abs.o
View file

Binary file not shown.

62
src/Grammar/Doc.txt
View file

@ -1,62 +0,0 @@
The Language Grammar
BNF Converter
%Process by txt2tags to generate html or latex
This document was automatically generated by the //BNF-Converter//. It was generated together with the lexer, the parser, and the abstract syntax module, which guarantees that the document matches with the implementation of the language (provided no hand-hacking has taken place).
==The lexical structure of Grammar==
===Identifiers===
Identifiers //Ident// are unquoted strings beginning with a letter,
followed by any combination of letters, digits, and the characters ``_ '``
reserved words excluded.
===Literals===
Integer literals //Integer// are nonempty sequences of digits.
===Reserved words and symbols===
The set of reserved words is the set of terminals appearing in the grammar. Those reserved words that consist of non-letter characters are called symbols, and they are treated in a different way from those that are similar to identifiers. The lexer follows rules familiar from languages like Haskell, C, and Java, including longest match and spacing conventions.
The reserved words used in Grammar are the following:
| ``main`` | | |
The symbols used in Grammar are the following:
| = | + | - | *
| / | % | \ | ->
| ( | ) | |
===Comments===
Single-line comments begin with --.Multiple-line comments are enclosed with {- and -}.
==The syntactic structure of Grammar==
Non-terminals are enclosed between < and >.
The symbols -> (production), **|** (union)
and **eps** (empty rule) belong to the BNF notation.
All other symbols are terminals.
| //Program// | -> | ``main`` ``=`` //Exp//
| //Exp3// | -> | //Ident//
| | **|** | //Integer//
| | **|** | //Exp3// ``%`` //Exp4//
| | **|** | //Exp4//
| //Exp2// | -> | //Exp2// //Exp3//
| | **|** | //Exp2// ``*`` //Exp3//
| | **|** | //Exp2// ``/`` //Exp3//
| | **|** | //Exp3//
| //Exp1// | -> | //Exp1// ``+`` //Exp2//
| | **|** | //Exp1// ``-`` //Exp2//
| | **|** | //Exp2//
| //Exp// | -> | ``\`` //Ident// ``->`` //Exp//
| | **|** | //Exp1//
| //Exp4// | -> | ``(`` //Exp// ``)``
%% File generated by the BNF Converter (bnfc 2.9.4.1).

91
src/Grammar/ErrM.hs
View file

@ -1,91 +0,0 @@
-- File generated by the BNF Converter (bnfc 2.9.4.1).
{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 708
---------------------------------------------------------------------------
-- Pattern synonyms exist since ghc 7.8.
-- | BNF Converter: Error Monad.
--
-- Module for backwards compatibility.
--
-- The generated parser now uses @'Either' String@ as error monad.
-- This module defines a type synonym 'Err' and pattern synonyms
-- 'Bad' and 'Ok' for 'Left' and 'Right'.
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE FlexibleInstances #-}
module Grammar.ErrM where
import Prelude (id, const, Either(..), String)
import Control.Monad (MonadPlus(..))
import Control.Applicative (Alternative(..))
#if __GLASGOW_HASKELL__ >= 808
import Control.Monad (MonadFail(..))
#endif
-- | Error monad with 'String' error messages.
type Err = Either String
pattern Bad msg = Left msg
pattern Ok a = Right a
#if __GLASGOW_HASKELL__ >= 808
instance MonadFail Err where
fail = Bad
#endif
instance Alternative Err where
empty = Left "Err.empty"
(<|>) Left{} = id
(<|>) x@Right{} = const x
instance MonadPlus Err where
mzero = empty
mplus = (<|>)
#else
---------------------------------------------------------------------------
-- ghc 7.6 and before: use old definition as data type.
-- | BNF Converter: Error Monad
-- Copyright (C) 2004 Author: Aarne Ranta
-- This file comes with NO WARRANTY and may be used FOR ANY PURPOSE.
module Grammar.ErrM where
-- the Error monad: like Maybe type with error msgs
import Control.Applicative (Applicative(..), Alternative(..))
import Control.Monad (MonadPlus(..), liftM)
data Err a = Ok a | Bad String
deriving (Read, Show, Eq, Ord)
instance Monad Err where
return = Ok
Ok a >>= f = f a
Bad s >>= _ = Bad s
instance Applicative Err where
pure = Ok
(Bad s) <*> _ = Bad s
(Ok f) <*> o = liftM f o
instance Functor Err where
fmap = liftM
instance MonadPlus Err where
mzero = Bad "Err.mzero"
mplus (Bad _) y = y
mplus x _ = x
instance Alternative Err where
empty = mzero
(<|>) = mplus
#endif

BIN
src/Grammar/Lex.hi
View file

Binary file not shown.

526
src/Grammar/Lex.hs
View file

File diff suppressed because one or more lines are too long

BIN
src/Grammar/Lex.o
View file

Binary file not shown.

BIN
src/Grammar/Par.hi
View file

Binary file not shown.

709
src/Grammar/Par.hs
View file

@ -1,709 +0,0 @@
{-# OPTIONS_GHC -w #-}
{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}
#if __GLASGOW_HASKELL__ >= 710
{-# OPTIONS_GHC -XPartialTypeSignatures #-}
#endif
{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
{-# LANGUAGE PatternSynonyms #-}
module Grammar.Par
( happyError
, myLexer
, pProgram
, pExp3
, pExp2
, pExp1
, pExp
, pExp4
) where
import Prelude
import qualified Grammar.Abs
import Grammar.Lex
import qualified Data.Array as Happy_Data_Array
import qualified Data.Bits as Bits
import qualified GHC.Exts as Happy_GHC_Exts
import Control.Applicative(Applicative(..))
import Control.Monad (ap)
-- parser produced by Happy Version 1.20.0
newtype HappyAbsSyn = HappyAbsSyn HappyAny
#if __GLASGOW_HASKELL__ >= 607
type HappyAny = Happy_GHC_Exts.Any
#else
type HappyAny = forall a . a
#endif
newtype HappyWrap9 = HappyWrap9 (Grammar.Abs.Ident)
happyIn9 :: (Grammar.Abs.Ident) -> (HappyAbsSyn )
happyIn9 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap9 x)
{-# INLINE happyIn9 #-}
happyOut9 :: (HappyAbsSyn ) -> HappyWrap9
happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut9 #-}
newtype HappyWrap10 = HappyWrap10 (Integer)
happyIn10 :: (Integer) -> (HappyAbsSyn )
happyIn10 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap10 x)
{-# INLINE happyIn10 #-}
happyOut10 :: (HappyAbsSyn ) -> HappyWrap10
happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut10 #-}
newtype HappyWrap11 = HappyWrap11 (Grammar.Abs.Program)
happyIn11 :: (Grammar.Abs.Program) -> (HappyAbsSyn )
happyIn11 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap11 x)
{-# INLINE happyIn11 #-}
happyOut11 :: (HappyAbsSyn ) -> HappyWrap11
happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut11 #-}
newtype HappyWrap12 = HappyWrap12 (Grammar.Abs.Exp)
happyIn12 :: (Grammar.Abs.Exp) -> (HappyAbsSyn )
happyIn12 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap12 x)
{-# INLINE happyIn12 #-}
happyOut12 :: (HappyAbsSyn ) -> HappyWrap12
happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut12 #-}
newtype HappyWrap13 = HappyWrap13 (Grammar.Abs.Exp)
happyIn13 :: (Grammar.Abs.Exp) -> (HappyAbsSyn )
happyIn13 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap13 x)
{-# INLINE happyIn13 #-}
happyOut13 :: (HappyAbsSyn ) -> HappyWrap13
happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut13 #-}
newtype HappyWrap14 = HappyWrap14 (Grammar.Abs.Exp)
happyIn14 :: (Grammar.Abs.Exp) -> (HappyAbsSyn )
happyIn14 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap14 x)
{-# INLINE happyIn14 #-}
happyOut14 :: (HappyAbsSyn ) -> HappyWrap14
happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut14 #-}
newtype HappyWrap15 = HappyWrap15 (Grammar.Abs.Exp)
happyIn15 :: (Grammar.Abs.Exp) -> (HappyAbsSyn )
happyIn15 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap15 x)
{-# INLINE happyIn15 #-}
happyOut15 :: (HappyAbsSyn ) -> HappyWrap15
happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut15 #-}
newtype HappyWrap16 = HappyWrap16 (Grammar.Abs.Exp)
happyIn16 :: (Grammar.Abs.Exp) -> (HappyAbsSyn )
happyIn16 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap16 x)
{-# INLINE happyIn16 #-}
happyOut16 :: (HappyAbsSyn ) -> HappyWrap16
happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOut16 #-}
happyInTok :: (Token) -> (HappyAbsSyn )
happyInTok x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyInTok #-}
happyOutTok :: (HappyAbsSyn ) -> (Token)
happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x
{-# INLINE happyOutTok #-}
happyExpList :: HappyAddr
happyExpList = HappyA# "\x00\x00\x00\x04\x00\x80\x00\x06\x00\x20\x80\x01\x00\x08\x60\x00\x00\x02\x1a\x00\x80\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x80\x22\x06\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x8a\x18\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x02\x1a\x00\x80\x00\x00\x00\x10\x00\x00\x00\x08\x60\x00\x00\x02\x18\x00\x80\x00\x06\x00\x20\x80\x01\x00\x00\x01\x00\x00\x04\x00\x00\x00\x00\x00\x00\x20\xa0\x01\x00\x28\x62\x00\x00\x8a\x18\x00\x40\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
{-# NOINLINE happyExpListPerState #-}
happyExpListPerState st =
token_strs_expected
where token_strs = ["error","%dummy","%start_pProgram","%start_pExp3","%start_pExp2","%start_pExp1","%start_pExp","%start_pExp4","Ident","Integer","Program","Exp3","Exp2","Exp1","Exp","Exp4","'%'","'('","')'","'*'","'+'","'-'","'->'","'/'","'='","'\\\\'","'main'","L_Ident","L_integ","%eof"]
bit_start = st Prelude.* 30
bit_end = (st Prelude.+ 1) Prelude.* 30
read_bit = readArrayBit happyExpList
bits = Prelude.map read_bit [bit_start..bit_end Prelude.- 1]
bits_indexed = Prelude.zip bits [0..29]
token_strs_expected = Prelude.concatMap f bits_indexed
f (Prelude.False, _) = []
f (Prelude.True, nr) = [token_strs Prelude.!! nr]
happyActOffsets :: HappyAddr
happyActOffsets = HappyA# "\xf9\xff\x12\x00\x12\x00\x12\x00\x0e\x00\x03\x00\xfa\xff\x00\x00\xfb\xff\x0e\x00\x00\x00\x00\x00\x16\x00\x06\x00\x10\x00\x0b\x00\x00\x00\x05\x00\x00\x00\x17\x00\xff\xff\x01\x00\x13\x00\x19\x00\x0e\x00\x1e\x00\x2c\x00\x12\x00\x12\x00\x12\x00\x12\x00\x2e\x00\x3a\x00\x00\x00\x0e\x00\x06\x00\x06\x00\x44\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
happyGotoOffsets :: HappyAddr
happyGotoOffsets = HappyA# "\x47\x00\x5a\x00\x4b\x00\x43\x00\x23\x00\x46\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x33\x00\x5c\x00\x00\x00\x64\x00\x69\x00\x50\x00\x55\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x6e\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int#
happyAdjustOffset off = off
happyDefActions :: HappyAddr
happyDefActions = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\xff\x00\x00\x00\x00\xf6\xff\xf5\xff\xef\xff\xec\xff\xea\xff\x00\x00\xf3\xff\x00\x00\xf8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\xff\x00\x00\xed\xff\xee\xff\xf0\xff\xf1\xff\xf4\xff\xf7\xff\xeb\xff"#
happyCheck :: HappyAddr
happyCheck = HappyA# "\xff\xff\x02\x00\x01\x00\x04\x00\x0b\x00\x02\x00\x0c\x00\x08\x00\x02\x00\x0e\x00\x04\x00\x0c\x00\x0d\x00\x0e\x00\x08\x00\x0e\x00\x02\x00\x0c\x00\x0c\x00\x0d\x00\x02\x00\x05\x00\x06\x00\x01\x00\x0a\x00\x0e\x00\x0c\x00\x0d\x00\x05\x00\x06\x00\x0c\x00\x0d\x00\x02\x00\x0e\x00\x09\x00\x00\x00\x01\x00\x0e\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x00\x00\x01\x00\x01\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x00\x00\x01\x00\x07\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x00\x00\x01\x00\x03\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x00\x00\x01\x00\x01\x00\x03\x00\x04\x00\x05\x00\x02\x00\x07\x00\x00\x00\x01\x00\x07\x00\x03\x00\x04\x00\x00\x00\x01\x00\x07\x00\x03\x00\x04\x00\x00\x00\x01\x00\x07\x00\x03\x00\x04\x00\x00\x00\x01\x00\x07\x00\x03\x00\x00\x00\x00\x00\x01\x00\x07\x00\x03\x00\x07\x00\x00\x00\x01\x00\x07\x00\x03\x00\xff\xff\x00\x00\x01\x00\x07\x00\x03\x00\xff\xff\x00\x00\x01\x00\x07\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
happyTable :: HappyAddr
happyTable = HappyA# "\x00\x00\x0a\x00\x1a\x00\x1c\x00\x18\x00\x0a\x00\x08\x00\x1d\x00\x0a\x00\xff\xff\x1c\x00\x08\x00\x13\x00\xff\xff\x1d\x00\xff\xff\x0a\x00\x08\x00\x08\x00\x13\x00\x0a\x00\x1e\x00\x1f\x00\x1a\x00\x12\x00\xff\xff\x08\x00\x13\x00\x1e\x00\x1f\x00\x08\x00\x13\x00\x0a\x00\xff\xff\x19\x00\x0a\x00\x0b\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x0a\x00\x0b\x00\x1a\x00\x0c\x00\x0d\x00\x0e\x00\x20\x00\x10\x00\x0a\x00\x0b\x00\x23\x00\x0c\x00\x0d\x00\x0e\x00\x28\x00\x10\x00\x0a\x00\x0b\x00\x22\x00\x0c\x00\x0d\x00\x0e\x00\x29\x00\x10\x00\x0a\x00\x0b\x00\x1a\x00\x0c\x00\x0d\x00\x13\x00\x16\x00\x10\x00\x0a\x00\x0b\x00\x08\x00\x0c\x00\x14\x00\x0a\x00\x0b\x00\x10\x00\x0c\x00\x24\x00\x0a\x00\x0b\x00\x10\x00\x0c\x00\x23\x00\x0a\x00\x0b\x00\x10\x00\x15\x00\x1f\x00\x0a\x00\x0b\x00\x10\x00\x1a\x00\x27\x00\x0a\x00\x0b\x00\x10\x00\x26\x00\x00\x00\x0a\x00\x0b\x00\x10\x00\x25\x00\x00\x00\x0a\x00\x0b\x00\x10\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
happyReduceArr = Happy_Data_Array.array (6, 22) [
(6 , happyReduce_6),
(7 , happyReduce_7),
(8 , happyReduce_8),
(9 , happyReduce_9),
(10 , happyReduce_10),
(11 , happyReduce_11),
(12 , happyReduce_12),
(13 , happyReduce_13),
(14 , happyReduce_14),
(15 , happyReduce_15),
(16 , happyReduce_16),
(17 , happyReduce_17),
(18 , happyReduce_18),
(19 , happyReduce_19),
(20 , happyReduce_20),
(21 , happyReduce_21),
(22 , happyReduce_22)
]
happy_n_terms = 15 :: Prelude.Int
happy_n_nonterms = 8 :: Prelude.Int
happyReduce_6 = happySpecReduce_1 0# happyReduction_6
happyReduction_6 happy_x_1
= case happyOutTok happy_x_1 of { (PT _ (TV happy_var_1)) ->
happyIn9
(Grammar.Abs.Ident happy_var_1
)}
happyReduce_7 = happySpecReduce_1 1# happyReduction_7
happyReduction_7 happy_x_1
= case happyOutTok happy_x_1 of { (PT _ (TI happy_var_1)) ->
happyIn10
((read happy_var_1) :: Integer
)}
happyReduce_8 = happySpecReduce_3 2# happyReduction_8
happyReduction_8 happy_x_3
happy_x_2
happy_x_1
= case happyOut15 happy_x_3 of { (HappyWrap15 happy_var_3) ->
happyIn11
(Grammar.Abs.Program happy_var_3
)}
happyReduce_9 = happySpecReduce_1 3# happyReduction_9
happyReduction_9 happy_x_1
= case happyOut9 happy_x_1 of { (HappyWrap9 happy_var_1) ->
happyIn12
(Grammar.Abs.EId happy_var_1
)}
happyReduce_10 = happySpecReduce_1 3# happyReduction_10
happyReduction_10 happy_x_1
= case happyOut10 happy_x_1 of { (HappyWrap10 happy_var_1) ->
happyIn12
(Grammar.Abs.EInt happy_var_1
)}
happyReduce_11 = happySpecReduce_3 3# happyReduction_11
happyReduction_11 happy_x_3
happy_x_2
happy_x_1
= case happyOut12 happy_x_1 of { (HappyWrap12 happy_var_1) ->
case happyOut16 happy_x_3 of { (HappyWrap16 happy_var_3) ->
happyIn12
(Grammar.Abs.EMod happy_var_1 happy_var_3
)}}
happyReduce_12 = happySpecReduce_1 3# happyReduction_12
happyReduction_12 happy_x_1
= case happyOut16 happy_x_1 of { (HappyWrap16 happy_var_1) ->
happyIn12
(happy_var_1
)}
happyReduce_13 = happySpecReduce_2 4# happyReduction_13
happyReduction_13 happy_x_2
happy_x_1
= case happyOut13 happy_x_1 of { (HappyWrap13 happy_var_1) ->
case happyOut12 happy_x_2 of { (HappyWrap12 happy_var_2) ->
happyIn13
(Grammar.Abs.EApp happy_var_1 happy_var_2
)}}
happyReduce_14 = happySpecReduce_3 4# happyReduction_14
happyReduction_14 happy_x_3
happy_x_2
happy_x_1
= case happyOut13 happy_x_1 of { (HappyWrap13 happy_var_1) ->
case happyOut12 happy_x_3 of { (HappyWrap12 happy_var_3) ->
happyIn13
(Grammar.Abs.EMul happy_var_1 happy_var_3
)}}
happyReduce_15 = happySpecReduce_3 4# happyReduction_15
happyReduction_15 happy_x_3
happy_x_2
happy_x_1
= case happyOut13 happy_x_1 of { (HappyWrap13 happy_var_1) ->
case happyOut12 happy_x_3 of { (HappyWrap12 happy_var_3) ->
happyIn13
(Grammar.Abs.EDiv happy_var_1 happy_var_3
)}}
happyReduce_16 = happySpecReduce_1 4# happyReduction_16
happyReduction_16 happy_x_1
= case happyOut12 happy_x_1 of { (HappyWrap12 happy_var_1) ->
happyIn13
(happy_var_1
)}
happyReduce_17 = happySpecReduce_3 5# happyReduction_17
happyReduction_17 happy_x_3
happy_x_2
happy_x_1
= case happyOut14 happy_x_1 of { (HappyWrap14 happy_var_1) ->
case happyOut13 happy_x_3 of { (HappyWrap13 happy_var_3) ->
happyIn14
(Grammar.Abs.EAdd happy_var_1 happy_var_3
)}}
happyReduce_18 = happySpecReduce_3 5# happyReduction_18
happyReduction_18 happy_x_3
happy_x_2
happy_x_1
= case happyOut14 happy_x_1 of { (HappyWrap14 happy_var_1) ->
case happyOut13 happy_x_3 of { (HappyWrap13 happy_var_3) ->
happyIn14
(Grammar.Abs.ESub happy_var_1 happy_var_3
)}}
happyReduce_19 = happySpecReduce_1 5# happyReduction_19
happyReduction_19 happy_x_1
= case happyOut13 happy_x_1 of { (HappyWrap13 happy_var_1) ->
happyIn14
(happy_var_1
)}
happyReduce_20 = happyReduce 4# 6# happyReduction_20
happyReduction_20 (happy_x_4 `HappyStk`
happy_x_3 `HappyStk`
happy_x_2 `HappyStk`
happy_x_1 `HappyStk`
happyRest)
= case happyOut9 happy_x_2 of { (HappyWrap9 happy_var_2) ->
case happyOut15 happy_x_4 of { (HappyWrap15 happy_var_4) ->
happyIn15
(Grammar.Abs.EAbs happy_var_2 happy_var_4
) `HappyStk` happyRest}}
happyReduce_21 = happySpecReduce_1 6# happyReduction_21
happyReduction_21 happy_x_1
= case happyOut14 happy_x_1 of { (HappyWrap14 happy_var_1) ->
happyIn15
(happy_var_1
)}
happyReduce_22 = happySpecReduce_3 7# happyReduction_22
happyReduction_22 happy_x_3
happy_x_2
happy_x_1
= case happyOut15 happy_x_2 of { (HappyWrap15 happy_var_2) ->
happyIn16
(happy_var_2
)}
happyNewToken action sts stk [] =
happyDoAction 14# notHappyAtAll action sts stk []
happyNewToken action sts stk (tk:tks) =
let cont i = happyDoAction i tk action sts stk tks in
case tk of {
PT _ (TS _ 1) -> cont 1#;
PT _ (TS _ 2) -> cont 2#;
PT _ (TS _ 3) -> cont 3#;
PT _ (TS _ 4) -> cont 4#;
PT _ (TS _ 5) -> cont 5#;
PT _ (TS _ 6) -> cont 6#;
PT _ (TS _ 7) -> cont 7#;
PT _ (TS _ 8) -> cont 8#;
PT _ (TS _ 9) -> cont 9#;
PT _ (TS _ 10) -> cont 10#;
PT _ (TS _ 11) -> cont 11#;
PT _ (TV happy_dollar_dollar) -> cont 12#;
PT _ (TI happy_dollar_dollar) -> cont 13#;
_ -> happyError' ((tk:tks), [])
}
happyError_ explist 14# tk tks = happyError' (tks, explist)
happyError_ explist _ tk tks = happyError' ((tk:tks), explist)
happyThen :: () => Err a -> (a -> Err b) -> Err b
happyThen = ((>>=))
happyReturn :: () => a -> Err a
happyReturn = (return)
happyThen1 m k tks = ((>>=)) m (\a -> k a tks)
happyReturn1 :: () => a -> b -> Err a
happyReturn1 = \a tks -> (return) a
happyError' :: () => ([(Token)], [Prelude.String]) -> Err a
happyError' = (\(tokens, _) -> happyError tokens)
pProgram tks = happySomeParser where
happySomeParser = happyThen (happyParse 0# tks) (\x -> happyReturn (let {(HappyWrap11 x') = happyOut11 x} in x'))
pExp3 tks = happySomeParser where
happySomeParser = happyThen (happyParse 1# tks) (\x -> happyReturn (let {(HappyWrap12 x') = happyOut12 x} in x'))
pExp2 tks = happySomeParser where
happySomeParser = happyThen (happyParse 2# tks) (\x -> happyReturn (let {(HappyWrap13 x') = happyOut13 x} in x'))
pExp1 tks = happySomeParser where
happySomeParser = happyThen (happyParse 3# tks) (\x -> happyReturn (let {(HappyWrap14 x') = happyOut14 x} in x'))
pExp tks = happySomeParser where
happySomeParser = happyThen (happyParse 4# tks) (\x -> happyReturn (let {(HappyWrap15 x') = happyOut15 x} in x'))
pExp4 tks = happySomeParser where
happySomeParser = happyThen (happyParse 5# tks) (\x -> happyReturn (let {(HappyWrap16 x') = happyOut16 x} in x'))
happySeq = happyDontSeq
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
{-# LINE 1 "templates/GenericTemplate.hs" #-}
-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $
-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
#if __GLASGOW_HASKELL__ > 706
#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Prelude.Bool)
#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Prelude.Bool)
#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Prelude.Bool)
#else
#define LT(n,m) (n Happy_GHC_Exts.<# m)
#define GTE(n,m) (n Happy_GHC_Exts.>=# m)
#define EQ(n,m) (n Happy_GHC_Exts.==# m)
#endif
data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList
infixr 9 `HappyStk`
data HappyStk a = HappyStk a (HappyStk a)
-----------------------------------------------------------------------------
-- starting the parse
happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
-----------------------------------------------------------------------------
-- Accepting the parse
-- If the current token is ERROR_TOK, it means we've just accepted a partial
-- parse (a %partial parser). We must ignore the saved token on the top of
-- the stack in this case.
happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =
happyReturn1 ans
happyAccept j tk st sts (HappyStk ans _) =
(happyTcHack j (happyTcHack st)) (happyReturn1 ans)
-----------------------------------------------------------------------------
-- Arrays only: do the next action
happyDoAction i tk st
= {- nothing -}
case action of
0# -> {- nothing -}
happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Prelude.Int)) i tk st
-1# -> {- nothing -}
happyAccept i tk st
n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}
(happyReduceArr Happy_Data_Array.! rule) i tk st
where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))
n -> {- nothing -}
happyShift new_state i tk st
where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))
where off = happyAdjustOffset (indexShortOffAddr happyActOffsets st)
off_i = (off Happy_GHC_Exts.+# i)
check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))
then EQ(indexShortOffAddr happyCheck off_i, i)
else Prelude.False
action
| check = indexShortOffAddr happyTable off_i
| Prelude.otherwise = indexShortOffAddr happyDefActions st
indexShortOffAddr (HappyA# arr) off =
Happy_GHC_Exts.narrow16Int# i
where
i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)
high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))
low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))
off' = off Happy_GHC_Exts.*# 2#
{-# INLINE happyLt #-}
happyLt x y = LT(x,y)
readArrayBit arr bit =
Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `Prelude.mod` 16)
where unbox_int (Happy_GHC_Exts.I# x) = x
data HappyAddr = HappyA# Happy_GHC_Exts.Addr#
-----------------------------------------------------------------------------
-- HappyState data type (not arrays)
-----------------------------------------------------------------------------
-- Shifting a token
happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =
let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
-- trace "shifting the error token" $
happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)
happyShift new_state i tk st sts stk =
happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)
-- happyReduce is specialised for the common cases.
happySpecReduce_0 i fn 0# tk st sts stk
= happyFail [] 0# tk st sts stk
happySpecReduce_0 nt fn j tk st@((action)) sts stk
= happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)
happySpecReduce_1 i fn 0# tk st sts stk
= happyFail [] 0# tk st sts stk
happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')
= let r = fn v1 in
happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
happySpecReduce_2 i fn 0# tk st sts stk
= happyFail [] 0# tk st sts stk
happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')
= let r = fn v1 v2 in
happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
happySpecReduce_3 i fn 0# tk st sts stk
= happyFail [] 0# tk st sts stk
happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
= let r = fn v1 v2 v3 in
happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
happyReduce k i fn 0# tk st sts stk
= happyFail [] 0# tk st sts stk
happyReduce k nt fn j tk st sts stk
= case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of
sts1@((HappyCons (st1@(action)) (_))) ->
let r = fn stk in -- it doesn't hurt to always seq here...
happyDoSeq r (happyGoto nt j tk st1 sts1 r)
happyMonadReduce k nt fn 0# tk st sts stk
= happyFail [] 0# tk st sts stk
happyMonadReduce k nt fn j tk st sts stk =
case happyDrop k (HappyCons (st) (sts)) of
sts1@((HappyCons (st1@(action)) (_))) ->
let drop_stk = happyDropStk k stk in
happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))
happyMonad2Reduce k nt fn 0# tk st sts stk
= happyFail [] 0# tk st sts stk
happyMonad2Reduce k nt fn j tk st sts stk =
case happyDrop k (HappyCons (st) (sts)) of
sts1@((HappyCons (st1@(action)) (_))) ->
let drop_stk = happyDropStk k stk
off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1)
off_i = (off Happy_GHC_Exts.+# nt)
new_state = indexShortOffAddr happyTable off_i
in
happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
happyDrop 0# l = l
happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t
happyDropStk 0# l = l
happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs
-----------------------------------------------------------------------------
-- Moving to a new state after a reduction
happyGoto nt j tk st =
{- nothing -}
happyDoAction j tk new_state
where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st)
off_i = (off Happy_GHC_Exts.+# nt)
new_state = indexShortOffAddr happyTable off_i
-----------------------------------------------------------------------------
-- Error recovery (ERROR_TOK is the error token)
-- parse error if we are in recovery and we fail again
happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) =
let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
-- trace "failing" $
happyError_ explist i tk
{- We don't need state discarding for our restricted implementation of
"error". In fact, it can cause some bogus parses, so I've disabled it
for now --SDM
-- discard a state
happyFail ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts)
(saved_tok `HappyStk` _ `HappyStk` stk) =
-- trace ("discarding state, depth " ++ show (length stk)) $
DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk))
-}
-- Enter error recovery: generate an error token,
-- save the old token and carry on.
happyFail explist i tk (action) sts stk =
-- trace "entering error recovery" $
happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)
-- Internal happy errors:
notHappyAtAll :: a
notHappyAtAll = Prelude.error "Internal Happy error\n"
-----------------------------------------------------------------------------
-- Hack to get the typechecker to accept our action functions
happyTcHack :: Happy_GHC_Exts.Int# -> a -> a
happyTcHack x y = y
{-# INLINE happyTcHack #-}
-----------------------------------------------------------------------------
-- Seq-ing. If the --strict flag is given, then Happy emits
-- happySeq = happyDoSeq
-- otherwise it emits
-- happySeq = happyDontSeq
happyDoSeq, happyDontSeq :: a -> b -> b
happyDoSeq a b = a `Prelude.seq` b
happyDontSeq a b = b
-----------------------------------------------------------------------------
-- Don't inline any functions from the template. GHC has a nasty habit
-- of deciding to inline happyGoto everywhere, which increases the size of
-- the generated parser quite a bit.
{-# NOINLINE happyDoAction #-}
{-# NOINLINE happyTable #-}
{-# NOINLINE happyCheck #-}
{-# NOINLINE happyActOffsets #-}
{-# NOINLINE happyGotoOffsets #-}
{-# NOINLINE happyDefActions #-}
{-# NOINLINE happyShift #-}
{-# NOINLINE happySpecReduce_0 #-}
{-# NOINLINE happySpecReduce_1 #-}
{-# NOINLINE happySpecReduce_2 #-}
{-# NOINLINE happySpecReduce_3 #-}
{-# NOINLINE happyReduce #-}
{-# NOINLINE happyMonadReduce #-}
{-# NOINLINE happyGoto #-}
{-# NOINLINE happyFail #-}
-- end of Happy Template.

635
src/Grammar/Par.info
View file

@ -1,635 +0,0 @@
-----------------------------------------------------------------------------
Info file generated by Happy Version 1.20.0 from src/Grammar/Par.y
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
Grammar
-----------------------------------------------------------------------------
%start_pProgram -> Program (0)
%start_pExp3 -> Exp3 (1)
%start_pExp2 -> Exp2 (2)
%start_pExp1 -> Exp1 (3)
%start_pExp -> Exp (4)
%start_pExp4 -> Exp4 (5)
Ident -> L_Ident (6)
Integer -> L_integ (7)
Program -> 'main' '=' Exp (8)
Exp3 -> Ident (9)
Exp3 -> Integer (10)
Exp3 -> Exp3 '%' Exp4 (11)
Exp3 -> Exp4 (12)
Exp2 -> Exp2 Exp3 (13)
Exp2 -> Exp2 '*' Exp3 (14)
Exp2 -> Exp2 '/' Exp3 (15)
Exp2 -> Exp3 (16)
Exp1 -> Exp1 '+' Exp2 (17)
Exp1 -> Exp1 '-' Exp2 (18)
Exp1 -> Exp2 (19)
Exp -> '\\' Ident '->' Exp (20)
Exp -> Exp1 (21)
Exp4 -> '(' Exp ')' (22)
-----------------------------------------------------------------------------
Terminals
-----------------------------------------------------------------------------
'%' { 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) }
'main' { PT _ (TS _ 11) }
L_Ident { PT _ (TV $$) }
L_integ { PT _ (TI $$) }
-----------------------------------------------------------------------------
Non-terminals
-----------------------------------------------------------------------------
%start_pProgram rule 0
%start_pExp3 rule 1
%start_pExp2 rule 2
%start_pExp1 rule 3
%start_pExp rule 4
%start_pExp4 rule 5
Ident rule 6
Integer rule 7
Program rule 8
Exp3 rules 9, 10, 11, 12
Exp2 rules 13, 14, 15, 16
Exp1 rules 17, 18, 19
Exp rules 20, 21
Exp4 rule 22
-----------------------------------------------------------------------------
States
-----------------------------------------------------------------------------
State 0
%start_pProgram -> . Program (rule 0)
'main' shift, and enter state 23
Program goto state 22
State 1
%start_pExp3 -> . Exp3 (rule 1)
'(' shift, and enter state 9
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 21
Exp4 goto state 16
State 2
%start_pExp2 -> . Exp2 (rule 2)
'(' shift, and enter state 9
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 20
Exp4 goto state 16
State 3
%start_pExp1 -> . Exp1 (rule 3)
'(' shift, and enter state 9
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 13
Exp1 goto state 19
Exp4 goto state 16
State 4
%start_pExp -> . Exp (rule 4)
'(' shift, and enter state 9
'\\' shift, and enter state 17
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 13
Exp1 goto state 14
Exp goto state 15
Exp4 goto state 16
State 5
%start_pExp4 -> . Exp4 (rule 5)
'(' shift, and enter state 9
Exp4 goto state 8
State 6
Ident -> . L_Ident (rule 6)
L_Ident shift, and enter state 7
State 7
Ident -> L_Ident . (rule 6)
'%' reduce using rule 6
'(' reduce using rule 6
')' reduce using rule 6
'*' reduce using rule 6
'+' reduce using rule 6
'-' reduce using rule 6
'->' reduce using rule 6
'/' reduce using rule 6
L_Ident reduce using rule 6
L_integ reduce using rule 6
%eof reduce using rule 6
State 8
%start_pExp4 -> Exp4 . (rule 5)
%eof accept
State 9
Exp4 -> '(' . Exp ')' (rule 22)
'(' shift, and enter state 9
'\\' shift, and enter state 17
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 13
Exp1 goto state 14
Exp goto state 32
Exp4 goto state 16
State 10
Exp3 -> Ident . (rule 9)
'%' reduce using rule 9
'(' reduce using rule 9
')' reduce using rule 9
'*' reduce using rule 9
'+' reduce using rule 9
'-' reduce using rule 9
'/' reduce using rule 9
L_Ident reduce using rule 9
L_integ reduce using rule 9
%eof reduce using rule 9
State 11
Exp3 -> Integer . (rule 10)
'%' reduce using rule 10
'(' reduce using rule 10
')' reduce using rule 10
'*' reduce using rule 10
'+' reduce using rule 10
'-' reduce using rule 10
'/' reduce using rule 10
L_Ident reduce using rule 10
L_integ reduce using rule 10
%eof reduce using rule 10
State 12
Exp3 -> Exp3 . '%' Exp4 (rule 11)
Exp2 -> Exp3 . (rule 16)
'%' shift, and enter state 25
'(' reduce using rule 16
')' reduce using rule 16
'*' reduce using rule 16
'+' reduce using rule 16
'-' reduce using rule 16
'/' reduce using rule 16
L_Ident reduce using rule 16
L_integ reduce using rule 16
%eof reduce using rule 16
State 13
Exp2 -> Exp2 . Exp3 (rule 13)
Exp2 -> Exp2 . '*' Exp3 (rule 14)
Exp2 -> Exp2 . '/' Exp3 (rule 15)
Exp1 -> Exp2 . (rule 19)
'(' shift, and enter state 9
')' reduce using rule 19
'*' shift, and enter state 27
'+' reduce using rule 19
'-' reduce using rule 19
'/' shift, and enter state 28
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
%eof reduce using rule 19
Ident goto state 10
Integer goto state 11
Exp3 goto state 26
Exp4 goto state 16
State 14
Exp1 -> Exp1 . '+' Exp2 (rule 17)
Exp1 -> Exp1 . '-' Exp2 (rule 18)
Exp -> Exp1 . (rule 21)
')' reduce using rule 21
'+' shift, and enter state 29
'-' shift, and enter state 30
%eof reduce using rule 21
State 15
%start_pExp -> Exp . (rule 4)
%eof accept
State 16
Exp3 -> Exp4 . (rule 12)
'%' reduce using rule 12
'(' reduce using rule 12
')' reduce using rule 12
'*' reduce using rule 12
'+' reduce using rule 12
'-' reduce using rule 12
'/' reduce using rule 12
L_Ident reduce using rule 12
L_integ reduce using rule 12
%eof reduce using rule 12
State 17
Exp -> '\\' . Ident '->' Exp (rule 20)
L_Ident shift, and enter state 7
Ident goto state 31
State 18
Integer -> L_integ . (rule 7)
'%' reduce using rule 7
'(' reduce using rule 7
')' reduce using rule 7
'*' reduce using rule 7
'+' reduce using rule 7
'-' reduce using rule 7
'/' reduce using rule 7
L_Ident reduce using rule 7
L_integ reduce using rule 7
%eof reduce using rule 7
State 19
%start_pExp1 -> Exp1 . (rule 3)
Exp1 -> Exp1 . '+' Exp2 (rule 17)
Exp1 -> Exp1 . '-' Exp2 (rule 18)
'+' shift, and enter state 29
'-' shift, and enter state 30
%eof accept
State 20
%start_pExp2 -> Exp2 . (rule 2)
Exp2 -> Exp2 . Exp3 (rule 13)
Exp2 -> Exp2 . '*' Exp3 (rule 14)
Exp2 -> Exp2 . '/' Exp3 (rule 15)
'(' shift, and enter state 9
'*' shift, and enter state 27
'/' shift, and enter state 28
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
%eof accept
Ident goto state 10
Integer goto state 11
Exp3 goto state 26
Exp4 goto state 16
State 21
%start_pExp3 -> Exp3 . (rule 1)
Exp3 -> Exp3 . '%' Exp4 (rule 11)
'%' shift, and enter state 25
%eof accept
State 22
%start_pProgram -> Program . (rule 0)
%eof accept
State 23
Program -> 'main' . '=' Exp (rule 8)
'=' shift, and enter state 24
State 24
Program -> 'main' '=' . Exp (rule 8)
'(' shift, and enter state 9
'\\' shift, and enter state 17
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 13
Exp1 goto state 14
Exp goto state 40
Exp4 goto state 16
State 25
Exp3 -> Exp3 '%' . Exp4 (rule 11)
'(' shift, and enter state 9
Exp4 goto state 39
State 26
Exp3 -> Exp3 . '%' Exp4 (rule 11)
Exp2 -> Exp2 Exp3 . (rule 13)
'%' shift, and enter state 25
'(' reduce using rule 13
')' reduce using rule 13
'*' reduce using rule 13
'+' reduce using rule 13
'-' reduce using rule 13
'/' reduce using rule 13
L_Ident reduce using rule 13
L_integ reduce using rule 13
%eof reduce using rule 13
State 27
Exp2 -> Exp2 '*' . Exp3 (rule 14)
'(' shift, and enter state 9
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 38
Exp4 goto state 16
State 28
Exp2 -> Exp2 '/' . Exp3 (rule 15)
'(' shift, and enter state 9
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 37
Exp4 goto state 16
State 29
Exp1 -> Exp1 '+' . Exp2 (rule 17)
'(' shift, and enter state 9
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 36
Exp4 goto state 16
State 30
Exp1 -> Exp1 '-' . Exp2 (rule 18)
'(' shift, and enter state 9
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 35
Exp4 goto state 16
State 31
Exp -> '\\' Ident . '->' Exp (rule 20)
'->' shift, and enter state 34
State 32
Exp4 -> '(' Exp . ')' (rule 22)
')' shift, and enter state 33
State 33
Exp4 -> '(' Exp ')' . (rule 22)
'%' reduce using rule 22
'(' reduce using rule 22
')' reduce using rule 22
'*' reduce using rule 22
'+' reduce using rule 22
'-' reduce using rule 22
'/' reduce using rule 22
L_Ident reduce using rule 22
L_integ reduce using rule 22
%eof reduce using rule 22
State 34
Exp -> '\\' Ident '->' . Exp (rule 20)
'(' shift, and enter state 9
'\\' shift, and enter state 17
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 12
Exp2 goto state 13
Exp1 goto state 14
Exp goto state 41
Exp4 goto state 16
State 35
Exp2 -> Exp2 . Exp3 (rule 13)
Exp2 -> Exp2 . '*' Exp3 (rule 14)
Exp2 -> Exp2 . '/' Exp3 (rule 15)
Exp1 -> Exp1 '-' Exp2 . (rule 18)
'(' shift, and enter state 9
')' reduce using rule 18
'*' shift, and enter state 27
'+' reduce using rule 18
'-' reduce using rule 18
'/' shift, and enter state 28
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
%eof reduce using rule 18
Ident goto state 10
Integer goto state 11
Exp3 goto state 26
Exp4 goto state 16
State 36
Exp2 -> Exp2 . Exp3 (rule 13)
Exp2 -> Exp2 . '*' Exp3 (rule 14)
Exp2 -> Exp2 . '/' Exp3 (rule 15)
Exp1 -> Exp1 '+' Exp2 . (rule 17)
'(' shift, and enter state 9
')' reduce using rule 17
'*' shift, and enter state 27
'+' reduce using rule 17
'-' reduce using rule 17
'/' shift, and enter state 28
L_Ident shift, and enter state 7
L_integ shift, and enter state 18
%eof reduce using rule 17
Ident goto state 10
Integer goto state 11
Exp3 goto state 26
Exp4 goto state 16
State 37
Exp3 -> Exp3 . '%' Exp4 (rule 11)
Exp2 -> Exp2 '/' Exp3 . (rule 15)
'%' shift, and enter state 25
'(' reduce using rule 15
')' reduce using rule 15
'*' reduce using rule 15
'+' reduce using rule 15
'-' reduce using rule 15
'/' reduce using rule 15
L_Ident reduce using rule 15
L_integ reduce using rule 15
%eof reduce using rule 15
State 38
Exp3 -> Exp3 . '%' Exp4 (rule 11)
Exp2 -> Exp2 '*' Exp3 . (rule 14)
'%' shift, and enter state 25
'(' reduce using rule 14
')' reduce using rule 14
'*' reduce using rule 14
'+' reduce using rule 14
'-' reduce using rule 14
'/' reduce using rule 14
L_Ident reduce using rule 14
L_integ reduce using rule 14
%eof reduce using rule 14
State 39
Exp3 -> Exp3 '%' Exp4 . (rule 11)
'%' reduce using rule 11
'(' reduce using rule 11
')' reduce using rule 11
'*' reduce using rule 11
'+' reduce using rule 11
'-' reduce using rule 11
'/' reduce using rule 11
L_Ident reduce using rule 11
L_integ reduce using rule 11
%eof reduce using rule 11
State 40
Program -> 'main' '=' Exp . (rule 8)
%eof reduce using rule 8
State 41
Exp -> '\\' Ident '->' Exp . (rule 20)
')' reduce using rule 20
%eof reduce using rule 20
-----------------------------------------------------------------------------
Grammar Totals
-----------------------------------------------------------------------------
Number of rules: 23
Number of terminals: 13
Number of non-terminals: 14
Number of states: 42

BIN
src/Grammar/Par.o
View file

Binary file not shown.

BIN
src/Grammar/Print.hi
View file

Binary file not shown.

157
src/Grammar/Print.hs
View file

@ -1,157 +0,0 @@
-- File generated by the BNF Converter (bnfc 2.9.4.1).
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
#if __GLASGOW_HASKELL__ <= 708
{-# LANGUAGE OverlappingInstances #-}
#endif
-- | Pretty-printer for Grammar.
module Grammar.Print where
import Prelude
( ($), (.)
, Bool(..), (==), (<)
, Int, Integer, Double, (+), (-), (*)
, String, (++)
, ShowS, showChar, showString
, all, elem, foldr, id, map, null, replicate, shows, span
)
import Data.Char ( Char, isSpace )
import qualified Grammar.Abs
-- | The top-level printing method.
printTree :: Print a => a -> String
printTree = render . prt 0
type Doc = [ShowS] -> [ShowS]
doc :: ShowS -> Doc
doc = (:)
render :: Doc -> String
render d = rend 0 False (map ($ "") $ d []) ""
where
rend
:: Int -- ^ Indentation level.
-> Bool -- ^ Pending indentation to be output before next character?
-> [String]
-> ShowS
rend i p = \case
"[" :ts -> char '[' . rend i False ts
"(" :ts -> char '(' . rend i False ts
"{" :ts -> onNewLine i p . showChar '{' . new (i+1) ts
"}" : ";":ts -> onNewLine (i-1) p . showString "};" . new (i-1) ts
"}" :ts -> onNewLine (i-1) p . showChar '}' . new (i-1) ts
[";"] -> char ';'
";" :ts -> char ';' . new i ts
t : ts@(s:_) | closingOrPunctuation s
-> pending . showString t . rend i False ts
t :ts -> pending . space t . rend i False ts
[] -> id
where
-- Output character after pending indentation.
char :: Char -> ShowS
char c = pending . showChar c
-- Output pending indentation.
pending :: ShowS
pending = if p then indent i else id
-- Indentation (spaces) for given indentation level.
indent :: Int -> ShowS
indent i = replicateS (2*i) (showChar ' ')
-- Continue rendering in new line with new indentation.
new :: Int -> [String] -> ShowS
new j ts = showChar '\n' . rend j True ts
-- Make sure we are on a fresh line.
onNewLine :: Int -> Bool -> ShowS
onNewLine i p = (if p then id else showChar '\n') . indent i
-- Separate given string from following text by a space (if needed).
space :: String -> ShowS
space t s =
case (all isSpace t', null spc, null rest) of
(True , _ , True ) -> [] -- remove trailing space
(False, _ , True ) -> t' -- remove trailing space
(False, True, False) -> t' ++ ' ' : s -- add space if none
_ -> t' ++ s
where
t' = showString t []
(spc, rest) = span isSpace s
closingOrPunctuation :: String -> Bool
closingOrPunctuation [c] = c `elem` closerOrPunct
closingOrPunctuation _ = False
closerOrPunct :: String
closerOrPunct = ")],;"
parenth :: Doc -> Doc
parenth ss = doc (showChar '(') . ss . doc (showChar ')')
concatS :: [ShowS] -> ShowS
concatS = foldr (.) id
concatD :: [Doc] -> Doc
concatD = foldr (.) id
replicateS :: Int -> ShowS -> ShowS
replicateS n f = concatS (replicate n f)
-- | The printer class does the job.
class Print a where
prt :: Int -> a -> Doc
instance {-# OVERLAPPABLE #-} Print a => Print [a] where
prt i = concatD . map (prt i)
instance Print Char where
prt _ c = doc (showChar '\'' . mkEsc '\'' c . showChar '\'')
instance Print String where
prt _ = printString
printString :: String -> Doc
printString s = doc (showChar '"' . concatS (map (mkEsc '"') s) . showChar '"')
mkEsc :: Char -> Char -> ShowS
mkEsc q = \case
s | s == q -> showChar '\\' . showChar s
'\\' -> showString "\\\\"
'\n' -> showString "\\n"
'\t' -> showString "\\t"
s -> showChar s
prPrec :: Int -> Int -> Doc -> Doc
prPrec i j = if j < i then parenth else id
instance Print Integer where
prt _ x = doc (shows x)
instance Print Double where
prt _ x = doc (shows x)
instance Print Grammar.Abs.Ident where
prt _ (Grammar.Abs.Ident i) = doc $ showString i
instance Print Grammar.Abs.Program where
prt i = \case
Grammar.Abs.Program exp -> prPrec i 0 (concatD [doc (showString "main"), doc (showString "="), prt 0 exp])
instance Print Grammar.Abs.Exp where
prt i = \case
Grammar.Abs.EId id_ -> prPrec i 3 (concatD [prt 0 id_])
Grammar.Abs.EInt n -> prPrec i 3 (concatD [prt 0 n])
Grammar.Abs.EApp exp1 exp2 -> prPrec i 2 (concatD [prt 2 exp1, prt 3 exp2])
Grammar.Abs.EAdd exp1 exp2 -> prPrec i 1 (concatD [prt 1 exp1, doc (showString "+"), prt 2 exp2])
Grammar.Abs.ESub exp1 exp2 -> prPrec i 1 (concatD [prt 1 exp1, doc (showString "-"), prt 2 exp2])
Grammar.Abs.EMul exp1 exp2 -> prPrec i 2 (concatD [prt 2 exp1, doc (showString "*"), prt 3 exp2])
Grammar.Abs.EDiv exp1 exp2 -> prPrec i 2 (concatD [prt 2 exp1, doc (showString "/"), prt 3 exp2])
Grammar.Abs.EMod exp1 exp2 -> prPrec i 3 (concatD [prt 3 exp1, doc (showString "%"), prt 4 exp2])
Grammar.Abs.EAbs id_ exp -> prPrec i 0 (concatD [doc (showString "\\"), prt 0 id_, doc (showString "->"), prt 0 exp])

BIN
src/Grammar/Print.o
View file

Binary file not shown.

BIN
src/Grammar/Skel.hi
View file

Binary file not shown.

36
src/Grammar/Skel.hs
View file

@ -1,36 +0,0 @@
-- File generated by the BNF Converter (bnfc 2.9.4.1).
-- Templates for pattern matching on abstract syntax
{-# OPTIONS_GHC -fno-warn-unused-matches #-}
module Grammar.Skel where
import Prelude (($), Either(..), String, (++), Show, show)
import qualified Grammar.Abs
type Err = Either String
type Result = Err String
failure :: Show a => a -> Result
failure x = Left $ "Undefined case: " ++ show x
transIdent :: Grammar.Abs.Ident -> Result
transIdent x = case x of
Grammar.Abs.Ident string -> failure x
transProgram :: Grammar.Abs.Program -> Result
transProgram x = case x of
Grammar.Abs.Program exp -> failure x
transExp :: Grammar.Abs.Exp -> Result
transExp x = case x of
Grammar.Abs.EId ident -> failure x
Grammar.Abs.EInt integer -> failure x
Grammar.Abs.EApp exp1 exp2 -> failure x
Grammar.Abs.EAdd exp1 exp2 -> failure x
Grammar.Abs.ESub exp1 exp2 -> failure x
Grammar.Abs.EMul exp1 exp2 -> failure x
Grammar.Abs.EDiv exp1 exp2 -> failure x
Grammar.Abs.EMod exp1 exp2 -> failure x
Grammar.Abs.EAbs ident exp -> failure x

BIN
src/Grammar/Skel.o
View file

Binary file not shown.

BIN
src/Grammar/Test.hi
View file

Binary file not shown.

76
src/Grammar/Test.hs
View file

@ -1,76 +0,0 @@
-- File generated by the BNF Converter (bnfc 2.9.4.1).
-- | Program to test parser.
module Main where
import Prelude
( ($), (.)
, Either(..)
, Int, (>)
, String, (++), concat, unlines
, Show, show
, IO, (>>), (>>=), mapM_, putStrLn
, FilePath
, getContents, readFile
)
import System.Environment ( getArgs )
import System.Exit ( exitFailure )
import Control.Monad ( when )
import Grammar.Abs ()
import Grammar.Lex ( Token, mkPosToken )
import Grammar.Par ( pProgram, myLexer )
import Grammar.Print ( Print, printTree )
import Grammar.Skel ()
type Err = Either String
type ParseFun a = [Token] -> Err a
type Verbosity = Int
putStrV :: Verbosity -> String -> IO ()
putStrV v s = when (v > 1) $ putStrLn s
runFile :: (Print a, Show a) => Verbosity -> ParseFun a -> FilePath -> IO ()
runFile v p f = putStrLn f >> readFile f >>= run v p
run :: (Print a, Show a) => Verbosity -> ParseFun a -> String -> IO ()
run v p s =
case p ts of
Left err -> do
putStrLn "\nParse Failed...\n"
putStrV v "Tokens:"
mapM_ (putStrV v . showPosToken . mkPosToken) ts
putStrLn err
exitFailure
Right tree -> do
putStrLn "\nParse Successful!"
showTree v tree
where
ts = myLexer s
showPosToken ((l,c),t) = concat [ show l, ":", show c, "\t", show t ]
showTree :: (Show a, Print a) => Int -> a -> IO ()
showTree v tree = do
putStrV v $ "\n[Abstract Syntax]\n\n" ++ show tree
putStrV v $ "\n[Linearized tree]\n\n" ++ printTree tree
usage :: IO ()
usage = do
putStrLn $ unlines
[ "usage: Call with one of the following argument combinations:"
, " --help Display this help message."
, " (no arguments) Parse stdin verbosely."
, " (files) Parse content of files verbosely."
, " -s (files) Silent mode. Parse content of files silently."
]
main :: IO ()
main = do
args <- getArgs
case args of
["--help"] -> usage
[] -> getContents >>= run 2 pProgram
"-s":fs -> mapM_ (runFile 0 pProgram) fs
fs -> mapM_ (runFile 2 pProgram) fs

BIN
src/Grammar/Test.o
View file

Binary file not shown.

BIN
src/Grammar/test
View file

Binary file not shown.