前言

本篇文章主要是記錄一下在 GScript 中實現遞歸調用時所遇到的坑，類似的問題在中文互聯網上我幾乎沒有找到相關的內容，所以還是很有必要記錄一下。

在開始之前還是簡單介紹下本次更新的 GScript v0.0.9 所包含的內容：

支持可變參數
優化 append 函數語義
優化編譯錯誤信息
最後一個就是支持遞歸調用

先看第一個可變參數：

//formats according to a format specifier and writes to standard output.
printf(string format, any ...a){}

//formats according to a format specifier and returns the resulting string.
string sprintf(string format, any ...a){}

以上是隨着本次更新新增的兩個標準函數，均支持可變參數，其中使用 ... 表示可變參數，調用時如下：

printf("hello %s ","123");
printf("hello-%s-%s ","123","abc");
printf("hello-%s-%d ","123",123);
string format = "this is %s ";
printf(format, "gscript");

string s = sprintf("nice to meet %s", "you");
assertEqual(s,"nice to meet you");

與大部分語言類似，可變參數本質上就是一個數組，所以可以拿來循環遍歷：

int add(string s, int ...num){
	println(s);
	int sum = 0;
	for(int i=0;i<len(num);i++){
		int v = num[i];
		sum = sum+v;
	}
	return sum;
}
int x = add("abc", 1,2,3,4);
println(x);
assertEqual(x, 10);

// appends "v" to the end of a array "a"
append(any[] a, any v){}

之後是優化了內置函數 append() 的語義，本次優化來自於 issue12 的建議：
//github.com/crossoverJie/gscript/issues/12

// Before
int[] a={1,2,3};
println(a);
println();
a = append(a,4);
println(a);
// Output: [1 2 3 4]

// Now
int[] a={1,2,3};
println(a);
println();
append(a,4);
int b = a[3];
assertEqual(4, b);
println(a);
// Output: [1 2 3 4]

現在 append 之後不需要再重新賦值，也會追加數據，優化後這裡看起來是一個值/引用傳遞的問題，但其實底層也是值傳遞，只是在語法上增加了這樣的語法糖，幫使用者重新做了一次賦值。

之後是新增了編譯錯誤信息提示，比如下面這段代碼：

a+2;
b+c;

使用沒有聲明的變量，現在會直接編譯失敗：

1:0: undefined: a
2:0: undefined: b
2:2: undefined: c

class T{}
class T{}

// output:
2:0: class T redeclared in this block

重複聲明之類的語法錯誤也有相關提示。

最後一個才是本次討論的重點，也就是遞歸函數的支持。

int num(int x,int y){
	if (y==1 || y ==x) {
		return 1;
	}
	int v1 = num(x - 1, y - 1);
	return c;
}

再上一個版本中 int v1 = num(x - 1, y - 1); 這行代碼是不會執行的，具體原因後文會分析。

現在利用遞歸便可以實現類似於打印楊輝三角之類的程序了：

int num(int x,int y){
	if (y==1 || y ==x) {
		return 1;
	}
    int v1 = num(x - 1, y - 1);
    int v2 = num(x - 1, y);
	int c = v1+v2;
    // int c = num(x - 1, y - 1)+num(x - 1, y);
	return c;
}
printTriangle(int row){
	for (int i = 1; i <= row; i++) {
        for (int j = 1; j <= row - i; j++) {
           print(" ");
        }
        for (int j = 1; j <= i; j++) {
            print(num(i, j) + " ");
        }
        println("");
    }
}
printTriangle(7);

// output:
      1 
     1 1 
    1 2 1 
   1 3 3 1 
  1 4 6 4 1 
 1 5 10 10 5 1 
1 6 15 20 15 6 1

函數中的 return

int num(int x,int y){
	if (y==1 || y ==x) {
		return 1;
	}
	int v1 = num(x - 1, y - 1);
	return c;
}

現在我們來看看這樣的代碼為什麼執行完 return 1 之後就不會執行後邊的語句了。

其實在此之前我首先解決的時候函數 return 後不能執行後續 statement 的需求，其實正好就是上文提到的邏輯，只是這裡是遞歸而已。

先把代碼簡化一下方便分析：

int f1(int a){
	if (a==10){
		return 10;
	}
	println("abc");
}

當參數 a 等於 10 的時候確實不能執行後續的打印語句了，那麼如何實現該需求呢？

以正常人類的思考方式：當我們執行完 return 語句的時候，就應該標記該語句所屬的函數直接返回，不能在執行後續的 statement。

可是這應該如何實操呢？

其實看看 AST 就能明白了：

當碰到 return 語句的時，會遞歸向上遍歷語法樹，標記上所有 block 節點表明這個 block 後續的語句不再執行了，同時還得把返回值記錄下來。

這樣當執行到下一個 statement 時，也就是 println("abc"); 則會判斷他所屬的 block 是否有被標記，如果有則直接返回，這樣便實現了 return 語句不執行後續代碼。

部分實現代碼如下：

// 在 return 的時候遞歸向上掃描所有的 Block，並打上標記，用於後面執行 return 的時候直接返回。
func (v *Visitor) scanBlockStatementCtx(tree antlr.ParseTree, value interface{}) {
	context, ok := tree.(*parser.BlockContext)
	if ok {
		if v.blockCtx2Mark == nil {
			v.blockCtx2Mark = make(map[*parser.BlockContext]interface{})
		}
		v.blockCtx2Mark[context] = value
	}
	if tree.GetParent() != nil {
		v.scanBlockStatementCtx(tree.GetParent().(antlr.ParseTree), value)
	}
}