Language.C.DSL.Decl

Documentation

decl

Arguments

:: CDeclSpec

The declaration specifier, usually this is a type

-> CDeclr

Equivalent to the name of the object being declared. Often this will make use of the overloaded string instance for CDeclrs

-> Maybe CExpr

The optional init expression

-> CDecl

A low level way to declare something.

voidSpec :: CTypeSpec

The CTypeSpec for void

charSpec :: CTypeSpec

The CTypeSpec for char

shortSpec :: CTypeSpec

The CTypeSpec for short

intSpec :: CTypeSpec

The CTypeSpec for int

longSpec :: CTypeSpec

The CTypeSpec for long

floatSpec :: CTypeSpec

The CTypeSpec for float

doubleSpec :: CTypeSpec

The CTypeSpec for double

voidTy :: CDeclSpec

The CDeclSpec for declarations of type void

charTy :: CDeclSpec

The CDeclSpec for declarations of type char

shortTy :: CDeclSpec

The CDeclSpec for declarations of type short

intTy :: CDeclSpec

The CDeclSpec for declarations of type int

longTy :: CDeclSpec

The CDeclSpec for declarations of type long

floatTy :: CDeclSpec

The CDeclSpec for declarations of type float

doubleTy :: CDeclSpec

The CDeclSpec for declarations of type double

ty :: Ident -> CTypeSpec

Turns a string into the corresponding typedefed type.

For example

 struct "foo" [("bar, ty "quux")]

will generate the corresponding

 typedef foo {quux bar;} foo

ptr :: CDeclr -> CDeclr

Modifies a declarator to be a pointer. For example ptr someName would be *x in C.

char :: CDeclr -> Maybe CExpr -> CDecl

A short cut for declaring a char.

     char "x" .= 1
     uninit $ char "y"

Would generate

 char x = 1;
 char y;

short :: CDeclr -> Maybe CExpr -> CDecl

A short cut for declaring a short

int :: CDeclr -> Maybe CExpr -> CDecl

A short cut for declaring a int

long :: CDeclr -> Maybe CExpr -> CDecl

A short cut for declaring a long

float :: CDeclr -> Maybe CExpr -> CDecl

A short cut for declaring a float

double :: CDeclr -> Maybe CExpr -> CDecl

A short cut for declaring a double

charPtr :: CDeclr -> Maybe CExpr -> CDecl

Equivalent to char but wraps the CDeclr in a pointer. This means that uninit $ charPtr someName is equivalent to char *someName;

shortPtr :: CDeclr -> Maybe CExpr -> CDecl

intPtr :: CDeclr -> Maybe CExpr -> CDecl

longPtr :: CDeclr -> Maybe CExpr -> CDecl

floatPtr :: CDeclr -> Maybe CExpr -> CDecl

doublePtr :: CDeclr -> Maybe CExpr -> CDecl

(.=) :: (Maybe CExpr -> CDecl) -> CExpr -> CDecl

Supplies an initializer for an for a declaration. This is meant to be used with the char and friends short cuts

uninit :: (Maybe CExpr -> CDecl) -> CDecl

Leave a declaration uninitialized. This is meant to be used with the char and friends declaration

csu :: CStructTag -> String -> [(String, CTypeSpec)] -> CDecl

struct :: String -> [(String, CTypeSpec)] -> CDecl

Create a structure, for example struct foo [(bar, intTy)] is typedef struct foo {int bar;} foo;

union :: String -> [(String, CTypeSpec)] -> CDecl

Equivalent to struct but generates a C union instead.

fun :: [CDeclSpec] -> String -> [Maybe CExpr -> CDecl] -> CStat -> CFunDef

Defines a C function. For example

    test =
       fun [intTy] "test"[int "a", int "b"] $ hblock [
           creturn ("a" + "b")
       ]

Would be the equivalent of

   int test(int a, int b)
   {
      return a + b;
   }

annotatedFun :: [CDeclSpec] -> String -> [Maybe CExpr -> CDecl] -> [String] -> CStat -> CFunDef

Identical to fun except this annotates the list of attributes given as a list of strings.

class External a where

Methods

export :: a -> CExtDecl

Instances

External CFunDef

External CDecl

External CStrLit

transUnit :: [CExtDecl] -> CTranslUnit

Exports a series of declarations to a translation unit.