From: Mart Lubbers Date: Mon, 14 Mar 2016 20:13:34 +0000 (+0100) Subject: outline voor presentatie X-Git-Url: https://git.martlubbers.net/?a=commitdiff_plain;ds=sidebyside;h=d5abf2ad34be35640d0e1b04d4f3da24e4ea9967;p=cc1516.git outline voor presentatie --- diff --git a/deliverables/p1/p1.tex b/deliverables/p1/p1.tex index 7aff91d..1b923bd 100644 --- a/deliverables/p1/p1.tex +++ b/deliverables/p1/p1.tex @@ -1,4 +1,36 @@ %&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} diff --git a/lex.icl b/lex.icl index e3fb2c1..ce642a1 100644 --- a/lex.icl +++ b/lex.icl @@ -1,7 +1,7 @@ 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 diff --git a/spl.icl b/spl.icl index da8fa31..2b458e4 100644 --- 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) = - 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 <<< "---PARSER\n" <<< toString ast <<< "---PARSER\n" + stdin <<< "//PARSER\n" <<< toString ast <<< "//PARSER\n" (Left parse) = stdin <<< toString parse) = snd $ fclose stdin w where diff --git a/yard.dcl b/yard.dcl index c302420..08b2ff1 100644 --- 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 -import Data.Void +from Data.Void import :: Void :: 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 - 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 --- 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 - -instance + Error where - (+) r1 r2 = r2 //TODO instance Functor (Parser a) where - fmap f m = liftM f m + fmap f m = liftM f m 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 - 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 - 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 - (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 - [] = (Left $ Error "", []) - [x:xs] = (Right x, xs) + [] = (Left $ Error "", []) + [x:xs] = (Right x, xs) 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 [] - 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 - [] = (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