Parse an array type, which is of the form:

<pre>
ArrayType ::= Type '[' ']'
</pre>

@return
490801
private Type parseArrayType(EnclosingScope scope) {
		int start = index;
		Type element = parseBaseType(scope);
		while (tryAndMatch(true, LeftSquare) != null) {
			match(RightSquare);
			element = annotateSourceLocation(new Type.Array(element),start);
		}

		return element;
	}
1111000
public function ParseFromArray()
	{
		$this->value = $this->reader->next();
		$this->value = ($this->value != 0) ? 1 : 0;
	}
1115559
protected function getArrayInternal()
    {
        if ($this->isArray($this->resource)) {
            return $this->resource;
        }

        return $this->parseIniString($this->resource);
    }
332692
protected function getArrayInternal()
    {
        if ($this->isArray($this->resource)) {
            return $this->resource;
        }

        return $this->parseJsonString($this->resource);
    }
98298
private function parseByteArray()
    {
        list(, $length) = unpack('N', $this->buffer);

        try {
            return substr($this->buffer, 4, $length);
        } finally {
            $this->buffer = substr($this->buffer, $length + 4);
        }
    }
945027
protected function getArrayType(array $array) {
		$indices = count(array_filter(array_keys($array), 'is_string'));

		if ($indices == 0) {
			$type = self::ARRAY_TYPE_LIST;
		} elseif ($indices == count($array)) {
			$type = self::ARRAY_TYPE_DICT;
		} else {
			$type = self::ARRAY_TYPE_MIXED;
		}

		return $type;
	}
681107
private ArrayList<Object> parseArray(JsonParser jp) throws IOException {
        JsonToken value = jp.nextToken();
        ArrayList<Object> ret = new ArrayList<>();
        while(value != JsonToken.END_ARRAY) {
            if (value == JsonToken.START_OBJECT) {
                Object object = parseObject(jp);
                ret.add(object);
            } else if (value == JsonToken.START_ARRAY) {
                ArrayList<Object> arrayList = parseArray(jp);
                ret.add(arrayList.toArray());
            } else if (value == JsonToken.VALUE_NUMBER_INT) {
                ret.add(jp.getValueAsInt());
            } else if (value == JsonToken.VALUE_FALSE || value == JsonToken.VALUE_TRUE) {
                ret.add(jp.getValueAsBoolean());
            } else if (value == JsonToken.VALUE_NUMBER_FLOAT) {
                ret.add(jp.getValueAsDouble());
            } else if (value == JsonToken.VALUE_STRING) {
                ret.add(jp.getValueAsString());
            } else if (value == JsonToken.VALUE_NULL) {
                ret.add("null");
            }
            value = jp.nextToken();
        }
        return ret;
    }
963287
public Object[] toArray(List<?> list, Class<?> arrayType) {
        int[] dims = findArrayDimensions(list, arrayType);
        Object[] typedArray = (Object[]) Array.newInstance(arrayType, dims);
        return list.toArray(typedArray);
    }
762798
function ArrayType(typeSpec) {
  if (!typeSpec.subtype) {
    console.error('Array.typeSpec is missing subtype. Assuming string.' +
        JSON.stringify(typeSpec));
    typeSpec.subtype = 'string';
  }

  Object.keys(typeSpec).forEach(function(key) {
    this[key] = typeSpec[key];
  }, this);
  this.subtype = types.getType(this.subtype);
}
255149
def parse_array(array, *args, &block)
      return unless array.is_a?(Array)
      parse(array) { array.map { |val| parse_not_blank(val, *args, &block) } }
    end
1354519
function checkArrayTypes() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    var t, i;
    for (i = 0; i < arguments.length; i++) {
        if ((t = Object.prototype.toString.call(arguments[i])) !== '[object Uint8Array]')
            throw new TypeError('unexpected type ' + t + ', use Uint8Array');
    }
}
818661
private List<Object> parseArrayInternal() throws IOException {
		List<Object> result = new ArrayList<>();
		
		Type t;
		while (true) {
			t = lexer.readNextToken();
			if (t == Type.END_ARRAY) {
				break;
			}
			
			if (!result.isEmpty()) {
				//skip comma and read next token
				if (t != Type.COMMA) {
					throw new IOException("Unexpected token: " + t);
				}
				t = lexer.readNextToken();
			}
			
			//read value
			Object value = readValue(t);
			result.add(value);
		}
		
		return result;
	}
57264
public static long[] parseLongs(String[] array) {
    long[] result = new long[array.length];
    for (int i = 0; i < array.length; i++)
      result[i] = Long.parseLong(array[i]);
    return result;
  }
269198
public <T> T[] convertArray(String rawString, Class<T> arrayType) {
        String[] elements = split(rawString);
        T[] array = convertArray(elements, arrayType);

        return array;
    }
84191
function parseArrayInitialiser() {
  var elements = [];

  index = lookahead.start;
  expect('[');

  while (!match(']')) {
    if (match(',')) {
      lex();
      elements.push(null);
    } else {
      elements.push(parseConditionalExpression());

      if (!match(']')) {
        expect(',');
      }
    }
  }

  lex();

  return finishArrayExpression(elements);
}
437372
public static String arrayType( String type ) {
        if ( isArray( type ) )
            if ( type.length() == arrayDimSize(type) +1  ) {
                return type;
            } else {
                String ans = "Ljava/lang/Object;";
                for ( int j = 0; j < arrayDimSize( type ); j++ ) {
                    ans = "[" + ans;
                }
                return ans;
            }
        return null;
    }
22720
public boolean isArray() {
        if (this == NONE) {
            return false;
        }
        return (((this.type instanceof Class && ((Class<?>) this.type).isArray())) || this.type instanceof GenericArrayType
                || resolveType().isArray());
    }