; load "Int";
; load "CommandLine";


(* Aufgabe 8.1 *)

fun compare(nil  , nil  ) = EQUAL
  | compare(nil  , ys   ) = LESS
  | compare(xs   , nil  ) = GREATER
  | compare(x::xs, y::ys) = (case Char.compare(x,y) of
                                 EQUAL => compare(xs,ys)
                               |   x   => x)    
(* Aufgabe 8.2 *)

fun for n p =
    let
       fun for' i n p = if i > n then () else (p i ; for' (i+1) n p)
    in
       for' 1 n p 
    end

(* Aufgabe 8.3 *)

fun triangle n =
    for n 
    (fn k => (for k
              (fn _ => print "*") ; print "\n"))

fun main s = triangle(valOf(Int.fromString s))

val _ = List.app main (CommandLine.arguments())
    handle _ => print "Arguments must be numbers \n"

(* Aufgabe 8.4 *)

fun num x nil     = (x, nil)
  | num x (c::cr) = if Char.isDigit c 
                    then num (10*x + Char.ord c - Char.ord #"0") cr
                    else (x, c::cr)

datatype token = INT of int | ADD | SUB | MUL | LPAR | RPAR

exception Error
                   
fun lex ts      nil    = rev ts
  | lex ts (#" " ::cs) = lex ts cs
  | lex ts (#"\n"::cs) = lex ts cs
  | lex ts (#"+" ::cs) = lex (ADD::ts) cs
  | lex ts (#"-" ::cs) = lex (SUB::ts) cs
  | lex ts (#"*" ::cs) = lex (MUL::ts) cs
  | lex ts (#"(" ::cs) = lex (LPAR::ts) cs
  | lex ts (#")" ::cs) = lex (RPAR::ts) cs
  | lex ts ( c   ::cs) = if Char.isDigit c 
                         then let val (x,cr) = num 0 (c::cs)
                              in  lex (INT x::ts) cr
                              end
                         else raise Error

fun atom (INT x :: ts) = (x,ts)
  | atom (LPAR::ts)    = let val (x,tr) = exp ts
                         in case tr of
                             RPAR::tr' => (x,tr')
                           | _ => raise Error
                         end
  | atom      _        = raise Error

and term' (x, MUL::ts) = let val (x',tr) = atom ts
                         in term'(x*x', tr)
                         end
  | term' (x,    ts  ) = (x,ts)

and term  ts           = term'(atom ts)

and exp' (x, ADD::ts)  = let val (x',tr) = term ts
                         in exp'(x+x', tr)
                         end
  | exp' (x, SUB::ts)  = let val (x',tr) = term ts
                         in exp'(x-x', tr)
                         end
  | exp' (x,    ts  )  = (x,ts)

and exp   ts            = exp'(term ts)

fun eval s = let 
                 val (x, ts) = exp(lex nil (explode s))
             in  
                 if null ts then Int.toString x
                 else raise Error
             end
             handle 
                 Error => "! Syntax error"
               | Overflow => "! Overflow"
             
fun main () = (print "# " ;
               print(eval(TextIO.inputLine TextIO.stdIn)) ;
               print "\n" ; 
               main())

val _ = main()