definition module Sil.Syntax

from StdOverloaded import class toString

from Data.Maybe import :: Maybe

from Sil.Types import :: Type
from Sil.Util.Parser import :: ParsePosition, class getPos

:: Program =
	{ p_funs    :: [Function]
	, p_globals :: [Initialisation]
	}

:: Function =
	{ f_type :: Type
	, f_name :: Name
	, f_args :: [Arg]
	, f_code :: CodeBlock
	, f_pos  :: ParsePosition
	}

:: CodeBlock =
	{ cb_init    :: [Initialisation]
	, cb_content :: [Statement]
	}

:: Arg =
	{ arg_type :: Type
	, arg_name :: Name
	}

:: Initialisation =
	{ init_type  :: Type
	, init_name  :: Name
	, init_value :: Maybe Expression
	, init_pos   :: ParsePosition
	}

:: Statement
	= Declaration ParsePosition Name Expression
	| Application ParsePosition Expression
	| Return      ParsePosition (Maybe Expression)
	| If          ParsePosition [(Expression, CodeBlock)] (Maybe CodeBlock)
	| While       ParsePosition Expression CodeBlock
	| MachineStm  ParsePosition String

:: Expression
	= Name Name
	| Literal Literal
	| App Name [Expression]
	| BuiltinApp Op1 Expression
	| BuiltinApp2 Expression Op2 Expression
	| Field Name Expression
	| Tuple Int [Expression]
	| List (Maybe Type) [Expression]

:: Op1
	= Neg //* ~
	| Not //* !

:: Op2
	= Add      //* +
	| Sub      //* -
	| Mul      //* *
	| Div      //* /
	| Rem      //* %
	| Equals   //* ==
	| Unequals //* <>
	| CmpLe    //* <=
	| CmpGe    //* >=
	| CmpLt    //* <
	| CmpGt    //* >
	| LogOr    //* ||
	| LogAnd   //* &&
	| Cons     //* :

:: Literal
	= BLit Bool
	| ILit Int

:: Name :== String

instance toString Statement
instance toString Arg
instance toString Expression
instance toString Op1
instance toString Op2
instance toString Literal

instance getPos Function
instance getPos Initialisation
instance getPos Statement

class allStatements a :: a -> [Statement]
instance allStatements Program
instance allStatements Function
instance allStatements CodeBlock
instance allStatements Statement

class allCodeBlocks a :: a -> [CodeBlock]
instance allCodeBlocks Function
instance allCodeBlocks CodeBlock
instance allCodeBlocks Statement

class allLocals a :: a -> [(Type, Name)]
instance allLocals Function
instance allLocals CodeBlock