Beispiel #1
0
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
}
Beispiel #2
0
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
}
Beispiel #3
0
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
}
Beispiel #4
0
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
}
Beispiel #5
0
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
}
Beispiel #6
0
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
}
Beispiel #7
0
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
}
Beispiel #8
0
Datei: io.go Projekt: goist/anko
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
}
Beispiel #9
0
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
}
Beispiel #10
0
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
}
Beispiel #11
0
Datei: fmt.go Projekt: goist/anko
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
}
Beispiel #12
0
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
}
Beispiel #13
0
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
}
Beispiel #14
0
Datei: net.go Projekt: goist/anko
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
}
Beispiel #15
0
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
}
Beispiel #16
0
Datei: url.go Projekt: goist/anko
func Import(env *vm.Env) *vm.Env {
	m := env.NewEnv()
	m.Define("Parse", reflect.ValueOf(u.Parse))
	return m
}
Beispiel #17
0
Datei: os.go Projekt: goist/anko
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
}
Beispiel #18
0
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
}