Updated Programming language specification (Gemstone) (markdown)

servostar 2024-01-24 16:00:31 +01:00
parent fc7e017ab5
commit c13bf6f6f0
1 changed files with 49 additions and 1 deletions

@ -1,3 +1,51 @@
# Programming language specification
`TODO: write language specification`
## Primitive data types
The most fundamental types of data. They provide the base upon everything else is built. A primitive type has 2 properties: size in bytes and arithmetic model (additionally specifies representation on bit level). There are exactly two primitive data types:
| Type name | size in bytes | arithmetic model |
| - | - | - |
| `int` | 4 | signed integer stored as two's complement with the MSB representing the sign bit |
| `float` | 4 | signed single precision floating point as specified by IEEE-754 |
## Composite data types
Primitive data types provide the foundation upon which direct derivations can be built. The derivations of primitive types we call composite types. A composite type modifies or extends the definition of a primitive or another composite type.
Extensions or modifications can mean adding or removing a sign bit, exchanging the arithmetic model, etc.
The declaration of a composite data type is made with the following syntax:
`typedef <sign> <scale> <base> $name`
### Sign
The `<sign>` is a keyword specifying whether to implement a sign bit or not. Possible values are:
- `signed`: for a single sign bit
- `unsigned`: for no sign bit
### Scale
`<scale>` describes the scaling factor to use. This is a rational factor used alongside the byte size of the base. To calculate the final size of the composite type multiply all factors with the base types size in bytes.
#### Possible values
| Name | Factor |
| - | - |
| short | $2^{-1}$ |
| long | $2$ |
| half | $2^{-1}$ |
| double | $2$ |
#### Examples:
IEEE-754 double precision floating point: `long float` with size: `4 bytes * 2 = 8 bytes` <br>
32-Bit integer: `half long int` with size: `4 bytes * 2 * 2^(-1) = 4 bytes` <br>
A single byte: `half short int` with size: `4 bytes * 2^(-1) * 2^(-1) = 1 byte` <br>
#### Limitations:
The size of composite type cannot exceed 32 and be lower than 1 nor be a non integral value.
A notable exception is the primitive type `float`. Its size is constrained to 2, 4, 8, 10, 16 and 32 in order to remain compliant with the IEEE-754 standard. A platform may choose to only provide implementations for only a few of the previously named sizes. On x86 and x64 and ARM the most common composite floats are of the sizes: 4 (float) and 8 (double).
### Base
The base of a composite type specifies on which primitive or composite type a derivation is to be built.
## Example types
```cpp
typedef long float double_precision
typedef short short int ascii
typedef double int long_int
```