Operators: Arrayedit

Array Initializationedit

Use the array initialization operator '[] {}' to allocate a single-dimensional array type instance to the heap with a set of pre-defined elements. Each value used to initialize an element in the array type instance is cast to the specified element type value upon insertion. The order of specified values is maintained.

Errors

  • If a value is not castable to the specified type value.

Grammar

array_initialization: 'new' TYPE '[' ']' '{' expression_list '}'
                    | 'new' TYPE '[' ']' '{' '}';
expression_list: expression (',' expression);

Example:

  • Array initialization with static values.

     int[] x = new int[] {1, 2, 3};

    declare int[] x; allocate 1-d int array instance with length [3]1-d int array reference; store int 1 to index [0] of 1-d int array reference; store int 2 to index [1] of 1-d int array reference; store int 3 to index [2] of 1-d int array reference; store 1-d int array reference to x;

  • Array initialization with non-static values.

     int i = 1;
     long l = 2L;
     float f = 3.0F;
     double d = 4.0;
     String s = "5";
     def array = new def[] {i, l, f*d, s};

    declare int i; store int 1 to i

    declare long l; store long 2 to l

    declare float f; store float 3.0 to f

    declare double d; store double 4.0 to d

    declare String s; store String "5" to s

    declare def array; allocate 1-d def array instance with length [4]1-d def array reference; load from iint 1; implicit cast int 1 to defdef; store def to index [0] of 1-d def array reference; load from llong 2; implicit cast long 2 to defdef; store def to index [1] of 1-d def array reference; load from ffloat 3.0; load from ddouble 4.0; promote float 3.0 and double 4.0: result double; implicit cast float 3.0 to double 3.0double 3.0; multiply double 3.0 and double 4.0double 12.0; implicit cast double 12.0 to defdef; store def to index [2] of 1-d def array reference; load from sString "5"; implicit cast String "5" to defdef; store def to index [3] of 1-d def array reference; implicit cast 1-d int array reference to defdef; store def to array

Array Accessedit

Use the array access operator '[]' to store a value to or load a value from an array type value. Each element of an array type value is accessed with an int type value to specify the index to store/load. The range of elements within an array that are accessible is [0, size) where size is the number of elements specified at the time of allocation. Use a negative int type value as an index to access an element in reverse from the end of an array type value within a range of [-size, -1].

Errors

  • If a value other than an int type value or a value that is castable to an int type value is provided as an index.
  • If an element is accessed outside of the valid ranges.

Grammar

brace_access: '[' expression ']'

Examples

  • Array access with a single-dimensional array.

     int[] x = new int[2];
     x[0] = 2;
     x[1] = 5;
     int y = x[0] + x[1];
     int z = 1;
     int i = x[z];

    declare int[] x; allocate 1-d int array instance with length [2]1-d int array reference; store 1-d int array reference to x

    load from x1-d int array reference; store int 2 to index [0] of 1-d int array reference;

    load from x1-d int array reference; store int 5 to index [1] of 1-d int array reference;

    declare int y; load from x1-d int array reference; load from index [0] of 1-d int array referenceint 2; load from x1-d int array reference; load from index [1] of 1-d int array referenceint 5; add int 2 and int 5int 7; store int 7 to y

    declare int z; store int 1 to z;

    declare int i; load from x1-d int array reference; load from zint 1; load from index [1] of 1-d int array referenceint 5; store int 5 to i;

  • Array access with the def type.

     def d = new int[2];
     d[0] = 2;
     d[1] = 5;
     def x = d[0] + d[1];
     def y = 1;
     def z = d[y];

    declare def d; allocate 1-d int array instance with length [2]1-d int array reference; implicit cast 1-d int array reference to defdef; store def to d

    load from ddef implicit cast def to 1-d int array reference1-d int array reference; store int 2 to index [0] of 1-d int array reference;

    load from ddef implicit cast def to 1-d int array reference1-d int array reference; store int 5 to index [1] of 1-d int array reference;

    declare int x; load from ddef implicit cast def to 1-d int array reference1-d int array reference; load from index [0] of 1-d int array referenceint 2; load from ddef implicit cast def to 1-d int array reference1-d int array reference; load from index [1] of 1-d int array referenceint 5; add int 2 and int 5int 7; implicit cast int 7 to defdef; store def to x

    declare def y; implicit cast int 1 to defdef; store def to y;

    declare int i; load from ddef implicit cast def to 1-d int array reference1-d int array reference; load from ydef; implicit cast def to int 1int 1; load from index [1] of 1-d int array referenceint 5; implicit cast int 5 to def; store def to z;

  • Array access with a multi-dimensional array.

     int[][][] ia3 = new int[2][3][4];
     ia3[1][2][3] = 99;
     int i = ia3[1][2][3];

    declare int[][][] ia; allocate 3-d int array instance with length [2, 3, 4]3-d int array reference; store 3-d int array reference to ia3

    load from ia33-d int array reference; store int 99 to index [1, 2, 3] of 3-d int array reference

    declare int i; load from ia33-d int array reference; load from index [1, 2, 3] of 3-d int array referenceint 99; store int 99 to i

Array Lengthedit

An array type value contains a read-only member field named length. The length field stores the size of the array as an int type value where size is the number of elements specified at the time of allocation. Use the field access operator to load the field length from an array type value.

Examples

  • Access the length field.

     int[] x = new int[10];
     int l = x.length;

    declare int[] x; allocate 1-d int array instance with length [2]1-d int array reference; store 1-d int array reference to x

    declare int l; load x1-d int array reference; load length from 1-d int array referenceint 10; store int 10 to l;

New Arrayedit

Use the new array operator 'new []' to allocate an array type instance to the heap. Specify the element type following the new token. Specify each dimension with the [ and ] tokens following the element type name. The size of each dimension is specified by an int type value in between each set of [ and ] tokens.

Errors

  • If a value other than an int type value or a value that is castable to an int type value is specified for a dimension’s size.

Grammar

new_array: 'new' TYPE ('[' expression ']')+;

Examples

  • Allocation of different array types.

     int[] x = new int[5];
     x = new int[10];
     int y = 2;
     def z = new def[y][y*2];

    declare int[] x; allocate 1-d int array instance with length [5]1-d int array reference; store 1-d int array reference to x

    allocate 1-d int array instance with length [10]1-d int array reference; store 1-d int array reference to x

    declare int y; store int 2 to y;

    declare def z; load from yint 2 @0; load from yint 2 @1; multiply int 2 @1 by int 2 @2int 4; allocate 2-d int array instance with length [2, 4]2-d int array reference; implicit cast 2-d int array reference to defdef; store def to z;