github.com/yuin/gopher-lua@v1.1.2-0.20231212122839-2348fd042596/cmd/glua/glua.go (about)

     1  package main
     2  
     3  import (
     4  	"flag"
     5  	"fmt"
     6  	"github.com/chzyer/readline"
     7  	"github.com/yuin/gopher-lua"
     8  	"github.com/yuin/gopher-lua/parse"
     9  	"os"
    10  	"runtime/pprof"
    11  )
    12  
    13  func main() {
    14  	os.Exit(mainAux())
    15  }
    16  
    17  func mainAux() int {
    18  	var opt_e, opt_l, opt_p string
    19  	var opt_i, opt_v, opt_dt, opt_dc bool
    20  	var opt_m int
    21  	flag.StringVar(&opt_e, "e", "", "")
    22  	flag.StringVar(&opt_l, "l", "", "")
    23  	flag.StringVar(&opt_p, "p", "", "")
    24  	flag.IntVar(&opt_m, "mx", 0, "")
    25  	flag.BoolVar(&opt_i, "i", false, "")
    26  	flag.BoolVar(&opt_v, "v", false, "")
    27  	flag.BoolVar(&opt_dt, "dt", false, "")
    28  	flag.BoolVar(&opt_dc, "dc", false, "")
    29  	flag.Usage = func() {
    30  		fmt.Println(`Usage: glua [options] [script [args]].
    31  Available options are:
    32    -e stat  execute string 'stat'
    33    -l name  require library 'name'
    34    -mx MB   memory limit(default: unlimited)
    35    -dt      dump AST trees
    36    -dc      dump VM codes
    37    -i       enter interactive mode after executing 'script'
    38    -p file  write cpu profiles to the file
    39    -v       show version information`)
    40  	}
    41  	flag.Parse()
    42  	if len(opt_p) != 0 {
    43  		f, err := os.Create(opt_p)
    44  		if err != nil {
    45  			fmt.Println(err.Error())
    46  			os.Exit(1)
    47  		}
    48  		pprof.StartCPUProfile(f)
    49  		defer pprof.StopCPUProfile()
    50  	}
    51  	if len(opt_e) == 0 && !opt_i && !opt_v && flag.NArg() == 0 {
    52  		opt_i = true
    53  	}
    54  
    55  	status := 0
    56  
    57  	L := lua.NewState()
    58  	defer L.Close()
    59  	if opt_m > 0 {
    60  		L.SetMx(opt_m)
    61  	}
    62  
    63  	if opt_v || opt_i {
    64  		fmt.Println(lua.PackageCopyRight)
    65  	}
    66  
    67  	if len(opt_l) > 0 {
    68  		if err := L.DoFile(opt_l); err != nil {
    69  			fmt.Println(err.Error())
    70  		}
    71  	}
    72  
    73  	if nargs := flag.NArg(); nargs > 0 {
    74  		script := flag.Arg(0)
    75  		argtb := L.NewTable()
    76  		for i := 1; i < nargs; i++ {
    77  			L.RawSet(argtb, lua.LNumber(i), lua.LString(flag.Arg(i)))
    78  		}
    79  		L.SetGlobal("arg", argtb)
    80  		if opt_dt || opt_dc {
    81  			file, err := os.Open(script)
    82  			if err != nil {
    83  				fmt.Println(err.Error())
    84  				return 1
    85  			}
    86  			chunk, err2 := parse.Parse(file, script)
    87  			if err2 != nil {
    88  				fmt.Println(err2.Error())
    89  				return 1
    90  			}
    91  			if opt_dt {
    92  				fmt.Println(parse.Dump(chunk))
    93  			}
    94  			if opt_dc {
    95  				proto, err3 := lua.Compile(chunk, script)
    96  				if err3 != nil {
    97  					fmt.Println(err3.Error())
    98  					return 1
    99  				}
   100  				fmt.Println(proto.String())
   101  			}
   102  		}
   103  		if err := L.DoFile(script); err != nil {
   104  			fmt.Println(err.Error())
   105  			status = 1
   106  		}
   107  	}
   108  
   109  	if len(opt_e) > 0 {
   110  		if err := L.DoString(opt_e); err != nil {
   111  			fmt.Println(err.Error())
   112  			status = 1
   113  		}
   114  	}
   115  
   116  	if opt_i {
   117  		doREPL(L)
   118  	}
   119  	return status
   120  }
   121  
   122  // do read/eval/print/loop
   123  func doREPL(L *lua.LState) {
   124  	rl, err := readline.New("> ")
   125  	if err != nil {
   126  		panic(err)
   127  	}
   128  	defer rl.Close()
   129  	for {
   130  		if str, err := loadline(rl, L); err == nil {
   131  			if err := L.DoString(str); err != nil {
   132  				fmt.Println(err)
   133  			}
   134  		} else { // error on loadline
   135  			fmt.Println(err)
   136  			return
   137  		}
   138  	}
   139  }
   140  
   141  func incomplete(err error) bool {
   142  	if lerr, ok := err.(*lua.ApiError); ok {
   143  		if perr, ok := lerr.Cause.(*parse.Error); ok {
   144  			return perr.Pos.Line == parse.EOF
   145  		}
   146  	}
   147  	return false
   148  }
   149  
   150  func loadline(rl *readline.Instance, L *lua.LState) (string, error) {
   151  	rl.SetPrompt("> ")
   152  	if line, err := rl.Readline(); err == nil {
   153  		if _, err := L.LoadString("return " + line); err == nil { // try add return <...> then compile
   154  			return line, nil
   155  		} else {
   156  			return multiline(line, rl, L)
   157  		}
   158  	} else {
   159  		return "", err
   160  	}
   161  }
   162  
   163  func multiline(ml string, rl *readline.Instance, L *lua.LState) (string, error) {
   164  	for {
   165  		if _, err := L.LoadString(ml); err == nil { // try compile
   166  			return ml, nil
   167  		} else if !incomplete(err) { // syntax error , but not EOF
   168  			return ml, nil
   169  		} else {
   170  			rl.SetPrompt(">> ")
   171  			if line, err := rl.Readline(); err == nil {
   172  				ml = ml + "\n" + line
   173  			} else {
   174  				return "", err
   175  			}
   176  		}
   177  	}
   178  }