The pawn language itself has also changed in the area of handling arrays with symbolic subscripts and handling packed versus unpacked arrays. The scripts need to be adjusted to the new syntax to compile in version 4.0.

See the separate "Pawn Porting Guide" for instructions for porting scripts and host applications from pawn 3.x to pawn 4.0.

• The "core" set is the minimal set of instructions that an abstract machine must implement. If you need to mininmize the footprint of the pawn abstract machine (e.g. on an embedded system on a small micro-controller), use this set. A Just-In-Time compiler will typically also implement the core set.
• The "supplemental" set adds macro instructions to the core set. A macro instruction replaces two or more of the core instructions by a single one. This reduces the size of the script and makes it run quicker as well (by reducing the overhead of decoding the instructions). For a Just-In-Time compiler, it is usually redundant to support this, because the macro instructions are typically translated to the same native code as the original sequence of core instructions.
• The "full" instruction set is a superset that adds "packed" instructions to the supplemental+core instruction set. Packed instructions decrease the size that the compiled script takes. It is mostly useful on embedded systems (with a small micro-controller) that run a script from RAM (but have enough ROM to contain a full abstract machine).

For example:

  const a = 10        // single constant
    const Ping:         // constant list, default tag is "Ping"
        {
        b = 1,
        c,
        Pong: d         // tag override
        }

In practice, this means that in most cases the braces must be replaced by brackets. For example, to declare and initialize an array with four cells, you now use:
    new rect[4] = [ 1, 2, 3, 4 ]

For packed arrays, you use braces both in the declaration of the array size and in the initialization. For example:
    new packed{10} = {'a', 'b', 'c' ... }
The above declares an array of ten characters (these fit in three cells on a 32-bit configuration).

Symbolic indices may specify a tag for the field, and may also indicate a (pseudo-)array. Please see the "Language Guide" for details.

  #define PRODUCT[
         .code,
         .description{20},
         Float: .price
     ]

Later, this definition can be used to declare an array, for example:
    new product[PRODUCT]

  new arr[2][2] = {
      { 1, 2,},
      { 3, 4,},
  }