Golang Newの例

コード例 #1

func main() {

	qall.InitSafe(true)
	qlang.SetDumpCode(os.Getenv("QLANG_DUMPCODE"))

	libs := os.Getenv("QLANG_PATH")
	if libs == "" {
		libs = os.Getenv("HOME") + "/qlang"
	}

	if len(os.Args) > 1 {
		lang, err := qlang.New(qlang.InsertSemis)
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(1)
		}
		lang.SetLibs(libs)
		fname := os.Args[1]
		b, err := ioutil.ReadFile(fname)
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(2)
		}
		err = lang.SafeExec(b, fname)
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(3)
		}
		return
	}

	qall.Copyright()

	var ret interface{}
	qlang.SetOnPop(func(v interface{}) {
		ret = v
	})

	lang, err := qlang.New(nil)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	lang.SetLibs(libs)

	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		line := strings.Trim(scanner.Text(), " \t\r\n")
		if line == "" {
			continue
		}
		ret = nil
		err := lang.SafeEval(line)
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			continue
		}
		fmt.Printf("> %v\n\n", ret)
	}
}

コード例 #2

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestSwitchDefaultContinue(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`
		for i = 3; i < 10; i++ {
			x = 1
			y = 2
			switch {
			case false:
				z = 4
			default:
				z = 3
				continue
			}
			i = 100
		}`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("i"); !ok || v != 10 {
		t.Fatal("i =", v)
	}
}

コード例 #3

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestSwitchBreak(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`
		for i = 3; i < 10; i++ {
			x = 1
			y = 2
			switch {
			case true:
				z = 3
				break
			}
			i = 100
		}`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("i"); !ok || v != 101 {
		t.Fatal("i =", v)
	}
}

コード例 #4

ファイル: class2_test.go プロジェクト: ttthzy/qlang

func TestInject(t *testing.T) {

	lang := qlang.New()
	err := lang.SafeExec([]byte(testInjectCode), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 3 {
		t.Fatal("x != 3, x =", v)
	}

	err = lang.InjectMethods("typ", []byte(testInjectMethodsCode))
	if err != nil {
		t.Fatal("InjectMethods failed:", err)
	}

	err = lang.SafeEval(testInjectCheckCode)
	if err != nil {
		t.Fatal("SafeEval failed:", err)
	}
	if v, ok := lang.Var("x2"); !ok || v != 4 {
		t.Fatal("x2 != 4, x2 =", v)
	}
	if v, ok := lang.Var("x3"); !ok || v != 11 {
		t.Fatal("x3 != 11, x3 =", v)
	}
}

コード例 #5

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestForRange9(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`

		ch = mkchan("int", 2)
		ch <- 10
		ch <- 20
		close(ch)

		x = 0
		for v = range ch {
			x += v
		}`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 30 {
		t.Fatal("x =", v)
	}
}

コード例 #6

ファイル: class2_test.go プロジェクト: ttthzy/qlang

func TestMemberRef(t *testing.T) {

	lang := qlang.New()
	qlang.Import("", map[string]interface{}{
		"fooMemberPtr": fooMemberPtr,
		"fooCall":      fooCall,
	})

	err := lang.SafeExec([]byte(testMemberRefCode), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 3 {
		t.Fatal("x != 3, x =", v)
	}
	if v, ok := lang.Var("y"); !ok || v != 3 {
		t.Fatal("y != 3, y =", v)
	}
	if v, ok := lang.Var("z"); !ok || v != 3 {
		t.Fatal("z != 3, z =", v)
	}
	if v, ok := lang.Var("ret"); !ok || v != 3 {
		t.Fatal("ret != 3, ret =", v)
	}
}

コード例 #7

ファイル: goroutine_test.go プロジェクト: ttthzy/qlang

func TestGoroutine(t *testing.T) {

	lang := qlang.New()
	err := lang.SafeExec([]byte(testGoroutineCode), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 3 {
		t.Fatal("x != 3, x =", v)
	}
}

コード例 #8

ファイル: class2_test.go プロジェクト: ttthzy/qlang

func TestNewClass(t *testing.T) {

	lang := qlang.New()
	err := lang.SafeExec([]byte(testNewClassCode), "")
	if err != nil {
		t.Fatal(err)
	}
	if v, ok := lang.Var("x"); !ok || v != 2 {
		t.Fatal("x != 2, x =", v)
	}
}

コード例 #9

ファイル: mini.go プロジェクト: ttthzy/qlang

func main() {

	lang := qlang.New()
	err := lang.SafeExec([]byte(scriptCode), "")
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(2)
	}

	v, _ := lang.Var("x")
	fmt.Println("x:", v)
}

コード例 #10

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestContinue(t *testing.T) {

	lang, err := qlang.New(nil)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`for i = 3; i < 10; i++ { continue; i=100 }`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("i"); !ok || v != 10 {
		t.Fatal("i =", v)
	}
}

コード例 #11

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestIfBreak(t *testing.T) {

	lang, err := qlang.New(nil)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`for i = 3; i < 10; i++ { x = 1; y = 2; if i == 8 { z = 3; break } }`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("i"); !ok || v != 8 {
		t.Fatal("i =", v)
	}
}

コード例 #12

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestIf(t *testing.T) {

	lang, err := qlang.New(nil)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`fn { 0 }; if true { x = 3 } else { x = 5 }`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 3 {
		t.Fatal("x =", v)
	}
}

コード例 #13

ファイル: function_test.go プロジェクト: yonglehou/qlang

func TestAnonymFn(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(testAnonymFnCode), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 3 {
		t.Fatal("x != 3, x =", v)
	}
}

コード例 #14

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestNormalFor(t *testing.T) {

	lang, err := qlang.New(nil)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`for i = 3; i < 10; i++ {}`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("i"); !ok || v != 10 {
		t.Fatal("i =", 10)
	}
}

コード例 #15

ファイル: var_test.go プロジェクト: yonglehou/qlang

func TestErrMultiAssign(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(testErrMultiAssignCode), "")
	if err == nil {
		t.Fatal("qlang.SafeExec?")
	}
	if err.Error() != "line 3: runtime error: argument count of multi assignment doesn't match" {
		t.Fatal("testErrMultiAssignCode:", err)
	}
}

コード例 #16

ファイル: function_test.go プロジェクト: yonglehou/qlang

func TestTypeOf(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(testTypeOfCode), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != reflect.TypeOf(uint32(1)) {
		t.Fatal("x != uint32, x =", v)
	}
}

コード例 #17

ファイル: function_test.go プロジェクト: yonglehou/qlang

func TestClosure2(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(testClosureCode2), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 1 {
		t.Fatal("x != 1, x =", v)
	}
}

コード例 #18

ファイル: module_test.go プロジェクト: yonglehou/qlang

func TestInclude(t *testing.T) {

	lang, _ := qlang.New(qlang.InsertSemis)

	qlang.SetReadFile(func(file string) ([]byte, error) {
		return []byte(scriptA), nil
	})

	err := lang.SafeExec([]byte(scriptB), "b.ql")
	if err != nil {
		t.Fatal(err)
	}
	if v, ok := lang.Var("b"); !ok || v != 2 {
		t.Fatal("b != 2, b =", v)
	}
}

コード例 #19

ファイル: function_test.go プロジェクト: yonglehou/qlang

func TestUint32(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	lang.SetVar("foo", fooUint32)

	err = lang.SafeExec([]byte(testUint32Code), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != uint32(6) {
		t.Fatal("x != 6, x =", v)
	}
}

コード例 #20

ファイル: function_test.go プロジェクト: yonglehou/qlang

func TestReturn2(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(testReturnCode2), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 3 {
		t.Fatal("x != 3, x =", v)
	}
	if v, ok := lang.Var("y"); !ok || v != 2 {
		t.Fatal("y != 2, y =", v)
	}
}

コード例 #21

ファイル: qlang_test.go プロジェクト: yonglehou/qlang

func TestNilSlice(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(testNilSliceCode), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != reflect.TypeOf([]interface{}(nil)) {
		t.Fatal("x != []interface{}, x =", v)
	}
	if v, ok := lang.Var("y"); !ok || v != 1 {
		t.Fatal("y != 1, y =", v)
	}
}

コード例 #22

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestForRange3(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`
		x = 0
		for _, v = range [10, 20] {
			x += v
		}`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 30 {
		t.Fatal("x =", v)
	}
}

コード例 #23

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestForRange7(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`
		x = 0
		for k, v = range {10: 3, 20: 4} {
			x += k + v
		}`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 37 {
		t.Fatal("x =", v)
	}
}

コード例 #24

ファイル: module_test.go プロジェクト: yonglehou/qlang

func TestModuleClass(t *testing.T) {

	lang, _ := qlang.New(qlang.InsertSemis)

	qlang.SetFindEntry(func(file string, libs []string) (string, error) {
		return file, nil
	})

	qlang.SetReadFile(func(file string) ([]byte, error) {
		return []byte(scriptA2), nil
	})

	err := lang.SafeExec([]byte(scriptB2), "b.ql")
	if err != nil {
		t.Fatal(err)
	}
	if v, ok := lang.Var("x"); !ok || v != 2 {
		t.Fatal("x != 2, x =", v)
	}
}

コード例 #25

ファイル: module_test.go プロジェクト: yonglehou/qlang

func TestImport(t *testing.T) {

	lang, _ := qlang.New(qlang.InsertSemis)

	qlang.SetFindEntry(func(file string, libs []string) (string, error) {
		return file, nil
	})

	qlang.SetReadFile(func(file string) ([]byte, error) {
		return []byte(scriptA), nil
	})

	err := lang.SafeExec([]byte(scriptC), "c.ql")
	if err != nil {
		t.Fatal(err)
	}
	if v, ok := lang.Var("a"); !ok || v.(map[string]interface{})["b"] != 4 {
		t.Fatal("a.b != 4, a.b =", v)
	}
}

コード例 #26

ファイル: module_test.go プロジェクト: yonglehou/qlang

func TestModuleDefer(t *testing.T) {

	lang, _ := qlang.New(qlang.InsertSemis)

	qlang.SetFindEntry(func(file string, libs []string) (string, error) {
		return file, nil
	})

	qlang.SetReadFile(func(file string) ([]byte, error) {
		return []byte(scriptA1), nil
	})

	err := lang.SafeExec([]byte(scriptB1), "b.ql")
	if err != nil {
		t.Fatal(err)
	}
	if v, ok := lang.Var("a"); !ok || v.(map[string]interface{})["x"] != 2 {
		t.Fatal("x != 2, x =", v)
	}
}

コード例 #27

ファイル: var_test.go プロジェクト: yonglehou/qlang

func TestGet(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(testGetCode), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 3 {
		t.Fatal("x != 3, x =", v)
	}
	if v, ok := lang.Var("y"); !ok || v != byte('3') {
		t.Fatal("y != '3', y =", v)
	}
	if v, ok := lang.Var("z"); !ok || v != 1 {
		t.Fatal("z != 1, z =", v)
	}
}

コード例 #28

ファイル: eql_main.go プロジェクト: ttthzy/qlang

func main() {

	qall.InitSafe(false)
	qlang.Import("", interpreter.Exports)
	qlang.SetDumpCode(os.Getenv("QLANG_DUMPCODE"))

	libs := os.Getenv("QLANG_PATH")
	if libs == "" {
		libs = os.Getenv("HOME") + "/qlang"
	}

	lang := qlang.New()
	lang.SetLibs(libs)

	vars = lang.Context
	eql := eqlang.New(lang)

	parseFlags()
	if source == "" {
		fmt.Fprintln(os.Stderr, usage)
		return
	}

	fi, err := os.Stat(source)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(-2)
	}

	if fi.IsDir() {
		global := lang.CopyVars()
		eql.ExecuteDir(global, source, output)
	} else {
		eql.ExecuteFile(source, output)
	}
}

コード例 #29

ファイル: ctrl_test.go プロジェクト: yonglehou/qlang

func TestForRange11(t *testing.T) {

	lang, err := qlang.New(qlang.InsertSemis)
	if err != nil {
		t.Fatal("qlang.New:", err)
	}

	err = lang.SafeExec([]byte(`
		x = 0
		for i, v = range [10, 20, 30, 40] {
			if true {
				if i == 2 {
					continue
				}
			}
			x += v
		}`), "")
	if err != nil {
		t.Fatal("qlang.SafeExec:", err)
	}
	if v, ok := lang.Var("x"); !ok || v != 70 {
		t.Fatal("x =", v)
	}
}