ddc-core-salt-0.4.1.3: Disciplined Disciple Compiler C code generator.

Safe HaskellNone

DDC.Core.Salt.Name

Contents

Description

Names used in the Disciple Core Salt language profile.

Synopsis

Documentation

data Name Source

Names of things used in Disciple Core Salt.

Constructors

NameVar String

A type or value variable.

NameCon String

Constructor names.

NameObjTyCon

The abstract heap object type constructor.

NamePrimTyCon PrimTyCon

A primitive type constructor.

NamePrimOp PrimOp

A primitive operator.

NameLitVoid

The void literal.

NameLitBool Bool

A boolean literal.

NameLitNat Integer

A natural number literal.

NameLitInt Integer

An integer number literal.

NameLitTag Integer

A constructor tag literal.

NameLitWord Integer Int

A WordN# literal, of the given width.

Instances

Eq Name 
Ord Name 
Show Name 
Typeable Name 
Pretty Name 
NFData Name 

Primitive Type Constructors

data PrimTyCon Source

Primitive type constructors.

Constructors

PrimTyConVoid

Void# the Void type has no values.

PrimTyConBool

Bool# unboxed booleans.

PrimTyConNat

Nat# natural numbers. Enough precision to count every object in the heap, but NOT enough precision to count every byte of memory.

PrimTyConInt

Int# signed integers. Enough precision to count every object in the heap, but NOT enough precision to count every byte of memory. If N is the total number of objects that can exist in the heap, then the range of Int# is at least (-N .. +N) inclusive.

PrimTyConWord Int

WordN# machine words of the given width.

PrimTyConFloat Int

FloatN# floating point numbers of the given width.

PrimTyConVec Int

VecN# a packed vector of N values. This is intended to have kind (Data -> Data), so we use concrete vector types like Vec4.

PrimTyConAddr

Addr# a relative or absolute machine address. Enough precision to count every byte of memory. Unlike pointers below, an absolute Addr# need not refer to memory owned by the current process.

PrimTyConPtr

Ptr# should point to a well-formed object owned by the current process.

PrimTyConTag

Tag# data constructor tags. Enough precision to count every possible alternative of an enumerated type.

PrimTyConString

String# of UTF8 characters.

These are primitive until we can define our own unboxed types.

Instances

readPrimTyCon :: String -> Maybe PrimTyConSource

Read a primitive type constructor.

Words are limited to 8, 16, 32, or 64 bits.

Floats are limited to 32 or 64 bits.

primTyConIsIntegral :: PrimTyCon -> BoolSource

Integral constructors are the ones that we can reasonably convert from integers of the same size.

These are Bool Int and Tag#.

primTyConIsFloating :: PrimTyCon -> BoolSource

Floating point constructors.

These are FloatN.

primTyConIsUnsigned :: PrimTyCon -> BoolSource

Unsigned integral constructors.

These are Bool Nat WordN Tag.

primTyConIsSigned :: PrimTyCon -> BoolSource

Signed integral constructors.

This is just Int.

primTyConWidth :: Platform -> PrimTyCon -> Maybe IntegerSource

Get the representation width of a primitive type constructor, in bits. This is how much space it takes up in an object payload.

Bools are representable with a single bit, but we unpack them into a whole word.

The constructors Void and VecN# and String have no width.

Primitive Operators

data PrimOp Source

Primitive operators implemented directly by the machine or runtime system.

Constructors

PrimArith PrimArith

Arithmetic, logic, comparison and bit-wise operators.

PrimCast PrimCast

Casting between numeric types.

PrimStore PrimStore

Raw store access.

PrimCall PrimCall

Special function calling conventions.

PrimControl PrimControl

Non-functional control flow.

Instances

Eq PrimOp 
Ord PrimOp 
Show PrimOp 
Pretty PrimOp 
NFData PrimOp 

Primative Arithmetic

data PrimArith Source

Primitive arithmetic, logic, and comparison opretors. We expect the backend/machine to be able to implement these directly.

For the Shift Right operator, the type that it is used at determines whether it is an arithmetic (with sign-extension) or logical (no sign-extension) shift.

Constructors

PrimArithNeg

Negation

PrimArithAdd

Addition

PrimArithSub

Subtraction

PrimArithMul

Multiplication

PrimArithDiv

Division

PrimArithMod

Modulus

PrimArithRem

Remainder

PrimArithEq

Equality

PrimArithNeq

Negated Equality

PrimArithGt

Greater Than

PrimArithGe

Greater Than or Equal

PrimArithLt

Less Than

PrimArithLe

Less Than or Equal

PrimArithAnd

Boolean And

PrimArithOr

Boolean Or

PrimArithShl

Shift Left

PrimArithShr

Shift Right

PrimArithBAnd

Bit-wise And

PrimArithBOr

Bit-wise Or

PrimArithBXOr

Bit-wise eXclusive Or

Instances

readPrimArith :: String -> Maybe PrimArithSource

Read a primitive operator.

Primitive Calls

data PrimCall Source

Primitive ways of invoking a function, where control flow returns back to the caller.

Constructors

PrimCallTail Int

Tailcall a function

Instances

readPrimCall :: String -> Maybe PrimCallSource

Primitive Casts

data PrimCast Source

Primitive cast between two types.

The exact set of available casts is determined by the target platform. For example, you can only promote a Nat# to a Word32# on a 32-bit system. On a 64-bit system the Nat# type is 64-bits wide, so casting it to a Word32# would be a truncation.

Constructors

PrimCastConvert

Convert a value to a new representation with the same precision.

PrimCastPromote

Promote a value to one of similar or larger width, without loss of precision.

PrimCastTruncate

Truncate a value to a new width, possibly losing precision.

Instances

readPrimCast :: String -> Maybe PrimCastSource

primCastPromoteIsValidSource

Arguments

:: Platform

Target platform.

-> PrimTyCon

Source type.

-> PrimTyCon

Destination type.

-> Bool 

Check for a valid promotion primop.

primCastTruncateIsValidSource

Arguments

:: Platform

Target platform.

-> PrimTyCon

Source type.

-> PrimTyCon

Destination type.

-> Bool 

Check for valid truncation primop.

Primitive Control

data PrimControl Source

Primitive non-returning control flow.

Constructors

PrimControlFail

Ungraceful failure -- just abort the program. This is called on internal errors in the runtime system. There is no further debugging info provided, so you'll need to look at the stack trace to debug it.

PrimControlReturn

Return from the enclosing function with the given value.

Primitive Store

data PrimStore Source

Raw access to the store.

Constructors

PrimStoreSize

Number of bytes needed to store a value of a primitive type.

PrimStoreSize2

Log2 of number of bytes need to store a value of a primitive type.

PrimStoreCreate

Create a heap of the given size. This must be called before alloc# below, and has global side effect. Calling it twice in the same program is undefined.

PrimStoreCheck

Check whether there are at least this many bytes still available on the heap.

PrimStoreRecover

Force a garbage collection to recover at least this many bytes.

PrimStoreAlloc

Allocate some space on the heap. There must be enough space available, else undefined.

PrimStoreRead

Read a value from the store at the given address and offset.

PrimStoreWrite

Write a value to the store at the given address and offset.

PrimStorePlusAddr

Add an offset in bytes to an address.

PrimStoreMinusAddr

Subtract an offset in bytes from an address.

PrimStorePeek

Read a value from a pointer plus the given offset.

PrimStorePoke

Write a value to a pointer plus the given offset.

PrimStorePlusPtr

Add an offset in bytes to a pointer.

PrimStoreMinusPtr

Subtract an offset in bytes from a pointer.

PrimStoreMakePtr

Convert an raw address to a pointer.

PrimStoreTakePtr

Convert a pointer to a raw address.

PrimStoreCastPtr

Cast between pointer types.

Instances

readPrimStore :: String -> Maybe PrimStoreSource

Primitive Vector

data PrimVec Source

Primitive vector operators.

Constructors

PrimVecNeg

Negate elements of a vector.

Fields

primVecMulti :: Int
 
PrimVecAdd

Add elements of a vector.

Fields

primVecMulti :: Int
 
PrimVecSub

Subtract elements of a vector.

Fields

primVecMulti :: Int
 
PrimVecMul

Multiply elements of a vector.

Fields

primVecMulti :: Int
 
PrimVecDiv

Divide elements of a vector.

Fields

primVecMulti :: Int
 
PrimVecRep

Replicate a scalar into a vector.

Fields

primVecMulti :: Int
 
PrimVecPack

Pack multiple scalars into a vector

Fields

primVecMulti :: Int
 
PrimVecProj

Extract a single element from a vector.

Fields

primVecMulti :: Int
 
primVecIndex :: Int
 
PrimVecGather

Read multiple elements from memory.

Fields

primVecMulti :: Int
 
PrimVecScatter

Write multiple elements to memory.

Fields

primVecMulti :: Int
 

Instances

Eq PrimVec 
Ord PrimVec 
Show PrimVec 
Pretty PrimVec 
NFData PrimVec 

readPrimVec :: String -> Maybe PrimVecSource

Read a primitive vector operator.

multiOfPrimVec :: PrimVec -> Maybe IntSource

Yield the multiplicity of a vector operator.

liftPrimArithToVec :: Int -> PrimArith -> Maybe PrimVecSource

Yield the PrimVector that corresponds to a PrimArith of the given multiplicity, if any.

lowerPrimVecToArith :: PrimVec -> Maybe PrimArithSource

Yield the PrimArith that corresponds to a PrimVector, if any.

Primitive Literals

readLitInteger :: String -> Maybe IntegerSource

Read a signed integer.

readLitPrimNat :: String -> Maybe IntegerSource

Read an integer with an explicit format specifier like 1234i#.

readLitPrimInt :: String -> Maybe IntegerSource

Read an integer literal with an explicit format specifier like 1234i#.

readLitPrimWordOfBits :: String -> Maybe (Integer, Int)Source

Read a word with an explicit format speficier.

readLitPrimFloatOfBits :: String -> Maybe (Double, Int)Source

Read a float literal with an explicit format specifier like 123.00f32#.

Name Parsing

readName :: String -> Maybe NameSource

Read the name of a variable, constructor or literal.