outline voor presentatie

diff --git a/deliverables/p1/p1.tex b/deliverables/p1/p1.tex
index 7aff91d..1b923bd 100644 (file)
--- a/deliverables/p1/p1.tex
+++ b/deliverables/p1/p1.tex
@@ -1,4 +1,36 @@
 %&p1
 \begin{document}
 \frame{\titlepage}
 %&p1
 \begin{document}
 \frame{\titlepage}

+
+%- Anything that is specific to your parser                                                                                   
+%      - Positions
+%      - yard (parser combinators)
+%      - LL*
+%      - Implementation language
+%      - Elaborate diffulties and eases
+%- Did you split it into two phases lexing and parsing, or just one phase?                                                    
+%      - Why parser combinator for lexer
+%- Problems and learned things
+%- Code metrics, loc, etc, met stomme xkcd
+%- How many lines of code do you have, how many hours did you work on it?                                                     
+%      “Measuring programming progress by lines of code is like measuring
+%      aircraft building progress by weight.”
+%
+%      ― Bill Gates
+%- Did you change the grammar, and if so how?                                                                                 
+%      - Standard tricks, remove left assoc, get operator assoc correct.
+%      - How did you solve the problems of precedence and associativity?                                                            
+%- Does your parser stop after the first encountered error or can it go on?                                                   
+%      - Stops, this is design, parsing should be correct!!!1!
+%- Did you try your parser on weird inputs, like 100 megabyte of nested                                                       
+%parenthesis? 1 gigabyte?                                                                                                     
+%      - Yes, we did, didn't work out. Uses big heap and stack
+%- For a couple of example programs, when you do a sequence of                                                                
+%    1. parse                                                                                                                 
+%    2. pretty-print                                                                                                          
+%    3. parse                                                                                                                 
+%    4. pretty-print                                                                                                          
+%      -- Dit gaan we met een shell scriptje doen
+%- Demonstrate your parser and pretty-printer on two or three programs that you
+%      find interesting 

 \end{document}
 \end{document}

diff --git a/lex.icl b/lex.icl
index e3fb2c1..ce642a1 100644 (file)
--- a/lex.icl
+++ b/lex.icl
@@ -1,7 +1,7 @@
 implementation module lex
 
 import Control.Monad, Control.Applicative
 implementation module lex
 
 import Control.Monad, Control.Applicative

-import Data.Either, Data.Func
+import Data.Either, Data.Func, Data.Void

 from StdFunc import o
 import StdBool
 import StdList
 from StdFunc import o
 import StdBool
 import StdList

diff --git a/spl.icl b/spl.icl
index da8fa31..2b458e4 100644 (file)
--- a/spl.icl
+++ b/spl.icl
@@ -59,12 +59,12 @@ Start w
        # lexOut = lexer cs
        # stdin = if (not args.lex) stdin (case lexOut of
                (Right toks) = 
        # lexOut = lexer cs
        # stdin = if (not args.lex) stdin (case lexOut of
                (Right toks) = 

-                       stdin <<< "---LEXER\n" <<< printTokens toks <<< "---LEXER\n"
+                       stdin <<< "//LEXER\n" <<< printTokens toks <<< "//LEXER\n"

                _ = stdin)
        # parseOut = parser lexOut
        # stdin = if (not args.parse) stdin (case parser lexOut of
                (Right ast) = 
                _ = stdin)
        # parseOut = parser lexOut
        # stdin = if (not args.parse) stdin (case parser lexOut of
                (Right ast) = 

-                       stdin <<<  "---PARSER\n" <<< toString ast <<< "---PARSER\n" 
+                       stdin <<<  "//PARSER\n" <<< toString ast <<< "//PARSER\n" 

                (Left parse) = stdin <<< toString parse)
        = snd $ fclose stdin w
                where
                (Left parse) = stdin <<< toString parse)
        = snd $ fclose stdin w
                where

diff --git a/yard.dcl b/yard.dcl
index c302420..08b2ff1 100644 (file)
--- a/yard.dcl
+++ b/yard.dcl
@@ -6,7 +6,7 @@ from StdClass import class ==, class Eq
 from Data.Functor import class Functor
 from Control.Monad import class Monad
 from Control.Applicative import class Applicative, class Alternative
 from Data.Functor import class Functor
 from Control.Monad import class Monad
 from Control.Applicative import class Applicative, class Alternative

-import Data.Void
+from Data.Void import :: Void

 
 :: Error = PositionalError Int Int String | Error String
 :: Parser a b = Parser ([a] -> (Either Error b, [a]))
 
 :: Error = PositionalError Int Int String | Error String
 :: Parser a b = Parser ([a] -> (Either Error b, [a]))


@@ -18,7 +18,6 @@ instance Alternative (Parser a)
 
 instance toString Error
 
 
 instance toString Error
 

-

 runParser :: (Parser a b) [a] -> (Either Error b, [a])
 (<?>) :: (Parser a b) Error -> Parser a b
 fail :: Parser a b
 runParser :: (Parser a b) [a] -> (Either Error b, [a])
 (<?>) :: (Parser a b) Error -> Parser a b
 fail :: Parser a b

diff --git a/yard.icl b/yard.icl
index 9b2ec23..612efd1 100644 (file)
--- a/yard.icl
+++ b/yard.icl
@@ -21,71 +21,64 @@ instance toString Error where
 
 runParser :: (Parser a b) [a] -> (Either Error b, [a])
 runParser (Parser f) i = f i
 
 runParser :: (Parser a b) [a] -> (Either Error b, [a])
 runParser (Parser f) i = f i

-
-instance + Error where
-       (+) r1 r2 = r2 //TODO

  
 instance Functor (Parser a) where
  
 instance Functor (Parser a) where

-    fmap f m = liftM f m
+       fmap f m = liftM f m

 
 instance Applicative (Parser a) where
 
 instance Applicative (Parser a) where

-    pure a      = Parser \i -> (Right a, i)
-    (<*>) sf p  = ap sf p
+       pure a    = Parser \i -> (Right a, i)
+       (<*>) sf p  = ap sf p

 
 instance Monad (Parser a) where
 
 instance Monad (Parser a) where

-    bind p f    = Parser \i -> case runParser p i of
-        (Right r, rest) = runParser (f r) rest
-        (Left e, _)     = (Left e, i)
+       bind p f        = Parser \i -> case runParser p i of
+               (Right r, rest) = runParser (f r) rest
+               (Left e, _)      = (Left e, i)

 
 instance Alternative (Parser a) where
 
 instance Alternative (Parser a) where

-    empty       = Parser \i -> (Left $ Error "" , i)
-    (<|>) p1 p2 = Parser \i -> case runParser p1 i of
-        (Right r, rest) = (Right r, rest)
-        (Left e1, rest) = case runParser p2 i of
-            (Left e2, rest)  = (Left $ e1+e2, i)
-            (Right r, rest)  = (Right r, rest)
-
-//Try the parser, if it fails decorate the error with Expected of the given String and position
+       empty      = Parser \i -> (Left $ Error "" , i)
+       (<|>) p1 p2 = Parser \i -> case runParser p1 i of
+               (Right r, rest) = (Right r, rest)
+               (Left e1, rest) = case runParser p2 i of
+                       (Left e2, rest)  = (Left e2, i)
+                       (Right r, rest)  = (Right r, rest)
+
+//Try parser, if it fails decorate the error with the given String and position

 (<?>) :: (Parser a b) Error -> Parser a b
 (<?>) p e = Parser \i -> case runParser p i of
 (<?>) :: (Parser a b) Error -> Parser a b
 (<?>) p e = Parser \i -> case runParser p i of

-    (Left e1, rest) = (Left $ e1 + e, rest)
-    (Right r, rest) = (Right r, rest)
+       (Left e1, rest) = (Left e, rest)
+       (Right r, rest) = (Right r, rest)

 
 fail :: Parser a b
 fail = empty
 
 top :: Parser a a
 top = Parser \i -> case i of
 
 fail :: Parser a b
 fail = empty
 
 top :: Parser a a
 top = Parser \i -> case i of

-    []      = (Left $ Error "", [])
-    [x:xs]  = (Right x, xs)
+       []        = (Left $ Error "", [])
+       [x:xs]  = (Right x, xs)

 
 peek :: Parser a a
 peek = Parser \i -> case i of
 
 peek :: Parser a a
 peek = Parser \i -> case i of

-    []      = (Left $ Error "", [])
-    [x:xs]  = (Right x, [x:xs])
+       []        = (Left $ Error "", [])
+       [x:xs]  = (Right x, [x:xs])

 
 

-//runs the left parser until the right parser succeeds. Returns the result of the left parser 
-//Note: if the right parser consumes input then this input is lost!
-//If the left parser fails before the right parser succeeds the whole parser fails

 (until) infix 2 :: (Parser a b) (Parser a c) -> Parser a [b]
 (until) p guard = try $ until` p guard [] 
 (until) infix 2 :: (Parser a b) (Parser a c) -> Parser a [b]
 (until) p guard = try $ until` p guard [] 

-    where
-        until` :: (Parser a b) (Parser a c) [b] -> Parser a [b]
-        until` p guard acc = Parser \i -> case runParser guard i of 
-            (Right _, rest) = (Right acc, rest)
-            (Left _, _)     = case runParser p i of
-                (Right r, rest) = runParser (until` p guard [r:acc]) rest
-                (Left e, _)     = (Left e, i)
-        try :: (Parser a b) -> Parser a b
-        try p = Parser \i -> case runParser p i of
-            (Left e, _)     = (Left e, i)
-            (Right r, rest) = (Right r, rest)
-
+       where
+               until` :: (Parser a b) (Parser a c) [b] -> Parser a [b]
+               until` p guard acc = Parser \i -> case runParser guard i of 
+                       (Right _, rest) = (Right acc, rest)
+                       (Left _, _)      = case runParser p i of
+                               (Right r, rest) = runParser (until` p guard [r:acc]) rest
+                               (Left e, _)      = (Left e, i)
+               try :: (Parser a b) -> Parser a b
+               try p = Parser \i -> case runParser p i of
+                       (Left e, _)      = (Left e, i)
+                       (Right r, rest) = (Right r, rest)

 
 eof :: Parser a Void
 eof = Parser \i -> case i of 
 
 eof :: Parser a Void
 eof = Parser \i -> case i of 

-    []      = (Right Void, [])
-    _       = (Left $ Error "", i)
+       []      = (Right Void, [])
+       _       = (Left $ Error "", i)

 
 satisfy :: (a -> Bool) -> Parser a a
 satisfy f = top >>= \r -> if (f r) (return r) fail
 
 satisfy :: (a -> Bool) -> Parser a a
 satisfy f = top >>= \r -> if (f r) (return r) fail