プログラミング言語をつくってみる④ - クラス

クラスができました。

抽象木をもう一段階変換する

ここまでサクサクと作ってきたのですが、ジェネレートされたパーサから得られる抽象木は、処理の際に、毎回 Chidlren の中身を確認する必要があるなど、実行に不向きです。

非効率でもいいかとも思っていたのですが、実行処理があまり直感的ではないため、デバッグが大変になってきました。また、単純に変数や定数にアクセスするだけでも、 [expr] - [factor] - [incdec] - [primary] - [variable] と巡らないと行けないため超非効率かつ、ステップ実行でエラー探しも大変です。とはいえ、文法定義のときに処理のことまで考えながら作るのもそれはそれで大変です。

そこで、一回、もうちょっと直感的な抽象木に変換してから、それを実行するような方式にしました。変換後には、子が一つだけで何もしないような余分な階層をなくしたり、定数と変数の参照を区別したり、全て statement で管理していたものを文の種類ごとに別のクラスのオブジェクトにするようにしました。これで、実行中に余分な分岐もなく、少し効率的に実行できるようになったと思います。

もう一つ、構造変更によって、expr （中身は二項演算）の左辺と右辺の直下が定数かどうかの判断もしやすくなったため、定数の畳込みも実装しました。実装方法は、expr を管理するクラスの左辺と右辺のオブジェクトが定数を表すものなら、expr を計算してしまって、定数のオブジェクトに置き換えてしまう形にしました。この実装ですと、このパーサでは、

a + 6 + 5

は

(a + 6) + 5

と解釈されるため畳み込みが行われませんが、まぁ、これは諦めました。

クラスを追加する

文法を次のように変更し、クラスの構文を追加しました。そのほか、null を導入したりと微修正しています。

constants   : "true" | "false" | "null"
arg_list    : "(" [ expr {"," expr} ] ")"
index_acc   : "[" expr "]" /* 配列アクセス（下準備）*/
new_object	: "new" IDENTIFIER arg_list /* new 演算子 */
variable	: ("this" | "base" | new_object | IDENTIFIER) { arg_list | index_acc }
member      : variable { "." variable} /* メンバアクセス */
primary     : "(" expr ")" | INT | FLOAT | STRING | constants | member
incdec      : primary [("++" | "--")]
factor      : "-" incdec | "!" incdec | incdec
expr        : factor { OP factor}

block       : "{" { statement } "}"
declare_var : "var" IDENTIFIER [ "=" expr ]
break_st    : "break" | "continue" | "return" [ expr ]

statement   : "if" "(" expr ")" statement [ "else" statement ]
            | "while" "(" expr ")" statement
            | "for" "(" [ (declare_var | expr) { "," (declare_var | expr)} ]  ";" expr ";" [expr { "," expr }] ")" statement
            | expr ";"
            | break_st ";"
            | declare_var ";"
            | ";"
            | block

param_list  : "(" [IDENTIFIER {","  IDENTIFIER } ] ")"
declare_func: "func" IDENTIFIER param_list block
def_constructor : "constructor" param_list [":" ("base" | "this") param_list ] block

class_body  : "{" { (declare_var ";" | declare_func | def_constructor) } "}"
def_class   : "class" IDENTIFIER [":" IDENTIFIER] class_body

program     : { (declare_var ";" | declare_func | def_class) }

追加したのは、member 、new_object 、def_class 、class_body 、def_constructor くらいです。ドットでメンバアクセスできるようにしました。また、コンストラクタは、クラス名ではなく "constructor" で定義するようにしました。これは、構文解析が楽かな？という理由もありますが、クラス名を変更したときに毎回コンストラクタの名前も変更しないといけないのは面倒なので、このようにしています。（C# ならリファクタリング効きますが、C++ ですと IDE が変更し逃したりしていつも大変ですので…）

継承は多重継承は考えず、単一継承のみで、構文は C# 風に ":" で指定できるようにしました。

クラスの定義とオブジェクトの生成

def_class の評価の際に、環境に型情報を記録するようにしました。型情報には、メンバ変数名と初期化の抽象木、メンバ関数やコンストラクタを記録します。

オブジェクトの生成は、new 型名 () で行えるようにしました。オブジェクトの生成時、メンバ変数をパラメータに登録して初期化を行います。一方、メンバ関数は登録せず、その代りに、オブジェクトからメンバ関数が呼ばれたときに、型情報の方に記録した関数の抽象木を実行するようにしました。

オブジェクトを表すクラスは、SsEnvironment を継承しており、オブジェクトの Outer にグローバル環境を設定しています。そのようにすることで、クラスのメンバ関数の処理では、this などのキーワードなしに、オブジェクトのパラメータを参照できるようにしました。ついでに、"this" キーワードを調べると、そのオブジェクト自身を返すようにしました。

/**
 * SumireObjectの管理オブジェクトクラス
 * @param {SsTypeInfo} typeInfo 
 */
var SsObject = function (typeInfo) {
    this.Type = typeInfo;
    this.Params = {};
    SsEnvironment.call(null, typeInfo.Name);
}

SsObject.prototype =
    {
        DeclareParam: function (name, init, token) {
            //これはヒットしないはず
            if (!(this.Params[name] === undefined)) {
                throw new SsAlreadyDefinedException(token);
            }
            this.Params[name] = init;
        },
        Get: function (name, token) {
            var param = this.GetMember(name, token);
            if (!(param === undefined)) {
                return param;
            }
            if (this.Outer == null) {
                if (token == null) return undefined;
                throw new SsNotFoundMemberException(token);
            }
            else {
                return this.Outer.Get(name, token);
            }
        },
        GetMember: function (name, token) {
            //thisは自分を返す
            if (name == "this") return this;
            var param = this.Params[name];
            if (!(param === undefined)) {
                return param;
            }
            return this.Type.GetMethod(name, token);
        },
        Set: function (name, value, token) {

            if (this.SetValue(name, value, token)) {
                return;
            }
            if (this.Outer == null) {
                throw new SsNotFoundMemberException(token);
            }
            else {
                return this.Outer.Set(name, value, token);
            }
        },
        SetValue: function (name, value, token) {
            if (!(this.Params[name] === undefined)) {
                this.Params[name] = value;
                return true;
            }
            return false;
        },
    }

メンバの呼び出し

メンバ関数の呼び出しは以下の感じです。左から順に評価していっています。ただし、メンバを参照するときは、評価時の第二引数に対象オブジェクトを渡し、そちらからメンバを探すような処理にしました。ここは、もう少しきれいにならないかと思いますが、まぁ、動いているので良しとします。

コード1: メンバの呼び出し関連

SsExAST_member.prototype =
    {
        eval: function (env) {
			// . で区切られていなかったらそのまま評価
            if (this.MemberList.length == 1) {
                return this.MemberList[0].eval(env);
            }
			
			//2つ以上なら、左を評価して、その結果を次の評価に渡す
            var leftObject = null;
            for (var i = 0; i < this.MemberList.length - 1; i++) {
                var nObj = this.MemberList[i].eval(env, leftObject).Value;
                if (nObj == null) {
                    throw new SsNullPointerException(this.Dots[i]);
                }
                leftObject = nObj;
            }
            return this.MemberList[this.MemberList.length - 1].eval(env, leftObject);
        }
    }
	

SsExAST_Variable.prototype =
    {
        eval: function (env, leftObject) {
            if (leftObject == null) {
                return new SsResult(env.Get(this.Key.Token, this.Key));
            }
            else {
				//左辺のオブジェクトがあれば、そこから検索
                var param = leftObject.GetMember(this.Key.Token, this.Key);
                if (param == null) {
                    throw new SsNotFoundMemberException(this.Key);
                }
                return new SsResult(param);
            }
        }
    }

メンバ変数への設定

値の設定は若干大変でした。. でつないだ最後から 2 番目の評価値（オブジェクト）の一番最後の名前のメンバに値を設定しないといけません。これまでは、設定先の名前を返す関数を用意して、その名前 + env で設定していたのですが、設定先も変わるため、設定情報を格納したオブジェクトを返すような方式にしました。

エラーを表示する

今作っている処理系では、例外が発生するとそれに関連するトークンも返してくれるようになっています。また、トークンには、行番号と列番号が記録されています。そこで、その情報を使って、CodeMirror 上のトークンをハイライトする機能を作りました。

結構簡単で、CodeMirror の markText 関数を使うだけでした。

コード2: エラー箇所をハイライトするコード

// Catchの中
if (ex instanceof SsException) {
            var message = ex.Message + "\n";
            if (ex.Token != null) {
                if (typeof ex.Token === "string") {
                    message += "\"" + ex.Token + "\"";
                }
                else {
                    message += "\"" + ex.Token.Token + "\" " +
                        (ex.Token.S_Line + 1) + "行 " + (ex.Token.S_Ch + 1) + "列";
                }

                var doc = testEditor.getDoc();
                var marks = doc.getAllMarks();
                for (var i = 0; i < marks.length; i++) {
                    marks[i].clear();
                }
                doc.markText(
                    { line: ex.Token.S_Line, ch: ex.Token.S_Ch },
                    { line: ex.Token.E_Line, ch: ex.Token.E_Ch },
                    { className: "code-error" });
                doc.setSelection(
                    { line: ex.Token.S_Line, ch: ex.Token.S_Ch },
                    { line: ex.Token.E_Line, ch: ex.Token.E_Ch });

                testEditor.focus();
            }
            alert(message);
            console.error(ex);
        }

図1: エラー箇所を赤くハイライト

CodeMirror には、行番号をクリックするとブレークポイントを設置する（表示をする）など、IDE を作るベースとなる機能が揃っているようです。簡単な IDE くらいはなら、CodeMirror を使って作ると簡単そうです。

配列（インデクサ）とプロパティ（C# とかにあるやつ）

クラスができたので、組み込みクラスの一つとして配列を実装しました。作っている処理系では、JavaScript の関数もクラスのメンバ関数として登録できますので、組み込みクラスを作ること自体は簡単です。また、これまで作ってきた機能のみで、例えば、Get(index) 、Set(index, Value) といったメソッドを定義すれば十分に配列として機能してくれます。ただ、arr[i] といった表記ができませんので、それを定義できる構文を追加しました。C# でいうインデクサです。

構文は迷いましたが、func のかわりに _index_get と _index_set と書けば定義できるようにしました。C# 風に、例えば、

_index 名前 { get{} set{} }

とかでも良かったのですが、修正が面倒だったたとこと、あまりあの構文が好きではないため、関数定義風の文法にしました。ついで、外部からメンバ変数風にアクセッサにアクセスできる C# 風のプロパティも作りました。（プロパティ、結構好きなんですよね）

コード3: インデクサとプロパティの文法追加

def_indexer : ("_index_get" | "_index_set") param_list block /* インデクサの定義 */
def_property: ("_get" | "_set") IDENTIFIER param_list block /* プロパティの定義 */

index_acc   : "[" expr "]" /* インデックス参照 */
variable	: ("this" | "base" | new_object | IDENTIFIER) { arg_list | index_acc } /* variableの定義も修正 */

次は実装です。インデクサの Get 方向は、登録されているインデクサ用関数を探しそれに引数を渡して呼び出すだけで OK です。値の設定は、メンバ変数への設定のところで作った機構を利用し、対象のインデクサ関数を呼び出すようなオブジェクトを返すことで対応しました。プロパティも大体同じような方法で実装しました。以下、その辺りのコードです。

コード4: インデクサとプロパティ

/**
 * インデックス参照
 * @param {SsExAST} left 
 * @param {SsAST} expr 
 * @param {SsToken} debugToken 
 */
var SsExAST_index_acc = function (left, expr, debugToken) {
    SsExAST.call(this);
    this.Token = debugToken;
    this.Left = left;
    this.Index = expr;
    //this.setAST(ast);
}
SsExAST_index_acc.prototype =
    {
        eval: function (env, leftObject) {

            var variable = this.Left.eval(env, leftObject).Value;
            var index = this.Index.eval(env).Value;

            var newScope = variable;
            variable.Outer = env.GetGlobal();

            var indexer = variable.Type.GetGetIndexer();

            if (typeof indexer == "function") {
                //JavaScriptのネイティブ関数
                return new SsResult(indexer.apply(variable, [index]));
            }
            else if (indexer instanceof SsExAST_declare_func) //関数の抽象木
            {
                return new SsResult(indexer.Call(newScope, [index], this.Token).Value);
            }
            else {
                throw new SsNotFoundMemberException(this.Token);
            }
        },
        getSetter: function (env, leftObject) {
            var variable = this.Left.eval(env, leftObject).Value;
            var index = this.Index.eval(env).Value;
            var newScope = variable;
            variable.Outer = env.GetGlobal();
            var indexer = variable.Type.GetSetIndexer();
            if (indexer == null) {
                throw new SsNotFoundMemberException(this.Token);
            }
			//インデクサへの設定用オブジェクトを返す
            return new SsValueSetterIndexer(newScope, variable, indexer, index, this.Token);
        }

    }

/**
 * 変数アクセス プロパティ対応版
 * @param {SsToken} token 
 */
var SsExAST_Variable = function (token) {
    SsExAST.call(this);
    this.Key = token;
    //this.setAST(ast);
}
SsExAST_Variable.prototype =
    {
        eval: function (env, leftObject) {
            if (leftObject == null) {
                return new SsResult(env.Get(this.Key.Token, this.Key));
            }
            else {
                var param = leftObject.GetMember(this.Key.Token, this.Key);
                if (param == null) {
                    throw new SsNotFoundMemberException(this.Key);
                }
				//プロパティアクセス
                if (param instanceof SsProperty) {
                    if (param.Getter != null) {
                        var getter = param.Getter;
                        if (typeof getter == "function") {
                            //JavaScriptのネイティブ関数
                            return new SsResult(getter.apply(leftObject, []));
                        }
                        else if (getter instanceof SsExAST_declare_func) //関数の抽象木
                        {
                            return getter.Call(leftObject, [], this.Key.Token);
                        }
                        else {
                            throw new SsNotFunctionException(this.Key);
                        }
                    }
                    else {
                        throw new SsUndefinedPropertyException(this.Key);
                    }
                }
                return new SsResult(param);
            }
        },
        getSetter: function (env, leftObject) {
            if (leftObject == null) {
                return new SsValueSetter(env, this.Key.Token, this.Key);
            }
            var value = leftObject.GetMember(this.Key.Token, this.Key);
            if (value instanceof SsProperty) {
                //プロパティ設定用のセッターを返す
                if (value.Setter == null) {
                    throw new SsUndefinedPropertyException(this.Key);
                }
                return new SsValueSetterProperty(env, leftObject, value, this.Key);
            }
            return new SsValueSetter(leftObject, this.Key.Token, this.Key);
        }
    }

言語の機能ができたので、組み込み配列を環境に登録しました。以下のような感じで登録可能です。ちょっと書くことが多いですが、まぁまぁだと思います。

//配列 thisはSsEnvironmentオブジェクト
    {
        var typeInfo = new SsTypeInfo("Array");
        typeInfo.ParentType = SsTypeInfo_Object;
        typeInfo.DeclareParam("jsArray");
        typeInfo.SetConstructor(function (count) {
            this.Params.jsArray = [];
            this.Params.length = count;
        }
        );
		// インデクサ登録
        typeInfo.DefineGetIndexer(function (index) {
            return this.Params.jsArray[index];
        });
        typeInfo.DefineSetIndexer(function (index, value) {
            this.Params.jsArray[index] = value;
        });
		// プロパティ登録
		// プロパティは、SsProperty型のオブジェクトを登録するとそうなる
        typeInfo.DefineMethod("Length", new SsProperty("Length",
                function () {
                    return this.Params.length;
                },
                null));

        this.DefineType(typeInfo.Name, typeInfo);
    }

ここまで作れば、以下のようなコードが実行可能です。

コード5: テストコード

var x = "\n";

class Vector2
{
    var x = 0;
    var y = 0;

    constructor(_x, y)
    {
        x = _x;
        this.y = y;
    }

	_index_get(index)
	{
		if(index == 0) return x;
		if(index == 1) return y;
		return 0;
	}

	_index_set(index, value)
	{
		if(index == 0) x = value;
		if(index == 1) y = value;
	}

    _get X()
    {
        return x;
    }

    _set X(value)
    {
         x = value;
    }

	func ToString()
	{
        // thisのインデクサにアクセス
		return (" x = " + this[0] + ", y = " + y );
	}
}


func main()
{
	var arr = new Array(5);

	// arr.Lengthはプロパティ
    for(var i = 0; i < arr.Length; i++)
    {
        arr[i] = new Vector2(0,7);
        // 定義したインデクサにアクセス
		arr[i][0] = i;
        print("indexer = " + arr[i][0] + "\n");
        // プロパティに設定
		arr[i].X = i * 4;
        print("property = " + arr[i].X + "\n");
    }
	 for(var i = 0; i < arr.Length; i++)
    {
        println("arr["+i+"] : " + arr[i].ToString());
    }
}

func println(str)
{
    // ちゃんとグローバルを参照してる？
	print(str + x);
	return 10;
}

コード6: テストコードの実行結果

indexer = 0
property = 0
indexer = 1
property = 4
indexer = 2
property = 8
indexer = 3
property = 12
indexer = 4
property = 16
arr[0] : x = 0, y = 7
arr[1] : x = 4, y = 7
arr[2] : x = 8, y = 7
arr[3] : x = 12, y = 7
arr[4] : x = 16, y = 7

配列の初期化がまだですが、ここまでできれば簡単そうなので省略と…（文法を決めかねているのもあります）

まとめ

抽象木もスッキリし、クラスの実装も終わり、欲しかったインデクサとプロパティもできたので、個人的にはかなりいい感じになってきたと思います。ここまで作ってみると、言語の作り方もだいぶわかってきました。

色々と使って不具合が無いかを確認してから、そろそろこのバージョンは一旦終了しようかと思います。その次は、実用に向けて、静的型付け言語の制作に取り掛かりたいです。

ここまでの進捗は、こちらに置いてあります。