Pattern Language

https://docs.werwolv.net/pattern-language
Admin
Pattern Language is a C++ and Rust inspired DSL for analyzing and decoding binary data structures in...
Tokens:20,393
Snippets:244
Trust Score:7.6
Update:4 days ago
Show doc for...
Tokens:
Raw
### Attribute Syntax Examples

Source: https://docs.werwolv.net/pattern-language/core-language/attributes

Demonstrates the syntax for attributes with no arguments, attributes with arguments, and applying multiple attributes to a single entity.

```text
[[attribute_name]]
[[attribute_name("arg1", 1234)]]
[[attribute1, attribute2(1234)]]
```

--------------------------------

### While-Loops

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Basic while loop syntax and a practical example using memory reading within a function.

```text
while (check()) {
    // Keeps on executing as long as the check() function returns true
}
```

```text
    fn getSum(u32 offset) {
        u32 sum = 0;
        while (offset <= 0x7A) {
            offset +=1;
            sum += std::mem::read_unsigned(offset, 1);
        }
        
        return sum;
    };
 
    struct Loop {
        u32 offset;
        u32 sum = getSum(offset) [[export]];
    };
```

--------------------------------

### Applying Attributes to Structs and Members

Source: https://docs.werwolv.net/pattern-language/core-language/attributes

Example showing how to apply color attributes to struct members and a static color attribute to the struct itself.

```text
struct RGBA8 {
  u8 red   [[color("FF0000")]];
  u8 green [[color("00FF00")]];
  u8 blue  [[color("0000FF")]];
} [[static, color(std::format("{:02X}{:02X}{:02X}", red, green, blue))]];
```

--------------------------------

### #include directive examples

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Valid ways to use the #include directive with double quotes or pointy braces. The extension is optional; if omitted, the preprocessor looks for .pat and .hexpat files.

```plaintext
#include "std/io.pat"
#include <std/string.pat>
```

--------------------------------

### Create and populate a dynamic section

Source: https://docs.werwolv.net/pattern-language/core-language/sections

This example demonstrates creating a section named 'My Section', allocating a 0x100 byte buffer within it, populating specific bytes, and placing a pattern to decode the data.

```pat
#include <std/mem.pat>
 
std::mem::Section mySection = std::mem::create_section("My Section");
 
u8 sectionData[0x100] @ 0x00 in mySection;
 
sectionData[0] = 0xAA;
sectionData[1] = 0xBB;
sectionData[2] = 0xCC;
sectionData[3] = 0xDD;
 
sectionData[0xFF] = 0x00;
 
u32 value @ 0x00 in mySection;
```

--------------------------------

### Example of global variable usage

Source: https://docs.werwolv.net/pattern-language/core-language/variable-placement

Demonstrates using a global variable to store state while processing a struct array.

```text
u8 lastValue; // A global variable
 
fn setLastValue(u8 value) {
    lastValue = value;
};
 
struct Test {
    u8 value;
	
    setLastValue(value);
}; 
 
Test test[10] @ 0x00;
```

--------------------------------

### Instantiate a template with concrete types

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Creates a concrete type from a template by providing type arguments. The example instantiates MyTemplateStruct with u32 and u64 and places it at address 0x00.

```pattern
MyTemplateStruct<u32, u64> myConcreteStruct @ 0x00;
```

--------------------------------

### import statement example

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Imports a module using dot notation as folder separator. The file extension is resolved automatically, looking for .pat and .hexpat. The statement must end with a semicolon.

```plaintext
import sys.mem;
```

--------------------------------

### import as statement example

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Shows how to change the namespace that types and functions are imported into using the 'as' keyword, reducing verbosity. The first block uses the full namespace std::ctype, the second uses the alias c.

```plaintext
import std.ctype;
 
char character @ 0x00;
if (std::ctype::isdigit(character)) {
    // ...
}
 
 
// --------------
 
import std.ctype as c;
 
char character @ 0x00;
if (c::isdigit(character)) {
    // ...
}
```

--------------------------------

### Multi line comments

Source: https://docs.werwolv.net/pattern-language/core-language/comments

Multi line comments start with /* and end with */.

```text
/* This is
    a multi
    line comment */
```

--------------------------------

### Define a single-parameter user-defined literal

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Create a literal by defining a function starting with an underscore that takes a single parameter. The literal is then applied by appending the function name to a value.

```text
fn _literal(u32 value) {
    return value * 2;
};
 
u32 two_times = 123_literal; // two_times = 246
```

--------------------------------

### Insert manual padding in a struct

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Shows how to insert padding between struct members using the padding keyword. By default there is no padding between struct members. This example inserts 4 bytes between x and y, and 8 bytes between y and z.

```pattern
struct Vector3f {
  float x;
  padding[4];
  float y;
  padding[8];
  float z;
};
```

--------------------------------

### Export a pattern local variable with [[export]]

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Shows how to make a pattern local variable appear in the Pattern Data view by using the export attribute. The example declares localVariable with value 0.5 and the [[export]] attribute.

```pattern
struct MyType {
    u32 x, y, z; // Regular members
    float localVariable = 0.5 [[export]]; // This will appear in the Pattern Data view, similar to the regular members.
};
```

--------------------------------

### Use non-type template parameters with auto

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Shows how to pass expressions such as numbers, strings, or variables as template parameters. Mark a template parameter as non-type by using the auto keyword. The example defines an Array template with a size parameter and instantiates it with 0x100.

```pattern
struct Array<T, auto Size> {
  T data[Size];
};
 
Array<u32, 0x100> array @ 0x00;
```

--------------------------------

### Dollar operator to access single bytes of main data

Source: https://docs.werwolv.net/pattern-language/core-language/expressions

The dollar operator can index into the main data to access single bytes. This example prints the byte value at address 0x00.

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

--------------------------------

### Single line comments

Source: https://docs.werwolv.net/pattern-language/core-language/comments

Single line comments start with a double slash (//) and continue to the end of the line.

```text
// This is a single line comment
```

--------------------------------

### #include directive

Source: https://docs.werwolv.net/pattern-language/core-language/preprocessor

Copies the content of the specified file directly into the current program.

```hexpat
#include <mylibrary.hexpat>
```

--------------------------------

### Use parameter packs

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Parameter packs allow passing an unlimited number of arguments to a function, which can be expanded recursively.

```ImHex Pattern Language
fn print_sequence(auto first, auto ... rest) {
    std::print("{}", first);
 
    if (std::sizeof_pack(rest) > 0)
        print_sequence(rest);
};
 
print_sequence(1, 2, 3, 4, 5, 6);
```

--------------------------------

### Enum Ranges

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Use ranges in enums to map multiple values to a single named constant. Mathematical expressions using these entries yield the start value of the range.

```text
enum NumberType : u16 {
  Unsigned      = 0x00 ... 0x7F,
  Signed        = 0x80,
  FloatingPoint = 0x90
};
```

--------------------------------

### Define and call a basic function

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Demonstrates defining a function with explicit parameter types and calling it to perform a calculation.

```ImHex Pattern Language
fn min(s32 a, s32 b) {
    if (a > b)
        return b;
    else
        return a;
};
 
std::print(min(100, 200)); // 100
```

--------------------------------

### Pattern Views

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Creating a view of data using placement syntax, which allows accessing data without generating an output pattern.

```text
fn read_u32(u32 address) {
    u32 value @ address;
 
    return value;
};
 
std::print("{}", read_u32(0x1234)); // Prints the value at address 0x1234 formatted as a u32
```

--------------------------------

### Nested and reopened namespaces

Source: https://docs.werwolv.net/pattern-language/core-language/namespaces

Shows how to define nested namespaces and reopen an existing namespace to add helper functions, keeping internal logic encapsulated alongside main type definitions.

```imhex
namespace game {
 
    struct User {
        u32 id;
        u32 age;
    } [[format("game::impl::format_user")]];
 
    namespace impl {
        fn format_user(User user) {
            return std::format("User({}, {})", user.id, user.age);
        };
    }
 
    struct Score {
        u32 points;
        u32 level;
    } [[format("game::impl::format_score")]];
 
    namespace impl {
        fn format_score(Score score) {
            return std::format("Score({}, {})", score.points, score.level);
        };
    }
 
}
```

--------------------------------

### Declare a pattern local variable

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Declares a local variable inside a pattern that does not show up in the final type. Initialize it with a value using the = operator. The example declares localVariable with value 0.5.

```pattern
struct MyType {
    u32 x, y, z; // Regular members
    float localVariable = 0.5; // Local variable
};
```

--------------------------------

### Define a simple struct Vector3f

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Defines a struct named Vector3f with three float members x, y, and z. When placed in memory, all members are placed directly adjacent to each other starting at the specified address.

```pattern
struct Vector3f {
  float x, y, z;
};
```

--------------------------------

### #pragma directive

Source: https://docs.werwolv.net/pattern-language/core-language/preprocessor

Provides hints to the runtime regarding how to treat specific aspects of the pattern.

```hexpat
#pragma endian big
```

--------------------------------

### Import a Pattern File with import * from

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Use `import * from <Pattern File> as <Type Name>` to create a new struct type from another pattern file. The imported pattern is evaluated as if copy-pasted with offsets adjusted; it cannot access bytes before the placement address.

```Pattern Language
import * from pe as Executable;
 
Executable executable @ 0x1234;
```

--------------------------------

### Define a union Converter

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Defines a union named Converter with u32 integerData and float floatingPointData. All members share the same start address, allowing data to be interpreted and inspected as multiple different types.

```pattern
union Converter {
  u32 integerData;
  float floatingPointData;
};
```

--------------------------------

### Define and use a namespace

Source: https://docs.werwolv.net/pattern-language/core-language/namespaces

Demonstrates defining a namespace 'abc' containing a struct, accessing it via the scope resolution operator '::', and using the 'using' keyword to alias a namespaced type.

```imhex
namespace abc {
 
    struct Type {
        u32 x;
    };
 
}
 
abc::Type type1 @ 0x100;
 
using Type = abc::Type;
Type type2 @ 0x200;
```

--------------------------------

### Import Standard Library Headers

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Standard library headers use the `import` statement internally and should be imported using `import`. Custom patterns can still use `#include` for client project files.

```Pattern Language
import std.io;
import std.mem;
import type.float16;
```

--------------------------------

### Bitfield padding

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Shows how to insert padding between fields in a bitfield.

```text
bitfield Flags {
  a : 1;
  b : 2;
  padding : 4;
  c : 1;
};
```

--------------------------------

### Manual Include Guard with #ifndef and #define

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Use `#ifndef` and `#define` to write manual include guards when using the `#include` directive. This prevents duplicate declarations in the current file.

```Pattern Language
#ifndef FOO_HEXPAT
#define FOO_HEXPAT
 
// Pattern code
 
#endif
```

--------------------------------

### Using parent in a function to access caller struct members

Source: https://docs.werwolv.net/pattern-language/core-language/expressions

Shows how the parent operation refers to the caller struct or union inside a function. The function rename_field uses std::core::set_display_name to rename the first field of the caller struct, and the example expects Pattern Data to display s > fields > version.

```imhex-pattern
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
```

--------------------------------

### For-Loops

Source: https://docs.werwolv.net/pattern-language/core-language/functions

For loops using three comma-separated blocks for initialization, condition, and increment.

```text
// Declare a variable called i available only inside the for
for (u8 i = 0, i < 10, i = i + 1) {
    // Keeps on executing as long as i is less than 10
 
    // At the end, increment i by 1
}
```

```text
for (u8 i = 0, i < 10, i += 1) {
    // Body of loop
}
```

--------------------------------

### import statement with string argument

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Use a string argument to import a module whose name or folder contains a keyword, since keywords cannot be used as identifiers. This behaves the same as #include.

```plaintext
// Since match is a keyword, we can't import a module named "match.pat" as described
// in the previous example. We can pass a string argument to import instead.
import "tools/match.pat";
```

--------------------------------

### Define templates for struct, union, and using

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Shows template definitions for struct, union, and using declarations. Templates substitute parts of a custom type's member types with placeholders that can be defined later when instantiating the type.

```pattern
struct MyTemplateStruct<T> {
  T member;
};
 
union MyTemplateStruct<Type1, Type2> {
  Type1 value1;
  Type2 value2;
};
 
using MyTemplateUsing<Type1> = MyTemplateStruct<Type1, u32>;
```

--------------------------------

### fn print_sequence(auto first, auto ... rest)

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Defines a function that uses a parameter pack to accept an unlimited number of parameters. Demonstrates recursive processing of the pack.

```APIDOC
## fn print_sequence(auto first, auto ... rest)

### Description
Defines a function that uses a parameter pack to accept an unlimited number of parameters. Demonstrates recursive processing of the pack.

### Function Signature
fn print_sequence(auto first, auto ... rest)

### Parameters
- **first** (auto) - Required - The first parameter in the sequence.
- **rest** (auto ...) - Optional - A parameter pack containing the remaining parameters.

### Example
```
fn print_sequence(auto first, auto ... rest) {
    std::print("{}", first);
 
    if (std::sizeof_pack(rest) > 0)
        print_sequence(rest);
};
 
print_sequence(1, 2, 3, 4, 5, 6);
```
```

--------------------------------

### Multi-line match options with block bodies

Source: https://docs.werwolv.net/pattern-language/core-language/control-flow

Shows match options with multi-line block bodies, allowing multiple statements per case.

```imhex-pattern
struct Packet {
  Type type;
  u8 size;
  bool isValid = false;
 
  match (type, size) {
    (Type::A, 0x200): {
        PacketA packet;
        isValid = true;
    }
    (Type::C, 0x100 | 0x200): PacketC packet;
    (Type::B, 0x100 ... 0x300): PacketB packet;
  }
};
 
Packet packet[3] @ 0xF0;
```

--------------------------------

### Enable allow_edits pragma

Source: https://docs.werwolv.net/pattern-language/core-language/preprocessor

The allow_edits pragma enables modification of values already loaded in memory, allowing for the replacement of binary data.

```text
#pragma allow_edits
 
Struct Foo {
    u8 firstByte; // 0x01
    u8 secondByte; // 0x02
    secondByte = 0x04; // This will replace 0x02 with the new value of 0x04
};
 
Foo f @ 0x0;
```

--------------------------------

### Interleaved bitfield

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Demonstrates mixing regular types with bitfield fields.

```text
bitfield InterleavedBitfield {
    field_1 : 4;
    field_2 : 2;
    u16 regular_value;
};
```

--------------------------------

### Loop sized array with break statement

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Demonstrates using a loop-sized array in conjunction with a break statement within a struct.

```text
struct Segment {
    u8 width, height, x, y;
    u16 endFlag; // 0x01 if it's the last segment
 
    if (endFlag == 0x01) {
        break;
    }
};
 
struct Sprite {
    u32 id;
    Segment segments[while(true)];
};
```

--------------------------------

### fn min(s32 a, s32 b)

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Defines a function that returns the minimum of two signed 32-bit integers. Demonstrates basic function syntax with explicit parameter types and automatic return type deduction.

```APIDOC
## fn min(s32 a, s32 b)

### Description
Defines a function that returns the minimum of two signed 32-bit integers. Demonstrates basic function syntax with explicit parameter types and automatic return type deduction.

### Function Signature
fn min(s32 a, s32 b)

### Parameters
- **a** (s32) - Required - First integer to compare.
- **b** (s32) - Required - Second integer to compare.

### Return Value
Returns the smaller of the two input integers.

### Example
```
fn min(s32 a, s32 b) {
    if (a > b)
        return b;
    else
        return a;
};
 
std::print(min(100, 200)); // 100
```
```

--------------------------------

### fn print_my_string(ref MyString myString)

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Defines a function that takes a reference parameter to a custom type. Demonstrates avoiding copying large data and passing custom types by reference.

```APIDOC
## fn print_my_string(ref MyString myString)

### Description
Defines a function that takes a reference parameter to a custom type. Demonstrates avoiding copying large data and passing custom types by reference.

### Function Signature
fn print_my_string(ref MyString myString)

### Parameters
- **myString** (ref MyString) - Required - A reference to a MyString instance.

### Example
```
struct MyString {
    char value[while(std::mem::read_unsigned($, 1) != 0xFF)];
};
 
fn print_my_string(ref MyString myString) {
    std::print(myString.value);
};
```
```

--------------------------------

### fn print_numbers(u32 a, u32 b, u32 c = 3, u32 d = 4)

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Defines a function with default parameter values. Demonstrates how default parameters allow omitting arguments when calling the function.

```APIDOC
## fn print_numbers(u32 a, u32 b, u32 c = 3, u32 d = 4)

### Description
Defines a function with default parameter values. Demonstrates how default parameters allow omitting arguments when calling the function.

### Function Signature
fn print_numbers(u32 a, u32 b, u32 c = 3, u32 d = 4)

### Parameters
- **a** (u32) - Required - First number to print.
- **b** (u32) - Required - Second number to print.
- **c** (u32) - Optional - Third number to print, defaults to 3.
- **d** (u32) - Optional - Fourth number to print, defaults to 4.

### Example
```
fn print_numbers(u32 a, u32 b, u32 c = 3, u32 d = 4) {
    std::print("{} {} {} {}", a, b, c, d);
};
 
print_numbers(1, 2);            // Prints 1 2 3 4
print_numbers(8, 9, 10, 11);    // Prints 8 9 10 11
```
```

--------------------------------

### Implement a Searcher Pattern

Source: https://docs.werwolv.net/pattern-language/core-language/control-flow

The Searcher Pattern uses a loop and continue to scan memory for a specific needle value, placing a struct pattern once found.

```text
struct Command {
  u32 data;
};
 
u8 needle = 0xCD;
 
struct PatternSearcher {
  u32 test = std::mem::read_unsigned($, 1);
  if (test != needle) { $ += 1; continue; }
  Command command @ $;
  $ += sizeof(Command);
};
 
// Search from 0x0000 to 0xFFFF
PatternSearcher search[while($ < 0xFFFF)] @ 0x00;
 
// Search the entire file
PatternSearcher search[while(!std::mem::eof())] @ 0x00;
 
// Search from 0x3FFF to the end of the file
PatternSearcher search[while(!std::mem::eof())] @ 0x3FFF;
```

--------------------------------

### #ifdef, #ifndef, and #endif directives

Source: https://docs.werwolv.net/pattern-language/core-language/preprocessor

Conditionally includes code blocks based on whether a specific define exists.

```hexpat
#ifdef SOME_DEFINE
    u32 value @ 0x00;
#endif
```

--------------------------------

### fn get_value() with const

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Defines a function that declares a constant local variable. Demonstrates using the 'const' keyword inside functions.

```APIDOC
## fn get_value() with const

### Description
Defines a function that declares a constant local variable. Demonstrates using the 'const' keyword inside functions.

### Function Signature
fn get_value()

### Parameters
None.

### Return Value
Returns the constant value (u32).

### Example
```
fn get_value() {
    const u32 value = 1234;
    return value;
};
 
std::print("{}", get_value()); // 1234
```
```

--------------------------------

### #define directive

Source: https://docs.werwolv.net/pattern-language/core-language/preprocessor

Performs a find-and-replace of the label with the specified value throughout the program.

```hexpat
#define MY_CONSTANT 1337
```

--------------------------------

### #error directive

Source: https://docs.werwolv.net/pattern-language/core-language/preprocessor

Throws an error during the preprocessing phase if the line is reached.

```hexpat
#error "Something went wrong!"
```

--------------------------------

### fn get_value()

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Defines a function that declares local variables and returns a computed value. Demonstrates variable declaration and usage inside a function.

```APIDOC
## fn get_value()

### Description
Defines a function that declares local variables and returns a computed value. Demonstrates variable declaration and usage inside a function.

### Function Signature
fn get_value()

### Parameters
None.

### Return Value
Returns the computed value (u32).

### Example
```
fn get_value() {
    u32 value;
    u8 x = 1234;
 
    value = x * 2;
 
    return value;
};
```
```

--------------------------------

### Place a variable at a specific address

Source: https://docs.werwolv.net/pattern-language/core-language/variable-placement

Uses the @ operator to place an unsigned 32-bit variable at the memory offset 0x110.

```text
u32 myPlacedVariable @ 0x110;
```

--------------------------------

### Pass an array as a reference parameter

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Use 'ref auto' to pass an array to a function, allowing iteration over its elements.

```ImHex Pattern Language
fn print_array(ref auto arr) {
    std::print("{}", arr);
    for (auto i = 0, i < std::core::member_count(arr), i += 1) {
        std::print("{}: {}", i, arr[i]);
    }
};
u8 v[1];
v[0] = 1;
print_array(v);  // 0: 1
```

--------------------------------

### Match statement with range and OR operators

Source: https://docs.werwolv.net/pattern-language/core-language/control-flow

Uses the _..._ operator for range matching and the | operator to match multiple values.

```imhex-pattern
struct Packet {
  Type type;
  u8 size;
 
  match (type, size) {
    (Type::A, 0x200): PacketA packet;
    (Type::C, 0x100 | 0x200): PacketC packet;
    (Type::B, 0x100 ... 0x300): PacketB packet;
  }
};
 
Packet packet[3] @ 0xF0;
```

--------------------------------

### Match statement with wildcard and multiple values

Source: https://docs.werwolv.net/pattern-language/core-language/control-flow

Matches on multiple values (type and size) and uses the _ wildcard as a default case.

```imhex-pattern
struct Packet {
  Type type;
  u8 size;
 
  match (type, size) {
    (Type::A, 0x200): PacketA packet;
    (Type::C, _): PacketC packet;
    (_, _): PacketB packet;
  }
};
 
Packet packet[3] @ 0xF0;
```

--------------------------------

### fn print_array(ref auto arr)

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Defines a function that takes an array parameter using the 'ref auto' type. Demonstrates how to accept arrays and iterate over their elements.

```APIDOC
## fn print_array(ref auto arr)

### Description
Defines a function that takes an array parameter using the 'ref auto' type. Demonstrates how to accept arrays and iterate over their elements.

### Function Signature
fn print_array(ref auto arr)

### Parameters
- **arr** (ref auto) - Required - An array to be printed and iterated over.

### Example
```
fn print_array(ref auto arr) {
    std::print("{}", arr);
    for (auto i = 0, i < std::core::member_count(arr), i += 1) {
        std::print("{}: {}", i, arr[i]);
    }
};
u8 v[1];
v[0] = 1;
print_array(v);  // 0: 1
```
```

--------------------------------

### Use reference parameters for custom types

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Reference parameters avoid copying data and are useful for custom types without a fixed layout.

```ImHex Pattern Language
struct MyString {
    char value[while(std::mem::read_unsigned($, 1) != 0xFF)];
};
 
fn print_my_string(ref MyString myString) {
    std::print(myString.value);
};
```

--------------------------------

### Define default parameters

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Default values can be assigned to parameters, which are used if the caller does not provide them.

```ImHex Pattern Language
fn print_numbers(u32 a, u32 b, u32 c = 3, u32 d = 4) {
    std::print("{} {} {} {}", a, b, c, d);
};
 
print_numbers(1, 2);            // Prints 1 2 3 4
print_numbers(8, 9, 10, 11);    // Prints 8 9 10 11
```

--------------------------------

### If-Else-Statements

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Conditional branching using if, else if, and else. Curly braces are optional for single-statement bodies.

```text
if (x > 5) {
    // Execute when x is greater than 5
} else if (x == 2) {
    // Execute only when x is equals to 2
} else {
    // Execute otherwise
}
```

--------------------------------

### Return Statements

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Returning values from functions where the return type is automatically inferred.

```text
fn get_value() {
    return 1234;
};
 
std::print("{}", get_value()); // 1234
```

--------------------------------

### Doc comments

Source: https://docs.werwolv.net/pattern-language/core-language/comments

Doc comments provide extra documentation for the whole pattern, individual functions, or types.

```text
/*!
    This is a global doc comment.
    It documents the whole pattern and can contain various attributes that can be used by tools to extract information about the pattern.
*/
 
/**
    This is a local doc comment.
    It documents the function or type that immediately follows it.
*/
 
/**
    This is a doc comment documenting a function that adds two numbers together
    @param x The first parameter.
    @param y The second parameter.
    @return The sum of the two parameters.
*/
fn add(u32 x, u32 y) {
    return x + y;
};
 
/// This is a single line local comment. It documents the function or type that immediately follows it.
```

--------------------------------

### Basic AnimationBank structure

Source: https://docs.werwolv.net/pattern-language

Defines the initial structure for an animation file, reading a u32 count at offset 0x0.

```ImHex Pattern Language
struct AnimationBank {
    u32 count;
};
 
AnimationBank animationBank @ 0x0;
```

--------------------------------

### Forward declare a type with using B;

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Shows forward declaration of a type B so that two types can recursively reference each other. The using B; syntax tells the language that a type named B will be declared in the future, so parsing of variables with that type is postponed until the type is declared.

```pattern
// Tell the language that there will be a type named B in the future so if it encounters
// a variable with this type, it has to postpone the parsing until the type has been declared
using B;
 
struct A {
  bool has_b;
 
  if (has_b)
    B b;
};
 
struct B {
  bool has_a;
 
  if (has_a)
    A a;
};
```

--------------------------------

### Pattern with In and Out variables

Source: https://docs.werwolv.net/pattern-language/core-language/in-out-variables

A simple pattern that reads a value from an input field, performs a calculation, and writes the result to an output label.

```text
u32 inputValue in;
u32 outputValue out;
 
fn main() {
    outputValue = inputValue * 2;
};
```

--------------------------------

### Declare a global variable

Source: https://docs.werwolv.net/pattern-language/core-language/variable-placement

Defines a global variable without using the @ placement instruction.

```text
u32 globalVariable;
```

--------------------------------

### String array types

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Declares char and char16 arrays which are displayed as strings terminated by a null byte.

```text
char myCString[];
char16 myUTF16String[];
```

--------------------------------

### Mark a Namespace as auto for Import

Source: https://docs.werwolv.net/pattern-language/core-language/importing-modules

Mark a namespace as `auto` in a library file so that only that namespace is imported and renamed when using the `import` statement. Other namespaces in the file are not imported.

```Pattern Language
// std/ctype.pat
 
namespace auto std::ctype {
 
    // ...
 
}
 
namespace impl {
 
    // ...
 
}
```

```Pattern Language
// Import the std::type namespace from the ctype.pat library file
// and rename the std::ctype namespace to test
import std.ctype as test;
```

--------------------------------

### Define a multi-parameter user-defined literal

Source: https://docs.werwolv.net/pattern-language/core-language/functions

Literals can accept multiple parameters where the applied value is the first argument and subsequent arguments are passed within parentheses.

```text
fn _literal(u32 value, u32 multiplier) {
    return value * multiplier;
};
 
u32 three_times = 123_literal(3); // three_times = 369
```

--------------------------------

### Pointer declaration

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Declares a pointer whose address is a u32 and points to a u16.

```text
u16 *pointer : u32 @ 0x08;
```

--------------------------------

### AnimationEntry placed at offset

Source: https://docs.werwolv.net/pattern-language

Introduces an AnimationEntry struct and places it within Animation at the specified offset.

```ImHex Pattern Language
struct AnimationEntry {
};
 
struct Animation {
    u32 offset;
    AnimationEntry entry @ offset;
};
 
struct AnimationBank {
    u32 count;
    Animation animations[count];
};
 
AnimationBank animationBank @ 0x0;
```

--------------------------------

### Bitfield field types

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Shows various field types within a bitfield, including signed, unsigned, boolean, and enum interpretations.

```text
bitfield TestBitfield {
    regular_value           : 4;    // Regular field, regular unsigned value
    unsigned unsigned_value : 5;    // Unsigned field, same as regular_value
    signed   signed_value   : 4;    // Signed field, interpreting the value as two's complement
    bool     boolean_value  : 1;    // Boolean field, 
    TestEnum enum_value     : 8;    // Enum field, displays the enum value corresponding to that value
};
```

--------------------------------

### Pointer to array declaration

Source: https://docs.werwolv.net/pattern-language/core-language/data-types

Declares a pointer to an array of 10 u32s with a pointer size of s16.

```text
u32 *pointerToArray[10] : s16 @ 0x10;
```
Tokens:
Raw