Extended compiler warnings (GPC60xx)

GPC6010 — Argument Out of Recommended Range

Argument {i} of '{name}' is {value}, minimum is {min}
Argument {i} of '{name}' is {value}, maximum is {max}
Argument {i} of '{name}' has value {value} which is not in the allowed set

Severity: Warning

A constant argument falls outside the recommended range (or allowed value set) for that built-in parameter on the target device. The call still compiles; behavior at runtime may be clamped or undefined. (Hard limits report the error GPC5153 instead.)

---

GPC6011 — Deprecated Function

Function '{name}' is deprecated

Often extended with the reason, e.g. Function '{name}' is deprecated — Use '{replacement}' instead.

Severity: Warning (tagged deprecated)

The called built-in is deprecated on the target device. It still works, but a better alternative exists — when the message names a replacement, switch to it. For example, printf on the Cronus Zen 32 reports Function 'printf' is deprecated — Use 'print' instead. A few deprecated functions report a more specific code instead of this generic one — see GPC9000 for the data-section reader functions.

---

GPC6012 — Function in Loop

'{name}': {message}

Where {message} explains the specific concern for that function.

Severity: Warning

A built-in that should not run repeatedly is called inside a loop. What the risk is depends on the function — the message spells it out. The classic case is set_pvar, which writes persistent storage that wears out with repeated writes; on devices where that matters it reports the more specific GPC9001 instead.

---

GPC6014 — Assignment in Condition

Assignment in condition — did you mean '==' instead of '='?

Severity: Warning

An assignment expression is used directly as a condition. Legal, but overwhelmingly a typo for ==. This only fires for a plain =; compound assignment operators (+=, -=, ...) used in a condition are not flagged.

if (mode = 2) { ... }    // GPC6014 — assigns 2, always true
if (mode == 2) { ... }   // comparison

---

GPC6015 — Division Results in Zero

Division with constant operands results in 0

Severity: Warning

A division of compile-time constants folds to 0 (integer division truncates, e.g. 1 / 2). The expression is replaced by the constant 0 — if you expected a fraction, rescale your math.

---

GPC6016 — Modulus Results in Zero

Modulus with constant operands results in 0

Severity: Warning

A modulus of compile-time constants folds to 0. Usually indicates the left operand is a multiple of the right, or a misunderstanding of the operands.

---

GPC6017 — Shift Out of Bounds

Shift amount {n} exceeds maximum of {max} for {bits}-bit target

Severity: Warning

A constant shift amount is >= the width of the script's integer type (16 or 32). The result is not what the literal math suggests.

---

GPC6018 — Switch Case Fallthrough

Switch case falls through to the next case without break or return

Severity: Warning

A non-empty case block does not end in break or return, so execution continues into the next case. Add break; (or a comment-free intentional restructure) — GPC has no fallthrough annotation.

---

GPC6019 — Unused Variable

Variable '{name}' is declared but never directly used

Severity: Warning

A variable is declared but no statement reads or writes it. Remove it to free a variable slot.

---

GPC6020 — Assigned But Never Read

Variable '{name}' is directly assigned but never directly read

Severity: Warning

The variable is written (or initialized) but its value is never read back. The stores are wasted work; either use the value or delete the variable.

---

GPC6021 — Read But Never Assigned

Variable '{name}' is directly read but never directly assigned (always has default value 0)

Severity: Warning

---

The variable is read but never written, so every read yields the default value 0. Usually a forgotten initialization or a name mix-up.

GPC6022 — Unused Const Array

Const array '{name}' is declared but never used

Severity: Warning

A const array is never referenced. Its data still occupies space in the data section — delete it.

---

GPC6023 — Unused Function Argument

Function argument '{name}' is never used

Severity: Warning

A parameter of a user-defined function is never referenced in the function body.

---

GPC6024 — combo_restart in init

combo_restart in init section is equivalent to combo_run

Severity: Warning

combo_restart inside init has nothing to restart (no combo state exists yet), so the compiler emits the same code as combo_run. Write combo_run for clarity.

---

GPC6026 — Empty Switch

Switch statement has no cases and has no effect
Switch statement has no cases; the 'default' block always runs

Severity: Warning

A switch contains no case labels. Without a default it does nothing; with only a default the switch is pointless — the block runs unconditionally.

---

GPC6027 — OLED Glyph Blank in Large Font

Argument {i} of '{function}': string '{name}' contains special glyphs with no bitmap in the LARGE OLED font: {bytes}

Severity: Warning

A string printed with OLED_FONT_LARGE contains special glyph bytes (\x7F–\x88, the controller-symbol glyphs). The 16x26 device font has no bitmaps for these, so they render blank. Use the small or medium font for symbol glyphs.

---

GPC6028 — Unsupported OLED String Byte

Argument {i} of '{function}': string '{name}' contains bytes with no OLED font glyph (supported range \x20-\x88): {bytes}

Severity: Warning

A string passed to an OLED print function contains bytes below \x20 or above \x88, which no OLED font can render. Check escape sequences and non-ASCII characters in the string.

---

GPC6029 — Postfix Increment in Return

Postfix '{++|--}' in a return statement yields the value before the {increment|decrement}. Use the prefix form if the updated value is intended

Severity: Warning

return x++; returns the value before the increment (standard C semantics), but the original Zen Studio compiler returned the value after it — so this construct behaves differently between compilers. return ++x; behaves identically in both; use the prefix form to make the intent unambiguous.

---

GPC6030 — Array Index Call Evaluated Twice

Function '{name}' is called twice: the array index is evaluated once for the read and once for the write
Function '{name}' is called twice: the index is re-evaluated when the assignment result is used

Severity: Warning

A dynamic array index (one that is not a compile-time constant) contains a function call, and the compiler must re-evaluate that index expression more than once — so the call, and any side effect it has, runs more than once per statement. The first message fires for compound assignment on a dynamic index (arr[f()] += 1;: one evaluation to read the current value, one to write the new one) — this happens unconditionally, even in bare-statement context. The second fires when a plain assignment's result is also consumed, e.g. used in a condition or as a value (if (arr[f()] = 5) { ... }) — a third, trailing re-read of the index. Give the index a fixed value first (i = f(); arr[i] += 1;) to avoid the repeat calls.

---

GPC6031 — Zero-Size Array

Zero-size array '{name}' occupies no storage and aliases the next declared variable

Severity: Warning

A zero-size array declaration (int arr[0];). This is an accepted quirky feature, not an error: the array occupies no storage and its name aliases the next declared variable's slot (some community scripts deliberately exploit this to get two names for one variable). Warned so accidental zero-size declarations are debuggable — the aliasing behavior itself is intentional and documented, not a bug. See GPC5154 for the invalid form, where there is no following variable to alias.

int arr[0];   // GPC6031 — aliases 'next'
int next;

---

GPC6032 — 16-bit Data Value

Data value requires 2 bytes; subsequent data section indexes will be offset by 1

Severity: Warning

A value in the data(...) section does not fit in one byte and is stored as 2 bytes. Data-section access functions address bytes, so every index after this value shifts by 1. Keep data values in -128..255 if you rely on 1-value-per-index addressing.

---

GPC6033 — 24-bit Data Value

Data value requires 3 bytes; subsequent data section indexes will be offset by 2

Severity: Warning

A value in the data(...) section does not fit in two bytes and is stored as 3 bytes (values outside -32768..65535 but within -8388608..16777215, on devices that support 24-bit data values). Data-section access functions address bytes, so every index after this value shifts by 2. Keep data values in -128..255 if you rely on 1-value-per-index addressing.

---

GPC6034 — 32-bit Data Value

Data value requires 4 bytes; subsequent data section indexes will be offset by 3

Severity: Warning

A value in the data(...) section is stored as 4 bytes — it falls outside -8388608..16777215, or outside -32768..65535 on devices without 24-bit data support. Data-section access functions address bytes, so every index after this value shifts by 3. Keep data values in -128..255 if you rely on 1-value-per-index addressing.

---

GPC6035 — Potential Stack Overflow

Potential stack overflow at instruction '{opcode}' (line {line}, column {column}). Variables: {count}, Stack: {depth}, Max: {max}

A variant naming the called function exists for call instructions.

Severity: Warning

The compiler determined that at some point the script could use more working stack than the device provides — variables, in-flight expression values, and function calls all count against the same fixed limit. Deeply nested expressions or deep call chains are the usual cause. A legitimately-compilable script can trigger this; it warns of a real on-device crash risk, not a compiler bug. Flatten the expression or shorten the call chain.

---

GPC6036 — Recursive Function Call

Recursive function call detected: {name}. Cannot statically determine max stack usage.

Severity: Warning

A user function calls itself (directly or through a cycle), so the compiler cannot determine how much stack it may use — the GPC6035 overflow check cannot cover that chain. Recursion on a device with a small fixed stack is risky; prefer iteration.

---

GPC6037 — Empty or Missing main

No main block, or the main block is empty

Severity: Warning

The script has no main section, or one that contains no statements. A GPC script's real-time logic lives in main; without it the compiled script does nothing per report cycle.

This also fires on scripts that deliberately do all their work in init — the warning is expected there, not a mistake.