www.jammni.de

import Control.Monad
import qualified Lexer
import qualified Parser
import qualified Grammar

main :: IO ()
main = do content <- getContents
          let grammar = Parser.statement (Lexer.alexScanTokens content)
          putStrLn $ (Grammar.startSymbol grammar) ++ " {"
          forM_ (Grammar.productions grammar) (putStrLn . ("  " ++) . show)
          putStrLn $ "}"

module Grammar where

import qualified Data.List as List

type Variable = String
type Terminal = Char
data Symbol = V Variable | T Terminal
              deriving (Eq, Ord)

data Grammar = Grammar Variable [Production]

data Production = Production Variable [Symbol]
                  deriving Eq

showSymbols :: [Symbol] -> String
showSymbols = concat . List.intersperse " " . map show

instance Show Symbol where
    show (V v) = v
    show (T t) = [t]

instance Show Production where
    show (Production v symbs) = v ++ " : " ++ showSymbols symbs

instance Show Grammar where
    show (Grammar v ps) = "???"

startSymbol :: Grammar -> Variable
startSymbol (Grammar x _) = x

productions :: Grammar -> [Production]
productions (Grammar _ ps) = ps

<non-terminal> [ :: { <type> } ]
        :  <id> ... {[%] <expression> }
      [ |  <id> ... {[%] <expression> }
        ... ]