func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("ErrNotFound", reflect.ValueOf(e.ErrNotFound))
m.Define("LookPath", reflect.ValueOf(e.LookPath))
m.Define("Command", reflect.ValueOf(e.Command))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("ReadAll", reflect.ValueOf(u.ReadAll))
m.Define("ReadDir", reflect.ValueOf(u.ReadDir))
m.Define("ReadFile", reflect.ValueOf(u.ReadFile))
m.Define("WriteFile", reflect.ValueOf(u.WriteFile))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("DefaultClient", reflect.ValueOf(h.DefaultClient))
m.Define("NewServeMux", reflect.ValueOf(h.NewServeMux))
m.Define("Handle", reflect.ValueOf(h.Handle))
m.Define("HandleFunc", reflect.ValueOf(h.HandleFunc))
m.Define("ListenAndServe", reflect.ValueOf(h.ListenAndServe))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Match", reflect.ValueOf(r.Match))
m.Define("MatchReader", reflect.ValueOf(r.MatchReader))
m.Define("MatchString", reflect.ValueOf(r.MatchString))
m.Define("QuoteMeta", reflect.ValueOf(r.QuoteMeta))
m.Define("Compile", reflect.ValueOf(r.Compile))
m.Define("CompilePOSIX", reflect.ValueOf(r.CompilePOSIX))
m.Define("MustCompile", reflect.ValueOf(r.MustCompile))
m.Define("MustCompilePOSIX", reflect.ValueOf(r.MustCompilePOSIX))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Base", reflect.ValueOf(pkg.Base))
m.Define("Clean", reflect.ValueOf(pkg.Clean))
m.Define("Dir", reflect.ValueOf(pkg.Dir))
m.Define("ErrBadPattern", reflect.ValueOf(pkg.ErrBadPattern))
m.Define("Ext", reflect.ValueOf(pkg.Ext))
m.Define("IsAbs", reflect.ValueOf(pkg.IsAbs))
m.Define("Join", reflect.ValueOf(pkg.Join))
m.Define("Match", reflect.ValueOf(pkg.Match))
m.Define("Split", reflect.ValueOf(pkg.Split))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Ints", reflect.ValueOf(func(ints []interface{}) []interface{} {
s.Sort(is(ints))
return ints
}))
m.Define("Float64s", reflect.ValueOf(func(ints []interface{}) []interface{} {
s.Sort(is(ints))
return ints
}))
m.Define("Strings", reflect.ValueOf(func(ints []interface{}) []interface{} {
s.Sort(is(ints))
return ints
}))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Contains", reflect.ValueOf(pkg.Contains))
m.Define("ContainsAny", reflect.ValueOf(pkg.ContainsAny))
m.Define("ContainsRune", reflect.ValueOf(pkg.ContainsRune))
m.Define("Count", reflect.ValueOf(pkg.Count))
m.Define("EqualFold", reflect.ValueOf(pkg.EqualFold))
m.Define("Fields", reflect.ValueOf(pkg.Fields))
m.Define("FieldsFunc", reflect.ValueOf(pkg.FieldsFunc))
m.Define("HasPrefix", reflect.ValueOf(pkg.HasPrefix))
m.Define("HasSuffix", reflect.ValueOf(pkg.HasSuffix))
m.Define("Index", reflect.ValueOf(pkg.Index))
m.Define("IndexAny", reflect.ValueOf(pkg.IndexAny))
m.Define("IndexByte", reflect.ValueOf(pkg.IndexByte))
m.Define("IndexFunc", reflect.ValueOf(pkg.IndexFunc))
m.Define("IndexRune", reflect.ValueOf(pkg.IndexRune))
m.Define("Join", reflect.ValueOf(pkg.Join))
m.Define("LastIndex", reflect.ValueOf(pkg.LastIndex))
m.Define("LastIndexAny", reflect.ValueOf(pkg.LastIndexAny))
m.Define("LastIndexFunc", reflect.ValueOf(pkg.LastIndexFunc))
m.Define("Map", reflect.ValueOf(pkg.Map))
m.Define("NewReader", reflect.ValueOf(pkg.NewReader))
m.Define("NewReplacer", reflect.ValueOf(pkg.NewReplacer))
m.Define("Repeat", reflect.ValueOf(pkg.Repeat))
m.Define("Replace", reflect.ValueOf(pkg.Replace))
m.Define("Split", reflect.ValueOf(pkg.Split))
m.Define("SplitAfter", reflect.ValueOf(pkg.SplitAfter))
m.Define("SplitAfterN", reflect.ValueOf(pkg.SplitAfterN))
m.Define("SplitN", reflect.ValueOf(pkg.SplitN))
m.Define("Title", reflect.ValueOf(pkg.Title))
m.Define("ToLower", reflect.ValueOf(pkg.ToLower))
m.Define("ToLowerSpecial", reflect.ValueOf(pkg.ToLowerSpecial))
m.Define("ToTitle", reflect.ValueOf(pkg.ToTitle))
m.Define("ToTitleSpecial", reflect.ValueOf(pkg.ToTitleSpecial))
m.Define("ToUpper", reflect.ValueOf(pkg.ToUpper))
m.Define("ToUpperSpecial", reflect.ValueOf(pkg.ToUpperSpecial))
m.Define("Trim", reflect.ValueOf(pkg.Trim))
m.Define("TrimFunc", reflect.ValueOf(pkg.TrimFunc))
m.Define("TrimLeft", reflect.ValueOf(pkg.TrimLeft))
m.Define("TrimLeftFunc", reflect.ValueOf(pkg.TrimLeftFunc))
m.Define("TrimPrefix", reflect.ValueOf(pkg.TrimPrefix))
m.Define("TrimRight", reflect.ValueOf(pkg.TrimRight))
m.Define("TrimRightFunc", reflect.ValueOf(pkg.TrimRightFunc))
m.Define("TrimSpace", reflect.ValueOf(pkg.TrimSpace))
m.Define("TrimSuffix", reflect.ValueOf(pkg.TrimSuffix))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Copy", reflect.ValueOf(pkg.Copy))
m.Define("CopyN", reflect.ValueOf(pkg.CopyN))
m.Define("EOF", reflect.ValueOf(pkg.EOF))
m.Define("ErrClosedPipe", reflect.ValueOf(pkg.ErrClosedPipe))
m.Define("ErrNoProgress", reflect.ValueOf(pkg.ErrNoProgress))
m.Define("ErrShortBuffer", reflect.ValueOf(pkg.ErrShortBuffer))
m.Define("ErrShortWrite", reflect.ValueOf(pkg.ErrShortWrite))
m.Define("ErrUnexpectedEOF", reflect.ValueOf(pkg.ErrUnexpectedEOF))
m.Define("LimitReader", reflect.ValueOf(pkg.LimitReader))
m.Define("MultiReader", reflect.ValueOf(pkg.MultiReader))
m.Define("MultiWriter", reflect.ValueOf(pkg.MultiWriter))
m.Define("NewSectionReader", reflect.ValueOf(pkg.NewSectionReader))
m.Define("Pipe", reflect.ValueOf(pkg.Pipe))
m.Define("ReadAtLeast", reflect.ValueOf(pkg.ReadAtLeast))
m.Define("ReadFull", reflect.ValueOf(pkg.ReadFull))
m.Define("TeeReader", reflect.ValueOf(pkg.TeeReader))
m.Define("WriteString", reflect.ValueOf(pkg.WriteString))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Arg", reflect.ValueOf(pkg.Arg))
m.Define("Args", reflect.ValueOf(pkg.Args))
m.Define("Bool", reflect.ValueOf(pkg.Bool))
m.Define("BoolVar", reflect.ValueOf(pkg.BoolVar))
m.Define("CommandLine", reflect.ValueOf(pkg.CommandLine))
m.Define("ContinueOnError", reflect.ValueOf(pkg.ContinueOnError))
m.Define("Duration", reflect.ValueOf(pkg.Duration))
m.Define("DurationVar", reflect.ValueOf(pkg.DurationVar))
m.Define("ErrHelp", reflect.ValueOf(pkg.ErrHelp))
m.Define("ExitOnError", reflect.ValueOf(pkg.ExitOnError))
m.Define("Float64", reflect.ValueOf(pkg.Float64))
m.Define("Float64Var", reflect.ValueOf(pkg.Float64Var))
m.Define("Int", reflect.ValueOf(pkg.Int))
m.Define("Int64", reflect.ValueOf(pkg.Int64))
m.Define("Int64Var", reflect.ValueOf(pkg.Int64Var))
m.Define("IntVar", reflect.ValueOf(pkg.IntVar))
m.Define("Lookup", reflect.ValueOf(pkg.Lookup))
m.Define("NArg", reflect.ValueOf(pkg.NArg))
m.Define("NFlag", reflect.ValueOf(pkg.NFlag))
m.Define("NewFlagSet", reflect.ValueOf(pkg.NewFlagSet))
m.Define("PanicOnError", reflect.ValueOf(pkg.PanicOnError))
m.Define("Parse", reflect.ValueOf(pkg.Parse))
m.Define("Parsed", reflect.ValueOf(pkg.Parsed))
m.Define("PrintDefaults", reflect.ValueOf(pkg.PrintDefaults))
m.Define("Set", reflect.ValueOf(pkg.Set))
m.Define("String", reflect.ValueOf(pkg.String))
m.Define("StringVar", reflect.ValueOf(pkg.StringVar))
m.Define("Uint", reflect.ValueOf(pkg.Uint))
m.Define("Uint64", reflect.ValueOf(pkg.Uint64))
m.Define("Uint64Var", reflect.ValueOf(pkg.Uint64Var))
m.Define("UintVar", reflect.ValueOf(pkg.UintVar))
m.Define("Usage", reflect.ValueOf(pkg.Usage))
m.Define("Var", reflect.ValueOf(pkg.Var))
m.Define("Visit", reflect.ValueOf(pkg.Visit))
m.Define("VisitAll", reflect.ValueOf(pkg.VisitAll))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Join", reflect.ValueOf(f.Join))
m.Define("Clean", reflect.ValueOf(f.Join))
m.Define("Abs", reflect.ValueOf(f.Abs))
m.Define("Base", reflect.ValueOf(f.Base))
m.Define("Clean", reflect.ValueOf(f.Clean))
m.Define("Dir", reflect.ValueOf(f.Dir))
m.Define("EvalSymlinks", reflect.ValueOf(f.EvalSymlinks))
m.Define("Ext", reflect.ValueOf(f.Ext))
m.Define("FromSlash", reflect.ValueOf(f.FromSlash))
m.Define("Glob", reflect.ValueOf(f.Glob))
m.Define("HasPrefix", reflect.ValueOf(f.HasPrefix))
m.Define("IsAbs", reflect.ValueOf(f.IsAbs))
m.Define("Join", reflect.ValueOf(f.Join))
m.Define("Match", reflect.ValueOf(f.Match))
m.Define("Rel", reflect.ValueOf(f.Rel))
m.Define("Split", reflect.ValueOf(f.Split))
m.Define("SplitList", reflect.ValueOf(f.SplitList))
m.Define("ToSlash", reflect.ValueOf(f.ToSlash))
m.Define("VolumeName", reflect.ValueOf(f.VolumeName))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Errorf", reflect.ValueOf(pkg.Errorf))
m.Define("Fprint", reflect.ValueOf(pkg.Fprint))
m.Define("Fprintf", reflect.ValueOf(pkg.Fprintf))
m.Define("Fprintln", reflect.ValueOf(pkg.Fprintln))
m.Define("Fscan", reflect.ValueOf(pkg.Fscan))
m.Define("Fscanf", reflect.ValueOf(pkg.Fscanf))
m.Define("Fscanln", reflect.ValueOf(pkg.Fscanln))
m.Define("Print", reflect.ValueOf(pkg.Print))
m.Define("Printf", reflect.ValueOf(pkg.Printf))
m.Define("Println", reflect.ValueOf(pkg.Println))
m.Define("Scan", reflect.ValueOf(pkg.Scan))
m.Define("Scanf", reflect.ValueOf(pkg.Scanf))
m.Define("Scanln", reflect.ValueOf(pkg.Scanln))
m.Define("Sprint", reflect.ValueOf(pkg.Sprint))
m.Define("Sprintf", reflect.ValueOf(pkg.Sprintf))
m.Define("Sprintln", reflect.ValueOf(pkg.Sprintln))
m.Define("Sscan", reflect.ValueOf(pkg.Sscan))
m.Define("Sscanf", reflect.ValueOf(pkg.Sscanf))
m.Define("Sscanln", reflect.ValueOf(pkg.Sscanln))
return m
}
func timeImport(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("ANSIC", reflect.ValueOf(time.ANSIC))
m.Define("Date", reflect.ValueOf(time.Date))
m.Define("FixedZone", reflect.ValueOf(time.FixedZone))
m.Define("Hour", reflect.ValueOf(time.Hour))
m.Define("Kitchen", reflect.ValueOf(time.Kitchen))
m.Define("LoadLocation", reflect.ValueOf(time.LoadLocation))
m.Define("Local", reflect.ValueOf(time.Local))
m.Define("Microsecond", reflect.ValueOf(time.Microsecond))
m.Define("Millisecond", reflect.ValueOf(time.Millisecond))
m.Define("Minute", reflect.ValueOf(time.Minute))
m.Define("Nanosecond", reflect.ValueOf(time.Nanosecond))
m.Define("Now", reflect.ValueOf(time.Now))
m.Define("Parse", reflect.ValueOf(time.Parse))
m.Define("ParseDuration", reflect.ValueOf(time.ParseDuration))
m.Define("ParseInLocation", reflect.ValueOf(time.ParseInLocation))
m.Define("RFC1123", reflect.ValueOf(time.RFC1123))
m.Define("RFC1123Z", reflect.ValueOf(time.RFC1123Z))
m.Define("RFC3339", reflect.ValueOf(time.RFC3339))
m.Define("RFC3339Nano", reflect.ValueOf(time.RFC3339Nano))
m.Define("RFC822", reflect.ValueOf(time.RFC822))
m.Define("RFC822Z", reflect.ValueOf(time.RFC822Z))
m.Define("RFC850", reflect.ValueOf(time.RFC850))
m.Define("RubyDate", reflect.ValueOf(time.RubyDate))
m.Define("Second", reflect.ValueOf(time.Second))
m.Define("Since", reflect.ValueOf(time.Since))
m.Define("Stamp", reflect.ValueOf(time.Stamp))
m.Define("StampMicro", reflect.ValueOf(time.StampMicro))
m.Define("StampMilli", reflect.ValueOf(time.StampMilli))
m.Define("StampNano", reflect.ValueOf(time.StampNano))
m.Define("UTC", reflect.ValueOf(time.UTC))
m.Define("Unix", reflect.ValueOf(time.Unix))
m.Define("UnixDate", reflect.ValueOf(time.UnixDate))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("ChangeColor", reflect.ValueOf(func(fg string, fa bool, rest ...interface{}) {
if len(rest) == 2 {
bg, ok := rest[0].(string)
if !ok {
panic("Argument #3 should be string")
}
ba, ok := rest[1].(bool)
if !ok {
panic("Argument #4 should be string")
}
ct.ChangeColor(colorOf(fg), fa, colorOf(bg), ba)
} else {
ct.ChangeColor(colorOf(fg), fa, ct.None, false)
}
}))
m.Define("ResetColor", reflect.ValueOf(func() {
ct.ResetColor()
}))
return m
}
func jsonImport(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Marshal", reflect.ValueOf(json.Marshal))
m.Define("Unmarshal", reflect.ValueOf(jsonUnmarshal))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Parse", reflect.ValueOf(u.Parse))
return m
}
func handleAppEngine(m *vm.Env) {
m.Define("Getppid", reflect.ValueOf(pkg.Getppid))
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Args", reflect.ValueOf(pkg.Args))
m.Define("Chdir", reflect.ValueOf(pkg.Chdir))
m.Define("Chmod", reflect.ValueOf(pkg.Chmod))
m.Define("Chown", reflect.ValueOf(pkg.Chown))
m.Define("Chtimes", reflect.ValueOf(pkg.Chtimes))
m.Define("Clearenv", reflect.ValueOf(pkg.Clearenv))
m.Define("Create", reflect.ValueOf(pkg.Create))
m.Define("DevNull", reflect.ValueOf(pkg.DevNull))
m.Define("Environ", reflect.ValueOf(pkg.Environ))
m.Define("ErrExist", reflect.ValueOf(pkg.ErrExist))
m.Define("ErrInvalid", reflect.ValueOf(pkg.ErrInvalid))
m.Define("ErrNotExist", reflect.ValueOf(pkg.ErrNotExist))
m.Define("ErrPermission", reflect.ValueOf(pkg.ErrPermission))
m.Define("Exit", reflect.ValueOf(pkg.Exit))
m.Define("Expand", reflect.ValueOf(pkg.Expand))
m.Define("ExpandEnv", reflect.ValueOf(pkg.ExpandEnv))
m.Define("FindProcess", reflect.ValueOf(pkg.FindProcess))
m.Define("Getegid", reflect.ValueOf(pkg.Getegid))
m.Define("Getenv", reflect.ValueOf(pkg.Getenv))
m.Define("Geteuid", reflect.ValueOf(pkg.Geteuid))
m.Define("Getgid", reflect.ValueOf(pkg.Getgid))
m.Define("Getgroups", reflect.ValueOf(pkg.Getgroups))
m.Define("Getpagesize", reflect.ValueOf(pkg.Getpagesize))
m.Define("Getpid", reflect.ValueOf(pkg.Getpid))
handleAppEngine(m)
m.Define("Getuid", reflect.ValueOf(pkg.Getuid))
m.Define("Getwd", reflect.ValueOf(pkg.Getwd))
m.Define("Hostname", reflect.ValueOf(pkg.Hostname))
m.Define("Interrupt", reflect.ValueOf(pkg.Interrupt))
m.Define("IsExist", reflect.ValueOf(pkg.IsExist))
m.Define("IsNotExist", reflect.ValueOf(pkg.IsNotExist))
m.Define("IsPathSeparator", reflect.ValueOf(pkg.IsPathSeparator))
m.Define("IsPermission", reflect.ValueOf(pkg.IsPermission))
m.Define("Kill", reflect.ValueOf(pkg.Kill))
m.Define("Lchown", reflect.ValueOf(pkg.Lchown))
m.Define("Link", reflect.ValueOf(pkg.Link))
m.Define("Lstat", reflect.ValueOf(pkg.Lstat))
m.Define("Mkdir", reflect.ValueOf(pkg.Mkdir))
m.Define("MkdirAll", reflect.ValueOf(pkg.MkdirAll))
m.Define("ModeAppend", reflect.ValueOf(pkg.ModeAppend))
m.Define("ModeCharDevice", reflect.ValueOf(pkg.ModeCharDevice))
m.Define("ModeDevice", reflect.ValueOf(pkg.ModeDevice))
m.Define("ModeDir", reflect.ValueOf(pkg.ModeDir))
m.Define("ModeExclusive", reflect.ValueOf(pkg.ModeExclusive))
m.Define("ModeNamedPipe", reflect.ValueOf(pkg.ModeNamedPipe))
m.Define("ModePerm", reflect.ValueOf(pkg.ModePerm))
m.Define("ModeSetgid", reflect.ValueOf(pkg.ModeSetgid))
m.Define("ModeSetuid", reflect.ValueOf(pkg.ModeSetuid))
m.Define("ModeSocket", reflect.ValueOf(pkg.ModeSocket))
m.Define("ModeSticky", reflect.ValueOf(pkg.ModeSticky))
m.Define("ModeSymlink", reflect.ValueOf(pkg.ModeSymlink))
m.Define("ModeTemporary", reflect.ValueOf(pkg.ModeTemporary))
m.Define("ModeType", reflect.ValueOf(pkg.ModeType))
m.Define("NewFile", reflect.ValueOf(pkg.NewFile))
m.Define("NewSyscallError", reflect.ValueOf(pkg.NewSyscallError))
m.Define("O_APPEND", reflect.ValueOf(pkg.O_APPEND))
m.Define("O_CREATE", reflect.ValueOf(pkg.O_CREATE))
m.Define("O_EXCL", reflect.ValueOf(pkg.O_EXCL))
m.Define("O_RDONLY", reflect.ValueOf(pkg.O_RDONLY))
m.Define("O_RDWR", reflect.ValueOf(pkg.O_RDWR))
m.Define("O_SYNC", reflect.ValueOf(pkg.O_SYNC))
m.Define("O_TRUNC", reflect.ValueOf(pkg.O_TRUNC))
m.Define("O_WRONLY", reflect.ValueOf(pkg.O_WRONLY))
m.Define("Open", reflect.ValueOf(pkg.Open))
m.Define("OpenFile", reflect.ValueOf(pkg.OpenFile))
m.Define("PathListSeparator", reflect.ValueOf(pkg.PathListSeparator))
m.Define("PathSeparator", reflect.ValueOf(pkg.PathSeparator))
m.Define("Pipe", reflect.ValueOf(pkg.Pipe))
m.Define("Readlink", reflect.ValueOf(pkg.Readlink))
m.Define("Remove", reflect.ValueOf(pkg.Remove))
m.Define("RemoveAll", reflect.ValueOf(pkg.RemoveAll))
m.Define("Rename", reflect.ValueOf(pkg.Rename))
m.Define("SEEK_CUR", reflect.ValueOf(pkg.SEEK_CUR))
m.Define("SEEK_END", reflect.ValueOf(pkg.SEEK_END))
m.Define("SEEK_SET", reflect.ValueOf(pkg.SEEK_SET))
m.Define("SameFile", reflect.ValueOf(pkg.SameFile))
m.Define("Setenv", reflect.ValueOf(pkg.Setenv))
m.Define("StartProcess", reflect.ValueOf(pkg.StartProcess))
m.Define("Stat", reflect.ValueOf(pkg.Stat))
m.Define("Stderr", reflect.ValueOf(pkg.Stderr))
m.Define("Stdin", reflect.ValueOf(pkg.Stdin))
m.Define("Stdout", reflect.ValueOf(pkg.Stdout))
m.Define("Symlink", reflect.ValueOf(pkg.Symlink))
m.Define("TempDir", reflect.ValueOf(pkg.TempDir))
m.Define("Truncate", reflect.ValueOf(pkg.Truncate))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("Abs", reflect.ValueOf(t.Abs))
m.Define("Acos", reflect.ValueOf(t.Acos))
m.Define("Acosh", reflect.ValueOf(t.Acosh))
m.Define("Asin", reflect.ValueOf(t.Asin))
m.Define("Asinh", reflect.ValueOf(t.Asinh))
m.Define("Atan", reflect.ValueOf(t.Atan))
m.Define("Atan2", reflect.ValueOf(t.Atan2))
m.Define("Atanh", reflect.ValueOf(t.Atanh))
m.Define("Cbrt", reflect.ValueOf(t.Cbrt))
m.Define("Ceil", reflect.ValueOf(t.Ceil))
m.Define("Copysign", reflect.ValueOf(t.Copysign))
m.Define("Cos", reflect.ValueOf(t.Cos))
m.Define("Cosh", reflect.ValueOf(t.Cosh))
m.Define("Dim", reflect.ValueOf(t.Dim))
m.Define("Erf", reflect.ValueOf(t.Erf))
m.Define("Erfc", reflect.ValueOf(t.Erfc))
m.Define("Exp", reflect.ValueOf(t.Exp))
m.Define("Exp2", reflect.ValueOf(t.Exp2))
m.Define("Expm1", reflect.ValueOf(t.Expm1))
m.Define("Float32bits", reflect.ValueOf(t.Float32bits))
m.Define("Float32frombits", reflect.ValueOf(t.Float32frombits))
m.Define("Float64bits", reflect.ValueOf(t.Float64bits))
m.Define("Float64frombits", reflect.ValueOf(t.Float64frombits))
m.Define("Floor", reflect.ValueOf(t.Floor))
m.Define("Frexp", reflect.ValueOf(t.Frexp))
m.Define("Gamma", reflect.ValueOf(t.Gamma))
m.Define("Hypot", reflect.ValueOf(t.Hypot))
m.Define("Ilogb", reflect.ValueOf(t.Ilogb))
m.Define("Inf", reflect.ValueOf(t.Inf))
m.Define("IsInf", reflect.ValueOf(t.IsInf))
m.Define("IsNaN", reflect.ValueOf(t.IsNaN))
m.Define("J0", reflect.ValueOf(t.J0))
m.Define("J1", reflect.ValueOf(t.J1))
m.Define("Jn", reflect.ValueOf(t.Jn))
m.Define("Ldexp", reflect.ValueOf(t.Ldexp))
m.Define("Lgamma", reflect.ValueOf(t.Lgamma))
m.Define("Log", reflect.ValueOf(t.Log))
m.Define("Log10", reflect.ValueOf(t.Log10))
m.Define("Log1p", reflect.ValueOf(t.Log1p))
m.Define("Log2", reflect.ValueOf(t.Log2))
m.Define("Logb", reflect.ValueOf(t.Logb))
m.Define("Max", reflect.ValueOf(t.Max))
m.Define("Min", reflect.ValueOf(t.Min))
m.Define("Mod", reflect.ValueOf(t.Mod))
m.Define("Modf", reflect.ValueOf(t.Modf))
m.Define("NaN", reflect.ValueOf(t.NaN))
m.Define("Nextafter", reflect.ValueOf(t.Nextafter))
m.Define("Pow", reflect.ValueOf(t.Pow))
m.Define("Pow10", reflect.ValueOf(t.Pow10))
m.Define("Remainder", reflect.ValueOf(t.Remainder))
m.Define("Signbit", reflect.ValueOf(t.Signbit))
m.Define("Sin", reflect.ValueOf(t.Sin))
m.Define("Sincos", reflect.ValueOf(t.Sincos))
m.Define("Sinh", reflect.ValueOf(t.Sinh))
m.Define("Sqrt", reflect.ValueOf(t.Sqrt))
m.Define("Tan", reflect.ValueOf(t.Tan))
m.Define("Tanh", reflect.ValueOf(t.Tanh))
m.Define("Trunc", reflect.ValueOf(t.Trunc))
m.Define("Y0", reflect.ValueOf(t.Y0))
m.Define("Y1", reflect.ValueOf(t.Y1))
m.Define("Yn", reflect.ValueOf(t.Yn))
return m
}
func Import(env *vm.Env) *vm.Env {
m := env.NewEnv()
m.Define("CIDRMask", reflect.ValueOf(pkg.CIDRMask))
m.Define("Dial", reflect.ValueOf(pkg.Dial))
m.Define("DialIP", reflect.ValueOf(pkg.DialIP))
m.Define("DialTCP", reflect.ValueOf(pkg.DialTCP))
m.Define("DialTimeout", reflect.ValueOf(pkg.DialTimeout))
m.Define("DialUDP", reflect.ValueOf(pkg.DialUDP))
m.Define("DialUnix", reflect.ValueOf(pkg.DialUnix))
m.Define("ErrWriteToConnected", reflect.ValueOf(pkg.ErrWriteToConnected))
m.Define("FileConn", reflect.ValueOf(pkg.FileConn))
m.Define("FileListener", reflect.ValueOf(pkg.FileListener))
m.Define("FilePacketConn", reflect.ValueOf(pkg.FilePacketConn))
m.Define("FlagBroadcast", reflect.ValueOf(pkg.FlagBroadcast))
m.Define("FlagLoopback", reflect.ValueOf(pkg.FlagLoopback))
m.Define("FlagMulticast", reflect.ValueOf(pkg.FlagMulticast))
m.Define("FlagPointToPoint", reflect.ValueOf(pkg.FlagPointToPoint))
m.Define("FlagUp", reflect.ValueOf(pkg.FlagUp))
m.Define("IPv4", reflect.ValueOf(pkg.IPv4))
m.Define("IPv4Mask", reflect.ValueOf(pkg.IPv4Mask))
m.Define("IPv4allrouter", reflect.ValueOf(pkg.IPv4allrouter))
m.Define("IPv4allsys", reflect.ValueOf(pkg.IPv4allsys))
m.Define("IPv4bcast", reflect.ValueOf(pkg.IPv4bcast))
m.Define("IPv4len", reflect.ValueOf(pkg.IPv4len))
m.Define("IPv4zero", reflect.ValueOf(pkg.IPv4zero))
m.Define("IPv6interfacelocalallnodes", reflect.ValueOf(pkg.IPv6interfacelocalallnodes))
m.Define("IPv6len", reflect.ValueOf(pkg.IPv6len))
m.Define("IPv6linklocalallnodes", reflect.ValueOf(pkg.IPv6linklocalallnodes))
m.Define("IPv6linklocalallrouters", reflect.ValueOf(pkg.IPv6linklocalallrouters))
m.Define("IPv6loopback", reflect.ValueOf(pkg.IPv6loopback))
m.Define("IPv6unspecified", reflect.ValueOf(pkg.IPv6unspecified))
m.Define("IPv6zero", reflect.ValueOf(pkg.IPv6zero))
m.Define("InterfaceAddrs", reflect.ValueOf(pkg.InterfaceAddrs))
m.Define("InterfaceByIndex", reflect.ValueOf(pkg.InterfaceByIndex))
m.Define("InterfaceByName", reflect.ValueOf(pkg.InterfaceByName))
m.Define("Interfaces", reflect.ValueOf(pkg.Interfaces))
m.Define("JoinHostPort", reflect.ValueOf(pkg.JoinHostPort))
m.Define("Listen", reflect.ValueOf(pkg.Listen))
m.Define("ListenIP", reflect.ValueOf(pkg.ListenIP))
m.Define("ListenMulticastUDP", reflect.ValueOf(pkg.ListenMulticastUDP))
m.Define("ListenPacket", reflect.ValueOf(pkg.ListenPacket))
m.Define("ListenTCP", reflect.ValueOf(pkg.ListenTCP))
m.Define("ListenUDP", reflect.ValueOf(pkg.ListenUDP))
m.Define("ListenUnix", reflect.ValueOf(pkg.ListenUnix))
m.Define("ListenUnixgram", reflect.ValueOf(pkg.ListenUnixgram))
m.Define("LookupAddr", reflect.ValueOf(pkg.LookupAddr))
m.Define("LookupCNAME", reflect.ValueOf(pkg.LookupCNAME))
m.Define("LookupHost", reflect.ValueOf(pkg.LookupHost))
m.Define("LookupIP", reflect.ValueOf(pkg.LookupIP))
m.Define("LookupMX", reflect.ValueOf(pkg.LookupMX))
m.Define("LookupNS", reflect.ValueOf(pkg.LookupNS))
m.Define("LookupPort", reflect.ValueOf(pkg.LookupPort))
m.Define("LookupSRV", reflect.ValueOf(pkg.LookupSRV))
m.Define("LookupTXT", reflect.ValueOf(pkg.LookupTXT))
m.Define("ParseCIDR", reflect.ValueOf(pkg.ParseCIDR))
m.Define("ParseIP", reflect.ValueOf(pkg.ParseIP))
m.Define("ParseMAC", reflect.ValueOf(pkg.ParseMAC))
m.Define("Pipe", reflect.ValueOf(pkg.Pipe))
m.Define("ResolveIPAddr", reflect.ValueOf(pkg.ResolveIPAddr))
m.Define("ResolveTCPAddr", reflect.ValueOf(pkg.ResolveTCPAddr))
m.Define("ResolveUDPAddr", reflect.ValueOf(pkg.ResolveUDPAddr))
m.Define("ResolveUnixAddr", reflect.ValueOf(pkg.ResolveUnixAddr))
m.Define("SplitHostPort", reflect.ValueOf(pkg.SplitHostPort))
return m
}
func Import(env *vm.Env) *vm.Env {
env.Define("len", reflect.ValueOf(func(v interface{}) int64 {
rv := reflect.ValueOf(v)
if rv.Kind() == reflect.Interface {
rv = rv.Elem()
}
if rv.Kind() == reflect.String {
return int64(len([]byte(rv.String())))
}
if rv.Kind() != reflect.Array && rv.Kind() != reflect.Slice {
panic("Argument #1 should be array")
}
return int64(rv.Len())
}))
env.Define("keys", reflect.ValueOf(func(v interface{}) []string {
rv := reflect.ValueOf(v)
if rv.Kind() == reflect.Interface {
rv = rv.Elem()
}
if rv.Kind() != reflect.Map {
panic("Argument #1 should be map")
}
keys := []string{}
mk := rv.MapKeys()
for _, key := range mk {
keys = append(keys, key.String())
}
return keys
}))
env.Define("range", reflect.ValueOf(func(args ...int64) []int64 {
if len(args) < 1 {
panic("Missing arguments")
}
if len(args) > 2 {
panic("Too many arguments")
}
var min, max int64
if len(args) == 1 {
min = 0
max = args[0] - 1
} else {
min = args[0]
max = args[1]
}
arr := []int64{}
for i := min; i <= max; i++ {
arr = append(arr, i)
}
return arr
}))
env.Define("toBytes", reflect.ValueOf(func(s string) []byte {
return []byte(s)
}))
env.Define("toRunes", reflect.ValueOf(func(s string) []rune {
return []rune(s)
}))
env.Define("toString", reflect.ValueOf(func(v interface{}) string {
return fmt.Sprint(v)
}))
env.Define("toInt", reflect.ValueOf(func(v interface{}) int64 {
nt := reflect.TypeOf(1)
rv := reflect.ValueOf(v)
if rv.Type().ConvertibleTo(nt) {
return 0
}
return rv.Convert(nt).Int()
}))
env.Define("toFloat", reflect.ValueOf(func(v interface{}) float64 {
nt := reflect.TypeOf(1.0)
rv := reflect.ValueOf(v)
if rv.Type().ConvertibleTo(nt) {
return 0.0
}
return rv.Convert(nt).Float()
}))
env.Define("toBool", reflect.ValueOf(func(v interface{}) bool {
nt := reflect.TypeOf(true)
rv := reflect.ValueOf(v)
if rv.Type().ConvertibleTo(nt) {
return false
}
return rv.Convert(nt).Bool()
}))
env.Define("toChar", reflect.ValueOf(func(s rune) string {
return string(s)
}))
env.Define("toRune", reflect.ValueOf(func(s string) rune {
if len(s) == 0 {
return 0
}
return []rune(s)[0]
}))
env.Define("string", reflect.ValueOf(func(b []byte) string {
return string(b)
}))
env.Define("typeof", reflect.ValueOf(func(v interface{}) string {
return reflect.TypeOf(v).String()
}))
env.Define("defined", reflect.ValueOf(func(s string) bool {
_, err := env.Get(s)
return err == nil
}))
env.Define("load", reflect.ValueOf(func(s string) interface{} {
body, err := ioutil.ReadFile(s)
if err != nil {
panic(err)
}
scanner := new(parser.Scanner)
scanner.Init(string(body))
stmts, err := parser.Parse(scanner)
if err != nil {
if pe, ok := err.(*parser.Error); ok {
pe.Filename = s
panic(pe)
}
panic(err)
}
rv, err := vm.Run(stmts, env)
if err != nil {
panic(err)
}
if rv.IsValid() && rv.CanInterface() {
return rv.Interface()
}
return nil
}))
env.Define("panic", reflect.ValueOf(func(e interface{}) {
os.Setenv("ANKO_DEBUG", "1")
panic(e)
}))
env.Define("print", reflect.ValueOf(fmt.Print))
env.Define("println", reflect.ValueOf(fmt.Println))
env.Define("printf", reflect.ValueOf(fmt.Printf))
return env
}
