Semantic errors (GPC40xx)

GPC4000 — Redefinition

Redefinition of {kind} '{name}' detected (previously declared on {location})
Duplicate parameter name '{name}' in function '{function}'

Severity: Error

The same name is declared twice as the same kind of symbol — two variables, two functions, two defines with the same name, or two parameters of one function. The message points at the earlier declaration.

---

GPC4001 — Naming Conflict

'{name}' is already declared on {location}
Function '{name}' conflicts with built-in function '{name}'
{Kind} '{name}' conflicts with {other kind} '{name}' declared on {location}

Severity: Error

The same name is used where the compiler requires uniqueness. Variables, definitions, enum members, and const-data names share the data-symbol namespace, so a define and variable cannot reuse one name. Function names and combo names are resolved separately from that namespace, while built-in names and language keywords remain reserved. A user function named after almost any built-in (set_val, get_val, ...) also triggers this diagnostic; only min, max, and clamp get special handling instead (see GPC4025).

---

GPC4002 — Undefined Identifier

'{name}' is not defined
Undefined variable: {name}
No variable or const array named '{name}' could be found.

The first may carry the suggestion Did you mean '{other}'?.

Severity: Error

An identifier is referenced but no variable, define, enum member, const array, function parameter, or built-in constant with that name exists. Check spelling and case — GPC names are case-sensitive; the compiler suggests the closest existing name when one is similar enough.

int speed;
main {
    sped = 100;   // GPC4002 — Did you mean 'speed'?
}

---

GPC4003 — Scoped Variable Not Supported

Variables should be declared at top level

Severity: Error

A variable is declared inside a block (function body, main, if body, ...). GPC has no block scope — all variables must be declared at the top level of the script.

main {
    int count;   // GPC4003 — move above main
}

---

GPC4004 — Function Used as Value

'{name}' is a function and cannot be used as a variable or value
'{name}' is not a function and cannot be called

Severity: Error

Either a function name is used where a value is expected (e.g. x = myFunc; without parentheses), or the inverse: a value symbol (variable, define, ...) is called like a function (myVar()).

---

GPC4005 — Invalid Control Flow

'break' is not allowed outside a loop or switch
'continue' is not allowed outside a loop
Cannot use 'return' outside of a function

Severity: Error

A control-flow statement appears in a context where it has no meaning. Note that continue is not allowed inside a switch unless the switch itself is inside a loop, and return is only valid inside a user-defined function body.

---

GPC4006 — Invalid Array Access

2D array access not supported in this context

Severity: Error

Two-dimensional index syntax (name[a][b]) is applied to something that is not a 2D const array. Only const arrays declared with two bracket pairs support two indexes.

---

GPC4007 — Invalid Assignment Target

Invalid assignment target
Increment/decrement requires a variable
'{name}' is {a constant/a define/...} and cannot be used as a variable

Severity: Error

The left side of an assignment (or the operand of ++/--) is not something writable: it is a literal, an expression, a define, an enum member, a const array, or a built-in constant. Only variables and array-slot accesses can be assigned.

---

GPC4009 — Invalid Function Parameter

'{name}' is {kind} and cannot be used as a combo name in {function}(). Only combo names are allowed here.
The argument to {function}() must be a combo name, not an expression.

Severity: Error

The argument to a combo keyword (combo_run, combo_stop, combo_pause, combo_running, ...) is not the name of a declared combo — it is a variable, function, define, or a computed expression. Combo references are resolved at compile time and must be plain combo names.

---

GPC4010 — Invalid Combo Usage

'{name}' is a combo and cannot be used as a variable or value
'{name}' is a combo and cannot be called as a function. Use combo keywords like combo_run({name}) instead.
'{keyword}' is only allowed inside combos. Use '{keyword}' within a combo block.
'{keyword}' is only allowed at the root level of combos, not inside nested blocks (if, while, for, etc.).

Severity: Error

A combo name or combo-only keyword is used in the wrong place. Combos are not values and not functions; combo-only keywords such as wait() and call() may only appear directly at the root level of a combo body — not in main, and not nested inside an if/while/for within the combo.

---

GPC4011 — Too Many Arguments

Function '{name}' expects {n} argument(s), but got {m}

Severity: Error

A call passes more arguments than the function declares.

---

GPC4012 — Too Many Parameters

Function '{name}' declares too many parameters

Severity: Error

A function declaration has more parameters than the compiler accepts.

---

GPC4013 — Variable Declared in for Initializer

Variables should be declared at top level

Severity: Error

A for loop header declares a variable in its initializer clause (for(int i = 0; ...)). GPC has no block scope — declare the counter at top level and only assign it in the header.

int i;
main {
    for(i = 0; i < 4; i++) { }   // OK
}

---

GPC4014 — for Initializer Shadows a Global

For loop initializer '{name}' shadows {kind} '{name}' declared on {location}.

Severity: Error

The name used in a for initializer collides with an existing global variable, definition, enum member, const array, or built-in constant.

---

GPC4015 — Recursive Combo Call

Combo '{name}' cannot call itself. Recursive combo calls are not allowed.

Severity: Error

A combo body uses call({name}) on itself. Combos are state machines that each advance one step at the end of every main loop iteration; call() doesn't hand execution off to the other combo and move on — it pauses the calling combo's state machine until the called combo finishes running, then resumes where it left off. A combo calling itself would have to finish before it can finish, which can never happen, so the compiler rejects it outright. (Using combo_run on itself is merely useless — see GPC3008 — since combo_run starts a combo rather than pausing to wait for one.)

---

GPC4016 — Mutual Combo Recursion

Combo '{name}' is part of a circular call chain: {A → B → A}. Mutual recursion between combos is not allowed.

Severity: Error

Two or more combos call() each other in a cycle (for example, A calls B and B calls A). Because call() pauses the calling combo's state machine until the called combo finishes, every combo in a cycle ends up waiting on another combo in that same cycle to finish first — none of them can ever complete. The message spells out the detected chain; break the cycle by restructuring so at least one combo in the chain no longer waits on a combo that, directly or indirectly, waits on it in return.

---

GPC4017 — Empty Const Array

Const array must not be empty
Const array row {n} must not be empty

Severity: Error

A const array (or one row of a 2D const array) is declared with zero values. The array's size comes from its initializer, so an empty initializer is meaningless.

---

GPC4018 — Invalid Const Array Structure

All rows must be the same size. Row {n} has {count} values, expected {expected}

Severity: Error

The rows of a 2D const array have different lengths. Every row must contain the same number of values as the first row.

const int8 grid[][] = {
    { 1, 2, 3 },
    { 4, 5 }      // GPC4018 — expected 3 values
};

---

GPC4019 — Invalid PS5ADT Data

PS5ADT data must have exactly 11 values, found {count}

Severity: Error

A const ps5adt entry does not contain exactly the 11 values the PS5 adaptive-trigger format requires.

---

GPC4020 — Const Array Negative Index

Const array '{name}' accessed with negative index {index}

Severity: Error

A const array is indexed with a compile-time-constant negative value.

---

GPC4021 — Const Array Index Out of Bounds

Const array '{name}' index {index} is out of bounds (size: {count})

Severity: Error

A const array is indexed with a compile-time constant that is >= the array's element count. Valid indexes are 0 through size - 1.

---

GPC4022 — Variable Slot Underflow

Array access '{name}[{index}]' resolves to slot {slot}, which is below slot 0

Severity: Error

Non-const variable arrays are laid out as consecutive variable slots, and a constant index is resolved at compile time. Here the index is negative enough that the access lands before the first allocated slot — it would silently read or clobber memory outside the array.

---

GPC4023 — Variable Slot Overflow

Array access '{name}[{index}]' resolves to slot {slot}, which is past the last allocated slot {last}

Severity: Error

Counterpart to GPC4022: a constant index on a variable array resolves past the end of all allocated variable slots.

---

GPC4025 — Built-in Function Conflict

Function '{name}' conflicts with built-in function '{name}' and has different behavior

Severity: Error

A user-defined function is named after a pattern-detectable built-in (min, max, clamp) but its body does not implement the built-in's semantics. Because calls to these names bind to the built-in, keeping a different implementation would silently change behavior — rename the function.

This behavior check is special-cased to only min, max, and clamp. Naming a function after any other built-in (set_val, get_val, ...) is always a plain naming conflict — reported as GPC4001 — no matter what the function's body does.

---

GPC4026 — Never-Ending do-while

Never-ending do-while loop: condition is always true and body has no break or return

Severity: Error

A do { ... } while (condition); whose condition is constant-true and whose body contains no break or return. On the Zen a script must yield back to the runtime every iteration of main; an infinite inner loop would hang the device, so it is rejected outright.

---

GPC4027 — Never-Ending while

Never-ending while loop: condition is always true and body has no break or return

Severity: Error

Same as GPC4026 for while (1) { ... }-style loops with no exit.

main {
    while (TRUE) {         // GPC4027 — no break/return in body
        set_val(PS4_CROSS, 100);
    }
}

---

GPC4028 — Never-Ending for

Never-ending for loop: condition is always true and body has no break or return

Severity: Error

Same as GPC4026 for for(;;)-style loops (empty or constant-true condition) with no exit.

---

GPC4029 — String Value in define

String literals are not allowed in define values

Severity: Error

A define is initialized with a string literal (e.g. define NAME = "text";). define values must be numeric compile-time constants.

---

GPC4030 — Invalid sizeof() Operand

sizeof() requires a variable, array access, or type keyword

Severity: Error

The operand of sizeof() is not a variable, an array access, or a type keyword.

---

GPC4031 — Const Array Single-Bracket 2D Access

Const array '{name}' is multi dimensional but is used as if it was single dimensional

Severity: Error

Single-bracket, value-context access to a two-dimensional const array (e.g. M[i] where M is declared const T M[][] = {...}). A 2D const array's element accessor takes a row and a column index — one bracket pair only supplies the row, so the access is rejected rather than silently reading an uninitialized column.

image, string, and ps5adt 2D arrays are exempt: they are row-addressed by design (a single bracket returns the row's base address, not a dereferenced row+column element), matching how the original Zen Studio compiler treats those two types. addr(M[row]) is a separate, unaffected code path for any element type.

const int8 M[][] = { {1, 2}, {3, 4} };
int x;
main {
    x = M[0];      // GPC4031 — M is 2D; write M[0][0] instead
}

---

GPC4032 — Conditional Used as a Statement

Conditional expression result is not used

Severity: Error

A conditional expression is written as a bare statement instead of producing a value. The operator selects between two values; it is not a substitute for if/else.

enabled ? set_val(PS5_CROSS, 100) : set_val(PS5_CROSS, 0);   // GPC4032

if(enabled) set_val(PS5_CROSS, 100);                         // OK
else set_val(PS5_CROSS, 0);