i++ Syntax

Learn i++ source files, imports, declarations, control flow, namespaces, and inline assembly syntax.

i++ inherits C11 syntax and adds constructs for libraries, namespaces, dynamic arrays, and assembly. Source files use .ix; library files use .ih.

C11 foundation

Use familiar declarations, functions, pointers, and control flow.

i++ additions

Organize code with libraries and namespaces. Add string, dynam, and assembly where the compiler supports them.

This guide distinguishes supported syntax from language-design features that are not implemented yet. Check compiler status before using an i++ addition.

File extensions

Extension	Purpose
.ix	i++ source file
.ih	i++ library file

Library files use i++ syntax and do not require a separate header file. The compiler can compile either extension.

Imports and namespaces

Use using to import a library or symbol. Angle-bracket imports search library paths; quoted imports refer to local library files.

// Import a standard library file
using <iodine/printd>

// Import a symbol from a library file
using printd from <iodine/printd>

// Import from a local library
using helper from "utils"

1. Import

   Add a using declaration for the library or symbol you need.

2. Choose how to access it

   Use expose for unqualified calls, or use @ to keep the namespace explicit.

For example, expose the imported library namespace and call a function:

expose printd
printd("value: %d", 42)

You can also qualify a call with @ when the library namespace is in scope. Use space to define a namespace and using functionName&variableName to import an intra-file variable.

space counters {
    int total = 0;
}

Variables and control flow

Use C11 declarations and control-flow statements as you would in C:

int count = 3;
string name = "i++";

for (int i = 0; i < count; i++) {
    if (i > 0) {
        count--;
    }
}

The string and dynam types are i++ additions. See types for supported behavior.

Keep a program valid C11 when you want to reuse it with a standard C compiler. Use i++ additions only when you need their specific behavior.

Functions

Function declarations use C syntax:

int add(int left, int right) {
    return left + right;
}

Dynamic arrays

Declare a dynamic array with dynam and an initializer list. The array can grow or shrink using its methods.

dynam int numbers = [1, 2, 3];
numbers.push(4);
numbers.remove(0);
int count = len(numbers);

len() is built in for strings and dynamic arrays. tuple is not implemented.

Dynamic arrays and len() are supported. Tuple examples in older language notes are design sketches, not working compiler input.

Inline assembly

Named asm functions contain target-specific assembly:

asm int addInts(int a, int b) {
    syntax x86_64_linux
    section .text
    mov rax, a
    mov rbx, b
    add rax, rbx
    return
}

The current supported assembly target is x86_64_linux. See inline assembly for syntax and constraints.