SPVM Language Specification

SPVM Language Specification is described in this document. Version is 1.0.

Last modified 2020-06-24

C99 compliant

C99 compliant compiler and runtime

The source code of the SPVM compiler and SPVM runtime is written in C and conforms to C99.

Note that this does not mean that users cannot call the functions of C versions other than C99 (C11, GNU extensions, etc.) or call the functions of C++ from SPVM.

This means that the SPVM compiler and runtime must be C99 compliant.

Type correspondence with C99

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

SPVM type C99 type Description
byte int8_t SPVM byte type matches C99 int8_t type.
short int16_t SPVM short type matches the C99 int16_t type.
int int32_t SPVM int Type matches the C99 int32_t type.
long int64_t SPVM long type matches C99 int64_t type.
float float SPVM float type matches the C99 float type.
double double SPVM double type matches C99 double.
Object type void* SPVM Object Type matches the C99 void* type.
Multiple Numeric Type Numeric Array Type that matches the type and length in SPVM multiple Numeric Type fields

For example, if SPVM multiple Numeric Type

package Point_2i: mulnum_t {has x: int; has y: int;}

matches the type declared in C99

int32_t var[2];

Lexical Analysis

This topic specifies the Lexical Analysis of the SPVM language.

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 Package Name, Subroutine Name, Field Name, Package Variable Name, and Lexical Variable Name.

Package Name

Package Name is one or more alphabet(a-zA-Z), number(0-9), underscore(_) or "::" of ASCII Code.

It is not necessary to include "::" in the Package Name.

Package Name must start a uppercase letter in ASCII Code

"::" cannot be continued twice. Last characters cannot end with "::".

Underscore cannot be continued twice.

# Valid Package Name
Foo
Foo::Bar
Foo::Bar::Baz3
Foo::bar
Foo_Bar::Baz_Baz

# Invalid Package Name
foo
_Foo
Foo::Bar::
Foo__Bar

If Package Name is invalid, Compilation Error occurs.

Subroutine Name

Subroutine 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 Subroutine Name
FOO
FOO_BAR3
foo
foo_bar
_foo
_foo_bar_

# Invalid Subroutine 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

Package Variable Name

Package 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 Package Variable Name
$FOO::BAR
$Foo::Bar3
$FOO
$FOO_BAR
$foo

# Invalid Package Variable Name
$FOO__BAR
$3FOO

Lexical Variable Name

Lexical Variable Name starts with "$", followed more alphabet characters of ASCII Code.

Followed character must not start with number.

Underscore cannot be continued twice.

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

# Invalid Lexical 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 package private
public precompile pointer_t return require rw ro self switch
sub string short scalar undef unless use void mulnum_t while
weaken wo __END__ __PACKAGE__ __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 Package Variable Name and Lexical 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.

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

Syntax Parsing

Syntax Parsing Definition

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

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

%type <opval> grammar
%type <opval> opt_packages packages package package_block refcnt
%type <opval> opt_declarations declarations declaration
%type <opval> enumeration enumeration_block opt_enumeration_values enumeration_values enumeration_value
%type <opval> sub cb_obj opt_args args arg invocant has use require our string_length
%type <opval> opt_descriptors descriptors sub_names opt_sub_names
%type <opval> opt_statements statements statement if_statement else_statement 
%type <opval> for_statement while_statement switch_statement case_statement default_statement
%type <opval> block eval_block begin_block switch_block if_require_statement
%type <opval> unary_op binary_op num_comparison_op str_comparison_op isa logical_op
%type <opval> call_sub opt_vaarg
%type <opval> array_access field_access weaken_field unweaken_field isweak_field convert array_length
%type <opval> deref ref assign inc dec allow
%type <opval> new array_init
%type <opval> my_var var
%type <opval> expression opt_expressions expressions opt_expression case_statements
%type <opval> field_name sub_name
%type <opval> type basic_type array_type array_type_with_length ref_type  type_or_void

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

%%

grammar
: opt_packages

opt_packages
:	/* Empty */
|	packages

packages
: packages package
| package

package
: PACKAGE basic_type package_block
| PACKAGE basic_type ':' opt_descriptors package_block
| PACKAGE basic_type ';'
| PACKAGE basic_type ':' opt_descriptors ';'

package_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_sub_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
: sub_name
| sub_name ASSIGN CONSTANT

our
: OUR PACKAGE_VAR_NAME ':' opt_descriptors type

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

sub
: opt_descriptors SUB sub_name ':' type_or_void '(' opt_args opt_vaarg')' block
| opt_descriptors SUB sub_name ':' type_or_void '(' opt_args opt_vaarg')' ';'

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

opt_args
:	/* Empty */
|	args
| invocant
| invocant ',' args

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

arg
: var ':' type

opt_vaarg
: /* Empty */
| DOT3

invocant
: var ':' SELF

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 ';' opt_expression ')' block

while_statement
: WHILE '(' expression ')' 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 ')' block else_statement
| UNLESS '(' expression ')' block else_statement

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

block 
: '{' opt_statements '}'

eval_block
: EVAL block ';'

opt_expressions
:	/* Empty */
|	expressions

opt_expression
: /* Empty */
| expression

expression
: var
| EXCEPTION_VAR
| package_var_access
| CONSTANT
| UNDEF
| call_sub
| field_access
| array_access
| convert
| new
| array_init
| array_length
| string_length
| refcnt
| my_var
| binary_op
| unary_op
| ref
| deref
| assign
| inc
| dec
| '(' expressions ')'
| CURRENT_PACKAGE
| isweak_field
| num_comparison_op
| str_comparison_op
| isa
| logical_op

refcnt
: REFCNT var
expressions
: expressions ',' expression
| expressions ','
| expression

unary_op
: '+' expression %prec PLUS
| '-' expression %prec MINUS
| BIT_NOT expression

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

num_comparison_op
: expression NUMEQ expression
| expression NUMNE expression
| expression NUMGT expression
| expression NUMGE expression
| expression NUMLT expression
| expression NUMLE expression

str_comparison_op
: expression STREQ expression
| expression STRNE expression
| expression STRGT expression
| expression STRGE expression
| expression STRLT expression
| expression STRLE expression

isa
: expression ISA type

logical_op
: expression LOGICAL_OR expression
| expression LOGICAL_AND expression
| LOGICAL_NOT expression

assign
: expression ASSIGN expression
| expression SPECIAL_ASSIGN expression

new
: NEW basic_type
| NEW array_type_with_length
| cb_obj

array_init
: '[' opt_expressions ']'

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

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

call_sub
: NAME '(' opt_expressions  ')'
| basic_type ARROW sub_name '(' opt_expressions  ')'
| basic_type ARROW sub_name
| expression ARROW sub_name '(' opt_expressions ')'
| expression ARROW sub_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 '}'

string_length
: LENGTH expression

deref
: DEREF var

ref
: REF var

my_var
: MY var ':' type
| MY var

var
: VAR_NAME

package_var_access
: PACKAGE_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

sub_name
: NAME

opt_sub_names
:	/* Empty */
|	sub_names

sub_names
: sub_names ',' sub_name
| sub_names ','
| sub_name
%%

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

Tokens in yacc/bisonKeywords and Operators in SPVM
PACKAGEpackage
SUBsub
OURour
ENUMenum
MYmy
SELFself
USEuse
REQUIRErequire
ALLOWallow
DESCRIPTORdescriptor
IFif
UNLESSunless
ELSIFelsif
ELSEelse
FORfor
WHILEwhile
LASTlast
BREAKbreak
NEXTnext
SWITCHswitch
CASEcase
DEFAULTdefault
EVALeval
NAMEname
VARvar
CONSTANTLiteral
PACKAGE_VAR_NAMEPackage Variable Name
EXCEPTION_VAR$@
UNDEFundef
VOIDvoid
BYTEbyte
SHORTshort
INTint
LONGlong
FLOATfloat
DOUBLEdouble
STRINGstring
OBJECTobject
DOT3...
FATCAMMA=>
RWrw
ROro
WOwo
INITINIT
NEWnew
RETURNreturn
WEAKENweaken
DIEdie
WARNwarn
PRINTprint
CURRENT_PACKAGE__PACKAGE__
UNWEAKENunweaken
ASSIGN=
SPECIAL_ASSIGN+= -= *= /= &= |= ^= %= <<= >>= >>>= .=
LOGICAL_OR||
LOGICAL_AND&&
BIT_OR|
BIT_XOR&
NUMEQ==
NUMNE!=
STREQeq
STRNEne
NUMGT>
NUMGE>=
NUMLT<
NUMLE<=
STRGTgt
STRGEge
STRLTlt
STRLEle
ISAisa
SHIFT<< >> >>>
MULTIPLY*
DIVIDE/
REMAINDER%
LOGICAL_NOT!
BIT_NOT~
REF\
DEREF$
PLUS+
MINUS-
CONVERT(TypeName)
SCALARscalar
LENGTHlength
ISWEAKisweak
REFCNTrefcnt
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.

Package

Package Definition

Package Definition is the following syntax.

package PACAKGE_NAME {

}

PACAKGE_NAME must follow the rule for Package Name.

Package Descriptor can be specified by the following syntax.

package PACAKGE_NAME : PACAKGE_DESCRIPTOR {

}

package PACAKGE_NAME : PACAKGE_DESCRIPTOR1 PACAKGE_DESCRIPTOR2 PACAKGE_DESCRIPTORN {

}

Package Definition Example:

# Package Name
package Point {

}
# Package Name and Package Descriptor
package Point : public {

}

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

package Foo {
  # use
  use Point;

  # Package Variable Definition
  our $VAR int;

  # Field Defintion
  has var : int;

  # Enumeration Definition
  enum {
    CONST_VAL1,
    CONST_VAL2,
  }

  # Subroutine Definition
  sub foo : int ($num : int) {

  }
}

If more than one package with the same name is defined, Compilation Error occurs.

Package Descriptor

The descriptions of Package Descriptors.

Descriptor Meaning
public This package is public. Other packages can new this package.
private This package is private. Other packages can't new this package. This is default setting.
callback_t This package is Callback Type.
mulnum_t This package is Multi Numeric Type.
pointer_t This package is Pointer Type.

If both "public" and "private" are specifed, Compilation Error occurs.

If more than one of "callback_t", "mulnum_t", "pointer_t" are specified, Compilation Error occurs.

Destructor

If the package is Class Type, the package defined a destructor.

Destructor is a special Subroutine called when the object of this class is freed.

Destructor name must be "DESTROY".

Destructor Retrun Value must be void Type, otherwise Compilation Error occurs.

Destructor arguments must be one and the type must be self Type, otherwise Compilation Error occurs.

sub DESTROY : void ($self : self) {

}

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

Destructor Example:

package Foo {
  sub new : Foo {
    return new Foo;
  }

  sub DESTROY : void ($self : self) {
    print "DESTROY";
  }
}

Allow Package Access

By default, private Subroutines, Fields, and Package Variables cannot be accessed from outside the Package.

Also, Private Package cannot Create Object from outside of Package.

If the package allow other package, the other package can access private Subroutines, Fields, and Package Variables, and can Create Object of the package.

allow PACKAGE_NAME;

allow must be defined directory under Package Definition.

package Foo {
  allow Bar;
}

In this example, Bar can access the private Subroutine, Field, and Package 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 is a single file that can be read as SPVM source code.

# lib/path/Foo/Bar.spvm
package Foo::Bar {

}

Module can contain multiple Packages.

# lib/path/Foo/Bar.spvm
package Foo::Bar {

}

package 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.

Foo.spvm
Foo/Bar.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, Compilation Error will occur.

use Keyword must be defined directly under Package Definition.

package Foo {
  use Foo;
}

Automatically Loaded Module

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

  • SPVM::Byte
  • SPVM::Short
  • SPVM::Int
  • SPVM::Long
  • SPVM::Float
  • SPVM::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 Compilation Error occurs and it is assumed that there is no if block

Therefore, "$foo = new Foo;" does not result in Compilation 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";
}

Package Variable

Package Variable Definition

Package Variable is a global variable that belongs to Package and exists from the start to the end of the program execution.

"our" Keyword defines a Package Variable.

our PACKAGE_VARIABLE_NAME : TYPE;

Package Variable must be defined directly under Package Definition.

Package Variable Definition must specify Type. The Type must be Numeric Type or Object Type.

Package Variable Name must follows the rule specified in Package Variable Name, and must not contain "::", otherwise Compilation Error occurs.

If more than one Package Variable with the same name is defined, Compilation Error occurs.

Package Variable Descriptor can be specified together in Package Variable definition.

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

Package Variable Descriptor

List of Package Variable Descriptors.

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

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

If more than one of "ro", "wo", and "rw" are specified at the same time, Compilation Error occurs

Read Accessor of Package Variable has no arguments and the return type is same as the type of Package Variable.

Write Acessor of Package Variable has one argument and the type is same as the type of Package 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 Package Variable Accessors.

Package Variable Definition Example:

package 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;
}

Package Variable Initial Value

Package Variable is initialized with Type Initial Value after compilation and before execution.

This initial value can be changed by using INIT Block.

package Foo {
  our $VAR : int;

  INIT {
    $VAR = 3;
  }
}

Package Variable Access

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

See Get Package Variable Value for how to get the value of Package Variable.

See Set Package Variable Value for the setting of the value of Package Variable.

Field

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 Package 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 Compilation Error occurs.

If more than one Field Name Variable with the same name is defined, Compilation 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 package.
private This field is private. This field can't be accessed from other package. 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, Compilation Error occurs.

If more than one of "ro", "wo", and "rw" are specified at the same time, Compilation 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 Package 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:

package 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 Subroutine.

my $z : SPVM::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 : SPVM::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.

Subroutine

Subroutine Definition

"sub" Keyword defines Subroutine.

sub SUBROUTINE_NAME : RETURN_VALUE_TYPE_NAME () {

}
sub SUBROUTINE_NAME : RETURN_VALUE_TYPE_NAME (ARGUMENT_NAME1 : ARGUMENT_TYPE_NAME1, ARGUMENT_NAME2 : ARGUMENT_TYPE_NAME2, ARGUMENT_NAMEN : ARGUMENT_TYPE_NAMEN) {

}

Subroutine must be defined directly under Package Definition.

Subroutine name must be follow the rule of Subroutine Name.

Subroutine Name is allowed as same as Keyword.

Type of Return Value must be void Type, Numeric Type, or Object Type, otherwise Compilation Error occurs.

Argument name must be follow the rule of Lexical 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 Compilation Error occurs.

The defined Subroutine can be called. See Subroutine Call about calling Subroutine, .

Subroutine Block can have zero or more Statements.

Subroutine Definition can have Subroutine Descriptor.

DESCRIPTOR1 DESCRIPTOR2 DESCRIPTORN sub SUBROUTINE_NAME : RETURN_VALUE_TYPE_NAME () {

}
DESCRIPTOR1 DESCRIPTOR2 DESCRIPTORN sub SUBROUTINE_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.

sub SUBROUTINE_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
sub sprintf : string ($format : string, $values : object[]...) {

}

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

Variable Length Argument can recieve Array.

# Call Variable Length Argument Subroutine 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]);

Subroutine Descriptor

List of Subroutine Descriptor.

Descriptor Description
native This Subroutine is Native Subroutine.
precompile This Subroutine is Precompiled Subroutine.

If both "native" and "precompile" Descriptors are specified, Compilation Error occurs

Native Subroutine

Native Subroutine is Subroutine that call function written in Native Language(C, C++, etc).

See SPVM Native API Native Subroutine.

Precompiled Subroutine

Precompiled Subroutine is a subroutine translated into C language and converted into machine code.

Precompiled Subroutine needs Build Directory described in SPVM Native API

Constant Subroutine

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

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

Inline Expansion optimization is performed to Constant Subroutine.

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 Subroutine.  Inline Expansion is not performed
sub foo : int () { return 5 + 3; }

Method

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

sub SUB_NAME : TYPE  ($self : self, ARGUMENT2 : TYPE2, ARGUMENT3 : TYPE3, ARGUMENTN : TYPEn) {

}

self Type must be first argument.

Method can be called from the object created by new. See Subroutine Call for Method Call.

$self is called Invocant.

Signature

Signature is a string that follow the following rule sequence of Subroutine 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:

# Subroutine Definition
sub foo : int ($num1 : double, $num2 : long[])

# Signature
int(double,long[])

# Subroutine Definition
sub foo : void ()

# Signature
void()

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

Subroutine Callstack

Subroutine Callstack is memory area allocated in each subroutine call.

Subroutine Callstackには,the following 情報が保存されます。

1. Lexical Variableのためのメモリ領域

2. Motal Lexical Variableの場所

Enumeration

Enumeration Definition

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

# Enumeration Definition
enum {
  FLAG1,
  FLAG2,
  FLAG3
}

Enumeration must be defined directly under Package Definition.

package 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 Subroutine that Return Type is int Type. It is equivalent to the following Subroutine Definition:

sub FLAG1 : int () { return 0; }
sub FLAG2 : int () { return 1; }
sub 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, Compilation 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 Package. This is default setting.
private This Enumeration is private. This Enumeration can not be accessed from other Package.

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

Enumeration Call

Enumeration is an alias for Constant Subroutine, so it can be called in exactly the same way as Subroutine 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 Package Definition.

package 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 Subroutine 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 Package, do not assume that INIT Block of the current package will be executed first.

A common use of INIT Block is to initialize Package Variable.

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

Lexical Variable

Lexical Variable Declaration

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

Lexical Variable is declared using my Keyword.

my LEXICAL_VARIABLE_NAME : TYPE;

Lexical variable name must be follow the rule of Lexical Variable Name.

Type must be specified. Type must be Numeric Type, Object Type, Multi Numeric Type, or Reference Type.

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

Lexical Variable is initialized by Lexical 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 : SPVM::Complex_2d;

Initialization can be done at the same time as Lexical 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 Lexical Variable Declaration.

# int
my $num = 1;

# double
my $num = 1.0;

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

my $ppp = my $bar = 4;

if (my $bar = 1) {

}

while (my $bar = 1) {

}

See Scope about Lexical Variable Scope.

Lexical Variable Initial Value

Lexical Variable is initialized by Type Initial Value.

Lexical Variable Access

Lexical Variable Access is an operation to access Lexical Variable to get or set the value.

See Get Lexical Variable Value to get Lexical Variable value.

Set Lexical Variable Value to get Lexical Variable value.

If Package Variable with the same name as the Lexical Variable exists, Program uses the variable as Lexical Variable, not Package Variable.

Scope

Scope Summary

Scope is a range surrounded by Scope Block.

# Scope Block 
{
  # Start of Scope
  
  # ...
  
  # End of Scope
}

Lexical Variable Declaration registers the Lexical Variable that is Object Type with Motal Variable in run-time.

If the object is not undef, The Reference Count is added by 1.

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

At the end of Scope, the object that is registered as Motal 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

Simple Block is a scope block.

# Simple Block
{

}

Subroutine Block

Subroutine Block is a scope block.

# Subroutine Block
sub 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

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, Compilation 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, Compilation 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 Subroutine 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, Compilation Error will occur.

If Integer Literal is assigned to a short Type variable or passed to short Type Subroutine 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, Compilation 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:

0755
-0644
0666L
0655_755
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, Compilation 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, Compilation 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は"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 '"'.

The content of String Literal is zero or more ASCII printable Characters or Escape Characters 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.
\s ASCII Code 92,115 \s
\S ASCII Code 92,83 \S
\d ASCII Code 92,100 \d
\D ASCII Code 92,68 \D
\w ASCII Code 92,119 \w
\W ASCII Code 92,87 \W
\ + ASCII Code Punctuation Character(33 to 47, 58 to 64, 91 to 96, 123 to 125) ASCII Code 92, Number of ASCII Code Punctuation Character. For eample, \- represents \-. \+ represents \+.

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 Lexical Variable, Package 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 String is byte[] Type.

# String is Array of byte Type
my $string = new byte[3];
$string->[0] = 'a';
$string->[1] = 'b';
$string->[2] = 'c';

byte[] Type can be assigned to string Type. The address of String is copied to the distination Variable.

my $string_const : string = $string;

string Type is same as byte[] Type, but can't set the element value.

# Compilation Error
$string_const->[0] = 'd';

String can be created by assigning String Literal. a new String that is return a new String based on String Literal.

A new String is created that copies the value of the String Literal. The Type of the returned string is string Type.

my $string_const = "abc";

byte[] Type is designed to represent "char *" type in C language.

string Type is designed to represent "const char *" type in C language.

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

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 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 Package Descriptor in Package Definition.

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

# Tow consecutive 64bit floating point numbers
package 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 Lexical Variable Declaration.

Multi Numeric Type can be used as an argument Type in Subroutine Definition .

Multi Numeric Type can be used as Type of Return Value in Subroutine 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 Lexical Variable Declaration. Lexical Variable Declaration create continuous area for fields of Multi Numeric Type Value on Subroutine 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 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

Reference is data that indicates the location of Lexical Variable in the memory. Reference is a feature corresponding to Pointer in C language.

You can get Reference of Lexical 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 Subroutine Argument.

# Subroutine Definition
sub sum : void ($out_ref : int&, $in1 : int, $in2 : int) {
  $$out_ref = $in1 + $in2;
}

# Subroutine 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

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 Lexical Variable Value

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

$var

Set Lexical Variable Value

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

$var = RIGHT_EXPRESSION

The Assignment must satisfy Type Compatibility.

Set Lexical 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 Lexical Variable.

Get Package Variable Value

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

$PACKAGE_NAME::PACKAGE_VARIABLE_NAME

"PACKAGE_NAME::" can be omitted when the Package Variable belongs to own Package.

$PACKAGE_VARIABLE_NAME

If you try to get the value of a Package Variable that is not defined, Compilation Error occurs.

If you try to access a private Package Variable from outside the Package, Compilation Error occurs.

Get Package Variable Value Example:

package Foo {
  our $VAR : int;

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

Set Package Variable Value

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

.

$PACKAGE_NAME::PACKAGE_VARIABLE_NAME = RIGHT_EXPRESSION

"PACKAGE_NAME::" can be omitted when the Package Variable belongs to own Package.

$PACKAGE_VARIABLE_NAME = RIGHT_EXPRESSION

If the assignment does not satisfy Type Compatibility, Compilation Error occurs.

Set Package Variable Value Expression returns the value after setting.

If you try to get the value of a Package Variable that is not defined, Compilation Error occurs.

If you try to access a private Package Variable from outside the Package, Compilation 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 Package Variable before the assignment, the Reference Count of that object is decremented by 1.

Set Package Variable Value Example:

package Foo {
  our $VAR : int;

  sub 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 Compatible 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 Compilation Error occurs.

If the Field Name does not found in the Package, Compilation 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 Compilation Error occurs.

If the assignment does not satisfy Type Compatibility of the Type of Field, Compilation Error occurs.

If the Field Name does not found in the Package, Compilation 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 Compilation Error occurs.

If the Field Name does not found in the Package, Compilation 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 : SPVM::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 Compilation Error occurs.

If the Field Name does not found in the Package, Compilation 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 : SPVM::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 Compilation Error occurs.

If the Field Name does not found in the Package, Compilation 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 : SPVM::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 Compilation Error occurs.

If the Field Name does not found in the Package, Compilation 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 : SPVM::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 PACKAGE_NAME;

Package that is specified by Package 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 Compilation Error will occur.

Subroutine Call

Subroutines defined by Subroutine Definition can be called. There are two types of calls, function call and Method Call.

Function call

Calling a function is a method of calling a Subroutine that is not Method. In Subroutine Definition, the first argument is self Type If the argument of> is specified, it becomes Method.

You can call the function in the following way. The argument is optional. You can specify up to 255 arguments.

Package Name->Subroutine Name(ARGS1, ARGS2, ARGS3, ..., ARGSn);

Note that what is called Class Method Call in Perl is called a function call in SPVM.

The Package Name can be omitted in the function call.

Subroutine Name(ARGS1, ARGS2, ARGS3, ..., ARGSn);

Which Package Subroutine is called depends on the following order.

Subroutine defined in Current Package, or Subroutine imported in Current Package

The function call receives the arguments. If the number of arguments does not match the number of arguments defined in the Subroutine Definition, Compilation Error occurs The Type of each argument and the type of the argument defined in Subroutine Definition and Type Compatibility, Compilation Error occurs

Calling the function returns Return Value if Return Value is other than void Type.

The function call is Expression.

Subroutine 呼び出しのExample

Subroutine call example

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

Method Call

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

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

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

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

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

Method Call is Expression.

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 = sub : int ($self: self, $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 Compilation Error occurs.

The value obtained by Dereference returns Expression.

  <b>Example of getting value by Dereference</b>
my $num : int;
my $num_ref : int& = \$num;
my $num_deref : int = $$num_ref;

my $z : SPVM::Complex_2d;
my $z_ref : SPVM::Complex_2d& = \$z;
my $z_deref : SPVM::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 Compilation Error occurs.

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

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

  <b>Example of setting values ​​with Dereference</b>
my $num : int;
my $num_ref : int& = \$num;
$$num_ref = 1;

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

my $z2 : SPVM::Complex_2d;

$$z_ref = $z2;

Get Current Package Name

Get Current Package Name is a Expression to get the current package name by __PACKAGE__ Keyword.

__PACKAGE__

Get Current Package Name Example:

package Foo::Bar {
  sub baz : void () {
    # Foo::Bar
    my $package_name == __PACKAGE__;
  }
}

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/Foo/Bar.spvm" and the relative path is "Foo/Bar.spvm". "Foo/Bar.spvm" is Current File Name.

Get Current File Name Example:

# Foo/Bar.spvm
package Foo::Bar {
  sub baz : void () {
    # Foo/Bar.spvm
    my $file_name == __FILE__;
  }
}
package Foo::Bar2 {
  sub baz : void () {
    # 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:

package Foo::Bar {
  sub baz : void () {
    # 4
    my $line = __LINE__;
  }
}

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 Compilation 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 Compilation 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 Compilation 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 Compilation 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 Compilation 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 Compilation 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 Compilation 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
++PACKAGE_VARIABLE
++FIELD_ACCESS
++ARRAY_ACCESS
++DEREFERENCE

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

The operand of Increment Operator must Lexical Variable, Package Variable, Field Access, Array Access, Dereference, otherwise Compilation Error occurs.

The Type of operand of Increment Operator must be Numeric Type, otherwise Compilation 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
--PACKAGE_VARIABLE
--FIELD_ACCESS
--ARRAY_ACCESS
--DEREFERENCE

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

The operand of Decrement Operator must Lexical Variable, Package Variable, Field Access, Array Access, Dereference, otherwise Compilation Error occurs.

The Type of operand of Decrement Operator must be Numeric Type, otherwise Compilation 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 Compilation 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 Compilation 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 Compilation 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 Compilation Error occurs.

Right Expression must be int Type, otherwise Compilation 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 Compilation Error occurs.

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

Right Expression must be int Type, otherwise Compilation 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 Compilation Error occurs.

Right Expression must be int Type, otherwise Compilation 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

The Types of Left Expression and Right Expression Comparable Types, otherwise Compilation 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);

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 Compatible 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

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 Compilation 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 Compilation Error occurs.

Logical Operator

Logical Operator is an Operator that performs logical operations,Logical AND OperatorLogical 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 Compatible Type There is an otherwise Compilation 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.

Special Assignment Operator

Special Assignment Operator is a and Assignment OperatorType Compatibilityを満たさない場合は,Compilation 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 <a href="#language-type-byte">byte Type</a>
$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, Compilation Error occurs

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

  <b>Reference Operator Example</b>
my $num : int;
my $num_ref : int& = \$num;

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

For a detailed description of Reference, see Reference.

Array Length Operator

Array Length Operator is a ArrayUnary Operator

@RIGHT EXPRESSION

Right Expression must be an Array Type, otherwise Compilation 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 Compatible Type, otherwise Compilation 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 Compilation 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 Compilation Error occurs.

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

The Type of the value stored in field must be Object Type, otherwise Compilation 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

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 Subroutine 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, Compilation 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 Compilation 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 Compilation 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 Subroutine. 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 Subroutine Definition is void Type, Expression Must not exist, otherwise Compilation Error occurs.

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

die Statement

die Statement is a Statement for raising Exception.

die EXPRESSION;

Expression must be a String Compatible 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 Compilation Error occurs.

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

The Type of the value saved in Field must be Object Type, otherwise Compilation 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 Compilation Error occurs.

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

The Type of the value saved in Field must be Object Type, otherwise Compilation 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 Compatible 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 Compatible 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

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

Lexical Variable Declaration, Field Definition, Package Variable Definition, and Arguments and Return Value of Subroutine Definition must specify Type.

In Lexical Variable Declaration, Type Inference can be used.

Type Initial Value

Lexical Variable Initial Value,Package 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

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.

Package Type

Package Type is the Type defined by Package Definition.

package Foo {

}

Package Type is Class Type Callback Type Multi Numeric Type.

# Class Type
package Foo {

}

# Callback Type
package Foo: callback_t {

}

# Multi Numeric Type
package Foo: mulnum_t {

}

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

# Pointer Type
package 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
SPVM::Byte Numeric Object Type with byte Type data
SPVM::Short Numeric Object Type with short Type data
SPVM::Int Numeric Object Type with int Type data
SPVM::Long Numeric Object Type with long Type data
SPVM::Float Numeric Object Type with float Type data
SPVM::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, Compilation Error occurs

Class Type

Class Type is the Type defined by Package 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 Object Type.

Class Type is Package Type.

Pointer Type is the Class Type.

Pointer Type

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

package 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, Compilation Error occurs

Callback Type

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

package SPVM::Comparator: callback_t {
  sub: int ($self: self, $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 Subroutine Definition. Subroutine must be Method.

Subroutine Name of Callback Type must be anonymouse.

Callback Type must not have any Field Definition and Package 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
package SPVM::Comparator: callback_t {
  sub: int ($self: self, $x1: object, $x2: object);
}

# Class Definition
package SomeComparator {
  sub new: int () {
    return new SomeComparator;
  }

  sub: int ($self: self, $x1: object, $x2: object) {

  }
}

# The object can be assign to the variable of Callback Type
my $comparator: SPVM::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
package SPVM::Comparator: callback_t {
  sub: int ($self: self, $x1: object, $x2: object);
}

# The object which is created by Create Callback Object can be assign to the variable of Callback Type
my $comparator : SPVM::Comparator = sub: int ($self: self, $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 substitute 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 Package Type to which it belongs, and indicates that the argument is Invocant.

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

void Type

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

Basic Type

A Type that does not have dimensions is called a Basic Type. Numeric Type, Package 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 Compatible 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, Compilation Error occurs

    Note that "oarrayType" is a different Type than "object[] Type". While oarrayType is a Type that can be substituted 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 SPVM::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 = (SPVM::Int)$array->[0];
    
    # Setting the value of the element of Any Object Array Type
    $array->[0] = SPVM::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, Compilation Error occurs

    # Compilation 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 Compatible Type

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

    When a String Compatible 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 Compatible 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 Package Definition.

    package 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 Lexical Variable acquired by Reference Operator can be assigned to the value of Reference Type.

    If only Lexical Variable Declaration of Reference Type is performed, Compilation Error occurs

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

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

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

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

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

    If the Reference Type is used at an Invalid location, Compilation 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 Lexical 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, Compilation Error occurs

    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, Compilation 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 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 SPVM::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 SPVM::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.

    Numeric Type Type Conversion

    Numeric Type Type Conversion is the conversion from Numeric Type to Numeric Type. That is.

    Numeric Type Type Conversion performs exactly the same processing as Numeric Type Type Conversion in the corresponding C language. For example, Type Conversion from int to long in SPVM is the same as Type Conversion from int32_tType to int64_tType 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;
    

    For the correspondence of Type, see Correspondence of Type with C99.

    Valid information may not be retained when converting from a large type to a small type or when converting from a floating point to an integral type. In SPVM, since the Type Conversion corresponding to C99 is performed as it is, which value is converted when the Valid information is not retained is the same as the C99 specification.

    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 Subroutine 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 SPVM::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 : SPVM::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 SPVM::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 = SPVM::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 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.

    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.

    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 Compilation Error occurs.

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

    If Expression is Undefined Value, 0 is returned.

    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.

    Exception

    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 Compatible 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 Package Name, Subroutine 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 TestCase/Minimal.spvm line 1640
    from TestCase->main at 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 <a href="#language-exception">Exception</a>
    };
    

    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 substituted.

    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

    Callback Type in SPVM is a Package Type in which only one unnamed Method with no implementation is defined. If callback_tDescriptor is specified in Package 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.

    package Foo1 {
      sub new : Foo1 () {
        new Foo1;
      }
      sub : int ($self : self, $num : int) {
        return 1 + $num;
      }
    }
    
    package Foo2 {
      sub new : Foo2 () {
        new Foo2;
      }
      sub : int ($self : self, $num : int) {
        return 2 + $num;
      }
    }
    
    package FooCallback : callback_t {
    sub : int ($self : self, $num : int);
    }
    

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

    In this case, if you define a Callback TypeFooCallback 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.

    sub : TYPE_NAME  ($self : self, ARGS1 : TYPE1, ARGS2 : TYPE2, ARGSN : TYPEn) {
    
    }
    

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

    my $cb_obj = sub : TYPE ($self : self, ARGS1 : TYPE1, ARGS2 : TYPE2, ..., ARGSn : TYPEn) {
    
    };
    

    Subroutine defined by Create Callback Object must be Method. It must also be a Subroutine with no name.

    Create Callback Object Example

    my $comparator = sub : int ($self : self, $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 Subroutine Call.

    Capture

    In Create Callback Object, you can use the syntax called Capture to use the variables defined outside the Subroutine defined by Create Callback Object inside the Subroutine defined by Create Callback Object.

    # Capture
    [変数名1 : Type1, 変数名2 : Type2] sub Subroutine Name : int ($self : self, $x1 : object, $x2 : object) {
    
    };
    

    Capture Example.

    my $foo = 1;
    my $bar = 5L;
    
    my $comparator = [$foo : int, $bar : long] sub : int ($self : self, $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 Lexical Variable with the same name as the Capture variable exists in the Scope, access the Lexical Variable.

    If there is a Package 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.

    package ComapartorImpl {
      has foo : int;
      has bar : long;
    
      sub : int ($self : self, $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.