NAME

SPVM::Document::LanguageSpecification - SPVM Language Specification

DESCRIPTION

SPVM Language Specification.

SPVM LANGUAGE SPECIFICATION

C99 Compliant
Tokenizing
Syntax Parsing
Comment
POD
Class
Module
Class Variable
Field
Method
Enumeration
INIT Block
Local Variable
Scope
Literal
String
Undefined Value
Array
Multi Numeric Value
Multi Numeric Array
Reference
Expression
Operator
Statement
Type
Type Inference
Type Compatibility
Type Conversion
Exception
Garbage Collection
Callback
Weaken Reference
Default loaded modules

C99 Compliant compiler and runtime

The source code of the SPVM compiler and SPVM runtime is written in C99. Note that this does not mean that SPVM cannot bind the functions of C specific versions(C11, GUN99, GNU11, etc.) or bind the functions of specific C++ versions. SPVM can bind any functions of C specific versions or C++ specific versions, and even can bind the functions of CUDA/GPGPU nvcc. This means that SPVM compiler and runtime must be C99 compliant.

SPVM Types correspondence with C99 Types

the following SPVM Types are exactly same as the following C99 Types:

SPVM Type	C99 Type	Description
byte	int8_t	SPVM byte Type is same as C99 int8_t Type.
short	int16_t	SPVM short Type is same as the C99 int16_t Type.
int	int32_t	SPVM int Type is same as the C99 int32_t Type.
long	int64_t	SPVM long Type is same as C99 int64_t Type.
float	float	SPVM float Type is same as the C99 float Type.
double	double	SPVM double Type is same as C99 double Type.
Object Type	void*	SPVM Object Type is same as the C99 void* Type.
Multiple Numeric Type	Numeric Array Type that is same as the Type and length in SPVM multiple Numeric Type fields	For example, if SPVM multiple Numeric Type class Point_2i: mulnum_t {has x: int; has y: int;} matches the Type declared in C99 int32_t var[2];

Tokenizing

This topic specifies the Tokenizing of the SPVM language.

LALR(1)
Character Set
Component
Line Terminater
Space Character
Identifiers
Separator
Fat Comma
Operator
Syntax Definition

LALR(1)

SPVM language can be analyzed by the LALR(1). It can be parsed by the parser generator generated by yacc/bison.

Character Set

SPVM programs are written in UTF-8.

Component

Component in SPVM is Space Character,Comment, POD, Literal, Identifier, Keyword, Separator, or Operator.

Line Terminator

Line Terminator in SPVM are ASCII Code "LF", "CR", "CRLF". When a line terminator appears, the line number is incremented.Line Terminator in a program is converted to ASCII Code "LF".

Space Character

Space Character in SPVM is ASCII Code "SP", "HT", "FF" or Line Terminator. Space Character has no meaning in the program execution.

Identifiers

Identifiers in SPVM are Class Name, Method Name, Field Name, Class Variable Name, and Local Variable Name.

Class Name

Class Name is one or more alphabet(a-zA-Z), number(0-9), underscore(_) or "::" of ASCII Code. The part name of Class name must start uppercase letter. Part name of Class name means "Foo", "Bar", "Baz" in Class Name "Foo:Bar::Baz". "::" cannot be continued twice. Last characters cannot end with "::". Underscore "_" cannot be continued twice. Class Name must be corresponding to the relative name of module file. If Class Name is "Foo::Bar::Baz", the relative name of module file must be "SPVM/Foo/Bar/Baz.spvm". If Class Name is invalid, Compile Error occurs. Valid Class Name Examples

Foo
Foo::Bar
Foo::Bar::Baz3
Foo::bar
Foo_Bar::Baz_Baz

Invalid Class Name Examples

Foo
Foo::::Bar
Foo::Bar::
Foo__Bar
Foo::bar

Method Name

Method Name is one or more alphabet(a-zA-Z), number(0-9), or underscore(_) of ASCII Code. First character must not number character. Underscore cannot be continued twice.

# Valid Method Name
FOO
FOO_BAR3
foo
foo_bar
_foo
_foo_bar_

# Invalid Method Name
foo__bar

Field Name

Field Name is one or more alphabet(a-zA-Z), number(0-9), or underscore(_) of ASCII Code. First character must not number character. Underscore cannot be continued twice.

# Valid Field Name
FOO
FOO_BAR3
foo
foo_bar
_foo
_foo_bar_

# Invalid Field Name
3foo
foo__bar

Class Variable Name

Class Variable Name starts with "$", followed more alphabet(a-zA-Z), number(0-9), underscore(_) or "::" of ASCII Code. Followed character must not start with number. "::" cannot be continued twice. Last characters cannot end with "::". Underscore cannot be continued twice.

# Valid Class Variable Name
$FOO::BAR
$Foo::Bar3
$FOO
$FOO_BAR
$foo

# Invalid Class Variable Name
$FOO__BAR
$3FOO

Local Variable Name

Local Variable Name starts with "$", followed more alphabet characters of ASCII Code. Followed character must not start with number. Underscore cannot be continued twice.

# Valid Local Variable Name
$foo
$foo_bar3
$_foo
$FOO

# Invalid Local Variable Name
$foo__bar
$3foo

Keywords

Keywords in SPVM are the followings.

allow byte INIT case die warn print default double elsif else enum eq
eval for float gt ge has if callback_t isa int last break length
lt le long my native ne next new our object class private
public precompile pointer_t return require rw ro switch
sub string short scalar undef unless use void mulnum_t while
weaken wo __END__ __CLASS__ __FILE__ __LINE__

Separators

Separators in SPVM are the followings.

( ) { } [ ] ; , ->=>

Fat Comma

Fat Comma is a Separator represented by "=>".

=>

Fat Comma is an alias for Comma ",". Wherever you can use "," you can use Fat Comma instead.

# Comma
["a", "b", "c", "d"]

# Use Fat Comma instead of Comma
["a" => "b", "c" => "d"]

Identifiers other than Class Variable Name and Local Variable Name placed on the Left of Fat Comma are treated as String Literal.

# Identifiers placed on the Left of Fat Comma are treated as String Literal
# a is "a", c is "c"
[a => "b", c => "d"]

Operators

Operators in SPVM are the followings.

=   >   <   !   ~
==  <=  >=  !=  <=> &&  || ++ --
+   -   *   /   &   |   ^   %   <<   >>   >>>
+=  -=  *=  /=  &=  |=  ^=  %=  <<=  >>=  >>>=
\   $  @   .   .=
cmp length isa ref

Syntax Parsing

Syntax Parsing Definition

The following is Syntax Parsing Definition in SPVM, using the syntax in yacc/bison.

%token  CLASS HAS METHOD OUR ENUM MY USE REQUIRE ALLOW
%token  DESCRIPTOR
%token  IF UNLESS ELSIF ELSE FOR WHILE LAST NEXT SWITCH CASE DEFAULT BREAK EVAL
%token  NAME VAR_NAME CONSTANT EXCEPTION_VAR
%token  UNDEF VOID BYTE SHORT INT LONG FLOAT DOUBLE STRING OBJECT TRUE FALSE
%token  DOT3 FATCAMMA RW RO WO INIT NEW
%token  RETURN WEAKEN DIE WARN CURRENT_CLASS UNWEAKEN '[' '{' '('

%type  grammar
%type  opt_classes classes class class_block
%type  opt_declarations declarations declaration
%type  enumeration enumeration_block opt_enumeration_values enumeration_values enumeration_value
%type  sub cb_obj opt_args args arg has use require our
%type  opt_descriptors descriptors method_names opt_method_names
%type  opt_statements statements statement if_statement else_statement 
%type  for_statement while_statement switch_statement case_statement default_statement
%type  block eval_block begin_block switch_block if_require_statement
%type  unary_op binary_op comparison_op isa logical_op  expression_or_logical_op
%type  call_method opt_vaarg
%type  array_access field_access weaken_field unweaken_field isweak_field convert array_length
%type  assign inc dec allow
%type  new array_init
%type  my_var var
%type  expression opt_expressions expressions opt_expression case_statements
%type  field_name method_name
%type  type basic_type array_type array_type_with_length ref_type type_or_void

%right  ASSIGN SPECIAL_ASSIGN
%left  LOGICAL_OR
%left  LOGICAL_AND
%left  BIT_OR BIT_XOR
%left  '&'
%nonassoc  NUMEQ NUMNE STREQ STRNE
%nonassoc  NUMGT NUMGE NUMLT NUMLE STRGT STRGE STRLT STRLE ISA NUMERIC_CMP STRING_CMP
%left  SHIFT
%left  '+' '-' '.'
%left  MULTIPLY DIVIDE REMAINDER
%right  LOGICAL_NOT BIT_NOT '@' REF DEREF PLUS MINUS CONVERT SCALAR STRING_LENGTH ISWEAK REFCNT REFOP DUMP
%nonassoc  INC DEC
%left  ARROW

%%

grammar
  : opt_classes

opt_classes
  : /* Empty */
  | classes

classes
  : classes class
  | class

class
  : CLASS basic_type class_block
  | CLASS basic_type ':' opt_descriptors class_block
  | CLASS basic_type ';'
  | CLASS basic_type ':' opt_descriptors ';'

class_block
  : '{' opt_declarations '}'

opt_declarations
  : /* Empty */
  | declarations

declarations
  : declarations declaration
  | declaration

declaration
  : has
  | sub
  | enumeration
  | our ';'
  | use
  | allow
  | begin_block

begin_block
  : INIT block

use
  : USE basic_type ';'
  | USE basic_type '(' opt_method_names ')' ';'

require
  : REQUIRE basic_type

allow
  : ALLOW basic_type ';'

enumeration
  : opt_descriptors ENUM enumeration_block

enumeration_block 
  : '{' opt_enumeration_values '}'

opt_enumeration_values
  : /* Empty */
  | enumeration_values

enumeration_values
  : enumeration_values ',' enumeration_value 
  | enumeration_values ','
  | enumeration_value

enumeration_value
  : method_name
  | method_name ASSIGN CONSTANT

our
  : OUR CLASS_VAR_NAME ':' opt_descriptors type

has
  : HAS field_name ':' opt_descriptors type ';'

sub
  : opt_descriptors METHOD method_name ':' type_or_void '(' opt_args opt_vaarg')' block
  | opt_descriptors METHOD method_name ':' type_or_void '(' opt_args opt_vaarg')' ';'

cb_obj
  : opt_descriptors METHOD ':' type_or_void '(' opt_args opt_vaarg')' block
  | '[' args ']' opt_descriptors METHOD ':' type_or_void '(' opt_args opt_vaarg')' block

opt_args
  : /* Empty */
  | args

args
  : args ',' arg
  | args ','
  | arg

arg
  : var ':' type

opt_vaarg
  : /* Empty */
  | DOT3

opt_descriptors
  : /* Empty */
  | descriptors

descriptors
  : descriptors DESCRIPTOR
  | DESCRIPTOR

opt_statements
  : /* Empty */
  | statements

statements
  : statements statement 
  | statement

statement
  : if_statement
  | for_statement
  | while_statement
  | block
  | switch_statement
  | case_statement
  | default_statement
  | eval_block
  | if_require_statement
  | expression ';'
  | LAST ';'
  | NEXT ';'
  | RETURN ';'
  | RETURN expression ';'
  | DIE ';'
  | DIE expression ';'
  | WARN ';'
  | WARN expression ';'
  | PRINT expression ';'
  | weaken_field ';'
  | unweaken_field ';'
  | ';'

for_statement
  : FOR '(' opt_expression ';' expression_or_logical_op ';' opt_expression ')' block

while_statement
  : WHILE '(' expression_or_logical_op ')' block

switch_statement
  : SWITCH '(' expression ')' switch_block

switch_block
  : '{' case_statements '}'
  | '{' case_statements default_statement '}'

case_statements
  : case_statements case_statement
  | case_statement

case_statement
  : CASE expression ':' block
  | CASE expression ':'

default_statement
  : DEFAULT ':' block
  | DEFAULT ':'

if_require_statement
  : IF '(' require ')' block
  | IF '(' require ')' block ELSE block

if_statement
  : IF '(' expression_or_logical_op ')' block else_statement
  | UNLESS '(' expression_or_logical_op ')' block else_statement

else_statement
  : /* NULL */
  | ELSE block
  | ELSIF '(' expression_or_logical_op ')' block else_statement

block 
  : '{' opt_statements '}'

eval_block
  : EVAL block ';'

opt_expressions
  : /* Empty */
  | expressions

opt_expression
  : /* Empty */
  | expression

expression_or_logical_op
  : expression
  | logical_op

expression
  : var
  | EXCEPTION_VAR
  | class_var_access
  | CONSTANT
  | UNDEF
  | call_method
  | field_access
  | array_access
  | convert
  | new
  | array_init
  | array_length
  | my_var
  | binary_op
  | unary_op
  | assign
  | inc
  | dec
  | '(' expressions ')'
  | CURRENT_CLASS
  | isweak_field
  | comparison_op
  | isa
  | TRUE
  | FALSE

expressions
  : expressions ',' expression
  | expressions ','
  | expression

unary_op
  : '+' expression %prec PLUS
  | '-' expression %prec MINUS
  | BIT_NOT expression
  | REFCNT var
  | REFOP expression
  | STRING_LENGTH expression
  | DUMP expression
  | DEREF var
  | REF var

inc
  : INC expression
  | expression INC

dec
  : DEC expression
  | expression DEC

binary_op
  : expression '+' expression
  | expression '-' expression
  | expression MULTIPLY expression
  | expression DIVIDE expression
  | expression REMAINDER expression
  | expression BIT_XOR expression
  | expression '&' expression
  | expression BIT_OR expression
  | expression SHIFT expression
  | expression '.' expression

comparison_op
  : expression NUMEQ expression
  | expression NUMNE expression
  | expression NUMGT expression
  | expression NUMGE expression
  | expression NUMLT expression
  | expression NUMLE expression
  | expression NUMERIC_CMP expression
  | expression STREQ expression
  | expression STRNE expression
  | expression STRGT expression
  | expression STRGE expression
  | expression STRLT expression
  | expression STRLE expression
  | expression STRING_CMP expression

isa
  : expression ISA type

logical_op
  : expression_or_logical_op LOGICAL_OR expression_or_logical_op
  | expression_or_logical_op LOGICAL_AND expression_or_logical_op
  | LOGICAL_NOT expression_or_logical_op
  | '(' logical_op ')'

assign
  : expression ASSIGN expression
  | expression SPECIAL_ASSIGN expression

new
  : NEW basic_type
  | NEW array_type_with_length
  | cb_obj

array_init
  : '[' opt_expressions ']'
  | '{' expressions '}'
  | '{' '}'

convert
  : '(' type ')' expression %prec CONVERT

array_access
  : expression ARROW '[' expression ']'
  | array_access '[' expression ']'
  | field_access '[' expression ']'

call_method
  : NAME '(' opt_expressions  ')'
  | basic_type ARROW method_name '(' opt_expressions  ')'
  | basic_type ARROW method_name
  | expression ARROW method_name '(' opt_expressions ')'
  | expression ARROW method_name
  | expression ARROW '(' opt_expressions ')'

field_access
: expression ARROW '{' field_name '}'
| field_access '{' field_name '}'
| array_access '{' field_name '}'

weaken_field
  : WEAKEN var ARROW '{' field_name '}'

unweaken_field
  : UNWEAKEN var ARROW '{' field_name '}'

isweak_field
  : ISWEAK var ARROW '{' field_name '}'

array_length
  : '@' expression
  | '@' '{' expression '}'
  | SCALAR '@' expression
  | SCALAR '@' '{' expression '}'

my_var
  : MY var ':' type
  | MY var

var
  : VAR_NAME

class_var_access
  : CLASS_VAR_NAME

type
  : basic_type
  | array_type
  | ref_type

basic_type
  : NAME
  | BYTE
  | SHORT
  | INT
  | LONG
  | FLOAT
  | DOUBLE
  | OBJECT
  | STRING

ref_type
  : basic_type '&'

array_type
  : basic_type '[' ']'
  | array_type '[' ']'

array_type_with_length
  : basic_type '[' expression ']'
  | array_type '[' expression ']'

type_or_void
  : type
  | VOID

field_name
  : NAME

method_name
  : NAME

opt_method_names
  : /* Empty */
  | method_names

method_names
  : method_names ',' method_name
  | method_names ','
  | method_name
%%

The following is a correspondence table between tokens in yacc/bison and keywords and operators in SPVM.

Tokens in yacc/bison	Keywords and Operators in SPVM
CLASS	class
METHOD	sub
OUR	our
ENUM	enum
MY	my
SELF	self
USE	use
REQUIRE	require
ALLOW	allow
DESCRIPTOR	descriptor
IF	if
UNLESS	unless
ELSIF	elsif
ELSE	else
FOR	for
WHILE	while
LAST	last
BREAK	break
NEXT	next
SWITCH	switch
CASE	case
DEFAULT	default
EVAL	eval
NAME	name
VAR	var
CONSTANT	Literal
CLASS_VAR_NAME	Class Variable Name
EXCEPTION_VAR	$@
UNDEF	undef
VOID	void
BYTE	byte
SHORT	short
INT	int
LONG	long
FLOAT	float
DOUBLE	double
STRING	string
OBJECT	object
DOT3	...
FATCAMMA	=>
RW	rw
RO	ro
WO	wo
INIT	INIT
NEW	new
RETURN	return
WEAKEN	weaken
DIE	die
WARN	warn
PRINT	print
CURRENT_CLASS	__CLASS__
UNWEAKEN	unweaken
ASSIGN	=
SPECIAL_ASSIGN	+= -= *= /= &= \|= ^= %= <<= >>= >>>= .=
LOGICAL_OR	\|\|
LOGICAL_AND	&&
BIT_OR	\|
BIT_XOR	&
NUMEQ	==
NUMNE	!=
NUMGT	>
NUMGE	>=
NUMLT	<
NUMLE	<=
NUMERIC_CMP	<=>
STREQ	eq
STRNE	ne
STRGT	gt
STRGE	ge
STRLT	lt
STRLE	le
SRING_CMP	cmp
ISA	isa
SHIFT	<< >> >>>
MULTIPLY	*
DIVIDE	/
REMAINDER	%
LOGICAL_NOT	!
BIT_NOT	~
REF	\
DEREF	$
PLUS	+
MINUS	-
CONVERT	(TypeName)
SCALAR	scalar
LENGTH	length
ISWEAK	isweak
REFCNT	refcnt
REFOP	ref
DUMP	dump
INC	++
DEC	--
ARROW	->

Comment

Comment begins with "#" and ends with Line Terminator.

# Comment

Comment has no meaning in the program execution.

POD

POD(Plain Old Document) is a syntax to write documents easily. You can use POD as Multi-Line comments. POD starts from the line beginning with "=", followed by any character string of one or more characters, and ending with Line Terminator. POD ends from the line beginning with "=cut", and ending with Line Terminator. POD Example:

=pod

Multi-Line
Comment

=cut

=head1

Multi-Line
Comment

=cut

POD has no meaning in the program execution.

Class

Class Definition
Class Descriptor
Destructor
Allow Class Access

Class Definition

Class Definition is the following syntax.

class PACAKGE_NAME {

}

PACAKGE_NAME must follow the rule for Class Name. Class Descriptor can be specified by the following syntax.

class PACAKGE_NAME : PACAKGE_DESCRIPTOR {

}

class PACAKGE_NAME : PACAKGE_DESCRIPTOR1 PACAKGE_DESCRIPTOR2 PACAKGE_DESCRIPTORN {

}

Class Definition Example:

# Class Name
class Point {

}

# Class Name and Class Descriptor
class Point : public {

}

In direct children of the class block, use, our, has, enum, sub can be defined.

class Foo {
  # use
  use Point;

  # Class Variable Definition
  our $VAR int;

  # Field Defintion
  has var : int;

  # Enumeration Definition
  enum {
    CONST_VAL1,
    CONST_VAL2,
  }

  # Method Definition
  static method foo : int ($num : int) {

  }
}

If more than one class with the same name is defined, Compile Error occurs.

Class Descriptor

The descriptions of Class Descriptors.

Descriptor	Meaning
public	This class is public. Other classes can new this class.
private	This class is private. Other classes can't new this class. This is default setting.
callback_t	This class is Callback Type.
mulnum_t	This class is Multi Numeric Type.
pointer_t	This class is Pointer Type.
precompile	Do precompile all methods in this class, except for accessor, and enum.

If both "public" and "private" are specifed, Compile Error occurs. If more than one of "callback_t", "mulnum_t", "pointer_t" are specified, Compile Error occurs.

Destructor

If the class is Class Type, the class defined a destructor. Destructor is a special Method called when the object of this class is freed. Destructor name must be "DESTROY". Destructor Retrun Value must be void Type, otherwise Compile Error occurs. Destructor arguments must be one and the type must be self Type, otherwise Compile Error occurs.

method DESTROY : void () {

}

If a Exception occurs in Destructor, the program don't exit, print the message of the exception to STDERR. Destructor Example:

class Foo {
  static method new : Foo {
    return new Foo;
  }

  method DESTROY : void () {
    print "DESTROY";
  }
}

Allow Class Access

By default, private Methods, Fields, and Class Variables cannot be accessed from outside the Class. Also, Private Class cannot Create Object from outside of Class. If the class allow other class, the other class can access private Methods, Fields, and Class Variables, and can Create Object of the class.

allow CLASS_NAME;

allow must be defined directory under Class Definition.

class Foo {
  allow Bar;
}

In this example, Bar can access the private Method, Field, and Class Variable of Foo can be accessed and can Create Object of Foo. Specifying the module of allow also loads the module by use at the same time.

Module

Module Summary
Module File Name
Load Module
Automatically Loaded Module
Selective Load Module

Module Summary

Module is a single file that can be read as SPVM source code.

# lib/path/SPVM/Foo/Bar.spvm
class Foo::Bar {

}

Module can contain multiple Classes.

# lib/path/SPVM/Foo/Bar.spvm
class Foo::Bar {

}

class Foo::Bar::Baz {

}

Module File Name

Modules must be placed in the module loading path with the following File Name. Change "::" to "/". Add ".spvm" at the end.

SPVM/Foo.spvm
SPVM/Foo/Bar.spvm
SPVM/Foo/Bar/Baz.spvm

Load Module

Use use keyword to load a Module.

use Foo;
use Foo::Bar;

Modules are loaded at compile-time. If the Module does not exist, Compile Error will occur. use Keyword must be defined directly under Class Definition.

class Foo {
  use Foo;
}

Automatically Loaded Module

The followings are Automatically Loaded Modules. They can be used without use.

Byte
Short
Int
Long
Float
Double

Load Module Selective

In SPVM, there is an if require Statement that loads a Module only if it exists in the module path, and if it does not exist, the block does not exist. It was designed to implement a part of features of "#ifdef" in C language.

if (require Foo) {

}

if require Statement can be followed by else Statement.

if (require Foo) {

}
else {

}

Note that elsif Statement cannot be followed. Let's look at an example. if Foo does not exist, no Compile Error occurs and it is assumed that there is no if block Therefore, "$foo = new Foo;" does not result in Compile Error because it is assumed that there is no if block. In the other hand, the else block exists, so a warning is issued.

my $foo : object;
if (require Foo) {
  $foo = new Foo;
}
else {
  warn "Warning: Can't load Foo";
}

Function Import

The Method which is defined as Class Method is imported as Function using use Statement.

use Foo(method1, method2);

This function is called by Function Call

Class Variable

Class Variable Definition
Class Variable Descriptor
Class Variable Initial Value
Class Variable Access

Class Variable Definition

Class Variable is a global variable that belongs to Class and exists from the start to the end of the program execution. "our" Keyword defines a Class Variable.

our CLASS_VARIABLE_NAME : TYPE;

Class Variable must be defined directly under Class Definition. Class Variable Definition must specify Type. The Type must be Numeric Type or Object Type. Class Variable Name must follows the rule specified in Class Variable Name, and must not contain "::", otherwise Compile Error occurs. If more than one Class Variable with the same name is defined, Compile Error occurs. Class Variable Descriptor can be specified together in Class Variable definition.

our CLASS_VARIABLE_NAME : DESCRIPTOR TYPE;
our CLASS_VARIABLE_NAME : DESCRIPTOR1 DESCRIPTOR2 DESCRIPTORN TYPE;

Class Variable Descriptor

List of Class Variable Descriptors.

Descriptor	Description
public	This Class Variable is public. This Class Variable can be accessed from other class.
private	This Class Variable is private. This Class Variable can't be accessed from other class. This is default setting of Class Variable.
ro	This Class Variable has Read Accessor. Read Accessor name is the same as Class Variable Name except removing "$". For example, If the Class Variable Name is "$FOO", Read Accessor name is "FOO".
wo	This Class Variable has Write Accessor. Write Accessor name is the same as Class Variable Name except removing "$" and adding "SET_" to top. For example, If the Class Variable Name is "$FOO", Read Accessor name is "SET_FOO".
rw	This Class Variable has Read accessor and Write Accessor.

If both "public" and "private" Descriptors are specified, Compile Error occurs. If more than one of "ro", "wo", and "rw" are specified at the same time, Compile Error occurs Read Accessor of Class Variable has no arguments and the return type is same as the type of Class Variable. Write Acessor of Class Variable has one argument and the type is same as the type of Class Variable. The type of return value is void Type. Inline Expansion optimization is performed to Read Accessor and Write Accessor. You don't have to worry about the performance penalty of using Class Variable Accessors. Class Variable Definition Example:

class Foo {
  our $NUM1 : byte;
  our $NUM2 : short;
  our $NUM3 : int;
  our $NUM4 : long;
  our $NUM5 : float;
  our $NUM6 : double;

  our $NUM_PUBLIC : public int;
  our $NUM_RO : ro int;
  our $NUM_WO : wo int;
  our $NUM_RW : rw int;
}

Class Variable Initial Value

Class Variable is initialized with Type Initial Value after compilation and before execution. This initial value can be changed by using INIT Block.

class Foo {
  our $VAR : int;

  INIT {
    $VAR = 3;
  }
}

Class Variable Access

Class Variable Access is an operation to access Class Variable to get or set a value. See Get Class Variable Value for how to get the value of Class Variable. See Set Class Variable Value for the setting of the value of Class Variable.

Field

Field Definition
Field Descriptor
Field Access

Field Definition

Field is a data area in a object created using new keyword "has" Keyword defines a Field.

has FIELD_NAME : TYPE;

Field must be defined directly under Class Definition. Field Definition must be specify Type. The Type must be Numeric Type or Object Type. Field Name must follows the rule specified in Field Name. Field Name is allowed as same as Keyword. Field Type must be Numeric Type or Object Type, otherwise Compile Error occurs. If more than one Field Name Variable with the same name is defined, Compile Error occurs. Field Descriptor can be specified together in Field Definition.

has FIELD_NAME : DESCRIPTOR TYPE_NAME;
has FIELD_NAME : DESCRIPTOR1 DESCRIPTOR2 DESCRIPTORN TYPE_NAME;

Field Descriptor

List of Field Descriptors.

Descriptor	Description
public	This field is public. This field can be accessed from other class.
private	This field is private. This field can't be accessed from other class. This is default setting.
ro	This Field has Read Accessor. Read Accessor name is the same as Field Name. For example, If the Field Name is "foo", Read Accessor name is "foo".
wo	This Field has Write Accessor. Write Accessor name is the same as Field Name adding "set_" to top. For example, If the Field Name is "foo", Read Accessor name is "set_foo".
rw	This Field has Read Accessor and Write Accessor.

If both "public" and "private" Descriptors are specified, Compile Error occurs. If more than one of "ro", "wo", and "rw" are specified at the same time, Compile Error occurs Read Accessor of Field has one argument that is self Type and the Return Type is same as the type of Field. Write Acessor of Class Variable has two arguments. First argument is self Type and second argument is same as the type of Field. The type of return value is void Type. Inline Expansion optimization is performed to Read Accessor and Write Accessor. You don't have to worry about the performance penalty of using Field Accessors. Field Definition Example:

class Foo {
  has num1 : byte;
  has num2 : short;
  has num3 : int;
  has num4 : long;
  has num5 : float;
  has num6 : double;

  has num_public : public int;
  has num_ro : ro int;
  has num_wo : wo int;
  has num_rw : rw int;
}

Field Access

Field Access is an operation to access Field to get or set a value.

EXPRESSION->{FIELD_NAME}

Field Access has three different meanings. 1. Class Based Object Field Access Class Based Object Field Access is Field Access from object which is create by new keyword.

my $point = new Point;
$point->{x} = 1;

See Get Field Value to get field of Class Based Object. See Set Field Value to set field of Class Based Object. 2. Multi Numeric Field Access Multi Numeric Field Access is Field Access from the value of Multi Numeric Type. The value of Multi Numeric Type is allocated Callstack of Method.

my $z : Complex_2d;
$z->{x} = 1;
$z->{y} = 3;

See Get Multi Numeric Field Value to get field of the value of Multi Numeric Type. See Set Multi Numeric Field Value to set field of the value of Multi Numeric Type. 3. Dereference Multi Numeric Field Dereference Multi Numeric Field is Field access from Reference of the value of Multi Numeric Type.

my $z : Complex_2d;
my $z_ref = \$z;
$z_ref->{x} = 1;
$z_ref->{y} = 3;

See Get Multi Numeric Field Value via Dereference to get Multi Numeric Field via Dereference. See Set Multi Numeric Field Value via Dereference to set Multi Numeric Field via Dereference.

Method

Method Definition
Method Descriptor
Native Method
Precompiled Method
Constant Method
Method
Signature
Method Callstack

Method Definition

"sub" Keyword defines Method.

static method METHOD_NAME : RETURN_VALUE_TYPE_NAME () {

}
static method METHOD_NAME : RETURN_VALUE_TYPE_NAME (ARGUMENT_NAME1 : ARGUMENT_TYPE_NAME1, ARGUMENT_NAME2 : ARGUMENT_TYPE_NAME2, ARGUMENT_NAMEN : ARGUMENT_TYPE_NAMEN) {

}

Method must be defined directly under Class Definition. Method name must be follow the rule of Method Name. Method Name is allowed as same as Keyword. Type of Return Value must be void Type, Numeric Type, or Object Type, otherwise Compile Error occurs. Argument name must be follow the rule of Local Variable Name. Minimal Argument Count is 0. Max Argument Count is 255. Type of Argument must be Numeric Type, Object Type, or Reference Type, otherwise Compile Error occurs. The defined Method can be called. See Method Call about calling Method, . Method Block can have zero or more Statements. Method Definition can have Method Descriptor.

DESCRIPTOR1 DESCRIPTOR2 DESCRIPTORN static method METHOD_NAME : RETURN_VALUE_TYPE_NAME () {

}
DESCRIPTOR1 DESCRIPTOR2 DESCRIPTORN static method METHOD_NAME : RETURN_VALUE_TYPE_NAME (ARGUMENT_NAME1 : ARGUMENT_TYPE_NAME1, ARGUMENT_NAME2 : ARGUMENT_TYPE_NAME2, ARGUMENT_NAMEN : ARGUMENT_TYPE_NAMEN) {

}

If "..." follows Type of Argument, the Argument becomes Variable Length Argument. Only the last Argument can be Variable Length Argument. The Type must be Array Type.

static method METHOD_NAME : RETURN_VALUE_TYPE_NAME (ARGUMENT_NAME1 : ARGUMENT_TYPE_NAME1, ARGUMENT_NAME2 : ARGUMENT_TYPE_NAME2...) {

}

Variable Length Argument can recieve multi values.

# Variable Length Argument Definition
static method sprintf : string ($format : string, $values : object[]...) {

}

# Call Variable Length Argument Method with multi values.
sprintf("Value %d %f", 1, 2.0);

Variable Length Argument can recieve Array.

# Call Variable Length Argument Method with Array.
sprintf("Value  %d %f", [(object)1, 2.0]);

If you want to treat the value of Array as an individual element of the variable length argument, cast it to Type other than Array Type.

sprintf("aaa %p", (object)[(object)1, 2.0]);

Method Descriptor

List of Method Descriptor.

Descriptor	Description
native	This Method is Native Method.

Native Method

Native Method is Method that call function written in Native Language(C, C++, etc). See SPVM Native API Native Method.

Precompiled Method

If the Class has "precompile" descriptor, the methods of the class become Precompiled Method. Precompiled Method is translated into C99 Compliant source code and converted into machine code. The precompiled methods are C code, so you can get performance of C language. Precompiled Method needs Build Directory described in SPVM Native API

Constant Method

Constant Method is a Method that Return Type is Numeric Type and returns Constant Value.

static method foo : int () { return 5; }
static method foo : long () { return 5L; }
static method foo : float () { return 5.0f; }
static method foo : double () { return 5.0; }

Inline Expansion optimization is performed to Constant Method. Note that SPVM does not perform constant convolution optimization, so if a constant is calculated, it will not performe Inline Expansion.

# This is not Constant Method.  Inline Expansion is not performed
static method foo : int () { return 5 + 3; }

Method

Method is Method that has self Type as its first argument.

method METHOD_NAME : TYPE  (ARGUMENT2 : TYPE2, ARGUMENT3 : TYPE3, ARGUMENTN : TYPEn) {

}

self Type must be first argument. Method can be called from the object created by new. See Method Call for Method Call. $self is called Invocant.

Signature

Signature is a string that follow the following rule sequence of Method Retrun Value and arguments arranged according to the following rules. Arguments do not need to exist. There cannot be spaces between them. 1. RETURN_VALUE_TYPE 2. ( 3. ARGUMENT_TYPE1,ARGUMENT_TYPE2,ARGUMENT_TYPE3 4. ) Signature Example:

# Method Definition
static method foo : int ($num1 : double, $num2 : long[])

# Signature
int(double,long[])

# Method Definition
static method foo : void ()

# Signature
void()

Signature is not used in SPVM programs. Signature is used when calling the SPVM Method from SPVM Native API.

Method Callstack

Method Callstack is memory area allocated in each method call.

Method Callstack save the folloing information.

1. Memroy area for Local Variable

2. The places of Mortal Local Variable

Enumeration

Enumeration Definition
Enumeration Descriptor
Enumeration Call

Enumeration Definition

Enumeration Definition is a syntax to define multiple Constant Methods easily.

# Enumeration Definition
enum {
  FLAG1,
  FLAG2,
  FLAG3
}

Enumeration must be defined directly under Class Definition.

class Foo {
  enum {
    FLAG1,
    FLAG2,
    FLAG3
  }
}

The first value starts with "0". The value is incremented by "1". In this example, "FLAG1" is "0", "FALG2" is "1", and "FLAG3" is "2". "," can be added after the last element of Enumeration.

enum {
  FLAG1,
  FLAG2,
  FLAG3,
}

Enumeration is an alias for Constant Method that Return Type is int Type. It is equivalent to the following Method Definition:

static method FLAG1 : int () { return 0; }
static method FLAG2 : int () { return 1; }
static method FLAG3 : int () { return 2; }

The value of int Type can be set in the enum element.

enum {
  FLAG1,
  FLAG2 = 4,
  FLAG3,
}

In the above case, "FLAG1" is "0", "FALG2" is "4", and "FLAG3" is "5". If Enum Definition is invalid, Compile Error occurs.

Enumeration Descriptor

Descriptor can be specified for Enumeration.

private enum {
  FLAG1,
  FLAG2 = 4,
  FLAG3,
}

List of Enumeration Descriptor

Descriptor	Description
public	This Enumeration is public. This Enumeration can be accessed from other Class. This is default setting.
private	This Enumeration is private. This Enumeration can not be accessed from other Class.

If both "public" and "private" Descriptors are specified, Compile Error occurs.

Enumeration Call

Enumeration is an alias for Constant Method, so it can be called in exactly the same way as Method call.

my $flag1 = Foo->FLAG1;
my $flag2 = Foo->FLAG2;
my $flag3 = Foo->FLAG3;

In special case, Enumeration Call can be used in case Statement of switch Statement.

switch ($num) {
  case Foo->FLAG1: {

    break;
  }
  case Foo->FLAG2: {

    break:
  }
  case Foo->FLAG3: {

    break:
  }
  default: {

  }
}

INIT Block

INIT Block is a block that is executed immediately after the compilation of program. INIT Keyword defines INIT Block.

INIT {

}

INIT Block must be defined directly under Class Definition.

class Foo {
  INIT {

  }
}

Zero or more Statements can be written in INIT Block.

INIT {
  my $foo = 1 + 1;
  my $bar;
}

return Statement cannot be written in INIT Block. Internally, INIT Block is a Method that Return Type is void Type and has no arguments. You can define multiple INIT Blocks. The execution order of INIT Block is not guaranteed. If ohter INIT Block is defined in ohter Class, do not assume that INIT Block of the current class will be executed first. A common use of INIT Block is to initialize Class Variable.

class Foo {
  use Point;

  our $NUM : int;
  our $POINT : Point;
  INIT {
    $NUM = 3;
    $POINT = Point->new;
  }
}

Local Variable

Local Variable Declaration
Local Variable Initial Value
Local Variable Access

Local Variable Declaration

Local Variable is a variable that is declared in Scope Block. Local Variable has Scope. This is same as Local Variable in C Language. Local Variable is declared using my Keyword.

my LEXICAL_VARIABLE_NAME : TYPE;

Lexical variable name must be follow the rule of Local Variable Name. Type must be specified. Type must be Numeric Type, Object Type, Multi Numeric Type, or Reference Type.

# Local Variable Declaration Examples
my $var : int;
my $var : Point;
my $var : Complex_2d;
my $var : int&;

Local Variable is initialized by Local Variable Initial Value.

# Initialized by 0
my $num : int;

# Initialized by 0
my $num : double;

# Initialized by undef
my $point : Point;

# x is initialized by 0. y is initialized by 0.
my $z : Complex_2d;

Initialization can be done at the same time as Local Variable Declaration.

# Initialized by 1
my $num : int = 1;

# Initialized by 2.5
my $num : double = 2.5;

# Initialized by Point object
my $point : Point = new Point;

Using Type Inference, you omit Type in Local Variable Declaration.

# int
my $num = 1;

# double
my $num = 1.0;

Local Variable Declaration returns the value of Local Variable. This is a Expression.

my $ppp = my $bar = 4;

if (my $bar = 1) {

}

while (my $bar = 1) {

}

See Scope about Local Variable Scope.

Local Variable Initial Value

Local Variable is initialized by Type Initial Value.

Local Variable Access

Local Variable Access is an operation to access Local Variable to get or set the value. See Get Local Variable Value to get Local Variable value. Set Local Variable Value to get Local Variable value. If Class Variable with the same name as the Local Variable exists, Program uses the variable as Local Variable, not Class Variable.

Scope

Scope Summary
Block
Scope Block

Scope Summary

Scope is a range surrounded by Scope Block.

# Scope Block 
{
  # Start of Scope

  # ...
  
  # End of Scope
}

Local Variable Declaration registers the Local Variable that is Object Type with Mortal Variable in run-time. If the object is not undef, The Reference Count is added by 1.

{
  # $num become Mortal Variable in run-time
  my $num = new Foo;
}

At the end of Scope, the object that is registered as Mortal Variable, Reference Count is reduced by 1 except the object is not undef. If the Reference Count become 0, the object released.

Block

The part enclosed by "{" and "}" is called Block.

# Block 
{

}

There are Scope Block that creates a scope and Non Scope Block that does not create a scope.

Scope Block

Scope Block is a block that creates a Scope. Zero or more Statement can be written in Scope Block. List of Scope Blocks

Simple Block
Method Block
eval Block
if Block
elsif Block
else Block
for Block
while Block
switch Block

Simple Block

Simple Block is a scope block.

# Simple Block
{

}

Method Block

Method Block is a scope block.

# Method Block
static method foo : int () {

}

eval Block

eval Block is a scope block.

# eval Block
eval {

}

if Block

if Block is a scope block.

# if Block
if (EXPRESSION) {

}

elsif Block

elsif Block is a scope block.

#elsif Block
elsif (EXPRESSION) {

}

else Block

else Block is a scope block.

# else Block
else {

}

for Block

for Block is a scope block.

# for Block 
for (my $i = 0; $i < 3; $i++) {

}

while Block

while Block is a scope block.

# while Block
while (EXPRESSION) {

}

switch Block

switch Block is a scope block.

switch (EXPRESSION) {

}

Literal

Literal Summary
Integer Literal
Floating Point Literal
Charater Literal
String Literal
Variable Expansion

Literal Summary

Literal is a Expression that represents Constant Value.

Integer Literal

Decimal Representation of Integer Literal

Decimal Representation of Integer Literal is represented by one or more consecutive characters from "0" to "9". Can be prefixed with "+" or "-". Type of Integer Literal is int Type by default. If Integer Literal exceeds the range of numbers that can be represented by int Type, Compile Error occurs. By suffixing "L" or "l" at the end, that represents long Type Integer Literal. If long Type Integer Literal exceeds the range of numbers that can be represented by long Type, If it exceeds the range, Compile Error occurs. "_" can be used as a Separator. Separator has no meaning. If Integer Literal is assigned to a byte Type variable or passed to byte Type Method Argument, and does not exceed the range of numbers that can be represented by byte Type, Numeric Narrowing Type Conversion is applied and the value converted to byte Type value. If it exceeds the range, Compile Error will occur. If Integer Literal is assigned to a short Type variable or passed to short Type Method Argument, and does not exceed the range of numbers that can be represented by short Type, Numeric Narrowing Type Conversion is applied and the value converted to short Type value. If it exceeds the range, Compile Error will occur. Integer Literal Example:

123
+123
-123
123L
123l
123_456_789
-123_456_789L

Hexadecimal Representation of Integer Literal

Hexadecimal Representation of Integer Literal is represented by the following rule. Hexadecimal Representation of Integer Literal starts with "0x" or "0X". It is followed by one or more consecutive characters "0" to "9", "a" to "f", or "A" to "F".. Other rules are same as Decimal Representation of Integer Literal Hexadecimal Representation of Integer Literal Example:

0x3b4f
-0x3F1A
0xDeL
0xFFFFFFFF_FFFFFFFF

Octal Representation of Integer Literal

Octal Representation of Integer Literal is represented by the following rule. Octal Representation of Integer Literal starts with "0". It is followed by one or more consecutive characters "0" to "7". Other rules are same as Decimal Representation of Integer Literal Octal Representation of Integer Literal Example:

Binary Representation of Integer Literal

Binary Representation of Integer Literal is represented by the following rule. Binary Representation of Integer Literal starts with "0b" or "0B". It is followed by one or more consecutive characters "0" or "1". Binary Representation of Integer Literal Example:

0b0101
-0b1010
0b110000L
0b10101010_10101010

Floating Point Literal

Floating Point Literal consists of Sign Part, Numeric Part, Exponent Part and Suffix.

# Floating Point Literal
[Sign Part][Numeric Part][Exponent Part][Suffix Part]

Floating Point Literal is Decimal Floating Point Literal or Hexadecimal Floating Point Literal. Sign Part is represented by "+" or "-". Sign Part is optional. Numeric Part of Decimal Floating Point Literal starts one or more "0" to "9". Numeric Part of Hexadecimal Floating Point Literal starts "0x" or "0X", and is followed by "0" to "9", "a" to "f", or "A" to "F". For that the Literal is Floating Point Literal, Numeric Part contains "." or, The Literal have Exponent Part, or have Suffix Part. Numeric part can contain "_". This is just a Numeric Separator and is ignored. Hexadecimal Floating Point Literal needs Exponent Part. Exponent Part is consist of Exponential Notation and Signed Decimal Integer.

# Exponent Part
[Exponential Notation][Signed Decimal Integer]

Exponential Notation is "e" or "E" for Decimal Floating Point Literal, and "p" or "P" for Hexadecimal Floating Point Literal. The meaning of Exponent Part is decimal shift for Decimal Floating Point Literal, or binary shift for Hexadecimal Floating Point Literal. If Suffix Part is "f" or "F", the Type of Floating Point Literal is float Type. If Suffix Part is "d" or "D", the Type of Floating Point Literal is double Type. If Suffix Part is omitted, the Type of Floating Point Literal is double Type. If Floating Point Literal is float Type, the Floating Point Literal is converted to float value using C standard "strtof" function. If the conversion fails, Compile Error occurs. If Floating Point Literal is double Type, the Floating Point Literal is converted to double value using C standard "strtod" function. If the conversion fails, Compile Error occurs. Floating Point Literal Example:

1.32
-1.32
1.32f
1.32F
1.32e3
1.32e-3
1.32E+3
1.32E-3
0x3d3d.edp0
0x3d3d.edp3
0x3d3d.edP3
0x3d3d.edP-3f

Charater Literal

Charater Literal represents one character of ASCII code. Character Literal is enclosed in single quotes "'". Content of Character Literal is one printable ASCII character or one Escape Character of Character Literal. Charater Literal Type is "byte Type" Type of Charater Literal is byte Type.

Escape Characters of Character Literal	Description
\0	ASCII Code 0 NUL
\a	ASCII Code 7 BEL
\b	ASCII Code 8 BS
\t	ASCII Code 9 HT
\n	ASCII Code 10 LF
\f	ASCII Code 12 "FF"
\r	ASCII Code 13 CR
\"	ASCII Code 34 "
\'	ASCII Code 39 '
\\	ASCII Code 92 \
\x + tow hexadecimal numbers	Specify ASCII code by hexadecimal. Hexadecimal numbers are "0" to "9", "a" to "z", "A" to "Z".

Charater Literal Example: Charater Literal represents one character of ASCII code.

# Charater Literal 
'a'
'x'

# Charater Literal using Escape Character
'\a'
'\b'
'\t'
'\n'
'\f'
'\r'
'\"'
'\''
'\\'
'\x0D'
'\x0A'

String Literal

String Literal represents String. String Literal is enclosed in double quotes '"'. String Literal return the value of string type. The content of String Literal is zero or more ASCII printable Characters or Escape Characters of String Literal".

Escape charaters of String Literal

Escape Character of String Literal	Description
\0	ASCII Code 0 NUL
\a	ASCII Code 7 BEL
\b	ASCII Code 8 BS
\t	ASCII Code 9 HT
\n	ASCII Code 10 LF
\f	ASCII Code 12 FF
\r	ASCII Code 13 CR
\"	ASCII Code 34 "
\'	ASCII Code 39 '
\\	ASCII Code 92 \
\x + two hexadecimal numbers	Specify ASCII code by hexadecimal. Hexadecimal numbers are "0" to "9", "a" to "z", "A" to "Z". For example, \x0D.
\N{U+} + hexadecimal numbers after U+	Specify the Unicode code point in hexadecimal. Hexadecimal numbers are expressed as "0" to "9", "a" to "f", "A" to "F". For example, \N{U+3046}. The code point is converted to UTF-8.
Raw escape character (For example, \s is become \s. This represents a sequence of two characters in a character literal '\\' 's')	\s \S \d \D \w \W \p \P \X \g \k \K \v \V \h \H \R \b \B \A \Z \z \G \N \1 \2 \3 \4 \5 \6 \7 \8 \9 \! \# \@ \% \& \* \+ \- \. \/ \: \; \< \= \> \? \[ \] \^ \_ \` \{ \\| \} \~ \,

If the espape characters which is not included avobe is used, a compiler error occurs.
String Literal Example:

# String Literal 
"abc"
"ããã"

# Escape Character of String Literal 
"abc\tdef\n"
"\x0D\x0A"
"\N{U+3042}\N{U+3044}\N{U+3046}"

Variable Expansion

Variable Expansion applys Local Variable, Class Variable, Dereference, Field Access, Array Access, Exception Variable in String Literal.

"AAA $foo BBB"
"AAA $FOO BBB"
"AAA $$foo BBB"
"AAA $foo->{x} BBB"
"AAA $foo->[3] BBB"
"AAA $foo->{x}[3] BBB"
"AAA $@ BBB"

The above is expanded as the following.

"AAA" . $foo . "BBB"
"AAA" . $FOO . "BBB"
"AAA" . $$foo . "BBB"
"AAA" . $foo->{x} . "BBB"
"AAA" . $foo->[3] . "BBB"
"AAA" . $foo->{x}[3] . "BBB"
"AAA" . $@ . "BBB"

The variable name can besurround with "{" and "}" to indicate the end of the variable name.

"AAA ${foo}_ccc BBB"

The above is expanded as the following.

"AAA " . ${foo} . "_ccc BBB"

If there is no enclosing "{" and "}", up to the valid part as a variable name is interpreted as a Variable. Dereference interpreting is same as this. If "->" follows the variable name, it is interpreted as Field Access or Array Access. [1] If the following Characters are "a-z" "A-Z" "0-9" "_" "{" "[", proceed with the interpretation. [2] If the Character following [1] is "}", or "]", then if the next Character is "->", "{", or "[", proceed with the interpretation and return back to [1], otherwise stop interpreting. The trailing $is not treated as the start of Variable Expansion. It is treated as "$".

"AAA$"

String

SPVM has String Type. String is created by String Literal or Type Convertion from byte[] Type. String is immutable and you can't change the each character. You can only get the each character.

# String is Array of byte Type
my $string : string = "Hello";
my $char0 = $string->[0];
my $char1 = $string->[1];
my $char2 = $string->[2];

# Compile Error because String Type is immutable.
$string_const->[0] = 'd';

# Create new String using Type Convertion;
my $bytes = new byte[3];
$bytes->[0] = 'a';
$bytes->[1] = 'b';
$bytes->[2] = 'c';
my $string = (string)$bytes;

Undefined Value

Undefined Value is "undef"

undef

Undefined Value can be assigned to all Object Type variable. Undefined Value can be compared with the value of Object Type using "==" Operator or "!=" Operator. Undefined Value is guaranteed not to be equal to the created object. If Undefined Value is used in the Condition Part, it will be false.

Array

Array Summary
Create Array
Array Access

Array Summary

Array is a data structure for continuous multiple values. There are the following types of Array.

Numeric Type Array
Object Type Array
Multi Numeric Type Array

Numeric Type Array is Array that element type is Numeric Type. Numeric Type Array is Array that element type is Object Type. Numeric Type Array is Array that element type is Multi Numeric Type.

Create Array

See Create Array to create Array.

Array Access

Array Access is an operation to access the element of Array to get or set the value.

ARRAY->[INDEX]

See Get Array Element Value to get the element value of Array. See Set Array Element Value to set the element value of Array.

Multi Numeric Value

Multi Numeric Type Definition
Multi Numeric Type Suffix
Multi Numeric Type Usage
Multi Numeric Type Field Access

Multi Numeric Type Definition

Multi Numeric type represents continuous numeric values. For example, there are three consecutive 32-bit signed integers, two consecutive double-precision floating point numbers. It isplaned to use 3D points, complex numbers, quaternions, etc. Multi Numeric Type is defined by specifying mulnum_t Class Descriptor in Class Definition.

# Three consecutive 32bit signed integers
class Point_3i : mulnum_t {
  has x : int;
  has y : int;
  has z : int;
}

# Tow consecutive 64bit floating point numbers
class Complex_2d : mulnum_t {
  x : double;
  y : double;
}

Multi Numeric Type must end with "_", Number of Fields, Multi Numeric Type Suffix. The suffix must correspond to Numeric Type. All Fields must be the same Numeric Type. The maximum number of Fields is 255. Multi Numeric Type can be used as Type of Local Variable Declaration. Multi Numeric Type can be used as an argument Type in Method Definition . Multi Numeric Type can be used as Type of Return Value in Method Definition. Multi Numeric Type can be used as Basic Type of Array Type .

my $points = new Point_3i[5];

Reference can be created for Multi Numeric Type value.

my $point : Point_3i;
my $point_ref = \$point;

Undefined Value cannot be assigned to Multi Numeric Type value. See Multi Numeric Type Field Access to get and set the value of field of Multi Numeric Type Value.

Multi Numeric Type Suffix

List of Multi Numeric Type Suffix.

Numeric Type	Multi Numeric Type Suffix
byte	b
short	s
int	i
long	l
float	f
double	d

Multi Numeric Type Usage

To use Multi Numeric Type, load a Module using use Statement.

use Point_3i;
use Complex_2d;

Next is Local Variable Declaration. Local Variable Declaration create continuous area for fields of Multi Numeric Type Value on Method Callstack. All fields of of Multi Numeric Type Value are initialized by Type Initial Value.

my $point : Point_3i;
my $z : Complex_2d;

Note that Multi Numeric Type value are not object, so cannot create a Object by new syntax.

Multi Numeric Type Field Access

Multi Numeric Type Field Access is an operation to access Multi Numeric Type Field to get or set a value.

MULTI_NUMERIC_TYPE_VALUE->{FIELD_NAME}

See Get Multi Numeric Field Value to get Multi Numeric Type Field Value. See Set Multi Numeric Field Value to set Multi Numeric Type Field Value.

Multi Numeric Array

Multi Numeric Array Summary
Multi Numeric Array Access

Multi Numeric Array Summary

Multi Numeric Value can be an element of Array.

my $points = new Point_3i[5];

my $zs = new Complex_2d[5];

Multi Numeric Array has continuous Multi Numeric Values. The Element Type is Multi Numeric Type, not Object Type. For example, Point_3i[5] is continuous 15 (= 3 * 5) count int Type Value. Type of Multi Numeric Array is Array Type.

Multi Numeric Array Access

Multi Numeric Array Access is an operation to access Multi Numeric Array to get and set the element value.

Array->[INDEX]

See Get Array Element Value to get Array Element Value. See Set Array Element Value to get Array Element Value.

Reference

Reference Summary
Dereference

Reference Summary

Reference is data that indicates the location of Local Variable in the memory. Reference is a feature corresponding to Pointer in C language. You can get Reference of Local Variable using Reference Operator. Reference Type is represented by Numeric Type "&" or Multi Numeric Type followed by "&". Reference types are represented by appending an & after Numeric Type or Multi Numeric Type.

# Numeric Type Reference
my $num : int;
my $num_ref : int& = \$num;

# Multi Numeric Type Reference
my $point : Point_3d;
my $point_ref : Point_3d& = \$point;

Target of Reference Operator is Variable of Numeric Type or Multi Numeric Type. Object Type Variable or Literal can't be target of Reference Operator. Reference Type can be used in Method Argument.

# Method Definition
static method sum : void ($out_ref : int&, $in1 : int, $in2 : int) {
  $$out_ref = $in1 + $in2;
}

# Method Call
my $num1 = 1;
my $num2 = 2;
my $out : int;
my $out_ref = \$out;
sum($out_ref, $num1, $num2);

Dereference

Dereference is an operation to get and set the value pointed by Reference.

# Dereference Numeric Type Reference to get the pointed value
my $num2 = $$num_ref;

# Dereference Numeric Type Reference to set the pointed value
$$num_ref = 3;

# Dereference Mutil Numeric Type Reference to get the pointed value
my $point2 = $$point_ref;

# Dereference Mutil Numeric Type Reference to set the pointed value
$$point_ref = $point2;

If the target of Reference Type is Multi Numeric Type, the setting and getting of Multi Numeric Type Field Value can be done by Arrow Operator.

# If the target of Reference Type is Multi Numeric Type, get Multi Numeric Type Field Value
my $x = $point_ref->{x};

# If the Target of Reference Type is Multi Numeric Type, set Multi Numeric Type Field Value
$point_ref->{x} = 1;

Expression

Expression Summary
Operator
Literal
Undefined Value
Get Local Variable Value
Set Local Variable Value
Get Class Variable Value
Set Class Variable Value
Get Exception Variable Value
Set Exception Variable Value
Get Field Value
Set Field Value
Get Multi Numeric Field Value
Set Multi Numeric Field Value
Get Multi Numeric Field Value via Dereference
Set Multi Numeric Field Value via Dereference
Get Array Element Value
Set Array Element Value
Create Object
Create Array
Array Initialization
Method Call
Class Method Call
Method Call
Function Call
Get Current Class Name
Get Current File Name
Get Current Line Number
Type Cast
(EXPRESSION)
Operator Precidence

Expression Summary

Expression is a syntax component that can be evaluated as a value.

Operator

Operator is a Expression.

Undefined Value

Undefined Value is a Expression.

Literal

Literal is a Expression.

Get Local Variable Value

Get Local Variable Value is a Expression to get Local Variable Value.

$var

Set Local Variable Value

Set Local Variable Value Expression is a Expression to set Local Variable Value using Assignment Operator.

$var = RIGHT_EXPRESSION

The Assignment must satisfy Type Compatibility. Set Local Variable Value Expression returns the value after setting. If Right Expression is Object Type, Reference Count of the object is incremented by 1. If an object has already been assigned to $var before the assignment, the Reference Count of that object is decremented by 1. See Scope to know Garbage Collection of Local Variable.

Get Class Variable Value

Get Class Variable Value Expression is a Expression to get Class Variable Value.

$CLASS_NAME::CLASS_VARIABLE_NAME

"CLASS_NAME::" can be omitted when the Class Variable belongs to own Class.

$CLASS_VARIABLE_NAME

If you try to get the value of a Class Variable that is not defined, Compile Error occurs. If you try to access a private Class Variable from outside the Class, Compile Error occurs. Get Class Variable Value Example:

class Foo {
  our $VAR : int;

  static method bar : int () {
    my $var1 = $Foo::VAR;
    my $var2 = $VAR;
  }
}

Set Class Variable Value

Set Class Variable Value Expression is a Expression to set Class Variable Value using Assignment Operator. .

$CLASS_NAME::CLASS_VARIABLE_NAME = RIGHT_EXPRESSION

"CLASS_NAME::" can be omitted when the Class Variable belongs to own Class.

$CLASS_VARIABLE_NAME = RIGHT_EXPRESSION

If the assignment does not satisfy Type Compatibility, Compile Error occurs. Set Class Variable Value Expression returns the value after setting. If you try to get the value of a Class Variable that is not defined, Compile Error occurs. If you try to access a private Class Variable from outside the Class, Compile Error occurs. If Right Expression is Object Type, Reference Count of the object is incremented by 1. If an object has already been assigned to Class Variable before the assignment, the Reference Count of that object is decremented by 1. Set Class Variable Value Example:

class Foo {
  our $VAR : int;

  static method bar : int () {
    $Foo::VAR = 1;
    $VAR = 3;
  }
}

Get Exception Variable Value

Get Exception Variable Value Expression is a Expression to get the value of Exception Variable.

$@

Get Exception Variable Value Expression returns the value of String Type. Get Exception Variable Value Example:

eval {
  foo();
};

if (my $message = $@) {

}

Set Exception Variable Value

Set Exception Variable Value Expression is a Expression to set the value of Exception Variable using Assignment Operator.

$@ = RIGHT_EXPRESSION

Right Expression must be String Type. Returns the value of Exception Variable after setting. This is String Type. The Reference Count of Right Expression is incremented by 1. If an object has already been assigned to Exception Variable before the assignment, the Reference Count of that object is decremented by 1. Set Exception Variable Value Example:

$@ = "Error";

Get Field Value

Get Field Value Expression is a Expression to get Field Value.

INVOCANT_EXPRESSION->{FIELD_NAME}

Invocant Expression is Class Type. If Expression is Multi Numeric Type Value, The Field Access is Get Multi Numeric Field Value. If Expression is Multi Numeric Reference Type Value, The Field Access is ,, otherwise Compile Error occurs. If the Field Name does not found in the Class, Compile Error occurs Get Field Value Expression returns the value of the Field stored in the object. Retrun Type is The Type of the Field. Get Field Value Example:

my $point = Point->new;
my $x = $point->{x};

Set Field Value

Set Field Value Expression is a Expression to set Field Value.

INVOCANT_EXPRESSION->{FIELD_NAME} = RIGHT_EXPRESSION

Invocant Expression is Class Type. If Invocant Expression is Multi Numeric Type, the Field Access is ,Set Multi Numeric Field Value. If Invocant Expression is Multi Numeric Reference Type, the Field Access is Set Multi Numeric Field Value via Dereference, otherwise Compile Error occurs. If the assignment does not satisfy Type Compatibility of the Type of Field, Compile Error occurs. If the Field Name does not found in the Class, Compile Error occurs. Set Field Value Expression returns the value of Field after setting. Return Value Type is the Type of Field. If Right Expression is Object Type, Reference Count of the object is incremented by 1. If an object has already been assigned to Field before the assignment, the Reference Count of that object is decremented by 1. Set Field Value Example:

my $point = Point->new;
$point->{x} = 1;

Get Multi Numeric Field Value

Get Multi Numeric Field Value Expression is a Expression to get Field Value of Multi Numeric Value.

INVOCANT_EXPRESSION->{FIELD_NAME}

Invocant Expression is Multi Numeric Type. If Invocant Expression is Class Type, the Field Access is . If Invocant Expression is Multi Numeric Reference Type, the Field Access is Get Multi Numeric Field Value via Dereference, otherwise Compile Error occurs. If the Field Name does not found in the Class, Compile Error occurs Get Multi Numeric Field Value Expression returns the field value in the Multi Numeric Value. Retrun Type is The Type of the Field. Get Multi Numeric Field Value Example:

my $z : Complex_2d;
my $re = $z->{x};

Set Multi Numeric Field Value

Set Multi Numeric Field Value Expression is a Expression to set Field Value of Multi Numeric Value using Assignment Operator.

INVOCANT_EXPRESSION->{FIELD_NAME} = RIGHT_EXPRESSION

< Invocant Expression is Multi Numeric Type. If Invocant Expression is Class Type, the Field Access is Set Field Value. Invocant Expression is Multi Numeric Reference Type, Set Multi Numeric Field Value via Dereference, otherwise Compile Error occurs. If the Field Name does not found in the Class, Compile Error occurs. Set Multi Numeric Field Value Expression returns the value of Field after setting. The Assignment must satisfy Type Compatibility. Return Value Type is the Type of Field. Set Multi Numeric Field Value Example:

my $z : Complex_2d;
$z->{x} = 2.5;

Get Multi Numeric Field Value via Dereference

Get Multi Numeric Field Value via Dereference Expression is a Expression to get Field Value of Multi Numeric Value via Dereference.

INVOCANT_EXPRESSION->{FIELD_NAME}

Invocant Expression is Multi Numeric Reference Type. If Invocant Expression is Class Type, the Field Access is , Get Field Value. If Invocant Expression is Multi Numeric Type, the Field Access is Get Multi Numeric Field Value, otherwise Compile Error occurs. If the Field Name does not found in the Class, Compile Error occurs Get Multi Numeric Field Value via Dereference Expression returns the field value in the Multi Numeric Value. Retrun Type is The Type of the Field. Get Multi Numeric Field Value via Dereference Example:

my $z : Complex_2d;
my $z_ref = \$z;
my $re = $z_ref->{x};

Set Multi Numeric Field Value via Dereference

Set Multi Numeric Field Value Expression via Dereference is a Expression to set Field Value of Multi Numeric Value via Dereference using Assignment Operator.

INVOCANT_EXPRESSION->{FIELD_NAME} = RIGHT_EXPRESSION

Invocant Expression is Multi Numeric Reference Type. If Invocant Expression is Class Type, Set Field Value. If Invocant Expression is Multi Numeric Type, Set Multi Numeric Field Value, otherwise Compile Error occurs. If the Field Name does not found in the Class, Compile Error occurs Set Multi Numeric Field Value via Dereference Expression returns the value of Field after setting. The Assignment must satisfy Type Compatibility. Return Value Type is the Type of Field. Set Multi Numeric Field Value via Dereference Example:

my $z : Complex_2d;
my $z_ref = \$z;
$z_ref->{x} = 2.5;

Get Array Element Value

Get Array Element Value Expression is a Expression to get a Element Value of Array.

ARRAY_EXPRESSION->[INDEX_EXPRESSION]

Array Expression must be Array Type. Index Expression must be int Type or the Type that become int Type by Unary Numeric Widening Type Conversion. Get Array Element Value Expression returns the Element Value of the Index. If Array Expression is Undefined Value, a Runtime Exception occurs. If Index Expression is lower than 0 or more than the max index of the Array, a Runtime Exception occurs. Get Array Element Value Example:

my $nums = new int[3];
my $num = $nums->[1];

my $points = new Point[3];
my $point = $points->[1];

my $objects : oarray = $points;
my $object = (Point)$objects->[1];

Set Array Element Value

Set Array Element Value Expression is a Expression to set a Element Value of a Array using Assignment Operator.

ARRAY_EXPRESSION->[INDEX_EXPRESSION] = RIGHT_EXPRESSION

Array Expression must be Array Type. Index Expression must be int Type or the Type that become int Type by Unary Numeric Widening Type Conversion. The Assignment must satisfy Type Compatibility. Set Array Element Value Expression returns the value of the element after setting. If Array Expression is Undefined Value, a Runtime Exception occurs. If Index Expression is lower than 0 or more than the max index of the Array, a Runtime Exception occurs. If Right Expression is Object Type, Reference Count of the object is incremented by 1. If an object has already been assigned to Field before the assignment, the Reference Count of that object is decremented by 1. Set Array Element Value Example:

my $nums = new int[3];
$nums->[1] = 3;

my $points = new Point[3];
$points->[1] = Point->new(1, 2);

my $objects : oarray = $points;
$objects->[2] = Point->new(3, 5);

Create Object

Create Object Expression is a Expression to create Object using new keyword.

my $object = new CLASS_NAME;

Class that is specified by Class Name must be Class Type. Fields of the Object are initialized by Type Initial Value. Created Object Reference count is 0 at first. If the Object is assigned to some Variable by Assignment Operator, The Reference Count is incremented by 1. If implicite assignment is not done, Temporary Variable is created, the object is assigned to the Temporary Variable. Create Object Example:

my $object = new Foo;

Create Object has the following information.

Reference Count
Back references of Weaken Reference
Basic Type ID
Type Dimension(Always 0)

Create Array

Create Array Expression is a Expression to create Array with new Keyword.

new Type[ELEMENTS_COUNT_EXPRESSION]

Type must be Numeric Type, Object Type, Multi Numeric Type. Elements Count Expression must be int Type or the Type that become int Type by Unary Numeric Widening Type Conversion. If Index Expression is lower than 0, a Runtime Exception occurs. Created Array Length is the value of Elements Count Expression. All Array Element is initialized by Type Initial Value. All Element is gurantied to be continued on Memory. Array is Array Type. This is also Object Type. Create Array Example:

my $nums = new int[3];
my $objects = new Foo[3];
my $objects = new object[3];
my $values = new Complex_2d[3]

Created Array has the following information.

Reference Count
Basic Type ID
Type Dimension(the value is 1)
Array Length

Multi-Dimention Array is created by the following syntax.

# 2 Dimention Array (3 elements of int[] Type)
my $nums = new int[][3];

# 3 Dimention Array (3 elements of int[][] Type)
my $nums = new int[][][3];

The max of Dimention of Multi-Dimention Array is 255.

Array Initialization

SPVM has a syntax for Array Initialization to simplify Create Array. Expression is not required.

[]
[Expression1, Expression2, Expression3]

Array Initialization returns an Array that has the length of the number of elements of Expression.

The type of Array is the type of Expression1 converted to Array Type. If no element is specified, it will be an Array Type of Any Object Type.

If Expression2 or later does not satisfy Type Compatibility, a Compile Error will occur.

Examples:

# int array
my $nums = [1, 2, 3];

# double array
my $nums = [1.5, 2.6, 3.7];

# string array
my $strings = ["foo", "bar", "baz"];

Array Initialization has another syntax. This is same as above array init syntax, but always the generated object type is Array Type of Any Object Type. And if count of expression is odd number, a compile error occurs.

{}
{Expression1, Expression2, Expression3, Expression4}

Examples:

# Key values empty
my $key_values = {};

# Key values
my $key_values = {foo => 1, bar => "Hello"};

Method Call

Methods defined by Method Definition can be called from program. There are three types of method calls. Class Method Call and Instance Method Call. Defined method can be called by Class Method Call except a case that the first argument is self Type.

ClassName->MethodName(ARGS1, ARGS2, ARGS3, ..., ARGSn);

The arguments max count is 255. If the number of arguments does not match the number of arguments defined in the Method Definition, Compile Error occurs The Type of each argument and the type of the argument defined in Method Definition and Type Compatibility, Compile Error occurs. Class Method Call Example

my $ret = Foo->bar(1, 2, 3);

Function Call

Method which is defined as Class Method is imported as Function using use Statement.

use Foo(MethodName);

MethodName(ARGS1, ARGS2, ARGS3, ..., ARGSn);

Function Call is Expression. Function Call Example

class Foo {
  use Fn (copy_string);

  static method test : void () {
    my $ret = copy_string("hello");
  }
}

Instance Method Call

Instance Method Call is a method to call Method which is Method. In Method Definition, the first argument is self Type If the argument of> is specified, it becomes Method.

Instance Method Call can be done with the following syntax using the object created by Create Object.

OBJECT_EXPRESSION->METHOD_NAME(ARGS1, ARGS2, ARGS3, ..., ARGSn);

Instance Method Call takes arguments. If the number of arguments does not match the number of arguments defined in the Method Definition, Compile Error occurs The Type of each argument and the type of the argument defined in Method Definition and Type Compatibility, Compile Error occurs

Instance Method Call returns Return Value if Return Value is other than void Type.

Instance Method Call is Expression.

Instance Method Call Example

my $point = new Point;
$point->set_x(3);

Since the object created by Create Callback Object is a normal object, you can call Method.

OBJECT_EXPRESSION->(ARGS1, ARGS2, ARGS3, ..., ARGSn);

Example that calls Method from the object created with Create Callback Object

An Example that calls a Method from the object created by Create Callback Object.

my $cb_obj = method : int ($num1 : int, $num2 : int) {
  return $num1 + $num2;
};

my $ret = $cb_obj->(1, 2);

Get value by Dereference

Obtaining a value by Dereference is an operation to obtain the actual value from Reference. It was designed to realize the C joint operator "*".

$VARIABLE

The variable Type must be Reference Type, otherwise Compile Error occurs.

The value obtained by Dereference returns Expression.

  Example of getting value by Dereference

my $num : int;
my $num_ref : int& = \$num;
my $num_deref : int = $$num_ref;

my $z : Complex_2d;
my $z_ref : Complex_2d& = \$z;
my $z_deref : Complex_2d = $$z_ref;

Setting the value with Dereference

Setting a value with Dereference is an operation to set the actual value from Reference. It was designed to realize the C joint operator "*".

$VARIABLE = Expression

The variable Type must be Reference Type, otherwise Compile Error occurs.

The Type of Expression must match the Type of the variable when dereferenced, otherwise Compile Error occurs.

Setting a value with Dereference returns the set value. This is Expression.

  Example of setting values ââwith Dereference

my $num : int;
my $num_ref : int& = \$num;
$$num_ref = 1;

my $z : Complex_2d;
my $z_ref : Complex_2d& = \$z;

my $z2 : Complex_2d;

$$z_ref = $z2;

Get Current Class Name

Get Current Class Name is a Expression to get the current class name by __CLASS__ Keyword.

__CLASS__

Get Current Class Name Example:

class Foo::Bar {
  static method baz : void () {
    # Foo::Bar
    my $class_name == __CLASS__;
  }
}

Get Current File Name

Get Current File Name is a Expression to get the current file name by __LINE__ Keyword.

__FILE__

Current File Name means the relative path from the base path of the module file. For example, if the Module Loaded Path is "/mypath" and the Module name is "Foo::Bar", the absolute path is "/mypath/SPVM/Foo/Bar.spvm" and the relative path is "SPVM/Foo/Bar.spvm". "SPVM/Foo/Bar.spvm" is Current File Name. Get Current File Name Example:

# SPVM/Foo/Bar.spvm
class Foo::Bar {
  static method baz : void () {
    # SPVM/Foo/Bar.spvm
    my $file_name == __FILE__;
  }
}
class Foo::Bar2 {
  static method baz : void () {
    # SPVM/Foo/Bar.spvm
    my $file_name == __FILE__;
  }
}

Get Current Line Number

Get Current Line Number is a Expression to get the current line number of the current file by __LINE__ Keyword.

__LINE__

Get Current Line Number Example:

class Foo::Bar {
  static method baz : void () {
    # 4
    my $line = __LINE__;
  }
}

Operator

Operator
Unary Operator
Binary Operator
Sequential Operator
Arithmetic Operator
Unary Plus Operator
Unary Minus Operator
Addition Operator
Subtraction Operator
Multiplication Operator
Division Operator
Remainder Operator
Increment Operator
Decrement Operator
Bit Operator
Bit AND Operator
Bit OR Operator
Bit NOT Operator
Shift Operator
Left Shift Operator
Arithmetic Right Shift Operator
Logical Right Shift Operator
Comparison Operator
Numeric Comparison Operator
String Comparison Operator
isa Operator
ref Operator
dump Operator
Logical Operator
Logical AND Operator
Logical OR Operator
Logical NOT Operator
String Concatenation Operator
Assignment Operator
Special Assignment Operator
Reference Operator
Array Length Operator
String Length Operator
Scalar Operator
isweak Operator

Operator

Operator is a Expression to culcurate number mainly. Operators are Unary Operator, Binary Operator, Increment Operator, Decrement Operator, Comparison Operator, Logical Operator, and Assignment Operator.

Unary Operator

Unary Operator is an Operator placed before Expression.

UNARY_OPERATOR EXPRESSION

Unary Operators are Unary Plus Operator, Unary Minus Operator, Bit NOT Operator, Logical NOT Operator, Array Length Operator, and String Length Operator. Note that Increment Operator and Decrement Operator is not Unary Operator.

Binary Operator

Binary Operator is a Operator placed between Left Expression and Right Expression.

LEFT_EXPRESSION BINARY_OPERATOR RIGHT_EXPRESSION

Binary Operators are Addition Operator, Subtraction Operator, Multiplication Operator, Division Operator, Remainder Operator, Bit AND Operator, Bit OR Operator, Logical AND Operator, Logical OR Operator, Shift Operator, and String Concatenation Operator.

Sequential Operator

Sequential Operator is an Operator that join "," with multiple Expressions and return the last Expression.

(EXPRESSION1, EXPRESSION2, EXPRESSION3)

Expression is executed from Left to Right and the last Expression is return. Sequential Operator Example:

# 3 is assigned to $foo
my $foo = (1, 2, 3);

# $x is 3, $ret is 5
my $x = 1;
my $y = 2;
my $ret = ($x += 2, $x + $y);

Arithmetic Operator

Arithmetic Operator is an Operator that performs arithmetic. Arithmetic Operators are Addition Operator, Subtraction Operator, Multiplication Operator, Division Operator, Remainder Operator, Unary Plus Operator, Unary Minus Operator, Increment Operator, and Decrement Operator.

Unary Plus Operator

Unary Plus Operator is a Unary Operator represented by "+".

+Expression

Expression must be Numeric Type, otherwise Compile Error occurs. Unary Numeric Widening Type Conversion applys to Expression. After that, returns the value copied from the avobe value. Return Type of Unary Plus Operator is the Type after Unary Numeric Widening Type Conversion is applied. Unary Plus Operator does not throw Exception. Unary Plus Operator Example:

my $num = +10;

Unary Minus Operator

Unary Minus Operator is a Unary Operator represented by "-".

-Expression

Expression must be Numeric Type, otherwise Compile Error occurs. Unary Numeric Widening Type Conversion applys to Expression. After that, Unary Minus Operator performs an operation that exactly matches the following operation in C99.

-x

int Type Operation, long Type Operation, float Type Operation, and double Type Operation are defined corresponding to C99 Type Return Type of Unary Minus Operator is the Type after Unary Numeric Widening Type Conversion is applied. Unary Minus Operator does not throw Exception. Unary Minus Operator Example:

my $num = -10;

Addition Operator

Addition Operator is a Binary Operator represtented by "+" to perform addition.

LEFT_EXPRESSION + RIGHT_EXPRESSION

Left Expression and Right Expression must be Numeric Type, otherwise Compile Error occurs. Binary Numeric Widening Type Conversion is applied to Left Expression and Right Expression. After that, Addition Operator performs an operation that exactly matches the following operation in C99.

x + y;

int Type Operation, long Type Operation, float Type Operation, and double Type Operation are defined corresponding to C99 Type Return Type of Addition Operator is the Type after Binary Numeric Widening Type Conversion is applied. Addition Operator does not throw Exception.

Subtraction Operator

Subtraction Operator is a Binary Operator represtented by "-" to perform Subtraction.

LEFT_EXPRESSION - RIGHT_EXPRESSION

Left Expression and Right Expression must be Numeric Type, otherwise Compile Error occurs. Binary Numeric Widening Type Conversion is applied to Left Expression and Right Expression. After that, Subtraction Operator performs an operation that exactly matches the following operation in C99.

x - y;

Return Type of Subtraction Operator is the Type after Binary Numeric Widening Type Conversion is applied. Subtraction Operator does not throw Exception.

Multiplication Operator

Multiplication Operator is a Binary Operator represtented by "*" to perform Multiplication.

LEFT_EXPRESSION * RIGHT_EXPRESSION

Left Expression and Right Expression must be Numeric Type, otherwise Compile Error occurs. Binary Numeric Widening Type Conversion is applied to Left Expression and Right Expression. After that, Multiplication Operator performs an operation that exactly matches the following operation in C99.

x * y;

int Type Operation, long Type Operation, float Type Operation, and double Type Operation are defined corresponding to C99 Type Return Type of Multiplication Operator is the Type after Binary Numeric Widening Type Conversion is applied. Multiplication Operator does not throw Exception.

Division Operator

Division Operator is a Binary Operator represtented by "/" to perform Division.

LEFT_EXPRESSION / RIGHT_EXPRESSION

Left Expression and Right Expression must be Numeric Type, otherwise Compile Error occurs. Binary Numeric Widening Type Conversion is applied to Left Expression and Right Expression. After that, Division Operator performs an operation that exactly matches the following operation in C99.

x / y;

int Type Operation, long Type Operation, float Type Operation, and double Type Operation are defined corresponding to C99 Type Return Type of Division Operator is the Type after Binary Numeric Widening Type Conversion is applied. In the operation to Integral Type, Division Operator throw Exception if Right Expression is 0. In the operation to Floating Point Type, Division Operator dose not throw Exception.

Remainder Operator

Remainder Operator is a Binary Operator represtented by "%" to perform Division.

LEFT_EXPRESSION % RIGHT_EXPRESSION

Left Expression and Right Expression must be Integral Type, otherwise Compile Error occurs. Binary Numeric Widening Type Conversion is applied to Left Expression and Right Expression. After that, Remainder Operator performs an operation that exactly matches the following operation in C99.

x % y;

int Type Operation, and long Type Operation are defined corresponding to C99 Type Return Type of Remainder Operator is the Type after Binary Numeric Widening Type Conversion is applied. Remainder Operator throw Exception if Right Expression is 0.

Increment Operator

Increment Operator is an Operator that adds 1 to the value. the meaning of Increment Operator is different depending on whether the Increment Operator is placed Pre or Post.

# Pre Increment Operator
++LEXICAL_VARIABLE
++CLASS_VARIABLE
++FIELD_ACCESS
++ARRAY_ACCESS
++DEREFERENCE

# Post Increment Operator
LEXICAL_VARIABLE++
CLASS_VARIABLE++
FIELD_ACCESS++
ARRAY_ACCESS++
DEREFERENCE++

The operand of Increment Operator must Local Variable, Class Variable, Field Access, Array Access, Dereference, otherwise Compile Error occurs.

The Type of operand of Increment Operator must be Numeric Type, otherwise Compile Error will occur.

Pre Increment Operator

Pre Increment Operator adds 1 to the operand and returns the value after increment.

Pre Increment Operator is equivalent to the following Expression. After 1 is added to the operand, Type Cast is performed with the operand Type and the value is assinged to original operand.

(OPERAND_EXPRESSION = (TYPE)(OPERAND_EXPRESSION + 1))

For example, Pre Increment of byte Type value is equivalent to the following Expression:

($num = (byte)($num + 1))

Post Increment Operator

Post Increment Operator add 1 to the operand and returns the value before Increment.

Post Increment Operator is equivalent to the following Expression using Sequential Operator. The value of operand is saved in a temporary variable, 1 is added to the operand, Type Cast is performed with the operand Type, and the value is assinged to original operand. Then the temporary variable is returned.

(my TMP_VARIABLE = OPERAND_EXPRESSION, OPERAND_EXPRESSION = (TYPE)(OPERAND_EXPRESSION + 1), TMP_VARIABLE)

For example, Post Increment of byte Type value is equivalent to the following Expression.

(my $tmp = $num, $num = (byte)($num + 1), $tmp)

Decrement Operator

Decrement Operator is an Operator that subtracts 1 to the value. the meaning of Decrement Operator is different depending on whether the Decrement Operator is placed Pre or Post.

# Pre Decrement Operator
--LEXICAL_VARIABLE
--CLASS_VARIABLE
--FIELD_ACCESS
--ARRAY_ACCESS
--DEREFERENCE

# Post Decrement Operator
LEXICAL_VARIABLE--
CLASS_VARIABLE--
FIELD_ACCESS--
ARRAY_ACCESS--
DEREFERENCE--

The operand of Decrement Operator must Local Variable, Class Variable, Field Access, Array Access, Dereference, otherwise Compile Error occurs.

The Type of operand of Decrement Operator must be Numeric Type, otherwise Compile Error will occur.

Pre Decrement Operator

Pre Decrement Operator subtracts 1 to the operand and returns the value after decrement.

Pre Decrement Operator is equivalent to the following Expression. After 1 is subtracted to the operand, Type Cast is performed with the operand Type and the value is assinged to original operand.

(OPERAND_EXPRESSION = (TYPE)(OPERAND_EXPRESSION - 1))

For example, Pre Decrement of byte Type value is equivalent to the following Expression:

($num = (byte)($num - 1))

Post Decrement Operator

Post Decrement Operator subtract 1 to the operand and returns the value before Decrement.

Post Decrement Operator is equivalent to the following Expression using Sequential Operator. The value of operand is saved in a temporary variable, 1 is subtracted to the operand, Type Cast is performed with the operand Type, and the value is assinged to original operand. Then the temporary variable is returned.

(my TMP_VARIABLE = OPERAND_EXPRESSION, OPERAND_EXPRESSION = (TYPE)(OPERAND_EXPRESSION - 1), TMP_VARIABLE)

For example, Post Decrement of byte Type value is equivalent to the following Expression.

(my $tmp = $num, $num = (byte)($num - 1), $tmp)

Bit Operator

Bit Operator is an Operator that performs Bit operation. Bit AND Operator, Bit OR Operator, Bit NOT Operator.

Bit AND Operator

Bit AND is Binary Operator represented by "&".

LEFT_EXPRESSION & RIGHT_EXPRESSION

Left Expression and Right Expression must be Integral Type, otherwise Compile Error occurs.

Binary Numeric Widening Type Conversion is performed on Left Expression and Right Expression.

After that, the operation result of Bit AND Operator performs the operation that exactly matches the following operation in C99

x & y;

int Type Operation and long Type Operation are defined corresponding to C99 Type

The Type of Return Value of Bit AND Operator is the type after Binary Numeric Widening Type is performed.

Bit AND Operator does not throw Exception.

Bit OR Operator

Bit OR is Binary Operator represented by "|".

LEFT_EXPRESSION | RIGHT_EXPRESSION

Left Expression and Right Expression must be Integral Type, otherwise Compile Error occurs.

Binary Numeric Widening Type Conversion is performed on Left Expression and Right Expression.

After that, the operation result of Bit OR Operator performs the operation that exactly matches the following operation in C99.

x | y;

int Type Operation and long Type Operation are defined corresponding to C99 Type

The Type of Return Value of Bit OR Operator is the type that is Binary Numeric Widening Type Converted.

Bit OR Operator does not throw Exception.

Bit NOT Operator

Bit NOT Operator is Unary Operator represented by "~".

~EXPRESSION

Expression must be Integral Type, otherwise Compile Error occurs.

Unary Numeric Widening Type Conversion is performed to Expression before Operation.

After that, the operation result of Bit NOT Operator performs the operation that exactly matches the following operation in C99.

~x

int Type Operation and long Type Operation are defined corresponding to C99 Type

The Type of Return Value of Bit NOT Operator is the type after Unary Numeric Widening Type Conversion

Bit NOT Operator does not throw Exception.

Bit NOT Operator Example

my $num = ~0xFF0A;

Shift Operator

Shift Operator is an operator that performs Bit shift. Left Shift Operator, Arithmetic Right Shift Operator, Logical Right Shift Operator.

Left Shift Operator

The Left shift is Binary Operator represented by "<<".

LEFT_EXPRESSION << RIGHT_EXPRESSION

Left Expression must be Integral Type, otherwise Compile Error occurs.

Right Expression must be int Type, otherwise Compile Error occurs.

The calculation result of Left Shift Operator is the same as the following calculation in C99.

x << y;

int Type Operation and long Type Operation are defined corresponding to C99 Type

Left Shift Operator does not throw Exception.

Arithmetic Right Shift Operator

Arithmetic Right Shift Operator is Binary Operator represented by ">>".

LEFT_EXPRESSION >> RIGHT_EXPRESSION

Left Expression must be Integral Type, otherwise Compile Error occurs.

First, for Left Expression, Unary Numeric Widening Type Conversion is performed.

Right Expression must be int Type, otherwise Compile Error occurs.

The operation result of Arithmetic Right Shift Operator is the operation that exactly matches the following operation in C99.

x >> y;

int Type Operation and long Type Operation are defined corresponding to C99 Type

Arithmetic Right Shift Operator does not throw Exception.

Logical Right Shift Operator

Logical Right Shift Operator is Binary Operator represented by ">>>".

LEFT_EXPRESSION >>> RIGHT_EXPRESSION

Left Expression must be Integral Type, otherwise Compile Error occurs.

Right Expression must be int Type, otherwise Compile Error occurs.

The calculation result of Logical Right Shift Operator is the same as the following calculation in C99.

(SIGNED_INTEGRAL_TYPE_CAST)((UNSINGED_INTEGRAL_TYPE_CAST)x >> y);

int Type Operation and long Type Operation are defined corresponding to C99 Type

Logical Right Shift Operator does not throw Exception.

Comparison Operator

Comparison Operator is an Operator that is placed between Left Expression and Right Expression to compare the size, and return True/False Value.

LEFT_EXPRESSION COMPARISON_OPERATOR RIGHT_EXPRESSION

Comparison Operators are Numeric Comparison Operator, String Comparison Operator, and isa Operator.

Numeric Comparison Operator

Numeric Comparison Operator is a Comparison Operator that is placed between Left Expression and Right Expression to compare the size of number or check the equqlity of objects.

LEFT_EXPRESSION NUMERIC_COMPARISON_OPERATOR RIGHT_EXPRESSION

A list of Numeric Comparison Operators.

Operator	Comparable Type	Description
LEFT_EXPRESSION == RIGHT_EXPRESSION	Left Expression and Right Expression are Numeric Type, Left Expression and Right Expression are Object Type (including Undefined Value)	Left Expression and Right Expression are equal
LEFT_EXPRESSION != RIGHT_EXPRESSION	Left Expression and Right Expression are Numeric Type, Left Expression and Right Expression are Object Type (including Undefined Value)	Left Expression and Right Expression are not equal
LEFT_EXPRESSION > RIGHT_EXPRESSION	Left Expression and Right Expression are Numeric Type	Left Expression is greater than Right Expression
LEFT_EXPRESSION >= RIGHT_EXPRESSION	Left Expression and Right Expression are Numeric Type	Left Expression is greater than or equal to Right Expression
LEFT_EXPRESSION < RIGHT_EXPRESSION	Left Expression and Right Expression are Numeric Type	Left Expression is less than Right Expression
LEFT_EXPRESSION <= RIGHT_EXPRESSION	Left Expression and Right Expression are Numeric Type	Left Expression is less than or equal to Right Expression
LEFT_EXPRESSION <=> RIGHT_EXPRESSION	Left Expression and Right Expression are Numeric Type	If Left Expression is greater than Right expression, return 1. If Left Expression is lower than Right expression, return -1. If Left Expression is equals to Right expression, return 0.

The Types of Left Expression and Right Expression Comparable Types, otherwise Compile Error occurs.

In Numeric Type Comparison, Binary Numeric Widening Type Conversion is performed for Left Expression and Right Expression.

After that, the Numeric Comparison Operation is performed that exactly matches the following operation in C99.

# Numeric Type Comparison, Object Type Comparison
(int32_t)(x == y);
(int32_t)(x != y);

# Numeric Type Comparison
(int32_t)(x > y);
(int32_t)(x >= y);
(int32_t)(x < y);
(int32_t)(x <= y);
(int32_t)(x > y ? 1 : x < y ? -1 : 0);

For Numeric Type Operation(==, !=, >, >=, <, <=), int Type Operation, long Type Operation, float Type Operation, double Type Operation is defined. And Object Type Operation(==, !=) is defined.

The Type of Return Value of the Numeric Comparison Operator is int Type.

Numeric Comparison Operator does not throw Exception.

String Comparison Operator

String Comparison Operator is a Comparison Operator that is placed between Left Expression and Right Expression to compare String Size in dictionary order.

LEFT_EXPRESSION STRING_COMPARISON_OPERATOR RIGHT_EXPRESSION

Left Expression and Right Expression must be String Type.

A list of String Comparison Operators.

Operator	Description
LEFT_EXPRESSION eq RIGHT_EXPRESSION	Left Expression and Right Expression are equal
LEFT_EXPRESSION ne RIGHT_EXPRESSION	Left Expression and Right Expression are not equal
LEFT_EXPRESSION gt RIGHT_EXPRESSION	Left Expression is greater than Right Expression in dictionary Expression order.
LEFT_EXPRESSION ge RIGHT_EXPRESSION	Left Expression is greater than or equal to Right Expression compared in dictionary Expression order
LEFT_EXPRESSION lt RIGHT_EXPRESSION	Left Expression is smaller than Right Expression when compared in dictionary Expression order
LEFT_EXPRESSION le RIGHT_EXPRESSION	Left Expression is less than or equal to Right Expression compared in dictionary Expression order
LEFT_EXPRESSION cmp RIGHT_EXPRESSION	If Left Expression is greater than Right expression, return 1. If Left Expression is lower than Right expression, return -1. If Left Expression is equals to Right expression, return 0.

The Type of Return Value of the String Comparison Operator is int Type. If the condition is met, returns 1, otherwise 0.

isa Operator

isa Operator is a Comparison Operator to check whether Left Expression satisfies Right Type.

LEFT_EXPRESSION isa RIGHT_TYPE

isa Operator has three behaviors, depending on Right Type.

1. If Right Type is Numeric Type, Multi Numeric Type, Any Object Type, Reference Type, isa operator checks whether the Type of Left Expression is same as Right Type. This check is done at compile time and isa operator is replaced by int Type value. If their types is same, replaced by 1, otherwise by 0.

2. If the Right Type is Class Type, isa operator checks whether the Type of Left Expression is same as Right Type at Run Time. If their types are same, int Type 1 is return, otherwise 0. The Type of Left Expression must be Object Type, otherwise Compile Error occurs.

3. If the Right Type is Callback Type, isa Operator checks whether the Type of Left Expression satisfy the Callback Type at Run Time. If Left Expression satisfies the Callback Type, returns int Type 1, otherwise 0. The Type of Left Expression must be Object Type, otherwise Compile Error occurs.

ref Operator

ref Operator is a Operator to get type name of the object.

ref EXPRESSION

ref Operator return type name if the object defined. Otherwise return undef. If EXPRESSION is not a object type, a compile error occurs.

dump Operator

dump Operator is a Operator to dump object value.

dump EXPRESSION

dump Operator return the dump string. If EXPRESSION is not a object type, a compile error occurs. The contents of the dumped string may vary from SPVM version to version. Please use dump operator only for viewing the content of object data.

Logical Operator

Logical Operator is an Operator that performs logical operations,Logical AND Operator Logical NOT Operator

Logical Operator returns Expression

Logical AND Operator

Logical AND Operator is a Binary Operator

LEFT_EXPRESSION && RIGHT_EXPRESSION

Logical AND Operator ã®Return Valueã®Typeã¯,int Type.

Logical AND Operator behaves as follows:

1. Run the Bool Type Conversion to Left Expression.

2. If the value of Left Expression is non-zero, execute the and return that value.

3. If the value of Left Expression is 0, it returns that value.

Logical AND Operator returns Expression

Logical AND Operator does not throw Exception.

Logical OR Operator

Logical OR Operator is a logical OR operation that is "Expression is an operand of Binary Operator

LEFT_EXPRESSION || RIGHT_EXPRESSION

Logical OR Operator behaves as follows:

Logical OR Operator ã®Return Valueã®Typeã¯,int Type.

1. Run the Bool Type Conversion to Left Expression.

2. If the value of Left Expression is 0, the and returns that value for Right Expression.

3. If the value of Left Expression is non-zero, it returns that value.

Logical OR Operator ã¯Expressionãè¿ãã¾ãã

Logical OR Operator returns Expression

Logical NOT Operator

Logical NOT Operator is an operator to the Left of expression to perform logical NOT operations, returning Unary Operator For more information about Expression, see Expression.

!EXPRESSION

Logical NOT Operator ã®Return Valueã®Typeã¯,int Type.

Logical NOT Operator executes =$Bool Type Conversion for Expression, returns 1 if its value is 0, and 0 if it is not 0.

Logical NOT Operator returns Expression

Logical NOT Operator does not throw Exception.

String Concatenation Operator

String StringOn Operator is a Binary Operator.

LEFT_EXPRESSION . RIGHT_EXPRESSION

If the Left Expression or Right Expression wasNumeric Type==>stringtype convertion converts it to a String.

Both Left Expression and Right Expression must be String Type There is an otherwise Compile Error.

String Concatenation Operator concatenates the String represented by Left Expression and Right Expression and returns a new String.

String Concatenation Operator retruns Expression, The Type is String Type.

If both Left Expression and Right Expression were String Literal, a string Literal concatenated at compile time is generated. You can concatenate String Literal with string Concatenation Operator without being aware of the cost of performance.

If Left expression or Right Expression is Undefined Value Exception occurs at Run Time.

String Concatenation Operator Example

my $str = "abc" . "def";
my $str = "def" . 34;
my $str = 123 . 456;

Assignment Operator

Assignment Operator is a Binary Operator for assignment, expressed in "=".

LEFT_EXPRESSION = RIGHTH_EXPRESSION

Assignment Operator has multiple meanings depending on the Right and Left sides. Please refer to each item.

In Assignment Operator, the Left Expression is evaluated after the Right Expression is evaluated. This is with the exception of expression being executed from Left to Right as a rule.

Set Local Variable Value

Special Assignment Operator

Special Assignment Operator is a and Assignment Operator Type Compatibilityãæºãããªãå ´åã¯,Compile Error occurs

List of Special Assignment Operators

List of Special Assignment Operators

Addition Assignment Operator	+=
Subtraction Assignment Operator	-=
Multiplication Assignment Operator	*=
Division Assignment Operator	/=
Remainder Assignment Operator	%=
Bit AND Assignment Operator	&=
Bit OR Assignment Operator	\|=
Left Shift Assignment Operator	<<=
Arithmetic Right Shift Assignment Operator	>>=
Logical Right Shift Operator	>>>=

The Special Assignment Operator is deployed as follows:

# Before unexpanding
LEFT_EXPRESSION SPECIAL_ASSIGNMENT_OPERATOR RIGHT_EXPRESSION

# After unwinding
LEFT_EXPRESSION ASSIGNMENT_OPERATOR (LEFT EXPRESSION TYPE CAST)(LEFT_EXPRESSION SPECIFIC_OPERATOR RIGHT_EXPRESSION)

For example, for add assignment Operator, it is expanded as follows:

# Before unexpanding x is byte Type
$x += 1;

# After unwinding
$x = (byte)($x + 1)

Special Assignment Operator Example

Special Assignment Operator Example

$x += 1;
$x -= 1;
$x *= 1;
$x /= 1;
$x &= 1;
$x |= 1;
$x ^= 1;
$x %= 1;
$x <<= 1;
$x >>= 1;
$x >>>= 1;

Reference Operator

The Reference Operator is an Operator that retrieves the address of a variable for Numeric Type or Multi Numeric Type. Designed to achieve c address Operator "&".

\VARIABLE

If the variable is not numeric type or Multi Numeric Type, Compile Error occurs

Reference Operator returns expression. The type returned is Reference Type.

  Reference Operator Example

my $num : int;
my $num_ref : int& = \$num;

my $z : Complex_2d;
my $z_ref : Complex_2d& = \$z;

For a detailed description of Reference, see Reference.

Array Length Operator

Array Length Operator is a Array Unary Operator

@RIGHT EXPRESSION

Right Expression must be an Array Type, otherwise Compile Error occurs.

Array Length Operator returns array length for int Type value.

Array Length Operator returns Expression

Array Length Operator Example

Array Length Operator Example

my $nums = new byte[10];
my $length = @$nums;

Note that SPVM does not have the idea of a context in Perl, and array length operators always return Array Length.

String Length Operator

String Length Operator is a String Unary Operator

length RIGHT_EXPRESSION

Right Expression must be String Type, otherwise Compile Error occurs.

The String Length Operator returns the length of the String as a int Type value. String Length The length of the String returned by the Operator is the length when viewed as a byte string.

String Length Operator returns the Expression

String Length Operator Example

String Length Operator Exampleã§ãã

my $nums = "abcde";
my $length = length $nums;

Scalar Operator

Scalar Operator is an Operator that returns the given value itself without doing anything. It is provided only to clarify the meaning of Array Length Operator operator

scalar RIGHT_EXPRESSION

Right Expressionã¯Array Length Operatorã§ãªããã°ãªãã¾ããã otherwise Compile Error occurs.

Scalar Operator returns Expression.

Scalar Operator Example

Scalar Operator Example

my $nums = new int[3];
foo(scalar @$nums);

isweak Operator

isweak Operator is an Operator that checks whether Field isWeaken Reference.

isweak VARIABLE->{FIELD_NAME};

The Type of object Expression must beClass Type.< otherwise Compile Error occurs.

Field Name must be a existed Field Name, otherwise Compile Error occurs.

The Type of the value stored in field must be Object Type, otherwise Compile Error occurs.

If the value stored in field at Run Time is Undefined Value, it returns false. This is Expression

isweak Operator returns if Field is weaken reference, or 0. This is Expression

Precidence

Operator Precidence is the following street. The lower you go, the higher your priority.

join direction	Operator
Right Join	Assignment Operator"=" Add Assignment Operator"+=" Subtraction Assignment Operator "-=" Multiply Assignment Operator "*=" Division Assignment Operator "/=" Remainder Assignment Operator "%=" Bit ANDAssignment Operator "&=" Bit ORAssignment Operator "\|=" Bit Exclusive ORAssignment Operator "^=" Left Shift Assignment Operator"< Arithmetic Right Shift Assignment Operator ">>=" Logical Right Shift Operator ">>>=" String Join Assignment Operator ".="
Left Join	Logical OR Operator "\| \| "
Left Join	Logical AND Operator "&&"
Left Join	Bit OR Operator "\|" Bit XOR Operator "^"
Left Join	Bit AND Operator "&"
Non Associative	Numerical Equivalence Operator"==" Numeric inequality Operator "!=" String Equivalent Operator "eq" String Inequality Operator"ne"
Non Associative	Numerical value operator ">" Number less Operator""" Numerical equivalent Operator ">=" Numerical or equivalent Operator "<=" String Large Operator"gt" String-large or equivalent Operator"ge" String less Operator"lt" String less or equivalent Operator"le" isa Operator"isa"
Left Join	Left Shift Operator"< Signed Right Shift Operator ">>" Unsigned Right Shift Operator ">>>"
Left Join	Addition Operator"+" Subtraction Operator"-" String StringOn Operator "."
Left Join	Sand Operator"*" Division Operator "/" Remainder Operator"%"
Right Join	Logical NOT Operator "!" Bit NOT Operator "~" Reference Operator "\" Unary Plus Operator "+" Unary Minus Operator "-" Array Length Operator "@" Dereference Operator "$" Type Cast"(TypeName)" Scalar Operator "scalar" String Length Operator "length" require keyword "require"
Non Associative	Pre Increment Operator "++" Post Increment Operator "++" Pre Decrement Operator "--" Post Decrement Operator "--"
Right Join	Arrow Operator "->"

Operator Precidence can be a top priority by using "()".

#  a * b is the first
a * b + c

# b + c is the first
a * (b + c)

Statement

Statement can be written more than one in Scope Block for a single process. Expression is not evaluated as a value.

List of Statements

List of Statements

if Statement
switch Statement
case Statement
while Statement
for Statement
default Statement
Simple Block
eval Statement
if requireStatement
next Statement
last Statement
break Statement
return Statement
die Statement
weaken Statement
unweaken Statement
expression Statement
print Statement
warn Statement
empty Statement

if Statement

If Statement is a statement for conditional branching.

if (EXPRESSION) {

}

Expression Bool Type Conversion is executed and Block is executed if the value is non-zero.

If you want to write more than one condition, you can continue with "elsif Statement". The condition determination is performed from above, and each Expression is Bool Type Conversion is executed, and a corresponding Block is executed if the value is non-zero.

if (EXPRESSION) {

}
elsif(EXPRESSION) {

}

You can use "elseStatement" to describe what happens if or if the elsif Statement does not meet the criteria. If the if statement and elsif statement condition determination are all false, the statement inside the elseBlock is executed. Elsif Statement does not have to be.

if (EXPRESSION) {

}
elsif (EXPRESSION) {

}
else {

}

if Statement Example

An example of if Statement.

my $flag = 1;

if ($flag == 1) {
  print "One \ n";
}
elsif ($flag == 2) {
  print "Tow \ n";
}
else {
  print "Other";
}

The if Statement is internally surrounded by an invisible Simple Block.

{
  if (EXPRESSION) {

  }
}

elsif is internally expanded into if Statement and else Statement.

#Before deployment
if (EXPRESSION1) {

}
elsif (EXPRESSION2) {

}
else {

}

#After deployment
if (EXPRESSION1) {
}
else {
  if (EXPRESSION2) {

  }
  else {

  }
}

When a variable is declared in the conditional part of if Statement, it must be surrounded by invisible Simple Block. Be aware that elsif is internally expanded into if Statement and else Statement.

#Before deployment
my $num = 1;
if (my $num = 2) {

}
elsif (my $num = 3) {

}
else {

}

#After deployment
my $num = 1;
{
  if (my $num = 2) {

  }
  else {
    {
      if (my $num = 3) {
        
      }
      else {
        
      }
    }
  }
}

switch Statement

The switch statement is a statement for conditional branching with an integer of int Type as a condition. Faster than if Statement if the condition is an integer of int Type and there are many branches.

switch (CONDITION_EXPRESSION) {
  case constant 1: (

    break;
  }
  case constant 2: {

    break;
  }
  case constant n: {
    break;
  }
  default: {

  }
}

As the condition Expression, Expression can be specified. Bool Type Conversion is executed for the condition Expression.

The constants specified in case Statement are byte Type or int Type constants. must be. For a constant of byte Type, type conversion to int Type at compile time. Will be done. The value of enumType and Constant Method of int Type are constants of int Type. As it is expanded at the time of syntax analysis, it can be used.

The constants specified in the case statement must not overlap. If there are duplicates, Compile Error occurs

If the value specified in the condition Expression matches the value specified in the case statement, jump to the position of that case statement.

If there is no match and a default statement is specified, jump to the default statement position. If no default statement is specified, switch block will not be executed.

A switch statement requires at least one case statement, otherwise Compile Error will occur.

The default Statement is optional.

Only case statement and default statement can be described directly under switch block.

The case and default Blocks can be omitted.

switch (CONDITION_EXPRESSION) {
  case constant 1:
  case constant 2:
  {
    break;
  }
  default:
}

If you use break Statement, you can exit from the switch block.

switch (CONDITION_EXPRESSION) {
  case constant 1: (
    break;
  }
  case constant 2: {
    break;
  }
  case constant n: {
    break;
  }
  default: {

  }
}

If a case Block exists, the last Statement must be a break Statement or a returnl Statement, otherwise Compile Error will occur.

Switch Statement Example

An example of a switch statement.

my $code = 2;
switch ($code) {
  case 1: {
    print "1 \ n";
    break;
  }
  case 2: {
    print "2 \ n";
    break;
  }
  case 3: {
    print "3 \ n";
    break;
  }
  case 4:
  case 5:
  {
    print "4 or 5 \ n"; {
    break;
  }
  default: {
    print "Other \ n";
  }
}

case Statement

A case statement is a Statement that can be used in a switch block to specify conditions. For more information on case statements, see the switch Statement description.

default Statement

The default Statement is a Statement that can be used in the switch block to specify the default condition. For more information on the default Statement, see the switch Statement description.

while Statement

while Statement is a Statement for repeating.

while (CONDITION_EXPRESSION) {

}

Expression can be described in the condition Expression. Bool Type Conversion is executed for condition Expression, and if the value is not 0, Block is executed. Exit the otherwise Block.

While Statement Example

An example of a while Statement.

my $i = 0;
while ($i <5) {

  print "$i \ n";

  $i++;
}

Inside the while block, you can leave the while block by using last Statement.

while (1) {
  last;
}

Inside a while block, you can use next Statement to move to the condition immediately before the next condition Expression.

my $i = 0;
while ($i <5) {

  if ($i == 3) {
    $i++;
    next;
  }

  print "$i \ n";
  $i++;
}

The while Statement is internally enclosed by an invisible Simple Block.

{
  while (CONDITION_EXPRESSION) {
  $i++;
}

# å±éå¾
my $num = 5;
{
  while (my $num = 3) {

    $i++;
  }
}

for Statement

for Statement is a Statement for repeating.

for (INITIALIZATION_EXPRESSION; CONDITIONAL_EXPRESSION; INCREMENT_EXPRESSION) {

}

Expression can be described in the initialization Expression. Generally, write Expression such as initialization of loop variable. Initialization Expression can be omitted.

Condition Expression, Expression can be described. Bool Type Conversion is executed for condition Expression, and if the value is not 0, Block is executed. Exit the otherwise block.

Expression can be described in INCREMENT_EXPRESSION. Generally, Expression of Increment of loop variable is described. INCREMENT_EXPRESSION can be omitted.

for Statement has the same meaning as the following while Statement. INCREMENT_EXPRESSION is executed at the end of Block. Initialization Expression is enclosed in Simple Block.

{
  INITIALIZATION_EXPRESSION;
  while (CONDITION_EXPRESSION) {

    INCREMENT_EXPRESSION;
  }
}

for Statement Example

An example of for Statement.

for (my $i = 0; $i <5; $i++) {

  print "$i \ n";
}

Inside the for Block, you can exit the for Block using last Statement.

for (INITIALIZATION_EXPRESSION; CONDITIONAL_EXPRESSION; INCREMENT_EXPRESSION) {

}

Inside the for Block, you can use next Statement to move immediately before the next INCREMENT_EXPRESSION to be executed.

for (my $i = 0; $i <5; $i++) {

  if ($i == 3) {
    next;
  }
}

returnl Statement

Use the returnl Statement to get out of the Method. The object assigned to the mortal variable is automatically released.

return;

If there is a Return Value, Expression can be specified.

return EXPRESSION;

If the Return Value Type in Method Definition is void Type, Expression Must not exist, otherwise Compile Error occurs.

Method Definition, if the Return Value Type is other than void Type, Expression Must match the Type of, otherwise Compile Error occurs.

die Statement

die Statement is a Statement for raising Exception.

die EXPRESSION;

Expression must be a String Type.

See Exception for a detailed explanation of the die statement.

weaken Statement

A weaken Statement is a Statement that sets Weaken Reference for the Field.

weaken VARIABLE->{FIELD_NAME};

The Type of the object Expression must be Class Type, otherwise Compile Error occurs.

Field Name must be an existing Field Name, otherwise Compile Error occurs.

The Type of the value saved in Field must be Object Type, otherwise Compile Error occurs.

If the value stored in the Field at execution time is Undefined Value, the weak Statement does nothing.

If the value stored in the Field at runtime is not Undefined Value, then the following is done:

1. Decrement the Reference Count of the object stored in Field by 1.

2. Set the Weaken Reference flag in Field.

3. Add Field to the back reference of the object saved in Field.

Note that the Weaken Reference flag is set on the Field itself, not on the object stored in the Field.

If the Reference Count of the object saved in Field becomes 0, the Weaken Reference is not created and the object saved in Field is released.

Back Reference is the data of the object saved in Field, and is added to know the Field with the Weaken Reference flag set. There may be more than one.

# There are multiple back references
my $foo = new Foo;
my $bar = new Bar;
my $baz = new Baz;

$foo->{bar} = $bar;
$foo->{baz} = $baz;

$bar->{foo} = $foo;
$baz->{foo} = $foo;

weaken $bar->{foo};
weaken $baz->{foo};

In the above example, "$bar->{foo}" and "$baz->{foo}" have the Weaken Reference flag set. The object represented by $foo has the back References "$bar->{foo}" and "$baz->{foo}".

The information of the back Reference is necessary because when the Garbage Collection is performed, it is necessary to assign the Undefined Value to the Field pointed to by the back Reference.

unweaken Statement

unweaken Statement is a Statement that cancels Weaken Reference for Field.

unweaken VARIABLE->{FIELD_NAME};

The Type of the object Expression must be Class Type, otherwise Compile Error occurs.

Field Name must be an existing Field Name, otherwise Compile Error occurs.

The Type of the value saved in Field must be Object Type, otherwise Compile Error occurs.

If the value stored in the Field at execution time is Undefined Value, the unweaken Statement does nothing.

If the value stored in the Field at runtime is not Undefined Value, then the following is done:

1. Increase the Reference Count of the object stored in the Field by 1.

2. Clear the Weaken Reference flag of Field.

3. Delete the Field from the back reference of the object stored in the Field.

next Statement

"next Statement" is a Statement to move to the beginning of the next loop. in while Block, for Block You can use it.

next;

Please see the explanation of while Statement, for Statement for the actual operation. ..

last Statement

"last Statement" is a Statement to break the loop. in while Block, for Block You can use it.

Please see the explanation of while Statement, for Statement for the actual operation. ..

last;

break Statement

"break Statement" is a Statement to escape the switch block. It can be used in switch Block.

See switch Statement for the actual operation.

break;

warn Statement

Use warnStatement to throw a warning.

warn Expression;

Expression must be String Type.

If the end is a line feed Character "\ n", the String specified in Expression is output to the standard error output.

If the end is not a line feed character, File Name and line number are added to the end, and standard error is output.

If the length of String specified in Expression is 0 or Undefined Value, the specified message behaves as "Warning: something's wrong".

The standard error output buffer is flushed.

print Statement

Use print Statement to print a String to standard output.

print Expression;

Expression must be String Type.

If Expression is Undefined Value, do nothing.

expression Statement

The expression Statement is a Statement consisting of Expression and ";".

Expression;

An example of an expression statement.

1;
$var;
1 + 2;
foo ();
my $num = 1 + 2;

empty Statement

An empty statement is a statement that ends with just ";".

Type

Type Summary
Type Initial Value
void Type
Numeric Type
Integral Type
byte Type
short Type
int Type
long Type
Floating Point Type
float Type
double Type
Class Type
Object Type
Numeric Object Type
Undefined Type
Class Type
Callback Type
Any Object Type
self Type
Array Type
Numeric Array Type
byte[] Type
Object Array Type
Multi Numeric Array Type
Any Object Array Type
String Type
String Type
Multi Numeric Type
Reference Type
Numeric Reference Type
Multi Numeric Reference Type

Type Summary

SPVM is a static type language. All data has a static type.

Local Variable Declaration, Field Definition, Class Variable Definition, and Arguments and Return Value of Method Definition must specify Type.

In Local Variable Declaration, Type Inference can be used.

Type Initial Value

Local Variable Initial Value,Class Variable Initial Value,Create Objectã«ãããFieldã®åæå¤ã¯,Type Initial Valueã«ãã£ã¦æ±ºã¾ãã¾ãã

A list of Type Initial Value. All Bit columns in the data are set to 0.

Type Name	Initial Value
byte	0
short	0
int	0
long	0
float	0
double	0
Object Type	undef
Multi Numeric Type	All Field is 0

Numeric Type

Numeric Type is Integral Type or Floating Point Type.

Integral Type

Integral Type are the following four types.

Type	Description	Size
byte	signed 8-bit integer type	1 byte
short	signed 16-bit integer type	2 bytes
int	signed 32-bit integer type	4 bytes
long	signed 64-bit integer type	8 bytes

See Arithmetic Operator for integer calculation rules. Note that SPVM has only singed Integral Type, and don't has unsigned Integral Type.

byte Type

byte Type is Integral Type that represents a signed 8-bit integer. It is the same Type as int8_tType of C99.

short Type

byte Type is Integral Type that represents a signed 16-bit integer. It is the same Type as int16_tType of C99.

int Type

int Type is a type that represents signed 32-bit integer. This is same as C99 int32_t Type. This is a Integral Type.

long Type

long Type is Integral Type that represents a signed 64-bit integer. It is the same Type as int64_tType of C99.

Floating Point Type

Floating Point Type are the following two.

Type	Description	Size
float	Single precision (32bit) floating po int Type	4 bytes
double	Double precision (64bit) floating po int Type	8 bytes

See Arithmetic Operator for floating-point calculation rules.

float Type

Floating Point Type It is the same Type as float Type of C99.

double Type

double Type represents a double precision floating point (64bit) Floating Point Type It is the same Type as double Type of C99.

Class Type

Class Type is the Type defined by Class Definition.

class Foo {

}

Class Type is Class Type Callback Type Multi Numeric Type.

# Class Type
class Foo {

}

# Callback Type
class Foo: callback_t {

}

# Multi Numeric Type
class Foo: mulnum_t {

}

Pointer Type is also Class Type, so Pointer Type will also be Class Type.

# Pointer Type
class Foo: pointer_t {

}

Object Type

What is Object Type Class Type Callback Type Array Type String Type Any Object Type It is a combination of a>. "Multi Numeric Type" and "Reference Type" are not included.

The Object Type value can be assigned to "Any Object Type".

my $object: object = new Foo;
my $object: object = new Foo [];
my $object: object = "abc";

The size of Object Type must match the value of "sizeof (void *)" in C99.

Numeric Object Type

Numeric Object Type are the following six.

Type	Description
Byte	Numeric Object Type with byte Type data
Short	Numeric Object Type with short Type data
Int	Numeric Object Type with int Type data
Long	Numeric Object Type with long Type data
Float	Numeric Object Type with float Type data
Double	Numeric Object Type with double Type data

For the conversion between Numeric Type and Numeric Object Type, see Type Conversion.

Undefined Type

Undefined Type is the Type that Undefined Value has. It cannot be used explicitly.

The only Undefined Type value is Undefined Value.

The value of Undefined Type can be assigned to Object Type.If you assign to another Type, Compile Error occurs

Class Type

Class Type is the Type defined by Class Definition and is not "Multi Numeric Type" "Callback Type".

packag Foo {

}

Class Type can create objects by new Operator.

my $foo = new Foo;

Class Type is a Object Type.

Class Type is a Class Type.

Pointer Type is the Class Type.

Pointer Type

Pointer Type is the one that "pointer_t Descriptor" is specified in Class Definition.

class Foo: pointer_t {

}

Pointer Type is a type of Class Type.

Pointer type data can store C language pointers.

Field cannot be defined for Pointer Type. If it is defined, Compile Error occurs

Callback Type

Callback Type is a Class Type with Class Descriptor "callback_t".

class Comparator: callback_t {
  method: int ($x1: object, $x2: object);
}

Callback Type is designed to provide a feature corresponding to Function Pointer in C language. Callback Type must have only one Method Definition. Method must be Method. Method Name of Callback Type must be anonymouse. Callback Type must not have any Field Definition and Class Variable Definition. Callback Type is a Object Type. Callback Type cannot be the operand of new Statement. The variable of Callback Type can be assigned a Class Type object that matches the Callback Type. "Matches the Callback Type" means the following two cases. 1. Class Type object with anonimouse name and the Signature is same as Callback Type

# Callback Type Definition
class Comparator: callback_t {
  method: int ($x1: object, $x2: object);
}

# Class Definition
class SomeComparator {
  static method new: int () {
    return new SomeComparator;
  }

  method: int ($x1: object, $x2: object) {

  }
}

# The object can be assign to the variable of Callback Type
my $comparator: Comparator = SomeComparator->new;

2. Class Type object which is created by Create Callback Object and the Signature is same as Callback Type.

Definition of #Callback Type
class Comparator: callback_t {
  method: int ($x1: object, $x2: object);
}

# The object which is created by Create Callback Object can be assign to the variable of Callback Type
my $comparator : Comparator = method: int ($x1: object, $x2: object) {

}

Any Object Type

Any Object Type is represented by "object". Designed to represent the "void *" Type in C.

my $object: object;

You can methodstitute the value of "Object Type" for Any Object Type.

my $object: object = new Foo;
my $object: object = "abc";
my $object: object = new Foo [3];

self Type

self Type represents the Class Type to which it belongs, and indicates that the argument is Invocant.

self

It can only be used as the Type of the first argument in Method Definition.

void Type

void Type is a special Type that can only be used in Return Type of Method Definition and indicates the Method has no Return Value.

void

Basic Type

A Type that does not have dimensions is called a Basic Type. Numeric Type, Class Type , Any Object Type, String Type is a Basic Type.

Array Type

Array Type represents multiple continuous data areas. Basic Type can be an Array.

int[]
double[]
Point[]
object[]
string []

Array has dimensions and can express up to 255 dimensions.

# Two dimensions
int[] []

# Three-dimensional
int[] [] []

Array Type is Object Type.

Use new Operator to create an Array. In the following example, int Type Array with 3 elements is created.

my $nums = new int [3];

You also use new Operator when creating a multidimensional Array.The following example creates an Array of int[] Type with 3 elements.

my $nums = new int[] [3];

Numeric Array Type

Numeric Array Type means Numeric Type with the element Array Type It is.

Numeric Array Type list

byte[]
short[]
int[]
long[]
float[]
double[]

Data represented by Numeric Array Type must have elements whose size is Numeric Type, and must be consecutive by the number of Array Length.

All elements of Numeric Array Type are initialized by Type Initial Value when Create Array is performed.

byte[] Type

In SPVM, the byte[] Type is a special Type in that it is String Type.

byte[]

String Type is treated as String Type at compile time, but at runtime It will be byte[] Type.

Object Array Type

Object Array Type is Array Type that has the value of Object Type as an element. It is.

Object Array Typeã®Example

Foo[]
Foo[][]
Comparable[]
object[]

The data represented by Object Array Type must have elements of size of Object Type and consecutive by the number of Array Length.

All elements of Object Array Type are initialized by Type Initial Value when Create Array is performed.

Multi Numeric Array Type

Multi Numeric Array Type means Array Type that has the value of Multi Numeric Type as an element..

Multi Numeric Array Type Example

Complex_2d[]
Complex_2f[]

Data represented by Multi Numeric Array Type must have elements whose size is Multi Numeric Type and must be contiguous with the number of Array Length ..

All elements of Multi Numeric Array Type are initialized by Type Initial Value when Create Array is performed.

Any Object Array Type

Any Object Array Type is an arbitrary Object Type expressed as an oarray as an element. A Type that can be assigned the value of array ">Array Type. Any Array Type can be cast to void * Type and passed to the first argument of the C language qsort function, but Any Object Array Type is not designed to realize the function corresponding to this. It was

my $array : oarray = new Point[3];
my $array : oarray = new object[3];

If a value with a Type other than Object Type is assigned, Compile Error occurs

Note that "oarrayType" is a different Type than "object[] Type". While oarrayType is a Type that can be methodstituted with an arbitrary Array Type value that has an Object Type value as an element, "object[] Type" is a Type that represents an "Array that has an objectType value as an element". Therefore, the value of arbitrary Array Type cannot be assigned.

Any Object Array Type is Array Type. Array Length Operator to get length, Set Array Element You can use Value, Get Array Element Value.

my $array : oarray = new Int[3];

# Get the length of the element of Any Object Array Type
my $length = @$array;

# Get the value of any object array type element
my $num = (Int)$array->[0];

# Setting the value of the element of Any Object Array Type
$array->[0] = Int->new(5);

When setting the value of the element of Any Object Array Type, a check is made at runtime whether the Type of the element is smaller than the Type Dimension of Array by 1. If the check fails, Exception will occur. Any Object Array Type guarantees runtime Type safety.

String Type

String Type is a Type that represents a String. Expressed by string. Designed to represent C "const char *".

my $str : string;

String Literal allows you to assign the generated String object.

my $str : string = "abc";

SPVM String is an Array of bytes whose elements cannot be changed. You can get the Character by accessing the Array.

# Acquisition of Character
my $ch = $str->[1];

If you try to change the element, Compile Error occurs

# Compile Error when changing element
$str->[1] = 'd';

String Type will be exactly the same as the Array of bytes Type after compilation. For example, the first expression is treated as the second expression.

# isa String Type
if ($str isa string) {

}

# isa byte[] Type
if ($str isa byte[]) {

}

Note that SPVM Strings are immutable, but this is a compile-time check.

String Type can be cast to byte[] Type, and the String can be changed at runtime.

my $bytes = (byte[])$str;
$bytes->[1] = 'd';

Treat String as if you can always change it.

String Type

String Type is a combination of String Type and byte[] Type. Say that.

When a String Type value is generated, it is guaranteed that the last one after the last memory area reserved for the value will be "\ 0". (For example, if it is "abc", "c" is followed by "\ 0".) From the SPVM language, this "\ 0" has no meaning, but when using the native API, String Type is It can be handled as a C language String.

Multi Numeric Type

Multi Numeric Type is a type that can represent continuous numerical values.

Multi Numeric Type can be defined by specifying "mulnum_t" Descriptor in Class Definition.

class Point_3i : mulnum_t {
  has x : int;
  has y : int;
  has z : int;
}

See Values ââ for a detailed explanation of Multi Numeric Type.

Reference Type

Reference Type is a Type that can store the address of a variable. Add "&" after Numeric Type or Multi Numeric Type You can define it.

my $num : int;
my $num_ref : int& = \$num;

my $point : Point_3i;
my $point_ref : Point_3i& = \$point;

Only the address of the Local Variable acquired by Reference Operator can be assigned to the value of Reference Type.

If only Local Variable Declaration of Reference Type is performed, Compile Error occurs

Reference Type can be used as Type of Local Variable Declaration. The address of the Local Variable must be stored by the Reference Operator. In case of only Local Variable Declaration, Compile Error occurs

Reference Type can be used as Type of argument in Method Definition.

Reference Type cannot be used as Return Value Type in Method Definition.

Reference Type cannot be used as the Type of Field in Class Definition.

Reference Type cannot be used as the Type of Class Variable in Class Definition.

If the Reference Type is used at an Invalid location, Compile Error occurs

See Reference for a detailed explanation of Reference.

Numeric Reference Type

Numeric Reference Type means Numeric Type for Reference Type. Says.

Multi Numeric Reference Type

Multi Numeric Reference Type means Reference Type for Multi Numeric Type variables. > Means.

Type Inference

Omitting Type when Local Variable Declaration by Type Inference can. Type Inference is always performed by the Type on the Right side of Assignment Operator.

# int
my $num = 1;

# double
my $num = 1.0;

# Foo
my $foo = new Foo;

Type Compatibility

Type compatibility means that the value can be moved without performing Type Cast.

Types are compatible in the following cases.

When the source and destination types are the same

If the source and destination types are the same, there is Type Compatibility.

my $num1 : int;
my $num2 : int;
$num1 = $num2;

When the source Type is byte[] Type and the destination Type is String Type

If the source Type is byte[] Type and the destination Type is String Type, there is Type Compatibility.

my $bytes = new byte[3];
my $str : string;
$str = $bytes;

When the source Type is Object Type and the destination Type is Any Object Type

my $foo : Foo = new Foo;
my $object : object;
$object = $foo;

When the source Type and destination Type are Any Object Type or Any Object Type Array and the source Type Dimension count is greater than or equal to the destination Type Dimension count

my $objects_dim2_src : object[];
my $objects_dim1_dist : object;
$objects_dim1_dist = $objects_dim2_src;

Note that the general object Array and the Basic Type Array are not compatible.

# Compilation error
my $objets : object[] = new int[3];

If the types are not compatible, implicit Type Conversion is tried. If the implicit Type Conversion fails, Compile Error occurs

Type Conversion

Type Cast
Implicit Type Conversion
Numeric Type Conversion
Numeric Type Order
Unary Numeric Widening Type Conversion
Binary Numeric Widening Type Conversion
Numeric Narrowing Type Conversion
Numeric Widening Type Conversion
Numeric-to-String Type Conversion
String-to-byte[] Type Conversion
byte[]-to-String Type Conversion
Boxing Type Conversion
Unboxing Type Conversion
Bool Type Conversion

Type Cast

Type Cast is Type Conversion that is explicitly described.

# Type Cast
(TYPE)EXPRESSION

int Type value is converted to long Type Become.

my $num = (long)3;

ype Cast returns Expression.

If the source Type and the specified Type are the same, the value is simply copied.

my $num : int = (int)4;

List of Type Conversion in Type Cast

It is a list of Type Conversion in Type Cast. If a Type Cast not listed in this table is performed, Compile Error occurs.

The specified Type	Source type	Content of conversion
byte[]	string	The address value is copied.
string	byte[]	The address value is copied.
Numeric Type	Numeric Type	Numeric Type Conversion is performed.
Numeric Object Type	Numeric Type	Boxing Type Conversion is performed. Numeric Type represented by Numeric Type and Numeric Object Type must be the same. For example, if Numeric Type is int, Numeric Object Type must be Int Type.
Any Object Type	Numeric Type	Boxing Type Conversion is performed.
Numeric Type	Numeric Object Type	Unboxing Type Conversion is performed. Numeric Type represented by Numeric Type and Numeric Object Type must be the same. For example, if Numeric Type is int, Numeric Object Type must be Int Type.
Numeric Type	Any Object Type	Unboxing Type Conversion is performed.
String Type	Numeric Type	The number is converted to a string using the "%g" format of the C standard sprintf function.

Implicit Type Conversion

Implicit type conversion is automatic type conversion performed by SPVM. The following are the places where implicit Type Conversion may occur.

When assigning to a different Type
When passing to Method Arguments of different Type
When returning a Type different from Return Value

Implicit Type Conversion occurs when:

If both the source and destination Type are Numeric Type and the destination Type is greater than the source Type, Numeric Widening Type Conversion is done.

# Implicit Widening Type Conversion
my $num : long = 123;
my $num : double = 12.5f;

Both the source and destination Type are Numeric Type, and the destination Type is smaller than the source Type, and the source value can be expressed in the range of Integer Literal and destination Type value. Numeric Narrowing Type Conversion is performed.

# Implicit Narrowing Type Conversion
my $num : byte = 123;
my $num : short = 134;

If the source Type is Numeric Type and the destination Type is Any Object Type, Boxing Type Conversion to the corresponding Numeric Object Type Is done. In the following case, the converted Int Type object is assigned to the generic object.

# Implicit Boxing Type Conversion to objectType
my $num = 123;
my $object : object = $num;

When the source Type is Numeric Type and the destination Type is the corresponding Numeric Object Type, Boxing Type Conversion to the corresponding Numeric Object Type a> is done.

# Implicit Boxing Type Conversion to object Type
my $num = 123;
my $object : Int = $num;

When the source Type is Any Object Type and the destination Type is Numeric Type, Unboxing Type Conversion in the corresponding Numeric Type is displayed. Will be opened. In the following case, an attempt is made to convert the Int Type object to int Type.

# Implicit Unboxing Type Conversion from objectType-
my $object : object;
my $num : int = $object;

If the source Type is Numeric Object Type and the destination Type is the corresponding Numeric Type, Unboxing Type Conversion in the corresponding Numeric Type Is done.

# Implicit Unboxing Type Conversion from Numeric Object Type
my $num_obj = Int->new(3);
my $num : int = $num_obj;

If the source Type is Numeric Type and the destination Type is String Type, Numeric-to-String Type Conversion is performed. In the following case, the numerical value "123" is converted to String "" 123 "" and assigned.

# mplicit Boxing Type Conversion to String Type
my $num = 123;
my $str : string = $num;

Numeric Type Conversion

Numeric Type Conversion is the conversion from Numeric Type to Numeric Type. Numeric Type Conversion performs exactly the same processing as Numeric Type Conversion in the corresponding C language. For example, Type Conversion from int to long in SPVM is the same as the type conversion from int32_t Type to int64_t Type in C language.

# SPVM conversion
my $src : int = 5;
my $dist = (long)$src;

# Correspondence in C language
int32_t src = 5;
int64_t dist = (int64_t)src;

See also Corresponding Type with C99. SPVM has two Numeric Type Convertions.

Numeric Narrowing Type Conversion
Numeric Widening Type Conversion

There are some rules for automatic type conversion of Numeric Type.

Unary Numeric Widening Type Conversion
Binary Numeric Widening Type Conversion

Numeric types have an order.

Numeric Type Order

Numeric Type Order

Numeric Type has the order of Type. The order of Type is "byte", "short", "int", "long", "float", "double" from the smallest.

Unary Numeric Widening Type Conversion

Unary Numeric Widening Type Conversion means that Expression is byte Type or short Type. In this case, perform Numeric Widening Type Conversion to int Type I say that.

Unary Numeric Widening Type Conversion is performed in the following cases.

Array Index
Dimension when creating Array
Unary Plus Operator operands
Unary Minus Operator operands
Left and Right operands of Shift Operator "<<" ">>" ">>>"

Binary Numeric Widening Type Conversion

Binary Numeric Widening Type Conversion is applied to Left Expression and Right Expression in Binary Operator that takes Numeric Type on the Left and Right sides. Numeric Widening Type Conversion.

The following rules apply.

1. When one Expression is double Type, the other Type is double Type Is converted to>.

2. If one Expression is float Type, the other Type is float Type Is converted to>.

3. When one Expression is long Type, the other Type is long Type Is converted to>.

4, otherwise, it will be converted to int Type.

Binary Numeric Widening Type Conversion is performed in the following cases.

Addition Operator
Subtraction Operator
Multiplication Operator
Division Operator
Remainder Operator
Bit AND Operator
Bit OR Operator
Numeric Comparison Operator

Numeric Narrowing Type Conversion

Numeric Narrowing Type Conversion is a conversion rule applied when converting from a large type to a small type in Numeric Type.

Numeric Widening Type Conversion

Numeric Widening Type Conversion is a conversion rule applied when converting from a small type to a large type in Numeric Type.

String-to-byte[] Type Conversion

String-to-byte[] Type Conversion is the Type Conversion from String Type to byte[] Type.

# String-to-byte[] Type Conversion
my $string : string = "Hello";
my $bytes : byte[] = (byte[])$string;

A new byte[] Type object is created and all characters in string are copied to the elements of byte[] Type.

byte[]-to-String Type Conversion

byte[]-to-String Type Conversion is the Type Conversion from byte[] Type to String Type.

# byte[]-to-String Type Conversion
my $bytes : byte[] = new byte[3];
$bytes->[0] = 'a';
$bytes->[1] = 'b';
$bytes->[2] = 'c';
my $string : string = (string)$bytes;

A new String Type object is created and all elements in byte[] are copied to the characters of String Type.

Boxing Type Conversion

Boxing Type Conversion is the operation to convert the value of Numeric Type to Numeric Object Type.

Unboxing Type Conversion

Unboxing Type Conversion is an operation to convert the value of Numeric Object Type to the corresponding value of Numeric Type.

Bool Type Conversion

Bool Type Conversion is a conversion applied in the conditional part of if Statement, etc. for True/False Value judgment.

Where Bool Type Conversion takes place

Inside the if statement braces

if (CONDITION) {

}

In unless statement brackets

unless (CONDITION) {

}

The second in the parentheses for

for (INITIALIZEATION;CONDITION;NEXT_VALUE;) {

}

in parentheses while

while (CONDITION) {

}

Left and Right of Logical AND Operator

CONDITION && CONDITION

Left and Right of Logical OR Operator

CONDITION || CONDITION

Right side of Logical NOT Operator

!CONDITION

Expression specified by Bool Type Conversion is Numeric Type or Object Type or It must be Undefined Type, otherwise Compile Error occurs.

Return Value of Bool Type Conversion is Expression of int Type.

If Expression is Undefined Value, 0 is returned.

If Expression is Bool->FALSE, 0 is returned. This is special case of the object of Bool class. false keywords means Bool->FALSE.

If Expression is Bool->TRUE, 1 is returned. This is special case of the object of Bool class. true keywords means Bool->TRUE.

When Expression is Numeric Type, Unary Numeric Widening Type Conversion is done.

If Expression is int Type, that value is returned.

Expression is long Type, float Type, double Type, Object Type, the operation that exactly matches the following operation in C99 is performed and the result is returned.

!!x

If Expression is Object Type, 0 is returned if it is Undefined Value, 1 otherwise.

Bool Type Conversion Examples

if (1) {
  # run
}

if (0) {
  # not run
}

if (1.5) {
  # run
}

if (0.0) {
  # not run
}

if (true) {
  # run
}

if (Bool->TRUE) {
  # run
}

if (false) {
  # not run
}

if (Bool->FALSE) {
  # not run
}

my $object = SPVM::Int->new(1);

if ($object) {
  # run
}

if (undef) {
  # not run
}

Exception

Exception overview
Throw Exception
Catch Exception
Exception Variable

Exception overview

SPVM has a mechanism of Exception. Exception consists of raising Exception and catching the exception.

Throw Exception

Use die Statement to throw Exception.

die EXPRESSION;

Expression must be String Type.

When the die statement is executed, the stack trace and the String specified by Expression are displayed, and the program ends. The stack trace includes Class Name, Method Name, File Name and line number. File Name is a relative File Name from the path where Module is loaded.

Error
from TestCase::Minimal->sum2 at SPVM/TestCase/Minimal.spvm line 1640
from TestCase->main at SPVM/TestCase.spvm line 1198

Catch Exception

Exception catching is a function that can stop the program from ending and get an error message when Exception is thrown.

Exceptions are caught using eval Block Statement. Please note that the eval Block Statement requires a semicolon at the end.

eval {
  # Processing that may throw Exception
};

When Exception is caught by the eval Block, the program termination is stopped and is added to Exception Variable. The message specified in Exception is thrown is methodstituted.

Exception Variable

Exception Variable is a global variable that is represented by "$@"

$@

See Get Exception Variable Value to get Exception Variable Value. See Set Exception Variable Value to set Exception Variable Value.

Garbage Collection

The object is released from memory when the Reference Count reaches 0.

If the object is an Array that has Object Type values ââas elements, the Reference Count of all Array elements that are not Undefined Value is decremented by 1 before Garbage Collection

When an object is a Class Type and has a Field of Object Type, the Reference Count of the objects owned by all Fields of Object Type that are not Undefined Value is decremented by 1 before Garbage Collection. If Weaken Reference is set to the object saved in Field, Weaken Reference is released before Reference Count is decremented by 1.

When the object has Back references of Weaken Reference, Undefined Value is assigned to all Fields registered as back References and all back References are deleted.

The above process is done recursively.

Callback

Create Callback Object
Capture

Callback Type in SPVM is a Class Type in which only one unnamed Method with no implementation is defined. If callback_tDescriptor is specified in Class Definition, it becomes Callback Type.

The purpose of Callback Type is to provide a Type that can be assigned to different objects when they have the same MethodDefinition. Consider that the function corresponding to the C function pointer is realized in SPVM.

class Foo1 {
  static method new : Foo1 () {
    new Foo1;
  }
  method : int ($num : int) {
    return 1 + $num;
  }
}

class Foo2 {
  static method new : Foo2 () {
    new Foo2;
  }
  method : int ($num : int) {
    return 2 + $num;
  }
}

class FooCallback : callback_t {
method : int ($num : int);
}

Foo1 and Foo2 have the same MethodDefinition "method: int ($num: int)". Now suppose you want to selectively call the Foo1 or :Foo2 Method.

In this case, if you define a Callback Type FooCallback with the same MethodDefinition, you can assign either object to this Type. Then you can call Method from this object.

my $foo1 = Foo1->new;
my $foo2 = Foo2->new;

my $foo : FooCallback;

my $flag = 1;
if ($flag) {
  $foo = $foo1;
}
else {
  $foo = $foo2;
}

my $ret = $foo->(5);

If $flag is 1, the anonymous Method of Foo1 is called, otherwise the anonymous Method of Foo2 is called.

For more information on Callback Type, see Callback Type.

Create Callback Object

Create Callback Object is a Syntax that creates an object that conforms to Callback Type by using a special syntax for the purpose of Callback.

method : TYPE_NAME  (ARGS1 : TYPE1, ARGS2 : TYPE2, ARGSN : TYPEn) {

}

When Create Callback Object is performed, Class Definition is performed internally, an object based on that Class is generated, and Expression. It is possible to assign to a variable like the following.

my $cb_obj = method : TYPE (ARGS1 : TYPE1, ARGS2 : TYPE2, ..., ARGSn : TYPEn) {

};

Method defined by Create Callback Object must be Method. It must also be a Method with no name.

Create Callback Object Example

my $comparator = method : int ($x1 : object, $x2 : object) {

}

You can call Method because the object created by Create Callback Object is a normal object. For the call to Create Callback Object, see Method Call.

Capture

In Create Callback Object, you can use the syntax called Capture to use the variables defined outside the Method defined by Create Callback Object inside the Method defined by Create Callback Object.

# Capture
[VariableName1 : Type1, VariableName2 : Type2] method Method Name : int ($x1 : object, $x2 : object) {

};

Capture Example.

my $foo = 1;
my $bar = 5L;

my $comparator = [$foo : int, $bar : long] method : int ($x1 : object, $x2 : object) {

  print "$foo\n";
  print "$bar\n";
}

The variable name used in Capture must be the one with "$" added at the beginning of Field Name.

The Capture is actually defined as a Field of Class. Capture is a field definition and value setting syntax sugar.

If Local Variable with the same name as the Capture variable exists in the Scope, access the Local Variable.

If there is a Class Variable with the same name as the Capture variable, access the Capture variable.

If you write Create Callback Object and Capture without using syntax sugar, it will be as follows.

class ComapartorImpl {
  has foo : int;
  has bar : long;

  method : int ($x1 : object, $x2 : object) {
    print $self->{foo} . "\n";
    print $self->{bar} . "\n";
  }
}

my $foo = 1;
my $bar = 5L;

my $comparator = new ComparatorImpl;

$comparator->{foo} = $foo;
$comparator->{bar} = $bar;

Capture is a syntax for writing such a long description short.

Weaken Reference

Weaken Reference is a reference that does not increase the Reference Count. Weaken Reference can be used to solve the problem of circular references.

SPVM has GC of Reference Count Type. In the GC of Reference Count Type, the object is automatically released when the Reference Count becomes 0, but when the circular reference occurs, the Reference Count does not become 0 and the object is automatically released. not.

This is an Example when the Field of the object is circularly referenced.

{
  my $foo = new Foo;
  my $bar = new Bar;

  $foo->{bar} = $bar;
  $bar->{foo} = $foo;
}

In this case, both objects are not released when the Scope ends. This is because a circular reference has occurred and the Reference Count does not become 0.

Weaken Reference is a function to correctly destroy objects when a circular reference occurs in a programming language that has a Reference Count GC.

In such a case, it is possible to release correctly by setting one Field to Weaken Reference using weaken Statement.

{
  my $foo = new Foo;
  my $bar = new Bar;

  $foo->{bar} = $bar;
  $bar->{foo} = $foo;

  weaken $foo->{bar};
}

Before the weaken statement is executed, $foo has a Reference Count of 2 and $bar has a Reference Count of 2.

If there is no weaken statement, the reference count of $foo and the reference count of $bar will not be 0 and will not be released even if the scope ends.

When a weaken statement is executed, $foo has a Reference Count of 2 and $bar has a Reference Count of 1.

When the Scope ends, the Reference Count of $bar is decremented by 1 and becomes 0, so it is released correctly.

Even if there are 3 circular references, you can release them correctly by setting Weaken Reference in 1 Field.

{
  my $foo = new Foo;
  my $bar = new Bar;
  my $baz = new Baz;

  $foo->{bar} = $bar;
  $bar->{baz} = $baz;
  $baz->{foo} = $foo;

  weaken $foo->{bar};
}

As a syntax related to Weaken Reference, Weaken Reference can be released weaken Statement, and it can be confirmed whether Field is Weaken Reference isweak Operator.

Default loaded modules

SPVM loads the following modules just after the program start. These modules are deeply relataed to core features, such as type conversion.

To install SPVM, copy and paste the appropriate command in to your terminal.

cpanm

cpanm SPVM

CPAN shell

perl -MCPAN -e shell
install SPVM

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)