implementation module Sil.Syntax

from StdFunc import o
import StdOverloaded
import StdString
import StdTuple

import Data.List
import Data.Maybe
import Text

import Sil.Types
import Sil.Util.Printer

instance toString Statement
where
	toString (Declaration n a) = n <+ " := " <+ a <+ ";"
	toString (Application e)   = toString e <+ ";"
	toString (Return Nothing)  = "return;"
	toString (Return (Just a)) = "return " <+ a <+ ";"
	toString (If bs e)         = "if ..."
	toString (MachineStm s)    = "|~" <+ s
	toString _                 = "<<unimplemented Statement>>"

instance toString Arg where toString arg = arg.arg_type <+ " " <+ arg.arg_name

instance toString Expression
where
	toString (Name n)               = n
	toString (Literal lit)          = toString lit
	toString (App n args)           = n <+ "(" <+ printersperse ", " args <+ ")"
	toString (BuiltinApp op e)      = op <+ "(" <+ e <+ ")"
	toString (BuiltinApp2 e1 op e2) = "(" <+ e1 <+ ") " <+ op <+ " (" <+ e2 <+ ")"

instance toString Op1
where
	toString Neg = "~"
	toString Not = "!"

instance toString Op2
where
	toString Add    = "+"
	toString Sub    = "-"
	toString Mul    = "*"
	toString Div    = "/"
	toString Rem    = "%"
	toString Equals = "=="
	toString LogOr  = "||"
	toString LogAnd = "&&"

instance toString Literal
where
	toString (BLit b) = toString b
	toString (ILit i) = toString i

instance allStatements Program
where allStatements p = concatMap allStatements p.p_funs

instance allStatements Function
where allStatements f = allStatements f.f_code

instance allStatements CodeBlock
where allStatements cb = concatMap allStatements cb.cb_content

instance allStatements Statement
where
	allStatements st=:(Declaration _ _) = [st]
	allStatements st=:(Application _)   = [st]
	allStatements st=:(Return _)        = [st]
	allStatements st=:(If bs Nothing)   = [st:concatMap (allStatements o snd) bs]
	allStatements st=:(If bs (Just e))  = [st:allStatements e ++ concatMap (allStatements o snd) bs]
	allStatements st=:(While _ cb)      = [st:allStatements cb]
	allStatements st=:(MachineStm _)    = [st]

instance allCodeBlocks Function where allCodeBlocks f = allCodeBlocks f.f_code

instance allCodeBlocks CodeBlock
where allCodeBlocks cb = [cb:concatMap allCodeBlocks cb.cb_content]

instance allCodeBlocks Statement
where
	allCodeBlocks (If bs Nothing)  = concatMap (allCodeBlocks o snd) bs
	allCodeBlocks (If bs (Just e)) = [e:concatMap (allCodeBlocks o snd) bs]
	allCodeBlocks (While _ cb)     = [cb]
	allCodeBlocks _                = []

instance allLocals Function
where
	allLocals f = [(a.arg_type, a.arg_name) \\ a <- f.f_args] ++
		allLocals f.f_code

instance allLocals CodeBlock
where allLocals cb = [(i.init_type, i.init_name) \\ i <- cb.cb_init]