GoPlus自由研究

package main

import (
	"fmt"

	"github.com/qiniu/goplus/tutorial/14-Using-goplus-in-Go/foo"
)

func main() {
	rmap := foo.ReverseMap(map[string]int{"Hi": 1, "Hello": 2})
	fmt.Println(rmap)
}

func main() {
	flag.Parse()
	if flag.NArg() < 1 {
		fmt.Fprintf(os.Stderr, "Usage: qrun [-asm -quiet -debug -prof] <gopSrcDir|gopSrcFile>\n")
		flag.PrintDefaults()
		return
	}

target, _ := filepath.Abs(flag.Arg(0))
	isDir, err := IsDir(target)
	if err != nil {
		log.Fatalln("input arg check failed:", err)
	}
	pkgs, err := parser.ParseGopFiles(fset, target, isDir, 0)
	if err != nil {
		log.Fatalln("ParseGopFiles failed:", err)
	}

cl.CallBuiltinOp = exec.CallBuiltinOp

	b := exec.NewBuilder(nil)
	_, err = cl.NewPackage(b.Interface(), pkgs["main"], fset, cl.PkgActClMain)
	if err != nil {
		log.Fatalln("cl.NewPackage failed:", err)
	}
	code := b.Resolve()
	if *flagAsm {
		code.Dump(os.Stdout)
		return
	}
	ctx := exec.NewContext(code)
	ctx.Exec(0, code.Len())
	if *flagProf {
		exec.ProfileReport()
	}

func NewPackage(out exec.Builder, pkg *ast.Package, fset *token.FileSet, act PkgAct) (p *Package, err error) {
	if pkg == nil {
		return nil, ErrNotFound
	}
	if CallBuiltinOp == nil {
		log.Panicln("NewPackage failed: variable CallBuiltinOp is uninitialized")
	}
	p = &Package{}
	ctxPkg := newPkgCtx(out, pkg, fset)
	ctx := newGblBlockCtx(ctxPkg)
	for _, f := range pkg.Files {
		loadFile(ctx, f)
	}
	switch act {
	case PkgActClAll:
		for _, sym := range ctx.syms {
			if f, ok := sym.(*funcDecl); ok && f.fi != nil {
				ctxPkg.use(f)
			}
		}
		if pkg.Name != "main" {
			break
		}
		fallthrough
	case PkgActClMain:
		if pkg.Name != "main" {
			return nil, ErrNotAMainPackage
		}
		entry, err := ctx.findFunc("main")
		if err != nil {
			if err == ErrNotFound {
				err = ErrMainFuncNotFound
			}
			return p, err
		}
		if entry.ctx.noExecCtx {
			ctx.file = entry.ctx.file
			compileBlockStmtWithout(ctx, entry.body)
			ctx.checkLabels()
		} else {
			out.CallFunc(entry.Get(), 0)
			ctxPkg.use(entry)
		}
		out.Return(-1)
	}
	ctxPkg.resolveFuncs()
	p.syms = ctx.syms
	return
}

func compileExpr(ctx *blockCtx, expr ast.Expr) func() {
	switch v := expr.(type) {
	case *ast.Ident:
		return compileIdent(ctx, v.Name)
	case *ast.BasicLit:
		return compileBasicLit(ctx, v)
	case *ast.CallExpr:
		return compileCallExpr(ctx, v)
	case *ast.BinaryExpr:
		return compileBinaryExpr(ctx, v)
	case *ast.UnaryExpr:
		return compileUnaryExpr(ctx, v)
	case *ast.SelectorExpr:
		return compileSelectorExpr(ctx, v)
	case *ast.ErrWrapExpr:
		return compileErrWrapExpr(ctx, v)
	case *ast.IndexExpr:
		return compileIndexExpr(ctx, v)
	case *ast.SliceExpr:
		return compileSliceExpr(ctx, v)
	case *ast.CompositeLit:
		return compileCompositeLit(ctx, v)
	case *ast.SliceLit:
		return compileSliceLit(ctx, v)
	case *ast.FuncLit:
		return compileFuncLit(ctx, v)
	case *ast.ParenExpr:
		return compileExpr(ctx, v.X)
	case *ast.ListComprehensionExpr:
		return compileListComprehensionExpr(ctx, v)
	case *ast.MapComprehensionExpr:
		return compileMapComprehensionExpr(ctx, v)
	case *ast.ArrayType:
		return compileArrayType(ctx, v)
	case *ast.Ellipsis:
		return compileEllipsis(ctx, v)
	case *ast.KeyValueExpr:
		panic("compileExpr: ast.KeyValueExpr unexpected")
	default:
		log.Panicln("compileExpr failed: unknown -", reflect.TypeOf(v))
		return nil
	}
}

func compileSliceExpr(ctx *blockCtx, v *ast.SliceExpr) func() { // x[i:j:k]
	var kind reflect.Kind
	exprX := compileExpr(ctx, v.X)
	x := ctx.infer.Get(-1)
	typ := x.(iValue).Type()
	if kind = typ.Kind(); kind == reflect.Ptr {
		typ = typ.Elem()
		if kind = typ.Kind(); kind != reflect.Array {
			logPanic(ctx, v, `cannot slice a (type *%v)`, typ)
		}
		typ = reflect.SliceOf(typ.Elem())
		ctx.infer.Ret(1, &goValue{typ})
	}
	return func() {
		exprX()
		i, j, k := exec.SliceDefaultIndex, exec.SliceDefaultIndex, exec.SliceDefaultIndex
		if v.Low != nil {
			i = compileIdx(ctx, v.Low, exec.SliceConstIndexLast, kind)
		}
		if v.High != nil {
			j = compileIdx(ctx, v.High, exec.SliceConstIndexLast, kind)
		}
		if v.Max != nil {
			k = compileIdx(ctx, v.Max, exec.SliceConstIndexLast, kind)
		}
		if v.Slice3 {
			ctx.out.Slice3(i, j, k)
		} else {
			ctx.out.Slice(i, j)
		}
	}
}