SPVM::Document::Spec - SPVM Language Specification(BETA before 1.0)
Package declaration is the following.
package PackageName { }
PackageName is package name.
PackageName
Package name is consist of Upper Case and Lower Case and Number and ::. Package name must start with Upper Case. Package name which start with Lower Case is forbidden. Package name which start with Lower Case is resolved for core.
::
Note that package name can't contain Under Score _. Under Score is used for Package Template.
_
Package Template
# Legal Foo Foo2 Foo::Bar Foo::Bar::Baz Foo::bar # Illegal foo foo::Bar 2Foo Foo_Bar
Package Declaration must be just under file itself.
# Legal package PackageName { } # Illegal sub foo() : int { package PackageName { } }
Field declaration is the following.
has field_name : type_name;
filed_name is field name. Field name is consist of Upper Case and Lower Case and Number and Under Score _. Field name must not start with Number. Under score must not continue more than one.
filed_name
# Legal foo foo_bar foo2 foo_bar2 FOO # Illegal 2foo foo__bar
type_name is a type. Type is explained in "Type" section.
type_name
Field Declaration must be just under Package Declaration.
# Legal package PackageName { has field_name : type_name; } # Illeagal has field_name : type_name; sub foo() : int { has field_name : type_name }
Subroutine declaration is the following.
sub sub_name(arg_name : type_name, ...) : descripter_name return_type_name { }
sub_name is subroutine name. Subroutine name is consist of Upper Case and Lower Case and Number and Under Score _. Subroutine name must not start with Number. Under score must not continue more than one.
sub_name
arg_name is Argument Name. This is Variable name. Variable name is explained in "Variable Declaration" section,
arg_name
type_name is a Type. Type is explained "Type" section.
arg_name : type_name can be repeated with ,. If argument is none, that is ok. Max arguments count is 255.
arg_name : type_name
,
255
descripter_name is a Descripter. If descripter is none, that is ok. Available descripters are following. Currently only one descripter is available.
descripter_name
[Name] [Description] native the subroutine is native
Native subroutine is explained in "Native Subroutine".
return_type_name is a Type or void. void mean the subroutine don't have return value. Type is explained "Type" section.
return_type_name
void
Subroutine Declaration must be just under Package Declaration.
# Legal package PackageName { sub foo($nums : int[]) : int { } } # Illeagal sub foo() : double { sub var() : void { } }
Variable Declaration is the following.
my var_name : type_name;
var_name is Variable Name. Variable Name first character is $. Rest characters is consist of Upper case, Lower case, Number and Under score _.
var_name
$
# Legal $foo $FOO $foo2 $foo_bar
If Variable Declaration is done, you can use variable after the declaration.
type_name is a <Type>. Type is explained "Type" section.
Default number literal type is int.
int
123
You can use hex number literal by start 0x. A, B, C, D, E, F must be upper case.
0x
A
B
C
D
E
F
0xAF
If you use . in number literal, the number is floating point literal.
.
1.23
You can use E or e to specify exponential notation.
e
1.23E+12 1.23E-12 1.23e+12 1.23e-12
You can use under line _ in number literal. Under line is meanless, only for visuality.
123_456 0xAB_CD
You can use specifier to specify number leteral type
b
# Byte 123b
s
# Short 123s
L
# Long 123L
f
# Float 123f
d
# Double 123d
Numeric types are byte, short, int, long, float, double.
byte signed integer 1byte short signed integer 2byte int signed integer 4byte long signed integer 8byte float floating-point number 4byte double floating-point number 8byte
Declaration
my $value : byte; my $value : short; my $value : int; my $value : long; my $value : float; my $value : double;
String type is string.
This is same as byte[] at internal data structure.
my $string : string;
Reference types are `array` and `object`.
Object type
my $object : PackageName;
Array type
byte[] byte array short[] short array int[] int array array long[] long array float[] float array doube[] double array PackageName[] object array
my $values : byte[]; my $values : short[]; my $values : int[]; my $values : long[]; my $values : float[]; my $values : double[]; my $values : PackageName[];
Multiple array type
my $values : byte[][]; my $values : short[][]; my $values : int[][]; my $values : long[][]; my $values : float[][]; my $values : double[][]; my $values : PackageName[][]; my $values : byte[][][]; my $values : short[][][]; my $values : int[][][]; my $values : long[][][]; my $values : float[][][]; my $values : double[][][]; my $values : PackageName[][][];
If the type of right value is known, the type of left value is automatically decided.
# Type of $value2 is byte. my $value1 : byte; my $value2 = $value1; # Type of $values2 is int[] my $values1 = new int[3]; my $values2 = $values1; # Type of $object2 is PackageName my $object1 = new PackageName my $object2 = $object1;
Array is created by new. Elements values is not initialized.
my $nums = new byte[3]; my $nums = new short[3]; my $nums = new int[3]; my $nums = new long[3]; my $nums = new float[3]; my $nums = new double[3];
my $len = @$nums; my $len = @{$nums}; my $len = len $nums;
# Get my $num = $nums->[0]; # Set $nums->[0] = 5;
if (1) { } elsif (2) { } else { }
my $nums = new int[10]; for (my $i = 0; $i < @$nums; $i++) { $nums->[$i] = 0; }
my $nums = new int[10]; my $i = 0; while ($i < @$nums) { $nums->[$i] = 0; }
Type of constant default integral value is `int`.
# int type 1; 3;
Type of constant default floating-point value is `double`.
# double 1.2 5.3
Type of constant is specified by type specifier.
# long 3L # float 3.2f # double 3.2d
=pod AAAA =cut
__END__
die "Error";
eval { die "Error"; };
$@;
Package name is a combination of alphabets, numbers, and `::`. Numbers should not appear as the first character. `_` can't be used in class name.
# OK Foo Foo::Bar Foo1::Bar1 # Not OK 1Foo Foo::2Bar Foo_Bar;
Subroutine name is a combination of alphabets, numbers, and `_` separators. Continual `_`(For example `__`) can't be used in subroutine name.
# OK foo foo1 foo_bar # Not OK 1foo foo__bar
Field name is a combination of alphabets, numbers, and `_` separators. Continual `_`(For example `__`) can't be used in field name.
Absolute name is combination of package name and subroutine name, or package name and field name.
PackageName1::foo PackageName1::PackageName2::foo_bar
Using weak reference, recursive reference is resolved.
my $foo = new Foo; my $bar = new Bar; # Recursive reference $foo->{bar} = $foo; $bar->{foo} = $foo; # Weak reference weaken $foo->{bar};
Destructor.
package Foo { sub DESTROY($self : Foo) : void { } }
Enumeration.
package Foo { enum { ONE, TWO, THREE } enum { FORE = 4, FIVE, } }
package TestCase::Extension { sub sum($num1 : int, $num2 : int) : native int; } __NATIVE__ #include <spvm_api.h> int32_t SPVM__TestCase__Extension__sum(SPVM_API* api, SPVM_API_VALUE* args) { int32_t total = args[0].int_value + args[1].int_value; return total; }
To install SPVM, copy and paste the appropriate command in to your terminal.
cpanm
cpanm SPVM
CPAN shell
perl -MCPAN -e shell install SPVM
For more information on module installation, please visit the detailed CPAN module installation guide.