definition module Sil.Syntax

from StdOverloaded import class toString

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 :: ?Expression
	, init_pos   :: ParsePosition
	}

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

:: Expression
	= Name        ParsePosition Name
	| Literal     ParsePosition Literal
	| App         ParsePosition Name [Expression]
	| BuiltinApp  ParsePosition Op1 Expression
	| BuiltinApp2 ParsePosition Expression Op2 Expression
	| Field       ParsePosition Name Expression
	| Tuple       ParsePosition Int [Expression]
	| List        ParsePosition (?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
instance getPos Expression

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