View on
MetaCPAN
Yuki Kimoto > SPVM-0.0265 > SPVM::Document::Spec

Download:
SPVM-0.0265.tar.gz

Annotate this POD

CPAN RT

New  3
Open  2
View/Report Bugs
Source   Latest Release: SPVM-0.0270

NAME ^

SPVM::Document::Spec - SPVM Language Specification(BETA before 1.0)

SPVM Language Specification ^

Package Declaration

Package declaration is the following.

  package PackageName {
    
  }

PackageName is package name.

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.

  # 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

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.

  # Legal
  foo
  foo_bar
  foo2
  foo_bar2
  FOO
  
  # Illegal
  2foo
  foo__bar

type_name is a type. Type is explained in "Type" section.

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 Decralation

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.

  # Legal
  foo
  foo_bar
  foo2
  foo_bar2
  FOO
  
  # Illegal
  2foo
  foo__bar

arg_name is Argument Name. This is Variable name. Variable name is explained in "Variable Declaration" section,

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.

descripter_name is a Descripter. If descripter is none, that is ok. Available descripters are following. Currently only one descripter is available.

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

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

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

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

Number literal

Default number literal type is int.

  123

You can use hex number literal by start 0x. A, B, C, D, E, F must be upper case.

  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.

  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

Type

Numeric type

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

String type is string.

This is same as byte[] at internal data structure.

Declaration

  my $string : string;

Reference type

Reference types are `array` and `object`.

Object type

    PackageName

Declaration

    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

Declaration

  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[][][];

Type inference

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

Create array

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];

Get array length

  my $len = @$nums;
  my $len = @{$nums};
  my $len = len $nums;

Get and set array element

  # Get
  my $num = $nums->[0];

  # Set
  $nums->[0] = 5;

Condition branch

  if (1) {

  }
  elsif (2) {

  }
  else {

  }

Loop

for

  my $nums = new int[10];
  for (my $i = 0; $i < @$nums; $i++) {
    $nums->[$i] = 0;
  }

while

  my $nums = new int[10];
  my $i = 0;
  while ($i < @$nums) {
    $nums->[$i] = 0;
  }

Constant

Constant type

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

  =pod
    AAAA
  =cut

__END__

  __END__

Exception

Exception occur

  die "Error";

Catch exception

  eval {
    die "Error";
  };

Exception message

  $@;

Name

Package name

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

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

Field name is a combination of alphabets, numbers, and `_` separators. Continual `_`(For example `__`) can't be used in field name.

  # OK
  foo
  foo1
  foo_bar

  # Not OK
  1foo
  foo__bar

Absolute name

Absolute name is combination of package name and subroutine name, or package name and field name.

  PackageName1::foo
  PackageName1::PackageName2::foo_bar

Weak reference

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

Destructor.

  package Foo {
  
    sub DESTROY($self : Foo) : void {
      
    }
  }

enumeration

Enumeration.

  package Foo {
    enum {
      ONE,
      TWO,
      THREE
    }
    
    enum {
      FORE = 4,
      FIVE,
    }
  }

Extension native function

  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;
  }
syntax highlighting: