# Expressions

### Operators

| Operator      | Description                                                                        |
| ------------- | ---------------------------------------------------------------------------------- |
| `a + b`       | Addition                                                                           |
| `a - b`       | Subtraction                                                                        |
| `a * b`       | Multiplication                                                                     |
| `a / b`       | Division                                                                           |
| `a % b`       | Modulus                                                                            |
| `a >> b`      | Bitshift right                                                                     |
| `a << b`      | Bitshift left                                                                      |
| `~a`          | Bitwise NOT                                                                        |
| `a & b`       | Bitwise AND                                                                        |
| `a \| b`      | Bitwise OR                                                                         |
| `a ^ b`       | Bitwise XOR                                                                        |
| `a == b`      | Equality comparison                                                                |
| `a != b`      | Inequality comparison                                                              |
| `a > b`       | Greater-than comparison                                                            |
| `a < b`       | Less-than comparison                                                               |
| `a >= b`      | Greater-than-or-equals comparison                                                  |
| `a <= b`      | Less-than-or-equals comparison                                                     |
| `!a`          | Boolean NOT                                                                        |
| `a && b`      | Boolean AND                                                                        |
| `a \|\| b`    | Boolean OR                                                                         |
| `a ^^ b`      | Boolean XOR                                                                        |
| `a ? b : c`   | Ternary                                                                            |
| `(a)`         | Parenthesis                                                                        |
| `function(a)` | [Function](https://docs.werwolv.net/pattern-language/core-language/functions) call |

`a`, `b` and `c` can be any numeric literal or another expression.

### Type Operators

Type Operators are operators that work on types. They can only be used on a variable, not on a mathematical expression.

| Operator        | Description                                  |
| --------------- | -------------------------------------------- |
| `addressof(a)`  | Address of variable                          |
| `sizeof(a)`     | Size of variable                             |
| `typenameof(a)` | String representation of the variable's type |

`a` can be a variable, either by naming it directly or finding it through member access

**PROVIDER OPERATORS**

`a` can also be replaced with the `$` operator to query information about the loaded data

| Operator       | Description                     |
| -------------- | ------------------------------- |
| `addressof($)` | Base address of the loaded data |
| `sizeof($)`    | Size of the loaded data         |

### String Operators

String operators are any operators acting on strings directly.

| Operator       | Description                    |
| -------------- | ------------------------------ |
| `a + b`        | String concatenation           |
| `str * number` | String repetition              |
| `a == b`       | Lexical equality               |
| `a != b`       | Lexical inequality             |
| `a > b`        | Lexical greater-than           |
| `a >= b`       | Lexical greater-than-or-equals |
| `a < b`        | Lexical less-than              |
| `a <= b`       | Lexical less than-or-equals    |

### Member Access

Member access is the act of accessing members inside a struct, union or bitfield or referencing the index of an array to access its value.

Below the simplest operations are shown, however they may be concatenated and extended indefinitely as suitable.

| Operation       | Access type                                                                           |
| --------------- | ------------------------------------------------------------------------------------- |
| `structVar.var` | Accessing a variable inside a struct, union or bitfield                               |
| `arrayVar[x]`   | Accessing a variable inside an array                                                  |
| `parent.var`    | Accessing a variable inside the parent struct or union of the current struct or union |
| `this`          | Referring to the current pattern. Can only be used inside of a struct or union        |

The `parent` operation refers to the caller struct or union, not the "parent struct" in the Inheritance section. It can also be used in a function:

```rust
struct Field {
    u8 x;
};
fn rename_field() {
    std::core::set_display_name(parent.fields[0], "version");
};
struct Struct {
    Field fields[3];
    rename_field();
};
Struct s @ 0;  // Pattern Data shows s > fields > version
```

### `$` Dollar Operator

The Dollar Operator is a special operator which expands to the current offset within the current pattern.

```rust
#pragma base_address 0x00

std::print($); // 0
u32 x @ 0x00;
std::print($); // 4
```

It’s also possible to assign a value to the dollar operator to change the current cursor position.

```rust
$ += 0x100;
```

The dollar operator can also be used to access single bytes of the main data.

```rust
std::print($[0]); // Prints the value of the byte at address 0x00
```

You can store it in a [global variable](https://docs.werwolv.net/pattern-language/variable-placement#global-variables) and access it later:

```rust

u32 readLaterOffset;

struct Header {
    u32 id;
    u32 bodyOffset;
    readLaterOffset = $; 
};

struct Body {
    u32 name;
    u32 type;
    u32 data[4] @ readLaterOffset;
};

struct Main {
    Header header;
    Body body @ header.bodyOffset;
};

Main main @ 0x0;
```

### Casting Operator

The cast operator changes the type of an expression into another.

```rust
fn test(float x) {
    return 1 + u32(x);
}

test(3.14159); // 4
```