Sound.DF.Uniform.LL.CGen

C code generator

C init / call

type C_Comment = String

C comment.

c_comment :: String -> C_Comment

Add comment markers.

 c_comment "c" == "/* c */"

type C_Type = String

C type.

c_typerep_ctype :: TypeRep -> C_Type

Translate TypeRep to C_Type.

 c_typerep_ctype bool_t == "bool"
 c_typerep_ctype (typeOf (0.0::Float)) == "float"

type C_QName = (String, String, String)

Qualified name, (structure,access,member).

c_init_atom :: Show a => C_QName -> a -> String

Initialise C_QName to value.

 c_init_atom ("s",".","r") 5 == "s.m = 5;"

c_init_vec :: (Eq a, Show a) => C_QName -> [a] -> [String]

Initialise C_QName to array. Generates loop code for sequences of equal initial values.

 c_init_vec ("s",".","r") [0,1] == ["s.r[0] = 0;"
                                   ,"s.r[1] = 1;"]

 let r = ["for(int i=0;i < 2;i++) {s.r[i] = 0;}"]
 in c_init_vec ("s",".","r") [0,0] == r

c_init_var :: (Eq n, Show n) => C_QName -> Either n [n] -> [String]

Initialise C_QName to value or array.

 let {qn = ("s","->","r")
     ;r = ["for(int i=0;i < 2;i++) {s->r[i] = 0;}","s->r[2] = 1;"]}
 in c_init_var qn (Right [0,0,1]) == r

c_array_qual :: Maybe Int -> String -> Bool -> String

Qualify name if required. The rf flag indicates if array is a reference or an allocation.

 c_array_qual (Vec_Port float_t 3) "a" True == "*a"
 c_array_qual (Vec_Port float_t 3) "a" False == "a[3]"

type C_Call = (Maybe String, String, [(Var_Ty, Id)])

C function call. (comment?,function,arguments)

c_call :: C_Call -> String

Construct a function/macro call.

 c_call (Nothing,"f",["0","1"]) == "f(0,1);"
 c_call ("c","f",["0","1"]) == "f(0,1); /* c */"

Variables

data Var_Ty

Enumeration of variable types.

Constructors

Rec_Var

Std_Var

Buf_Var Int

Instances

Eq Var_Ty

Show Var_Ty

var_ty_char :: Var_Ty -> Char

The character prefix for a Var name is given by the Var_Ty.

type Var = (Var_Ty, TypeRep, Id, Maybe (Either Float [Float]))

(Type,Array,Label,Initialised)

var_nm :: Var -> String

Var name.

is_stateful :: Var -> Bool

Non-Std_Var are stateful, ie. Rec_Var and Buf_Var.

is_stateful_atom :: Var -> Bool

Rec_Var are stateful and atoms.

k_var :: Id -> Var_Ty -> K -> Var

Generate Var from K.

buffer_var :: Id -> Vec Float -> Var

Generate Buf_Var from Vec.

var_init :: String -> String -> Var -> [String]

c_init_var of Var.

var_decl :: Bool -> Var -> String

Var C declaration, rf determines c_array_qual form.

gen_var_struct :: String -> (Var -> Bool) -> [Var] -> [String]

Generate a C struct for Var, predicate determines if array variables are refernces or allocations.

clabel :: (Var_Ty, Id) -> String

Construct an identifier.

 clabel (Std_Var,0) == "n_0"

std_clabel :: Id -> String

clabel of Std_Var.

 std_clabel 0 == "n_0"

m_clabel :: (Var_Ty, Id) -> String

Variant with m. prefix.

c_const :: (Id, K) -> [String]

c_init_var for constant.

 c_const (0,I 1) == ["m.n_0 = 1;"]

Code generators

dsp_fun_decl :: [String]

C declarations for DSP functions (memreq,init and step).

cmem :: [Var] -> [String]

The structure for all memory stores. In the uniform model this is a notational convenience only. In a partioned model it is functional.

cstate :: [Var] -> [String]

The structure for stateful Var.

dsp_memreq :: [String]

Generate dsp_memreq function.

dsp_init :: [Var] -> [String]

Generate dsp_init function.

type Instructions = ([(Id, K)], [Var], [C_Call])

List of constants, list of variables, list of c-calls.

dsp_step :: Instructions -> [String]

Generate dsp_step function.

code_gen :: Host -> Instructions -> String

Generate C code for graph.

Host

data Host

Enumeration of code hosts.

Constructors

JACK

SC3

Text

host_include :: Host -> String

Host specific #include file.

host_dsp_fun_decl :: Host -> [String]

Host specific form of dsp_fun_decl (extern C where required).

host_compiler_cmd :: (Host, FilePath) -> (String, [String])

Generate compiler command for Host given include directory prefix.

 host_compiler_cmd (JACK,"/home/rohan/opt")
 host_compiler_cmd (SC3,"/home/rohan/opt")
 host_compiler_cmd (Text,"/home/rohan/opt")

IO

dl_gen :: FilePath -> (Host, FilePath) -> Instructions -> IO ()

Generate C code, write file to disk and call the GNU C compiler to build shared library.

List

bracket :: (a, a) -> [a] -> [a]

Bracket list with elements.

 bracket ('<','>') "float" == "<float>"

dx_d :: Num n => [n] -> [n]

Integrate, with implicit 0.

 dx_d [5,6] == [0,5,11]