Rosetta スクリプト・マニュアル

表記	16進	内容
\a	07H	ベル（BEL）
\b	08H	後進（BS）
\t	09H	水平タブ（HT）
\n	0AH	改行（LF）
\v	0BH	垂直タブ（VT）
\f	0CH	書式送り（FF）
\r	0DH	行復帰（CR）
\?	3FH	? 記号
\\	5CH	バックスラッシュ（日本語環境では半角円記号）
\"	22H	ダブルクォーテーション
\'	27H	シングルクォーテーション
\x###	###	文字コード指定（16進表記）
\###	###	文字コード指定（8進表記）

　String 型は JavaScript や Java の String と似ていますが、setString メソッドによって内容を変更できるため、関数の引数に渡して文字列を受け取ることが出来ます。

void foo( String s )
{
s.setString( "foo" ) ;
}

String str = "hoge" ;
foo( str ) ;
System.console().printf( "%s\n", str ) ; // foo

　また比較演算はポインタの比較ではなく、内容文字列の比較となります。（JavaScript と同等）

String str1 = "hoge" ;
String str2 = "ho" + "ge" ;
if ( str1 == str2 )
{
System.console().printf( "equals\n" ) ;
}

Array 型

　Array 型は配列を提供します。
　Java 同様に Type[] のように記述することによって型付きの配列型を表現できます。

　リテラルの表現は、JavaScript 同様、角括弧 [] 内にコンマで区切って要素を列挙します。
　整数配列リテラルを型付き配列型へ代入する場合には、要素の型を明示する必要があります。

Integer[] a = [ 1, 2, 3 ] ; // OK
int[] b = (int[]) [ 1, 2, 3 ] ; // 要キャスト
int[] c = [ (int) 1, (int) 2, (int) 3 ] ;

　多重配列も同様に記述できます。

Integer[][] a = [ [ 1 ], [ 2, 3 ], [ 4, 5, 6 ] ] ;
int[][] b = (int[][]) [ [ 1 ], [ 2, 3 ], [ 4, 5, 6 ] ] ;

　Java のように new Type[] によって配列オブジェクトを生成できます。

String[] a = new String[] ;

　配列長（制限値）を指定して生成することも出来ます。

String[] a = new String[100] ;

　配列長を指定した場合でも、配列の初期サイズは 0 です。
　配列は自動的に伸長されますが、制限値を超えた場合にはエラーとなります。

String[] a = new String[100] ;
System.console().printf( "%d\n", a.length() ) ; // 0
a[9] = "abc" ;
System.console().printf( "%d\n", a.length() ) ; // 10
a[100] = "xyz" ; // Error

HashMap 型

　HashMap 型は、Java の HashMap とほぼ同等のクラスで、JavaScript の Object に似ています。

　リテラルの表現は、JavaScript 同様、波括弧 { } 内にコンマで区切って要素を列挙します。各要素は、コロンで区切って左辺に要素名、右辺に値を記述します。

HashMap a = { name : "abc", value : 1000 } ;

　また、HashMap のコンストラクタは要素型 class を受け取ることができ、要素への代入時に型チェック／変換を行うことができます。

class Foo {}
class Hoge extends Foo {}

HashMap a = new HashMap( Foo ) ;
a.abc = new Hoge() ; // OK
a.def = new String() ; // Error
a["ghi"] = new Foo() ; // OK

　要素型を指定した型として記述することもできます。

HashMap<Foo> a = new HashMap<Foo>() ;

Function 型

　Function 型は HashMap の派生型として定義されており、記述上は無名関数を受け取る変数の型として使用されます。

Function f = function( int a, int b ) : int
{
return a * b ;
} ;

　関数は、f(a,b) のように記述することにより呼び出すことが出来ます。
　また、.* 演算子を用い C++ ライクにメンバ関数として呼び出すことが出来ます。

class Foo
{
public int m_a = 3 ;
public int m_b = 5 ;
}
Function func = function( int a, int b )
{
return m_a * a + m_b * b ;
} ;
Foo foo = new Foo() ;
(foo .* func)( 7, 11 ) ;

　無名関数内部から、その関数を生成した時の名前空間を参照できます。

Function getFunc( int x )
{
int a = 123 + x ;
return function( int b ) { return a * b ; } ;
}
Function foo = getFunc( 456 ) ;
System.console().printf( "%d\n", foo( 2 ) ) ; // 1158

　その為、以下のように関数内のローカル変数で、生成した関数を保持していると循環参照となり永遠に解放されないため注意が必要です。

Function getFunc( int x )
{
int a = 123 + x ;
Function f = function( int b ) { return a * b ; } ;
return f ;
}

　可能であれば、関数を保持しているローカル変数は、必要でなくなったら null を代入し、解放可能にすることが推奨されます。

　また以下のような構文でプロトタイプ型付きの関数型を記述できます。

Function<double,MyClass,String,int>
f = function( String s, int i ) : double -> MyClass
{
return m_memberOfMyClass ;
} ;

　Function 型の1つ目の引数は関数の返り値型で、voidを指定することも出来ます。function 式では、引数の後に「:」記号に続けて記述します。
　2つ目の引数は関数のメンバとなるクラスを指定します。function 式は返り値型の後に「->」に続けて記述します。省略した場合には Object となります。
　3つ目以降は関数の引数の型となります。
　プロトタイプ型付きの Function 変数には、プロトタイプの一致する関数しか代入できません。

　なお、文末には必ずセミコロンが必要ですので、function 式の文末にセミコロンを忘れないように注意が必要です。

Object 型

　Object は Java の Object とほぼ同等のクラスで、すべてのオブジェクトの基底クラスです。

　すべてのオブジェクトは Object にキャストして受け取ることが可能です。
　変数宣言時の Object は var と同じ意味です。

var obj = new Foo() ;
Object obj = new Foo() ;

　しかし、var の使用は推奨されません。

クラス

　Rosetta のクラス定義は Java と似ています。

class Foo
{
public int m_a = 3 ;
public int m_b = 5 ;
}

　クラスの派生も定義出来ます。

class Bar extends Foo
{
public int m_c ;

public Bar( int c )
{
super() ;
m_c = c ;
}
}

　Rosetta の構築関数では、明示的に super() を記述しなければ親クラスの構築関数は呼び出されないので注意が必要です。（但し、構築関数が呼び出される前に、メンバ変数は定義された初期値で初期化されます）

※インスタンス生成のメカニズムは Java より JavaScript に似ています。
　インスタンスの生成プロセスでは、まずプロトタイプが複製されます。
　プロトタイプとはメンバ変数の定義で記述された初期値で構成されたインスタンスです。初期値はメンバ定義時の評価値で、インスタンス生成時に式が都度評価されるわけではありません。
　次に構築関数が呼び出されます。この時、親クラスの構築関数は明示しない限り呼び出されません。但し派生クラスで構築関数をオーバーロードしていない場合、親クラスの構築関数が呼び出されます。
　将来のバージョンでは暗黙に親クラスの構築関数が呼び出されるよう変更されるかもしれません。互換性のため、必要であれば親クラスの構築関数の呼び出しを明示することが推奨されます。

　また、Java の interface に相当するクラスを多重派生することも出来ます。

class Hoge
{
public abstract void hoge() ;
}

class Bar extends Foo implements Hoge
{
public void hoge()
{
System.console().printf( "Bar.hoge\n" ) ;
}
}

ポインタ型

　Rosetta のポインタ型は、JavaScript の型付配列と似ています。
　基本的な使用法は、ArrayBuffer で確保されたメモリへ関連付け、配列の要素としてメモリを参照します。

ArrayBuffer buf = new ArrayBuffer( 100 * 4 ) ;
Int32Pointer p = new Int32Pointer( buf ) ;

p[i] = foo( i ) ;

　以下のようにコンストラクタに配列長を指定すると、自動的にメモリが確保されます。

Int32Pointer p = new Int32Pointer( 100 ) ;

　ポインタが JavaScript の型付配列と異なるのは、ポインタを加減算できる点です。
　配列長 n のポインタには、0～n の値を加算できます。ただし、(p+n)[0] は p[n] 同様、範囲外指標エラーとなります。
　p-- や p+=n+1 は加減算の時点でエラーとなります。（範囲外の値となったポインタは null と評価されます）
　ループでポインタを変化させながら使用する際には注意が必要です。（p+=n の後の p-- は問題ありません）

　またポインタ型は代入の際、ポインタオブジェクトへのポインタではなく、ポインタ値そのものが複製されます。

Int32Pointer p1 = new Int32Pointer( 3 ) ;
p1[0] = 100 ;
p1[1] = 200 ;
p1[2] = 300 ;
Int32Pointer p2 = p1 ;
Int32Pointer p3 = p1 + 2 ;
p2 += 1 ;
System.console().printf( "%d,%d,%d\n", p1[0], p2[0], p3[0] ) ; // 100,200,300

　すべてのポインタ型は Uint8Pointer へ変換できます。

Int32Pointer p1 = new Int32Pointer( 100 ) ;
Uint8Pointer p2 = p1 ;

　しかしそれ以外のポインタへの変換はできませんので、コンストラクタを呼び出す必要があります。
（※ポインタの型変換のみのコンストラクタは、コンパイルされた場合には単にポインタ値がコピーされるだけです）

Int16Pointer p1 = new Int16Pointer( 100 ) ;
Uint32Pointer p2 = new Uint32Pointer( p1 ) ;

　ポインタに半端なアドレスを指定するとアライメントエラーとなり例外がスローされます。

Uint8Pointer p1 = new Uint8Pointer( 10 ) ;
Uint32Pointer p2 = new Uint32Pointer( p1 + 1 ) ; // Error!

　整数ポインタが指すメモリへ数値を書き込むとき、数値は最近値の整数へ丸められ、整数は有効なビット数だけ下位ビットが書き込まれます。
　尚、書き込み数値のエンディアンは実行環境に依存します。

Int8Pointer p1 = new Int8Pointer( 10 ) ;
Uint8Pointer p2 = new Uint8Pointer( 10 ) ;
p1[0] = 128 ;
p1[1] = 255 ;
p2[0] = -1 ;
p2[1] = 257 ;
System.console().printf( "%d,%d,%d,%d\n", p1[0], p1[1], p2[0], p2[1] ) ; // -128, -1, 255, 1

構造体

　Rosetta では C/C++ 言語と同じような構造体が利用できます。
　構造体はクラスとは異なり、ArrayBuffer 上のメモリの構造を直接記述します。

struct Hoge
{
public int a = 1 ;
public short b, c ;
}

　構造体変数はポインタ型変数とよく似ており、ArrayBuffer で確保されたメモリへ関連付けて使用することが出来ます。

ArrayBuffer buf = new ArrayBuffer( Structure.sizeof(Hoge) ) ;
Hoge p = new Hoge( buf ) ;

　以下のように配列長を指定すると、自動的にメモリが確保されます。
　配列長を省略した場合には、長さ１の配列が確保されます。

Hoge p = new Hoge( 100 ) ;
Hoge q = new Hoge() ;

　ポインタ型同様、加減算することが出来ます。
　加減算と [] 括弧での要素参照はよく似ていますが、[] 括弧の場合、有効長が１に制限されている点、加減算の場合の有効範囲は 0～n に対し、[] 括弧の場合 0～(n-1) などの違いがあります。
　またポインタ型同様、代入の際には構造体ポインタ値そのものが複製されます。

Hoge p1 = new Hoge( 3 ) ;
p1.a = 100 ;
p1[1].b = 200 ;
p1[2].c = 300 ;
Hoge p2 = p1[1] ;
Hoge p3 = p1 + 2 ;
System.console().printf( "%d,%d,%d\n", p1.a, p2.b, p3.c ) ; // 100,200,300

Hoge p4 = p1[1] ;
Hoge p5 = p1 + 1 ;
p4[0].a = 110 ; // OK
p4[1].a = 120 ; // 指標範囲外エラー！
p5[1].a = 120 ; // OK

　構造体のメンバには配列を定義することが出来ます。
　配列メンバはポインタ型（構造体の場合は構造体の型）として評価されます。
　また、ポインタの有効長はメンバの配列長に制限されます。

struct Hoge
{
public int a ;
public char b[10] ;
public short c ;
}

Hoge hoge = new Hoge() ;
Uint16Pointer s = hoge.b ;
s[5] = 'a' ; // OK
s[10] = 'b' ; // 指標範囲外エラー！

　ポインタ型同様、Uint8Pointer へ変換できますが、それ以外の変換はコンストラクタを呼び出す必要があります。

Hoge hoge = new Hoge() ;
Uint8Pointer p1 = hoge ;
Uint32Pointer p2 = new Uint32Pointer( hoge ) ;

　構造体は派生することが出来、派生のメカニズムは C++ とよく似ています。

struct Foo
{
public int a, b ;
}
struct Bar
{
public int c, d ;
}
struct Hoge extends Foo, Bar
{
public int e ;
}
Hoge hoge = new Hoge() ;
Foo foo = hoge ;
Bar bar = hoge ;
foo.a = 1 ;
bar.c = 2 ;
hoge.e = 3 ;
Int32Pointer p = new Int32Pointer( hoge ) ;
System.console().printf( "%d,%d,%d\n", p[0], p[2] p[4] ) ; // 1,2,3

　構造体のメンバ関数は仮想関数ではありません。

struct Foo
{
public void put( void )
{
System.console().printf( "foo\n" ) ;
}
}
struct Bar extends Foo
{
public void put( void )
{
System.console().printf( "bar\n" ) ;
}
}
Bar bar = new Bar() ;
Foo foo = bar ;
bar.put() ; // bar
foo.put() ; // foo

　構造体の構築関数の記述には注意が必要です。
　構造体変数はポインタ変数であり、構築関数が明示的にメモリ確保を行う必要があります。

struct Point3D
{
public int x, y, z ;

public Point3D( int x, int y, int z )
{
super( 1 ) ; // 配列長 1 のメモリを確保
this.x = x ;
this.y = y ;
this.z = z ;
}
}

　なお、構築関数から super() が呼び出された場合、構造体の情報は保持されているので、派生クラスでも有効です。

struct Point4D extends Point3D
{
public int w ;

public Point4D( int x, int y, int z, int w )
{
super( x, y, z ) ;
this.w = w ; // このメモリまで確保されている
}
}

　また、構造体の消滅関数（finalize）は無効です。

定義済みリテラル

　Rosetta には JavaScript と同様に以下のリテラルが定義されています。

undefined

未定義データを表現します。
Rosetta の undefined は JavaScript ほど厳密ではなく（またグローバルオブジェクトではなく値の表現であり）、x === undefined の代わりに、x === null を使用してもかまいません。
しかし、(String) キャストでは "undefined" に変換されます。

null

Object の null ポインタを表現します。

true

boolean の true 値を表現します。

false

boolean の false 値を表現します。

void 型

　C++ 同様 Rosetta では void を関数の返り値型や、引数として指定できます。
　関数の返り値の場合、返り値が存在しないことを、引数の場合、引数が存在しないことを意味します。

void foo( void )
{
// 返り値も引数も無い関数
}

this と super

　Rosetta では Java 同様 this や super を使用できます。
　this は文字通りその関数が属しているクラスのオブジェクトを示します。
　super は this のコンストラクタから親クラスのコンストラクタを呼び出したり、this メンバ関数内から親クラスの関数を呼び出すのに使用します。
※Rosetta では親クラスのコンストラクタは super で明示しない限り呼び出されません。

class Foo extends Hoge
{
public Foo()
{
super( 1, 2, 3 ) ; // Hoge のコンストラクタを呼び出す
this.m_value = 100 ; // Foo か Hoge かその親クラスのメンバ変数
}
public int getHoge()
{
return super.getHoge() * 2 ; // Hoge の getHoge 関数を呼び出す
}
}

演算子

　Rosetta では以下の演算子が利用可能です。

( expr )	式の評価

expr ( arg-list )	関数呼び出し
expr []	配列型
expr [ expr ]	配列要素、又はメンバ参照

type-expr :: member	メンバ、又はクラスの static メンバ参照

expr . member	メンバ参照

expr .* expr	メンバ関数間接呼び出し

expr ++	インクリメント
expr --	デクリメント

new type-expr ( arg-list )	オブジェクトインスタンス生成
type-expr ( arg-list )	オブジェクトインスタンス生成（非推奨）
function ( arg-list ) [: type-expr ]opt [-> class-name ]opt { statement-list }	無名関数生成
++ expr	インクリメント
-- expr	デクリメント
( type-expr ) expr	型変換
+ expr	単項プラス
- expr	算術否定（マイナス）
~ expr	論理否定（ビット毎の1の補数）
! expr	論理否定

expr * expr	乗算
expr / expr	除算
expr % expr	剰余

expr + expr	加算
expr - expr	減算

expr & expr	論理積（ビット毎の論理積）

expr \| expr	論理和（ビット毎の論理和）

expr ^ expr	排他的論理和（ビット毎の排他的論理和）

expr >>> expr	論理右シフト
expr << expr	算術左シフト
expr >> expr	算術右シフト

expr == expr	同値判定
expr != expr	非同値判定
expr <= expr	同値又は劣勢値判定
expr < expr	劣勢値判定
expr >= expr	同値又は優勢値判定
expr > expr	優勢値判定
expr === expr	実体オブジェクトの一致判定（ポインタ同値判定）
expr !== expr	実体オブジェクトの不一致判定（ポインタ非同値判定）
expr instanceof type-expr	左辺オブジェクトの型適合判定

expr && expr	論理積

expr \|\| expr	論理和

expr ? expr : expr	値の選択

lvalue = expr	代入
lvalue *= expr	乗算代入
lvalue /= expr	除算代入
lvalue %= expr	剰余代入
lvalue += expr	加算代入
lvalue -= expr	減算代入
lvalue &= expr	論理積代入
lvalue \|= expr	論理和代入
lvalue ^= expr	排他的論理和代入
lvalue >>>= expr	論理右シフト代入
lvalue <<= expr	算術左シフト代入
lvalue >>= expr	算術右シフト代入