Added the src/Grammar folder to the gitingore.
This commit is contained in:
Samuel Hammersberg
parent
66fb77c84e
commit
d779605814
23 changed files with 1 additions and 2322 deletions
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -2,3 +2,4 @@ dist-newstyle
|
|||
*.y
|
||||
*.x
|
||||
*.bak
|
||||
src/Grammar/*
|
||||
Binary file not shown.
|
|
@ -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)
|
||||
|
||||
Binary file not shown.
|
|
@ -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).
|
||||
|
|
@ -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
|
||||
Binary file not shown.
File diff suppressed because one or more lines are too long
Binary file not shown.
Binary file not shown.
|
|
@ -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.
|
||||
|
|
@ -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
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -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])
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -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
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -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
|
||||
|
||||
Binary file not shown.
BIN
src/Grammar/test
BIN
src/Grammar/test
Binary file not shown.
Loading…
Add table
Add a link
Reference in a new issue