-
playground
+
playground (GopherJS {{version}})
+
diff --git a/playground/internal/cmd/precompile/precompile.go b/playground/internal/cmd/precompile/precompile.go
new file mode 100644
index 00000000..3b2e5af7
--- /dev/null
+++ b/playground/internal/cmd/precompile/precompile.go
@@ -0,0 +1,132 @@
+// Program precompile updates pre-built standard library packages for the
+// playground.
+//
+// This script performs the following sequence of steps:
+//
+// - Enumerate all standard packages that should be available in the playground.
+// - Precompile them, including transitive dependencies.
+// - Delete all old precompiled archive.
+// - Write all new precompiled archive in their place.
+//
+// This will use the same GopherJS version as specified in the playground gm.mod
+// to ensure consistency. The script uses GopherJS compiler API directly, so
+// it doesn't require the GopherJS tool to be installed.
+package main
+
+import (
+ "flag"
+ "fmt"
+ gobuild "go/build"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/gopherjs/gopherjs/build"
+ "github.com/gopherjs/gopherjs/compiler"
+ log "github.com/sirupsen/logrus"
+)
+
+type logLevelFlag struct{ log.Level }
+
+func (l *logLevelFlag) Set(raw string) error { return l.UnmarshalText([]byte(raw)) }
+
+var (
+ logLevel logLevelFlag = logLevelFlag{Level: log.ErrorLevel}
+)
+
+func init() {
+ flag.Var(&logLevel, "log_level", "Default logging level.")
+}
+
+func run() error {
+ s, err := build.NewSession(&build.Options{
+ Verbose: true,
+ Minify: true,
+ NoCache: true,
+ })
+ if err != nil {
+ return fmt.Errorf("failed to create a build session: %w", err)
+ }
+
+ packages, err := s.XContext().Match([]string{"std"})
+ if err != nil {
+ return fmt.Errorf("failed to enumerate standard library packages")
+ }
+ packages = importable(packages)
+ packages = append(packages, "github.com/gopherjs/gopherjs/js", "github.com/gopherjs/gopherjs/nosync")
+
+ for _, pkg := range packages {
+ _, err := s.BuildImportPath(pkg)
+ if err != nil {
+ return fmt.Errorf("failed to precompile package %q: %w", pkg, err)
+ }
+ }
+
+ target, err := targetDir(s)
+ if err := os.RemoveAll(target); err != nil {
+ return fmt.Errorf("failed to clean out old precompiled archives: %w", err)
+ }
+
+ for _, archive := range s.UpToDateArchives {
+ if err := writeArchive(target, archive); err != nil {
+ return fmt.Errorf("failed to write package %q archive: %w", archive.ImportPath, err)
+ }
+ }
+
+ return nil
+}
+
+func writeArchive(target string, archive *compiler.Archive) error {
+ path := filepath.Join(target, filepath.FromSlash(archive.ImportPath)+".a.js")
+ if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+ return fmt.Errorf("failed to create precompiled package directory %q: %w", filepath.Dir(path), err)
+ }
+ f, err := os.Create(path)
+ if err != nil {
+ return fmt.Errorf("failed to create precompiled archive %q: %w", path, err)
+ }
+ defer f.Close()
+
+ return compiler.WriteArchive(archive, f)
+}
+
+// targetDir returns path to the directory where precompiled packages must be
+// stored.
+func targetDir(s *build.Session) (string, error) {
+ pkg, err := s.XContext().Import("github.com/gopherjs/gopherjs.github.io/playground", "", gobuild.FindOnly)
+ if err != nil {
+ return "", fmt.Errorf("failed to find playground package directory: %w", err)
+ }
+ target := filepath.Join(pkg.Dir, "pkg")
+ if _, err := os.Stat(target); os.IsNotExist(err) {
+ return "", fmt.Errorf("target directory %q not found", target)
+ }
+ return target, nil
+}
+
+// importable excludes packages that are incompatible with GopherJS or can't be
+// directly imported by the user code. The remaining packages will be used as a
+// starting points for precompilation.
+func importable(all []string) []string {
+ result := []string{}
+ for _, pkg := range all {
+ switch {
+ case strings.HasPrefix(pkg, "vendor/"),
+ strings.Contains(pkg, "internal"),
+ strings.Contains(pkg, "pprof"),
+ strings.Contains(pkg, "plugin"):
+ continue
+ default:
+ result = append(result, pkg)
+ }
+ }
+ return result
+}
+
+func main() {
+ flag.Parse()
+ log.SetLevel(logLevel.Level)
+ if err := run(); err != nil {
+ log.Fatalf("Precompilation failed: %v", err)
+ }
+}
diff --git a/playground/internal/imports/fix.go b/playground/internal/imports/fix.go
new file mode 100644
index 00000000..779ba54c
--- /dev/null
+++ b/playground/internal/imports/fix.go
@@ -0,0 +1,179 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package imports
+
+import (
+ "go/ast"
+ "go/token"
+ "path"
+ "strings"
+
+ "golang.org/x/tools/go/ast/astutil"
+)
+
+// importToGroup is a list of functions which map from an import path to
+// a group number.
+var importToGroup = []func(importPath string) (num int, ok bool){
+ func(importPath string) (num int, ok bool) {
+ if strings.HasPrefix(importPath, "appengine") {
+ return 2, true
+ }
+ return
+ },
+ func(importPath string) (num int, ok bool) {
+ if strings.Contains(importPath, ".") {
+ return 1, true
+ }
+ return
+ },
+}
+
+func importGroup(importPath string) int {
+ for _, fn := range importToGroup {
+ if n, ok := fn(importPath); ok {
+ return n
+ }
+ }
+ return 0
+}
+
+func fixImports(fset *token.FileSet, f *ast.File) (added []string, err error) {
+ // refs are a set of possible package references currently unsatisfied by imports.
+ // first key: either base package (e.g. "fmt") or renamed package
+ // second key: referenced package symbol (e.g. "Println")
+ refs := make(map[string]map[string]bool)
+
+ // decls are the current package imports. key is base package or renamed package.
+ decls := make(map[string]*ast.ImportSpec)
+
+ // collect potential uses of packages.
+ var visitor visitFn
+ visitor = visitFn(func(node ast.Node) ast.Visitor {
+ if node == nil {
+ return visitor
+ }
+ switch v := node.(type) {
+ case *ast.ImportSpec:
+ if v.Name != nil {
+ decls[v.Name.Name] = v
+ } else {
+ local := importPathToName(strings.Trim(v.Path.Value, `\"`))
+ decls[local] = v
+ }
+ case *ast.SelectorExpr:
+ xident, ok := v.X.(*ast.Ident)
+ if !ok {
+ break
+ }
+ if xident.Obj != nil {
+ // if the parser can resolve it, it's not a package ref
+ break
+ }
+ pkgName := xident.Name
+ if refs[pkgName] == nil {
+ refs[pkgName] = make(map[string]bool)
+ }
+ if decls[pkgName] == nil {
+ refs[pkgName][v.Sel.Name] = true
+ }
+ }
+ return visitor
+ })
+ ast.Walk(visitor, f)
+
+ // Nil out any unused ImportSpecs, to be removed in following passes
+ unusedImport := map[string]bool{}
+ for pkg, is := range decls {
+ if refs[pkg] == nil && pkg != "_" && pkg != "." {
+ unusedImport[strings.Trim(is.Path.Value, `"`)] = true
+ }
+ }
+ for ipath := range unusedImport {
+ if ipath == "C" {
+ // Don't remove cgo stuff.
+ continue
+ }
+ astutil.DeleteImport(fset, f, ipath)
+ }
+
+ // Search for imports matching potential package references.
+ searches := 0
+ type result struct {
+ ipath string
+ name string
+ err error
+ }
+ results := make(chan result)
+ for pkgName, symbols := range refs {
+ if len(symbols) == 0 {
+ continue // skip over packages already imported
+ }
+ go func(pkgName string, symbols map[string]bool) {
+ ipath, rename, err := findImport(pkgName, symbols)
+ r := result{ipath: ipath, err: err}
+ if rename {
+ r.name = pkgName
+ }
+ results <- r
+ }(pkgName, symbols)
+ searches++
+ }
+ for i := 0; i < searches; i++ {
+ result := <-results
+ if result.err != nil {
+ return nil, result.err
+ }
+ if result.ipath != "" {
+ if result.name != "" {
+ astutil.AddNamedImport(fset, f, result.name, result.ipath)
+ } else {
+ astutil.AddImport(fset, f, result.ipath)
+ }
+ added = append(added, result.ipath)
+ }
+ }
+
+ return added, nil
+}
+
+// importPathToName returns the package name for the given import path.
+var importPathToName = importPathToNameBasic
+
+// importPathToNameBasic assumes the package name is the base of import path.
+func importPathToNameBasic(importPath string) (packageName string) {
+ return path.Base(importPath)
+}
+
+type pkg struct {
+ importpath string // full pkg import path, e.g. "net/http"
+ dir string // absolute file path to pkg directory e.g. "/usr/lib/go/src/fmt"
+}
+
+// findImport searches for a package with the given symbols.
+// If no package is found, findImport returns "".
+// Declared as a variable rather than a function so goimports can be easily
+// extended by adding a file with an init function.
+var findImport = findImportStdlib
+
+type visitFn func(node ast.Node) ast.Visitor
+
+func (fn visitFn) Visit(node ast.Node) ast.Visitor {
+ return fn(node)
+}
+
+func findImportStdlib(shortPkg string, symbols map[string]bool) (importPath string, rename bool, err error) {
+ for symbol := range symbols {
+ path := stdlib[shortPkg+"."+symbol]
+ if path == "" {
+ return "", false, nil
+ }
+ if importPath != "" && importPath != path {
+ // Ambiguous. Symbols pointed to different things.
+ return "", false, nil
+ }
+ importPath = path
+ }
+ return importPath, false, nil
+}
diff --git a/playground/internal/imports/gen.go b/playground/internal/imports/gen.go
new file mode 100644
index 00000000..39b237e3
--- /dev/null
+++ b/playground/internal/imports/gen.go
@@ -0,0 +1,6 @@
+//go:generate go run mkapi.go -output=syscalljs.txt -contexts js-wasm syscall/js
+//go:generate go run mkapi.go -output=gopherjs.txt -gopath github.com/gopherjs/gopherjs/js
+//go:generate go run mkstdlib.go -output=zstdlib
+//go:generate rm syscalljs.txt gopherjs.txt
+
+package imports
diff --git a/playground/internal/imports/imports.go b/playground/internal/imports/imports.go
new file mode 100644
index 00000000..3c83d1d4
--- /dev/null
+++ b/playground/internal/imports/imports.go
@@ -0,0 +1,279 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package imports implements a Go pretty-printer (like package "go/format")
+// that also adds or removes import statements as necessary.
+package imports
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/format"
+ "go/parser"
+ "go/printer"
+ "go/token"
+ "io"
+ "regexp"
+ "strconv"
+ "strings"
+
+ "golang.org/x/tools/go/ast/astutil"
+)
+
+// Options specifies options for processing files.
+type Options struct {
+ Fragment bool // Accept fragment of a source file (no package statement)
+ AllErrors bool // Report all errors (not just the first 10 on different lines)
+
+ Comments bool // Print comments (true if nil *Options provided)
+ TabIndent bool // Use tabs for indent (true if nil *Options provided)
+ TabWidth int // Tab width (8 if nil *Options provided)
+}
+
+// Process formats and adjusts imports for the provided file.
+// If opt is nil the defaults are used.
+func Process(filename string, src []byte, opt *Options) ([]byte, error) {
+ if opt == nil {
+ opt = &Options{Comments: true, TabIndent: true, TabWidth: 8}
+ }
+
+ fileSet := token.NewFileSet()
+ file, adjust, err := parse(fileSet, filename, src, opt)
+ if err != nil {
+ return nil, err
+ }
+
+ _, err = fixImports(fileSet, file)
+ if err != nil {
+ return nil, err
+ }
+
+ sortImports(fileSet, file)
+ imps := astutil.Imports(fileSet, file)
+
+ var spacesBefore []string // import paths we need spaces before
+ for _, impSection := range imps {
+ // Within each block of contiguous imports, see if any
+ // import lines are in different group numbers. If so,
+ // we'll need to put a space between them so it's
+ // compatible with gofmt.
+ lastGroup := -1
+ for _, importSpec := range impSection {
+ importPath, _ := strconv.Unquote(importSpec.Path.Value)
+ groupNum := importGroup(importPath)
+ if groupNum != lastGroup && lastGroup != -1 {
+ spacesBefore = append(spacesBefore, importPath)
+ }
+ lastGroup = groupNum
+ }
+
+ }
+
+ printerMode := printer.UseSpaces
+ if opt.TabIndent {
+ printerMode |= printer.TabIndent
+ }
+ printConfig := &printer.Config{Mode: printerMode, Tabwidth: opt.TabWidth}
+
+ var buf bytes.Buffer
+ err = printConfig.Fprint(&buf, fileSet, file)
+ if err != nil {
+ return nil, err
+ }
+ out := buf.Bytes()
+ if adjust != nil {
+ out = adjust(src, out)
+ }
+ if len(spacesBefore) > 0 {
+ out = addImportSpaces(bytes.NewReader(out), spacesBefore)
+ }
+
+ out, err = format.Source(out)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// parse parses src, which was read from filename,
+// as a Go source file or statement list.
+func parse(fset *token.FileSet, filename string, src []byte, opt *Options) (*ast.File, func(orig, src []byte) []byte, error) {
+ parserMode := parser.Mode(0)
+ if opt.Comments {
+ parserMode |= parser.ParseComments
+ }
+ if opt.AllErrors {
+ parserMode |= parser.AllErrors
+ }
+
+ // Try as whole source file.
+ file, err := parser.ParseFile(fset, filename, src, parserMode)
+ if err == nil {
+ return file, nil, nil
+ }
+ // If the error is that the source file didn't begin with a
+ // package line and we accept fragmented input, fall through to
+ // try as a source fragment. Stop and return on any other error.
+ if !opt.Fragment || !strings.Contains(err.Error(), "expected 'package'") {
+ return nil, nil, err
+ }
+
+ // If this is a declaration list, make it a source file
+ // by inserting a package clause.
+ // Insert using a ;, not a newline, so that the line numbers
+ // in psrc match the ones in src.
+ psrc := append([]byte("package main;"), src...)
+ file, err = parser.ParseFile(fset, filename, psrc, parserMode)
+ if err == nil {
+ // If a main function exists, we will assume this is a main
+ // package and leave the file.
+ if containsMainFunc(file) {
+ return file, nil, nil
+ }
+
+ adjust := func(orig, src []byte) []byte {
+ // Remove the package clause.
+ // Gofmt has turned the ; into a \n.
+ src = src[len("package main\n"):]
+ return matchSpace(orig, src)
+ }
+ return file, adjust, nil
+ }
+ // If the error is that the source file didn't begin with a
+ // declaration, fall through to try as a statement list.
+ // Stop and return on any other error.
+ if !strings.Contains(err.Error(), "expected declaration") {
+ return nil, nil, err
+ }
+
+ // If this is a statement list, make it a source file
+ // by inserting a package clause and turning the list
+ // into a function body. This handles expressions too.
+ // Insert using a ;, not a newline, so that the line numbers
+ // in fsrc match the ones in src.
+ fsrc := append(append([]byte("package p; func _() {"), src...), '}')
+ file, err = parser.ParseFile(fset, filename, fsrc, parserMode)
+ if err == nil {
+ adjust := func(orig, src []byte) []byte {
+ // Remove the wrapping.
+ // Gofmt has turned the ; into a \n\n.
+ src = src[len("package p\n\nfunc _() {"):]
+ src = src[:len(src)-len("}\n")]
+ // Gofmt has also indented the function body one level.
+ // Remove that indent.
+ src = bytes.Replace(src, []byte("\n\t"), []byte("\n"), -1)
+ return matchSpace(orig, src)
+ }
+ return file, adjust, nil
+ }
+
+ // Failed, and out of options.
+ return nil, nil, err
+}
+
+// containsMainFunc checks if a file contains a function declaration with the
+// function signature 'func main()'
+func containsMainFunc(file *ast.File) bool {
+ for _, decl := range file.Decls {
+ if f, ok := decl.(*ast.FuncDecl); ok {
+ if f.Name.Name != "main" {
+ continue
+ }
+
+ if len(f.Type.Params.List) != 0 {
+ continue
+ }
+
+ if f.Type.Results != nil && len(f.Type.Results.List) != 0 {
+ continue
+ }
+
+ return true
+ }
+ }
+
+ return false
+}
+
+func cutSpace(b []byte) (before, middle, after []byte) {
+ i := 0
+ for i < len(b) && (b[i] == ' ' || b[i] == '\t' || b[i] == '\n') {
+ i++
+ }
+ j := len(b)
+ for j > 0 && (b[j-1] == ' ' || b[j-1] == '\t' || b[j-1] == '\n') {
+ j--
+ }
+ if i <= j {
+ return b[:i], b[i:j], b[j:]
+ }
+ return nil, nil, b[j:]
+}
+
+// matchSpace reformats src to use the same space context as orig.
+// 1) If orig begins with blank lines, matchSpace inserts them at the beginning of src.
+// 2) matchSpace copies the indentation of the first non-blank line in orig
+// to every non-blank line in src.
+// 3) matchSpace copies the trailing space from orig and uses it in place
+// of src's trailing space.
+func matchSpace(orig []byte, src []byte) []byte {
+ before, _, after := cutSpace(orig)
+ i := bytes.LastIndex(before, []byte{'\n'})
+ before, indent := before[:i+1], before[i+1:]
+
+ _, src, _ = cutSpace(src)
+
+ var b bytes.Buffer
+ b.Write(before)
+ for len(src) > 0 {
+ line := src
+ if i := bytes.IndexByte(line, '\n'); i >= 0 {
+ line, src = line[:i+1], line[i+1:]
+ } else {
+ src = nil
+ }
+ if len(line) > 0 && line[0] != '\n' { // not blank
+ b.Write(indent)
+ }
+ b.Write(line)
+ }
+ b.Write(after)
+ return b.Bytes()
+}
+
+var impLine = regexp.MustCompile(`^\s+(?:[\w\.]+\s+)?"(.+)"`)
+
+func addImportSpaces(r io.Reader, breaks []string) []byte {
+ var out bytes.Buffer
+ sc := bufio.NewScanner(r)
+ inImports := false
+ done := false
+ for sc.Scan() {
+ s := sc.Text()
+
+ if !inImports && !done && strings.HasPrefix(s, "import") {
+ inImports = true
+ }
+ if inImports && (strings.HasPrefix(s, "var") ||
+ strings.HasPrefix(s, "func") ||
+ strings.HasPrefix(s, "const") ||
+ strings.HasPrefix(s, "type")) {
+ done = true
+ inImports = false
+ }
+ if inImports && len(breaks) > 0 {
+ if m := impLine.FindStringSubmatch(s); m != nil {
+ if m[1] == string(breaks[0]) {
+ out.WriteByte('\n')
+ breaks = breaks[1:]
+ }
+ }
+ }
+
+ fmt.Fprintln(&out, s)
+ }
+ return out.Bytes()
+}
diff --git a/playground/internal/imports/mkapi.go b/playground/internal/imports/mkapi.go
new file mode 100644
index 00000000..75174161
--- /dev/null
+++ b/playground/internal/imports/mkapi.go
@@ -0,0 +1,865 @@
+// +build generate
+
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Binary api computes the exported API of a set of Go packages.
+//
+// It's a copy of cmd/api tool, but with a patch to enable
+// operating on packages in GOPATH workspaces merged in
+// (https://github.com/golang/go/issues/4993#issuecomment-66075958),
+// and an output flag added for go generate usage.
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "flag"
+ "fmt"
+ "go/ast"
+ "go/build"
+ "go/parser"
+ "go/token"
+ "go/types"
+ "io"
+ "io/ioutil"
+ "log"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "sort"
+ "strings"
+)
+
+// Flags
+var (
+ output = flag.String("output", "", "output file name; if empty, then print to stdout")
+ includeGopath = flag.Bool("gopath", false, "include GOPATH packages")
+ checkFile = flag.String("c", "", "optional comma-separated filename(s) to check API against")
+ allowNew = flag.Bool("allow_new", true, "allow API additions")
+ exceptFile = flag.String("except", "", "optional filename of packages that are allowed to change without triggering a failure in the tool")
+ nextFile = flag.String("next", "", "optional filename of tentative upcoming API features for the next release. This file can be lazily maintained. It only affects the delta warnings from the -c file printed on success.")
+ verbose = flag.Bool("v", false, "verbose debugging")
+ forceCtx = flag.String("contexts", "", "optional comma-separated list of
-[-cgo] to override default contexts.")
+)
+
+// contexts are the default contexts which are scanned, unless
+// overridden by the -contexts flag.
+var contexts = []*build.Context{
+ {GOOS: "linux", GOARCH: "386", CgoEnabled: true},
+ {GOOS: "linux", GOARCH: "386"},
+ {GOOS: "linux", GOARCH: "amd64", CgoEnabled: true},
+ {GOOS: "linux", GOARCH: "amd64"},
+ {GOOS: "linux", GOARCH: "arm", CgoEnabled: true},
+ {GOOS: "linux", GOARCH: "arm"},
+ {GOOS: "darwin", GOARCH: "386", CgoEnabled: true},
+ {GOOS: "darwin", GOARCH: "386"},
+ {GOOS: "darwin", GOARCH: "amd64", CgoEnabled: true},
+ {GOOS: "darwin", GOARCH: "amd64"},
+ {GOOS: "windows", GOARCH: "amd64"},
+ {GOOS: "windows", GOARCH: "386"},
+ {GOOS: "freebsd", GOARCH: "386", CgoEnabled: true},
+ {GOOS: "freebsd", GOARCH: "386"},
+ {GOOS: "freebsd", GOARCH: "amd64", CgoEnabled: true},
+ {GOOS: "freebsd", GOARCH: "amd64"},
+ {GOOS: "freebsd", GOARCH: "arm", CgoEnabled: true},
+ {GOOS: "freebsd", GOARCH: "arm"},
+ {GOOS: "netbsd", GOARCH: "386", CgoEnabled: true},
+ {GOOS: "netbsd", GOARCH: "386"},
+ {GOOS: "netbsd", GOARCH: "amd64", CgoEnabled: true},
+ {GOOS: "netbsd", GOARCH: "amd64"},
+ {GOOS: "netbsd", GOARCH: "arm", CgoEnabled: true},
+ {GOOS: "netbsd", GOARCH: "arm"},
+ {GOOS: "openbsd", GOARCH: "386", CgoEnabled: true},
+ {GOOS: "openbsd", GOARCH: "386"},
+ {GOOS: "openbsd", GOARCH: "amd64", CgoEnabled: true},
+ {GOOS: "openbsd", GOARCH: "amd64"},
+}
+
+func contextName(c *build.Context) string {
+ s := c.GOOS + "-" + c.GOARCH
+ if c.CgoEnabled {
+ return s + "-cgo"
+ }
+ return s
+}
+
+func parseContext(c string) *build.Context {
+ parts := strings.Split(c, "-")
+ if len(parts) < 2 {
+ log.Fatalf("bad context: %q", c)
+ }
+ bc := &build.Context{
+ GOOS: parts[0],
+ GOARCH: parts[1],
+ }
+ if len(parts) == 3 {
+ if parts[2] == "cgo" {
+ bc.CgoEnabled = true
+ } else {
+ log.Fatalf("bad context: %q", c)
+ }
+ }
+ return bc
+}
+
+func setContexts() {
+ contexts = []*build.Context{}
+ for _, c := range strings.Split(*forceCtx, ",") {
+ contexts = append(contexts, parseContext(c))
+ }
+}
+
+var internalPkg = regexp.MustCompile(`(^|/)internal($|/)`)
+
+func main() {
+ flag.Parse()
+
+ if !strings.Contains(runtime.Version(), "weekly") && !strings.Contains(runtime.Version(), "devel") {
+ if *nextFile != "" {
+ fmt.Printf("Go version is %q, ignoring -next %s\n", runtime.Version(), *nextFile)
+ *nextFile = ""
+ }
+ }
+
+ if *forceCtx != "" {
+ setContexts()
+ }
+ for _, c := range contexts {
+ c.Compiler = build.Default.Compiler
+ }
+
+ var pkgNames []string
+ if flag.NArg() > 0 {
+ pkgNames = flag.Args()
+ } else if *includeGopath {
+ alls, err := exec.Command("go", "list", "all").Output()
+ if err != nil {
+ log.Fatal(err)
+ }
+ pkgNames = strings.Fields(string(alls))
+ } else {
+ stds, err := exec.Command("go", "list", "std").Output()
+ if err != nil {
+ log.Fatal(err)
+ }
+ for _, pkg := range strings.Fields(string(stds)) {
+ if !internalPkg.MatchString(pkg) {
+ pkgNames = append(pkgNames, pkg)
+ }
+ }
+ }
+
+ var featureCtx = make(map[string]map[string]bool) // feature -> context name -> true
+ for _, context := range contexts {
+ w := NewWalker(context, filepath.Join(build.Default.GOROOT, "src"))
+
+ for _, name := range pkgNames {
+ // - Package "unsafe" contains special signatures requiring
+ // extra care when printing them - ignore since it is not
+ // going to change w/o a language change.
+ // - We don't care about the API of commands.
+ if name != "unsafe" && !strings.HasPrefix(name, "cmd/") {
+ if name == "runtime/cgo" && !context.CgoEnabled {
+ // w.Import(name) will return nil
+ continue
+ }
+ pkg, _ := w.Import(name)
+ w.export(pkg)
+ }
+ }
+
+ ctxName := contextName(context)
+ for _, f := range w.Features() {
+ if featureCtx[f] == nil {
+ featureCtx[f] = make(map[string]bool)
+ }
+ featureCtx[f][ctxName] = true
+ }
+ }
+
+ var features []string
+ for f, cmap := range featureCtx {
+ if len(cmap) == len(contexts) {
+ features = append(features, f)
+ continue
+ }
+ comma := strings.Index(f, ",")
+ for cname := range cmap {
+ f2 := fmt.Sprintf("%s (%s)%s", f[:comma], cname, f[comma:])
+ features = append(features, f2)
+ }
+ }
+
+ fail := false
+ defer func() {
+ if fail {
+ os.Exit(1)
+ }
+ }()
+
+ var out io.Writer
+ switch *output {
+ case "":
+ out = os.Stdout
+ default:
+ f, err := os.OpenFile(*output, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+ if err != nil {
+ log.Fatalf("opening file %q for output: %v", *output, err)
+ }
+ defer f.Close()
+ out = f
+ }
+ bw := bufio.NewWriter(out)
+ defer bw.Flush()
+
+ if *checkFile == "" {
+ sort.Strings(features)
+ for _, f := range features {
+ fmt.Fprintln(bw, f)
+ }
+ return
+ }
+
+ var required []string
+ for _, file := range strings.Split(*checkFile, ",") {
+ required = append(required, fileFeatures(file)...)
+ }
+ optional := fileFeatures(*nextFile)
+ exception := fileFeatures(*exceptFile)
+ fail = !compareAPI(bw, features, required, optional, exception,
+ *allowNew && strings.Contains(runtime.Version(), "devel"))
+}
+
+// export emits the exported package features.
+func (w *Walker) export(pkg *types.Package) {
+ if *verbose {
+ log.Println(pkg)
+ }
+ pop := w.pushScope("pkg " + pkg.Path())
+ w.current = pkg
+ scope := pkg.Scope()
+ for _, name := range scope.Names() {
+ if ast.IsExported(name) {
+ w.emitObj(scope.Lookup(name))
+ }
+ }
+ pop()
+}
+
+func set(items []string) map[string]bool {
+ s := make(map[string]bool)
+ for _, v := range items {
+ s[v] = true
+ }
+ return s
+}
+
+var spaceParensRx = regexp.MustCompile(` \(\S+?\)`)
+
+func featureWithoutContext(f string) string {
+ if !strings.Contains(f, "(") {
+ return f
+ }
+ return spaceParensRx.ReplaceAllString(f, "")
+}
+
+func compareAPI(w io.Writer, features, required, optional, exception []string, allowAdd bool) (ok bool) {
+ ok = true
+
+ optionalSet := set(optional)
+ exceptionSet := set(exception)
+ featureSet := set(features)
+
+ sort.Strings(features)
+ sort.Strings(required)
+
+ take := func(sl *[]string) string {
+ s := (*sl)[0]
+ *sl = (*sl)[1:]
+ return s
+ }
+
+ for len(required) > 0 || len(features) > 0 {
+ switch {
+ case len(features) == 0 || (len(required) > 0 && required[0] < features[0]):
+ feature := take(&required)
+ if exceptionSet[feature] {
+ // An "unfortunate" case: the feature was once
+ // included in the API (e.g. go1.txt), but was
+ // subsequently removed. These are already
+ // acknowledged by being in the file
+ // "api/except.txt". No need to print them out
+ // here.
+ } else if featureSet[featureWithoutContext(feature)] {
+ // okay.
+ } else {
+ fmt.Fprintf(w, "-%s\n", feature)
+ ok = false // broke compatibility
+ }
+ case len(required) == 0 || (len(features) > 0 && required[0] > features[0]):
+ newFeature := take(&features)
+ if optionalSet[newFeature] {
+ // Known added feature to the upcoming release.
+ // Delete it from the map so we can detect any upcoming features
+ // which were never seen. (so we can clean up the nextFile)
+ delete(optionalSet, newFeature)
+ } else {
+ fmt.Fprintf(w, "+%s\n", newFeature)
+ if !allowAdd {
+ ok = false // we're in lock-down mode for next release
+ }
+ }
+ default:
+ take(&required)
+ take(&features)
+ }
+ }
+
+ // In next file, but not in API.
+ var missing []string
+ for feature := range optionalSet {
+ missing = append(missing, feature)
+ }
+ sort.Strings(missing)
+ for _, feature := range missing {
+ fmt.Fprintf(w, "±%s\n", feature)
+ }
+ return
+}
+
+func fileFeatures(filename string) []string {
+ if filename == "" {
+ return nil
+ }
+ bs, err := ioutil.ReadFile(filename)
+ if err != nil {
+ log.Fatalf("Error reading file %s: %v", filename, err)
+ }
+ lines := strings.Split(string(bs), "\n")
+ var nonblank []string
+ for _, line := range lines {
+ line = strings.TrimSpace(line)
+ if line != "" && !strings.HasPrefix(line, "#") {
+ nonblank = append(nonblank, line)
+ }
+ }
+ return nonblank
+}
+
+var fset = token.NewFileSet()
+
+type Walker struct {
+ context *build.Context
+ root string
+ scope []string
+ current *types.Package
+ features map[string]bool // set
+ imported map[string]*types.Package // packages already imported
+}
+
+func NewWalker(context *build.Context, root string) *Walker {
+ return &Walker{
+ context: context,
+ root: root,
+ features: map[string]bool{},
+ imported: map[string]*types.Package{"unsafe": types.Unsafe},
+ }
+}
+
+func (w *Walker) Features() (fs []string) {
+ for f := range w.features {
+ fs = append(fs, f)
+ }
+ sort.Strings(fs)
+ return
+}
+
+var parsedFileCache = make(map[string]*ast.File)
+
+func (w *Walker) parseFile(dir, file string) (*ast.File, error) {
+ filename := filepath.Join(dir, file)
+ if f := parsedFileCache[filename]; f != nil {
+ return f, nil
+ }
+
+ f, err := parser.ParseFile(fset, filename, nil, 0)
+ if err != nil {
+ return nil, err
+ }
+ parsedFileCache[filename] = f
+
+ return f, nil
+}
+
+func contains(list []string, s string) bool {
+ for _, t := range list {
+ if t == s {
+ return true
+ }
+ }
+ return false
+}
+
+// The package cache doesn't operate correctly in rare (so far artificial)
+// circumstances (issue 8425). Disable before debugging non-obvious errors
+// from the type-checker.
+const usePkgCache = true
+
+var (
+ pkgCache = map[string]*types.Package{} // map tagKey to package
+ pkgTags = map[string][]string{} // map import dir to list of relevant tags
+)
+
+// tagKey returns the tag-based key to use in the pkgCache.
+// It is a comma-separated string; the first part is dir, the rest tags.
+// The satisfied tags are derived from context but only those that
+// matter (the ones listed in the tags argument) are used.
+// The tags list, which came from go/build's Package.AllTags,
+// is known to be sorted.
+func tagKey(dir string, context *build.Context, tags []string) string {
+ ctags := map[string]bool{
+ context.GOOS: true,
+ context.GOARCH: true,
+ }
+ if context.CgoEnabled {
+ ctags["cgo"] = true
+ }
+ for _, tag := range context.BuildTags {
+ ctags[tag] = true
+ }
+ // TODO: ReleaseTags (need to load default)
+ key := dir
+ for _, tag := range tags {
+ if ctags[tag] {
+ key += "," + tag
+ }
+ }
+ return key
+}
+
+// Importing is a sentinel taking the place in Walker.imported
+// for a package that is in the process of being imported.
+var importing types.Package
+
+func (w *Walker) Import(name string) (*types.Package, error) {
+ pkg := w.imported[name]
+ if pkg != nil {
+ if pkg == &importing {
+ log.Fatalf("cycle importing package %q", name)
+ }
+ return pkg, nil
+ }
+ w.imported[name] = &importing
+
+ context := w.context
+ if context == nil {
+ context = &build.Default
+ }
+
+ // Determine package files.
+ var dir string
+ // if 'name' is not a std package, then include GOPATH
+ if pkg == nil && *includeGopath {
+ c_pkg, err := build.Default.Import(name, "", build.FindOnly)
+ if err != nil {
+ log.Fatalf("failed to find import %q", name)
+ }
+ dir = c_pkg.Dir
+ } else {
+ dir = filepath.Join(w.root, filepath.FromSlash(name))
+ if fi, err := os.Stat(dir); err != nil || !fi.IsDir() {
+ log.Fatalf("no source in tree for package %q (import name %q)", pkg, name)
+ }
+ }
+
+ // Look in cache.
+ // If we've already done an import with the same set
+ // of relevant tags, reuse the result.
+ var key string
+ if usePkgCache {
+ if tags, ok := pkgTags[dir]; ok {
+ key = tagKey(dir, context, tags)
+ if pkg := pkgCache[key]; pkg != nil {
+ w.imported[name] = pkg
+ return pkg, nil
+ }
+ }
+ }
+
+ info, err := context.ImportDir(dir, 0)
+ if err != nil {
+ if _, nogo := err.(*build.NoGoError); nogo {
+ return nil, nil
+ }
+ log.Fatalf("pkg %q, dir %q: ScanDir: %v", name, dir, err)
+ }
+
+ // Save tags list first time we see a directory.
+ if usePkgCache {
+ if _, ok := pkgTags[dir]; !ok {
+ pkgTags[dir] = info.AllTags
+ key = tagKey(dir, context, info.AllTags)
+ }
+ }
+
+ filenames := append(append([]string{}, info.GoFiles...), info.CgoFiles...)
+
+ // Parse package files.
+ var files []*ast.File
+ for _, file := range filenames {
+ f, err := w.parseFile(dir, file)
+ if err != nil {
+ log.Fatalf("error parsing package %s: %s", name, err)
+ }
+ files = append(files, f)
+ }
+
+ // Type-check package files.
+ conf := types.Config{
+ IgnoreFuncBodies: true,
+ FakeImportC: true,
+ Importer: w,
+ }
+ pkg, err = conf.Check(name, fset, files, nil)
+ if err != nil {
+ ctxt := ""
+ if w.context != nil {
+ ctxt = fmt.Sprintf("%s-%s", w.context.GOOS, w.context.GOARCH)
+ }
+ log.Fatalf("error typechecking package %s: %s (%s)", name, err, ctxt)
+ }
+
+ if usePkgCache {
+ pkgCache[key] = pkg
+ }
+
+ w.imported[name] = pkg
+ return pkg, nil
+}
+
+// pushScope enters a new scope (walking a package, type, node, etc)
+// and returns a function that will leave the scope (with sanity checking
+// for mismatched pushes & pops)
+func (w *Walker) pushScope(name string) (popFunc func()) {
+ w.scope = append(w.scope, name)
+ return func() {
+ if len(w.scope) == 0 {
+ log.Fatalf("attempt to leave scope %q with empty scope list", name)
+ }
+ if w.scope[len(w.scope)-1] != name {
+ log.Fatalf("attempt to leave scope %q, but scope is currently %#v", name, w.scope)
+ }
+ w.scope = w.scope[:len(w.scope)-1]
+ }
+}
+
+func sortedMethodNames(typ *types.Interface) []string {
+ n := typ.NumMethods()
+ list := make([]string, n)
+ for i := range list {
+ list[i] = typ.Method(i).Name()
+ }
+ sort.Strings(list)
+ return list
+}
+
+func (w *Walker) writeType(buf *bytes.Buffer, typ types.Type) {
+ switch typ := typ.(type) {
+ case *types.Basic:
+ s := typ.Name()
+ switch typ.Kind() {
+ case types.UnsafePointer:
+ s = "unsafe.Pointer"
+ case types.UntypedBool:
+ s = "ideal-bool"
+ case types.UntypedInt:
+ s = "ideal-int"
+ case types.UntypedRune:
+ // "ideal-char" for compatibility with old tool
+ // TODO(gri) change to "ideal-rune"
+ s = "ideal-char"
+ case types.UntypedFloat:
+ s = "ideal-float"
+ case types.UntypedComplex:
+ s = "ideal-complex"
+ case types.UntypedString:
+ s = "ideal-string"
+ case types.UntypedNil:
+ panic("should never see untyped nil type")
+ default:
+ switch s {
+ case "byte":
+ s = "uint8"
+ case "rune":
+ s = "int32"
+ }
+ }
+ buf.WriteString(s)
+
+ case *types.Array:
+ fmt.Fprintf(buf, "[%d]", typ.Len())
+ w.writeType(buf, typ.Elem())
+
+ case *types.Slice:
+ buf.WriteString("[]")
+ w.writeType(buf, typ.Elem())
+
+ case *types.Struct:
+ buf.WriteString("struct")
+
+ case *types.Pointer:
+ buf.WriteByte('*')
+ w.writeType(buf, typ.Elem())
+
+ case *types.Tuple:
+ panic("should never see a tuple type")
+
+ case *types.Signature:
+ buf.WriteString("func")
+ w.writeSignature(buf, typ)
+
+ case *types.Interface:
+ buf.WriteString("interface{")
+ if typ.NumMethods() > 0 {
+ buf.WriteByte(' ')
+ buf.WriteString(strings.Join(sortedMethodNames(typ), ", "))
+ buf.WriteByte(' ')
+ }
+ buf.WriteString("}")
+
+ case *types.Map:
+ buf.WriteString("map[")
+ w.writeType(buf, typ.Key())
+ buf.WriteByte(']')
+ w.writeType(buf, typ.Elem())
+
+ case *types.Chan:
+ var s string
+ switch typ.Dir() {
+ case types.SendOnly:
+ s = "chan<- "
+ case types.RecvOnly:
+ s = "<-chan "
+ case types.SendRecv:
+ s = "chan "
+ default:
+ panic("unreachable")
+ }
+ buf.WriteString(s)
+ w.writeType(buf, typ.Elem())
+
+ case *types.Named:
+ obj := typ.Obj()
+ pkg := obj.Pkg()
+ if pkg != nil && pkg != w.current {
+ buf.WriteString(pkg.Name())
+ buf.WriteByte('.')
+ }
+ buf.WriteString(typ.Obj().Name())
+
+ default:
+ panic(fmt.Sprintf("unknown type %T", typ))
+ }
+}
+
+func (w *Walker) writeSignature(buf *bytes.Buffer, sig *types.Signature) {
+ w.writeParams(buf, sig.Params(), sig.Variadic())
+ switch res := sig.Results(); res.Len() {
+ case 0:
+ // nothing to do
+ case 1:
+ buf.WriteByte(' ')
+ w.writeType(buf, res.At(0).Type())
+ default:
+ buf.WriteByte(' ')
+ w.writeParams(buf, res, false)
+ }
+}
+
+func (w *Walker) writeParams(buf *bytes.Buffer, t *types.Tuple, variadic bool) {
+ buf.WriteByte('(')
+ for i, n := 0, t.Len(); i < n; i++ {
+ if i > 0 {
+ buf.WriteString(", ")
+ }
+ typ := t.At(i).Type()
+ if variadic && i+1 == n {
+ buf.WriteString("...")
+ typ = typ.(*types.Slice).Elem()
+ }
+ w.writeType(buf, typ)
+ }
+ buf.WriteByte(')')
+}
+
+func (w *Walker) typeString(typ types.Type) string {
+ var buf bytes.Buffer
+ w.writeType(&buf, typ)
+ return buf.String()
+}
+
+func (w *Walker) signatureString(sig *types.Signature) string {
+ var buf bytes.Buffer
+ w.writeSignature(&buf, sig)
+ return buf.String()
+}
+
+func (w *Walker) emitObj(obj types.Object) {
+ switch obj := obj.(type) {
+ case *types.Const:
+ w.emitf("const %s %s", obj.Name(), w.typeString(obj.Type()))
+ w.emitf("const %s = %s", obj.Name(), obj.Val())
+ case *types.Var:
+ w.emitf("var %s %s", obj.Name(), w.typeString(obj.Type()))
+ case *types.TypeName:
+ w.emitType(obj)
+ case *types.Func:
+ w.emitFunc(obj)
+ default:
+ panic("unknown object: " + obj.String())
+ }
+}
+
+func (w *Walker) emitType(obj *types.TypeName) {
+ name := obj.Name()
+ typ := obj.Type()
+ switch typ := typ.Underlying().(type) {
+ case *types.Struct:
+ w.emitStructType(name, typ)
+ case *types.Interface:
+ w.emitIfaceType(name, typ)
+ return // methods are handled by emitIfaceType
+ default:
+ w.emitf("type %s %s", name, w.typeString(typ.Underlying()))
+ }
+
+ // emit methods with value receiver
+ var methodNames map[string]bool
+ vset := types.NewMethodSet(typ)
+ for i, n := 0, vset.Len(); i < n; i++ {
+ m := vset.At(i)
+ if m.Obj().Exported() {
+ w.emitMethod(m)
+ if methodNames == nil {
+ methodNames = make(map[string]bool)
+ }
+ methodNames[m.Obj().Name()] = true
+ }
+ }
+
+ // emit methods with pointer receiver; exclude
+ // methods that we have emitted already
+ // (the method set of *T includes the methods of T)
+ pset := types.NewMethodSet(types.NewPointer(typ))
+ for i, n := 0, pset.Len(); i < n; i++ {
+ m := pset.At(i)
+ if m.Obj().Exported() && !methodNames[m.Obj().Name()] {
+ w.emitMethod(m)
+ }
+ }
+}
+
+func (w *Walker) emitStructType(name string, typ *types.Struct) {
+ typeStruct := fmt.Sprintf("type %s struct", name)
+ w.emitf(typeStruct)
+ defer w.pushScope(typeStruct)()
+
+ for i := 0; i < typ.NumFields(); i++ {
+ f := typ.Field(i)
+ if !f.Exported() {
+ continue
+ }
+ typ := f.Type()
+ if f.Anonymous() {
+ w.emitf("embedded %s", w.typeString(typ))
+ continue
+ }
+ w.emitf("%s %s", f.Name(), w.typeString(typ))
+ }
+}
+
+func (w *Walker) emitIfaceType(name string, typ *types.Interface) {
+ pop := w.pushScope("type " + name + " interface")
+
+ var methodNames []string
+ complete := true
+ mset := types.NewMethodSet(typ)
+ for i, n := 0, mset.Len(); i < n; i++ {
+ m := mset.At(i).Obj().(*types.Func)
+ if !m.Exported() {
+ complete = false
+ continue
+ }
+ methodNames = append(methodNames, m.Name())
+ w.emitf("%s%s", m.Name(), w.signatureString(m.Type().(*types.Signature)))
+ }
+
+ if !complete {
+ // The method set has unexported methods, so all the
+ // implementations are provided by the same package,
+ // so the method set can be extended. Instead of recording
+ // the full set of names (below), record only that there were
+ // unexported methods. (If the interface shrinks, we will notice
+ // because a method signature emitted during the last loop
+ // will disappear.)
+ w.emitf("unexported methods")
+ }
+
+ pop()
+
+ if !complete {
+ return
+ }
+
+ if len(methodNames) == 0 {
+ w.emitf("type %s interface {}", name)
+ return
+ }
+
+ sort.Strings(methodNames)
+ w.emitf("type %s interface { %s }", name, strings.Join(methodNames, ", "))
+}
+
+func (w *Walker) emitFunc(f *types.Func) {
+ sig := f.Type().(*types.Signature)
+ if sig.Recv() != nil {
+ panic("method considered a regular function: " + f.String())
+ }
+ w.emitf("func %s%s", f.Name(), w.signatureString(sig))
+}
+
+func (w *Walker) emitMethod(m *types.Selection) {
+ sig := m.Type().(*types.Signature)
+ recv := sig.Recv().Type()
+ // report exported methods with unexported receiver base type
+ if true {
+ base := recv
+ if p, _ := recv.(*types.Pointer); p != nil {
+ base = p.Elem()
+ }
+ if obj := base.(*types.Named).Obj(); !obj.Exported() {
+ log.Fatalf("exported method with unexported receiver base type: %s", m)
+ }
+ }
+ w.emitf("method (%s) %s%s", w.typeString(recv), m.Obj().Name(), w.signatureString(sig))
+}
+
+func (w *Walker) emitf(format string, args ...interface{}) {
+ f := strings.Join(w.scope, ", ") + ", " + fmt.Sprintf(format, args...)
+ if strings.Contains(f, "\n") {
+ panic("feature contains newlines: " + f)
+ }
+
+ if _, dup := w.features[f]; dup {
+ panic("duplicate feature inserted: " + f)
+ }
+ w.features[f] = true
+
+ if *verbose {
+ log.Printf("feature: %s", f)
+ }
+}
diff --git a/playground/internal/imports/mkstdlib.go b/playground/internal/imports/mkstdlib.go
new file mode 100644
index 00000000..d7141306
--- /dev/null
+++ b/playground/internal/imports/mkstdlib.go
@@ -0,0 +1,130 @@
+//go:build generate
+// +build generate
+
+// mkstdlib generates the zstdlib.go file, containing the Go standard
+// library API symbols. It's baked into the binary to avoid scanning
+// GOPATH in the common case.
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "flag"
+ "fmt"
+ "go/format"
+ "io"
+ "io/ioutil"
+ "log"
+ "os"
+ "path"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "sort"
+ "strings"
+)
+
+var outputFlag = flag.String("output", "", "output file name without extension; if empty, then print to stdout")
+
+func mustOpenAll(names ...string) []io.Reader {
+ ff := []io.Reader{}
+ for _, name := range names {
+ f, err := os.Open(name)
+ if err != nil {
+ log.Fatal(err)
+ }
+ ff = append(ff, f)
+ }
+ return ff
+}
+
+func api(base string) string {
+ return filepath.Join(runtime.GOROOT(), "api", base)
+}
+
+func goAPIs() []string {
+ paths, err := filepath.Glob(filepath.Join(runtime.GOROOT(), "api", "go1.*.txt"))
+ if err != nil {
+ log.Fatalf("Failed to match Go API files: %s", err)
+ }
+ return paths
+}
+
+var sym = regexp.MustCompile(`^pkg (\S+).*?, (?:var|func|type|const) ([A-Z]\w*)`)
+
+var skips = map[string]struct{}{
+ // Skip syscall because it's really big and causes Maximum call stack size exceeded panic.
+ // See https://github.com/gopherjs/gopherjs/issues/305.
+ "syscall": {},
+}
+
+func main() {
+ flag.Parse()
+
+ var buf bytes.Buffer
+ outf := func(format string, args ...interface{}) {
+ fmt.Fprintf(&buf, format, args...)
+ }
+ outf("// AUTO-GENERATED BY mkstdlib.go\n\n")
+ outf("package imports\n")
+ outf("var stdlib = map[string]string{\n")
+ f := io.MultiReader(
+ mustOpenAll(append(
+ // Standard library packages.
+ goAPIs(),
+ // The API of the syscall/js package needs to be computed explicitly,
+ // because it's not included in the GOROOT/api/go1.*.txt files at this time.
+ "syscalljs.txt",
+ "gopherjs.txt")...)...)
+ sc := bufio.NewScanner(f)
+ fullImport := map[string]string{} // "zip.NewReader" => "archive/zip"
+ ambiguous := map[string]bool{}
+ var keys []string
+ for sc.Scan() {
+ l := sc.Text()
+ has := func(v string) bool { return strings.Contains(l, v) }
+ if has("struct, ") || has("interface, ") || has(", method (") {
+ continue
+ }
+ if m := sym.FindStringSubmatch(l); m != nil {
+ full := m[1]
+ key := path.Base(full) + "." + m[2]
+ if exist, ok := fullImport[key]; ok {
+ if exist != full {
+ ambiguous[key] = true
+ }
+ } else {
+ fullImport[key] = full
+ keys = append(keys, key)
+ }
+ }
+ }
+ if err := sc.Err(); err != nil {
+ log.Fatal(err)
+ }
+ sort.Strings(keys)
+ for _, key := range keys {
+ if _, skip := skips[fullImport[key]]; skip {
+ continue
+ }
+ if ambiguous[key] {
+ outf("\t// %q is ambiguous\n", key)
+ } else {
+ outf("\t%q: %q,\n", key, fullImport[key])
+ }
+ }
+ outf("}\n")
+ fmtbuf, err := format.Source(buf.Bytes())
+ if err != nil {
+ log.Fatal(err)
+ }
+ switch *outputFlag {
+ case "":
+ os.Stdout.Write(fmtbuf)
+ default:
+ err := ioutil.WriteFile(*outputFlag+".go", fmtbuf, 0644)
+ if err != nil {
+ log.Fatalf("writing output: %s", err)
+ }
+ }
+}
diff --git a/playground/internal/imports/sortimports.go b/playground/internal/imports/sortimports.go
new file mode 100644
index 00000000..68b3dc4e
--- /dev/null
+++ b/playground/internal/imports/sortimports.go
@@ -0,0 +1,214 @@
+// +build go1.2
+
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Hacked up copy of go/ast/import.go
+
+package imports
+
+import (
+ "go/ast"
+ "go/token"
+ "sort"
+ "strconv"
+)
+
+// sortImports sorts runs of consecutive import lines in import blocks in f.
+// It also removes duplicate imports when it is possible to do so without data loss.
+func sortImports(fset *token.FileSet, f *ast.File) {
+ for i, d := range f.Decls {
+ d, ok := d.(*ast.GenDecl)
+ if !ok || d.Tok != token.IMPORT {
+ // Not an import declaration, so we're done.
+ // Imports are always first.
+ break
+ }
+
+ if len(d.Specs) == 0 {
+ // Empty import block, remove it.
+ f.Decls = append(f.Decls[:i], f.Decls[i+1:]...)
+ }
+
+ if !d.Lparen.IsValid() {
+ // Not a block: sorted by default.
+ continue
+ }
+
+ // Identify and sort runs of specs on successive lines.
+ i := 0
+ specs := d.Specs[:0]
+ for j, s := range d.Specs {
+ if j > i && fset.Position(s.Pos()).Line > 1+fset.Position(d.Specs[j-1].End()).Line {
+ // j begins a new run. End this one.
+ specs = append(specs, sortSpecs(fset, f, d.Specs[i:j])...)
+ i = j
+ }
+ }
+ specs = append(specs, sortSpecs(fset, f, d.Specs[i:])...)
+ d.Specs = specs
+
+ // Deduping can leave a blank line before the rparen; clean that up.
+ if len(d.Specs) > 0 {
+ lastSpec := d.Specs[len(d.Specs)-1]
+ lastLine := fset.Position(lastSpec.Pos()).Line
+ if rParenLine := fset.Position(d.Rparen).Line; rParenLine > lastLine+1 {
+ fset.File(d.Rparen).MergeLine(rParenLine - 1)
+ }
+ }
+ }
+}
+
+func importPath(s ast.Spec) string {
+ t, err := strconv.Unquote(s.(*ast.ImportSpec).Path.Value)
+ if err == nil {
+ return t
+ }
+ return ""
+}
+
+func importName(s ast.Spec) string {
+ n := s.(*ast.ImportSpec).Name
+ if n == nil {
+ return ""
+ }
+ return n.Name
+}
+
+func importComment(s ast.Spec) string {
+ c := s.(*ast.ImportSpec).Comment
+ if c == nil {
+ return ""
+ }
+ return c.Text()
+}
+
+// collapse indicates whether prev may be removed, leaving only next.
+func collapse(prev, next ast.Spec) bool {
+ if importPath(next) != importPath(prev) || importName(next) != importName(prev) {
+ return false
+ }
+ return prev.(*ast.ImportSpec).Comment == nil
+}
+
+type posSpan struct {
+ Start token.Pos
+ End token.Pos
+}
+
+func sortSpecs(fset *token.FileSet, f *ast.File, specs []ast.Spec) []ast.Spec {
+ // Can't short-circuit here even if specs are already sorted,
+ // since they might yet need deduplication.
+ // A lone import, however, may be safely ignored.
+ if len(specs) <= 1 {
+ return specs
+ }
+
+ // Record positions for specs.
+ pos := make([]posSpan, len(specs))
+ for i, s := range specs {
+ pos[i] = posSpan{s.Pos(), s.End()}
+ }
+
+ // Identify comments in this range.
+ // Any comment from pos[0].Start to the final line counts.
+ lastLine := fset.Position(pos[len(pos)-1].End).Line
+ cstart := len(f.Comments)
+ cend := len(f.Comments)
+ for i, g := range f.Comments {
+ if g.Pos() < pos[0].Start {
+ continue
+ }
+ if i < cstart {
+ cstart = i
+ }
+ if fset.Position(g.End()).Line > lastLine {
+ cend = i
+ break
+ }
+ }
+ comments := f.Comments[cstart:cend]
+
+ // Assign each comment to the import spec preceding it.
+ importComment := map[*ast.ImportSpec][]*ast.CommentGroup{}
+ specIndex := 0
+ for _, g := range comments {
+ for specIndex+1 < len(specs) && pos[specIndex+1].Start <= g.Pos() {
+ specIndex++
+ }
+ s := specs[specIndex].(*ast.ImportSpec)
+ importComment[s] = append(importComment[s], g)
+ }
+
+ // Sort the import specs by import path.
+ // Remove duplicates, when possible without data loss.
+ // Reassign the import paths to have the same position sequence.
+ // Reassign each comment to abut the end of its spec.
+ // Sort the comments by new position.
+ sort.Sort(byImportSpec(specs))
+
+ // Dedup. Thanks to our sorting, we can just consider
+ // adjacent pairs of imports.
+ deduped := specs[:0]
+ for i, s := range specs {
+ if i == len(specs)-1 || !collapse(s, specs[i+1]) {
+ deduped = append(deduped, s)
+ } else {
+ p := s.Pos()
+ fset.File(p).MergeLine(fset.Position(p).Line)
+ }
+ }
+ specs = deduped
+
+ // Fix up comment positions
+ for i, s := range specs {
+ s := s.(*ast.ImportSpec)
+ if s.Name != nil {
+ s.Name.NamePos = pos[i].Start
+ }
+ s.Path.ValuePos = pos[i].Start
+ s.EndPos = pos[i].End
+ for _, g := range importComment[s] {
+ for _, c := range g.List {
+ c.Slash = pos[i].End
+ }
+ }
+ }
+
+ sort.Sort(byCommentPos(comments))
+
+ return specs
+}
+
+type byImportSpec []ast.Spec // slice of *ast.ImportSpec
+
+func (x byImportSpec) Len() int { return len(x) }
+func (x byImportSpec) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x byImportSpec) Less(i, j int) bool {
+ ipath := importPath(x[i])
+ jpath := importPath(x[j])
+
+ igroup := importGroup(ipath)
+ jgroup := importGroup(jpath)
+ if igroup != jgroup {
+ return igroup < jgroup
+ }
+
+ if ipath != jpath {
+ return ipath < jpath
+ }
+ iname := importName(x[i])
+ jname := importName(x[j])
+
+ if iname != jname {
+ return iname < jname
+ }
+ return importComment(x[i]) < importComment(x[j])
+}
+
+type byCommentPos []*ast.CommentGroup
+
+func (x byCommentPos) Len() int { return len(x) }
+func (x byCommentPos) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+func (x byCommentPos) Less(i, j int) bool { return x[i].Pos() < x[j].Pos() }
diff --git a/playground/internal/imports/zstdlib.go b/playground/internal/imports/zstdlib.go
new file mode 100644
index 00000000..4dcb554d
--- /dev/null
+++ b/playground/internal/imports/zstdlib.go
@@ -0,0 +1,3369 @@
+// AUTO-GENERATED BY mkstdlib.go
+
+package imports
+
+var stdlib = map[string]string{
+ "adler32.Size": "hash/adler32",
+ "aes.BlockSize": "crypto/aes",
+ "asn1.ClassApplication": "encoding/asn1",
+ "asn1.ClassContextSpecific": "encoding/asn1",
+ "asn1.ClassPrivate": "encoding/asn1",
+ "asn1.ClassUniversal": "encoding/asn1",
+ "asn1.MarshalWithParams": "encoding/asn1",
+ "asn1.NullBytes": "encoding/asn1",
+ "asn1.NullRawValue": "encoding/asn1",
+ "asn1.TagBMPString": "encoding/asn1",
+ "asn1.TagBitString": "encoding/asn1",
+ "asn1.TagBoolean": "encoding/asn1",
+ "asn1.TagEnum": "encoding/asn1",
+ "asn1.TagGeneralString": "encoding/asn1",
+ "asn1.TagGeneralizedTime": "encoding/asn1",
+ "asn1.TagIA5String": "encoding/asn1",
+ "asn1.TagInteger": "encoding/asn1",
+ "asn1.TagNull": "encoding/asn1",
+ "asn1.TagNumericString": "encoding/asn1",
+ "asn1.TagOID": "encoding/asn1",
+ "asn1.TagOctetString": "encoding/asn1",
+ "asn1.TagPrintableString": "encoding/asn1",
+ "asn1.TagSequence": "encoding/asn1",
+ "asn1.TagSet": "encoding/asn1",
+ "asn1.TagT61String": "encoding/asn1",
+ "asn1.TagUTCTime": "encoding/asn1",
+ "asn1.TagUTF8String": "encoding/asn1",
+ "ast.Bad": "go/ast",
+ "ast.CommentMap": "go/ast",
+ "ast.Con": "go/ast",
+ "ast.FilterFuncDuplicates": "go/ast",
+ "ast.FilterImportDuplicates": "go/ast",
+ "ast.FilterUnassociatedComments": "go/ast",
+ "ast.Fun": "go/ast",
+ "ast.Lbl": "go/ast",
+ "ast.NewCommentMap": "go/ast",
+ "ast.Pkg": "go/ast",
+ "ast.RECV": "go/ast",
+ "ast.SEND": "go/ast",
+ "ast.Typ": "go/ast",
+ "ast.Var": "go/ast",
+ "atomic.SwapInt32": "sync/atomic",
+ "atomic.SwapInt64": "sync/atomic",
+ "atomic.SwapPointer": "sync/atomic",
+ "atomic.SwapUint32": "sync/atomic",
+ "atomic.SwapUint64": "sync/atomic",
+ "atomic.SwapUintptr": "sync/atomic",
+ "atomic.Value": "sync/atomic",
+ "base32.NoPadding": "encoding/base32",
+ "base32.StdPadding": "encoding/base32",
+ "base64.NoPadding": "encoding/base64",
+ "base64.RawStdEncoding": "encoding/base64",
+ "base64.RawURLEncoding": "encoding/base64",
+ "base64.StdPadding": "encoding/base64",
+ "big.Above": "math/big",
+ "big.Accuracy": "math/big",
+ "big.AwayFromZero": "math/big",
+ "big.Below": "math/big",
+ "big.ErrNaN": "math/big",
+ "big.Exact": "math/big",
+ "big.Float": "math/big",
+ "big.Jacobi": "math/big",
+ "big.MaxBase": "math/big",
+ "big.MaxExp": "math/big",
+ "big.MaxPrec": "math/big",
+ "big.MinExp": "math/big",
+ "big.NewFloat": "math/big",
+ "big.ParseFloat": "math/big",
+ "big.RoundingMode": "math/big",
+ "big.ToNearestAway": "math/big",
+ "big.ToNearestEven": "math/big",
+ "big.ToNegativeInf": "math/big",
+ "big.ToPositiveInf": "math/big",
+ "big.ToZero": "math/big",
+ "big.Word": "math/big",
+ "binary.MaxVarintLen16": "encoding/binary",
+ "binary.MaxVarintLen32": "encoding/binary",
+ "binary.MaxVarintLen64": "encoding/binary",
+ "bits.Add": "math/bits",
+ "bits.Add32": "math/bits",
+ "bits.Add64": "math/bits",
+ "bits.Div": "math/bits",
+ "bits.Div32": "math/bits",
+ "bits.Div64": "math/bits",
+ "bits.LeadingZeros": "math/bits",
+ "bits.LeadingZeros16": "math/bits",
+ "bits.LeadingZeros32": "math/bits",
+ "bits.LeadingZeros64": "math/bits",
+ "bits.LeadingZeros8": "math/bits",
+ "bits.Len": "math/bits",
+ "bits.Len16": "math/bits",
+ "bits.Len32": "math/bits",
+ "bits.Len64": "math/bits",
+ "bits.Len8": "math/bits",
+ "bits.Mul": "math/bits",
+ "bits.Mul32": "math/bits",
+ "bits.Mul64": "math/bits",
+ "bits.OnesCount": "math/bits",
+ "bits.OnesCount16": "math/bits",
+ "bits.OnesCount32": "math/bits",
+ "bits.OnesCount64": "math/bits",
+ "bits.OnesCount8": "math/bits",
+ "bits.Rem": "math/bits",
+ "bits.Rem32": "math/bits",
+ "bits.Rem64": "math/bits",
+ "bits.Reverse": "math/bits",
+ "bits.Reverse16": "math/bits",
+ "bits.Reverse32": "math/bits",
+ "bits.Reverse64": "math/bits",
+ "bits.Reverse8": "math/bits",
+ "bits.ReverseBytes": "math/bits",
+ "bits.ReverseBytes16": "math/bits",
+ "bits.ReverseBytes32": "math/bits",
+ "bits.ReverseBytes64": "math/bits",
+ "bits.RotateLeft": "math/bits",
+ "bits.RotateLeft16": "math/bits",
+ "bits.RotateLeft32": "math/bits",
+ "bits.RotateLeft64": "math/bits",
+ "bits.RotateLeft8": "math/bits",
+ "bits.Sub": "math/bits",
+ "bits.Sub32": "math/bits",
+ "bits.Sub64": "math/bits",
+ "bits.TrailingZeros": "math/bits",
+ "bits.TrailingZeros16": "math/bits",
+ "bits.TrailingZeros32": "math/bits",
+ "bits.TrailingZeros64": "math/bits",
+ "bits.TrailingZeros8": "math/bits",
+ "bits.UintSize": "math/bits",
+ "bufio.ErrAdvanceTooFar": "bufio",
+ "bufio.ErrBadReadCount": "bufio",
+ "bufio.ErrFinalToken": "bufio",
+ "bufio.ErrNegativeAdvance": "bufio",
+ "bufio.ErrTooLong": "bufio",
+ "bufio.MaxScanTokenSize": "bufio",
+ "bufio.NewScanner": "bufio",
+ "bufio.ScanBytes": "bufio",
+ "bufio.ScanLines": "bufio",
+ "bufio.ScanRunes": "bufio",
+ "bufio.ScanWords": "bufio",
+ "bufio.Scanner": "bufio",
+ "bufio.SplitFunc": "bufio",
+ "build.AllowBinary": "go/build",
+ "build.FindOnly": "go/build",
+ "build.IgnoreVendor": "go/build",
+ "build.ImportComment": "go/build",
+ "build.MultiplePackageError": "go/build",
+ "bytes.ContainsAny": "bytes",
+ "bytes.ContainsRune": "bytes",
+ "bytes.LastIndexByte": "bytes",
+ "bytes.MinRead": "bytes",
+ "bytes.ReplaceAll": "bytes",
+ "bytes.ToValidUTF8": "bytes",
+ "bytes.TrimPrefix": "bytes",
+ "bytes.TrimSuffix": "bytes",
+ "cgo.Handle": "runtime/cgo",
+ "cgo.NewHandle": "runtime/cgo",
+ "cipher.AEAD": "crypto/cipher",
+ "cipher.NewGCM": "crypto/cipher",
+ "cipher.NewGCMWithNonceSize": "crypto/cipher",
+ "cipher.NewGCMWithTagSize": "crypto/cipher",
+ "color.CMYK": "image/color",
+ "color.CMYKModel": "image/color",
+ "color.CMYKToRGB": "image/color",
+ "color.NYCbCrA": "image/color",
+ "color.NYCbCrAModel": "image/color",
+ "color.RGBToCMYK": "image/color",
+ "constant.BinaryOp": "go/constant",
+ "constant.BitLen": "go/constant",
+ "constant.Bool": "go/constant",
+ "constant.BoolVal": "go/constant",
+ "constant.Bytes": "go/constant",
+ "constant.Compare": "go/constant",
+ "constant.Complex": "go/constant",
+ "constant.Denom": "go/constant",
+ "constant.Float": "go/constant",
+ "constant.Float32Val": "go/constant",
+ "constant.Float64Val": "go/constant",
+ "constant.Imag": "go/constant",
+ "constant.Int": "go/constant",
+ "constant.Int64Val": "go/constant",
+ "constant.Kind": "go/constant",
+ "constant.Make": "go/constant",
+ "constant.MakeBool": "go/constant",
+ "constant.MakeFloat64": "go/constant",
+ "constant.MakeFromBytes": "go/constant",
+ "constant.MakeFromLiteral": "go/constant",
+ "constant.MakeImag": "go/constant",
+ "constant.MakeInt64": "go/constant",
+ "constant.MakeString": "go/constant",
+ "constant.MakeUint64": "go/constant",
+ "constant.MakeUnknown": "go/constant",
+ "constant.Num": "go/constant",
+ "constant.Real": "go/constant",
+ "constant.Shift": "go/constant",
+ "constant.Sign": "go/constant",
+ "constant.String": "go/constant",
+ "constant.StringVal": "go/constant",
+ "constant.ToComplex": "go/constant",
+ "constant.ToFloat": "go/constant",
+ "constant.ToInt": "go/constant",
+ "constant.Uint64Val": "go/constant",
+ "constant.UnaryOp": "go/constant",
+ "constant.Unknown": "go/constant",
+ "constant.Val": "go/constant",
+ "constraint.AndExpr": "go/build/constraint",
+ "constraint.IsGoBuild": "go/build/constraint",
+ "constraint.IsPlusBuild": "go/build/constraint",
+ "constraint.NotExpr": "go/build/constraint",
+ "constraint.OrExpr": "go/build/constraint",
+ "constraint.Parse": "go/build/constraint",
+ "constraint.PlusBuildLines": "go/build/constraint",
+ "constraint.SyntaxError": "go/build/constraint",
+ "constraint.TagExpr": "go/build/constraint",
+ "context.Background": "context",
+ "context.CancelFunc": "context",
+ "context.Canceled": "context",
+ "context.Context": "context",
+ "context.DeadlineExceeded": "context",
+ "context.TODO": "context",
+ "context.WithCancel": "context",
+ "context.WithDeadline": "context",
+ "context.WithTimeout": "context",
+ "context.WithValue": "context",
+ "cookiejar.Jar": "net/http/cookiejar",
+ "cookiejar.New": "net/http/cookiejar",
+ "cookiejar.Options": "net/http/cookiejar",
+ "cookiejar.PublicSuffixList": "net/http/cookiejar",
+ "crc32.Castagnoli": "hash/crc32",
+ "crc32.IEEE": "hash/crc32",
+ "crc32.Koopman": "hash/crc32",
+ "crc32.Size": "hash/crc32",
+ "crc64.ECMA": "hash/crc64",
+ "crc64.ISO": "hash/crc64",
+ "crc64.Size": "hash/crc64",
+ "crypto.BLAKE2b_256": "crypto",
+ "crypto.BLAKE2b_384": "crypto",
+ "crypto.BLAKE2b_512": "crypto",
+ "crypto.BLAKE2s_256": "crypto",
+ "crypto.Decrypter": "crypto",
+ "crypto.DecrypterOpts": "crypto",
+ "crypto.MD4": "crypto",
+ "crypto.MD5": "crypto",
+ "crypto.MD5SHA1": "crypto",
+ "crypto.PublicKey": "crypto",
+ "crypto.RIPEMD160": "crypto",
+ "crypto.SHA1": "crypto",
+ "crypto.SHA224": "crypto",
+ "crypto.SHA256": "crypto",
+ "crypto.SHA384": "crypto",
+ "crypto.SHA3_224": "crypto",
+ "crypto.SHA3_256": "crypto",
+ "crypto.SHA3_384": "crypto",
+ "crypto.SHA3_512": "crypto",
+ "crypto.SHA512": "crypto",
+ "crypto.SHA512_224": "crypto",
+ "crypto.SHA512_256": "crypto",
+ "crypto.Signer": "crypto",
+ "crypto.SignerOpts": "crypto",
+ "debug.BuildInfo": "runtime/debug",
+ "debug.FreeOSMemory": "runtime/debug",
+ "debug.GCStats": "runtime/debug",
+ "debug.Module": "runtime/debug",
+ "debug.ReadBuildInfo": "runtime/debug",
+ "debug.ReadGCStats": "runtime/debug",
+ "debug.SetGCPercent": "runtime/debug",
+ "debug.SetMaxStack": "runtime/debug",
+ "debug.SetMaxThreads": "runtime/debug",
+ "debug.SetPanicOnFault": "runtime/debug",
+ "debug.SetTraceback": "runtime/debug",
+ "debug.WriteHeapDump": "runtime/debug",
+ "des.BlockSize": "crypto/des",
+ "doc.AllDecls": "go/doc",
+ "doc.AllMethods": "go/doc",
+ "doc.IllegalPrefixes": "go/doc",
+ "doc.IsPredeclared": "go/doc",
+ "doc.NewFromFiles": "go/doc",
+ "doc.Note": "go/doc",
+ "doc.PreserveAST": "go/doc",
+ "draw.Drawer": "image/draw",
+ "draw.FloydSteinberg": "image/draw",
+ "draw.Over": "image/draw",
+ "draw.Quantizer": "image/draw",
+ "draw.RGBA64Image": "image/draw",
+ "draw.Src": "image/draw",
+ "driver.ConnBeginTx": "database/sql/driver",
+ "driver.ConnPrepareContext": "database/sql/driver",
+ "driver.Connector": "database/sql/driver",
+ "driver.DriverContext": "database/sql/driver",
+ "driver.ErrRemoveArgument": "database/sql/driver",
+ "driver.ExecerContext": "database/sql/driver",
+ "driver.IsolationLevel": "database/sql/driver",
+ "driver.NamedValue": "database/sql/driver",
+ "driver.NamedValueChecker": "database/sql/driver",
+ "driver.Pinger": "database/sql/driver",
+ "driver.Queryer": "database/sql/driver",
+ "driver.QueryerContext": "database/sql/driver",
+ "driver.RowsColumnTypeDatabaseTypeName": "database/sql/driver",
+ "driver.RowsColumnTypeLength": "database/sql/driver",
+ "driver.RowsColumnTypeNullable": "database/sql/driver",
+ "driver.RowsColumnTypePrecisionScale": "database/sql/driver",
+ "driver.RowsColumnTypeScanType": "database/sql/driver",
+ "driver.RowsNextResultSet": "database/sql/driver",
+ "driver.SessionResetter": "database/sql/driver",
+ "driver.StmtExecContext": "database/sql/driver",
+ "driver.StmtQueryContext": "database/sql/driver",
+ "driver.TxOptions": "database/sql/driver",
+ "driver.Validator": "database/sql/driver",
+ "dsa.L1024N160": "crypto/dsa",
+ "dsa.L2048N224": "crypto/dsa",
+ "dsa.L2048N256": "crypto/dsa",
+ "dsa.L3072N256": "crypto/dsa",
+ "dwarf.AttrAbstractOrigin": "debug/dwarf",
+ "dwarf.AttrAccessibility": "debug/dwarf",
+ "dwarf.AttrAddrBase": "debug/dwarf",
+ "dwarf.AttrAddrClass": "debug/dwarf",
+ "dwarf.AttrAlignment": "debug/dwarf",
+ "dwarf.AttrAllocated": "debug/dwarf",
+ "dwarf.AttrArtificial": "debug/dwarf",
+ "dwarf.AttrAssociated": "debug/dwarf",
+ "dwarf.AttrBaseTypes": "debug/dwarf",
+ "dwarf.AttrBinaryScale": "debug/dwarf",
+ "dwarf.AttrBitOffset": "debug/dwarf",
+ "dwarf.AttrBitSize": "debug/dwarf",
+ "dwarf.AttrByteSize": "debug/dwarf",
+ "dwarf.AttrCallAllCalls": "debug/dwarf",
+ "dwarf.AttrCallAllSourceCalls": "debug/dwarf",
+ "dwarf.AttrCallAllTailCalls": "debug/dwarf",
+ "dwarf.AttrCallColumn": "debug/dwarf",
+ "dwarf.AttrCallDataLocation": "debug/dwarf",
+ "dwarf.AttrCallDataValue": "debug/dwarf",
+ "dwarf.AttrCallFile": "debug/dwarf",
+ "dwarf.AttrCallLine": "debug/dwarf",
+ "dwarf.AttrCallOrigin": "debug/dwarf",
+ "dwarf.AttrCallPC": "debug/dwarf",
+ "dwarf.AttrCallParameter": "debug/dwarf",
+ "dwarf.AttrCallReturnPC": "debug/dwarf",
+ "dwarf.AttrCallTailCall": "debug/dwarf",
+ "dwarf.AttrCallTarget": "debug/dwarf",
+ "dwarf.AttrCallTargetClobbered": "debug/dwarf",
+ "dwarf.AttrCallValue": "debug/dwarf",
+ "dwarf.AttrCalling": "debug/dwarf",
+ "dwarf.AttrCommonRef": "debug/dwarf",
+ "dwarf.AttrCompDir": "debug/dwarf",
+ "dwarf.AttrConstExpr": "debug/dwarf",
+ "dwarf.AttrConstValue": "debug/dwarf",
+ "dwarf.AttrContainingType": "debug/dwarf",
+ "dwarf.AttrCount": "debug/dwarf",
+ "dwarf.AttrDataBitOffset": "debug/dwarf",
+ "dwarf.AttrDataLocation": "debug/dwarf",
+ "dwarf.AttrDataMemberLoc": "debug/dwarf",
+ "dwarf.AttrDecimalScale": "debug/dwarf",
+ "dwarf.AttrDecimalSign": "debug/dwarf",
+ "dwarf.AttrDeclColumn": "debug/dwarf",
+ "dwarf.AttrDeclFile": "debug/dwarf",
+ "dwarf.AttrDeclLine": "debug/dwarf",
+ "dwarf.AttrDeclaration": "debug/dwarf",
+ "dwarf.AttrDefaultValue": "debug/dwarf",
+ "dwarf.AttrDefaulted": "debug/dwarf",
+ "dwarf.AttrDeleted": "debug/dwarf",
+ "dwarf.AttrDescription": "debug/dwarf",
+ "dwarf.AttrDigitCount": "debug/dwarf",
+ "dwarf.AttrDiscr": "debug/dwarf",
+ "dwarf.AttrDiscrList": "debug/dwarf",
+ "dwarf.AttrDiscrValue": "debug/dwarf",
+ "dwarf.AttrDwoName": "debug/dwarf",
+ "dwarf.AttrElemental": "debug/dwarf",
+ "dwarf.AttrEncoding": "debug/dwarf",
+ "dwarf.AttrEndianity": "debug/dwarf",
+ "dwarf.AttrEntrypc": "debug/dwarf",
+ "dwarf.AttrEnumClass": "debug/dwarf",
+ "dwarf.AttrExplicit": "debug/dwarf",
+ "dwarf.AttrExportSymbols": "debug/dwarf",
+ "dwarf.AttrExtension": "debug/dwarf",
+ "dwarf.AttrExternal": "debug/dwarf",
+ "dwarf.AttrFrameBase": "debug/dwarf",
+ "dwarf.AttrFriend": "debug/dwarf",
+ "dwarf.AttrHighpc": "debug/dwarf",
+ "dwarf.AttrIdentifierCase": "debug/dwarf",
+ "dwarf.AttrImport": "debug/dwarf",
+ "dwarf.AttrInline": "debug/dwarf",
+ "dwarf.AttrIsOptional": "debug/dwarf",
+ "dwarf.AttrLanguage": "debug/dwarf",
+ "dwarf.AttrLinkageName": "debug/dwarf",
+ "dwarf.AttrLocation": "debug/dwarf",
+ "dwarf.AttrLoclistsBase": "debug/dwarf",
+ "dwarf.AttrLowerBound": "debug/dwarf",
+ "dwarf.AttrLowpc": "debug/dwarf",
+ "dwarf.AttrMacroInfo": "debug/dwarf",
+ "dwarf.AttrMacros": "debug/dwarf",
+ "dwarf.AttrMainSubprogram": "debug/dwarf",
+ "dwarf.AttrMutable": "debug/dwarf",
+ "dwarf.AttrName": "debug/dwarf",
+ "dwarf.AttrNamelistItem": "debug/dwarf",
+ "dwarf.AttrNoreturn": "debug/dwarf",
+ "dwarf.AttrObjectPointer": "debug/dwarf",
+ "dwarf.AttrOrdering": "debug/dwarf",
+ "dwarf.AttrPictureString": "debug/dwarf",
+ "dwarf.AttrPriority": "debug/dwarf",
+ "dwarf.AttrProducer": "debug/dwarf",
+ "dwarf.AttrPrototyped": "debug/dwarf",
+ "dwarf.AttrPure": "debug/dwarf",
+ "dwarf.AttrRanges": "debug/dwarf",
+ "dwarf.AttrRank": "debug/dwarf",
+ "dwarf.AttrRecursive": "debug/dwarf",
+ "dwarf.AttrReference": "debug/dwarf",
+ "dwarf.AttrReturnAddr": "debug/dwarf",
+ "dwarf.AttrRnglistsBase": "debug/dwarf",
+ "dwarf.AttrRvalueReference": "debug/dwarf",
+ "dwarf.AttrSegment": "debug/dwarf",
+ "dwarf.AttrSibling": "debug/dwarf",
+ "dwarf.AttrSignature": "debug/dwarf",
+ "dwarf.AttrSmall": "debug/dwarf",
+ "dwarf.AttrSpecification": "debug/dwarf",
+ "dwarf.AttrStartScope": "debug/dwarf",
+ "dwarf.AttrStaticLink": "debug/dwarf",
+ "dwarf.AttrStmtList": "debug/dwarf",
+ "dwarf.AttrStrOffsetsBase": "debug/dwarf",
+ "dwarf.AttrStride": "debug/dwarf",
+ "dwarf.AttrStrideSize": "debug/dwarf",
+ "dwarf.AttrStringLength": "debug/dwarf",
+ "dwarf.AttrStringLengthBitSize": "debug/dwarf",
+ "dwarf.AttrStringLengthByteSize": "debug/dwarf",
+ "dwarf.AttrThreadsScaled": "debug/dwarf",
+ "dwarf.AttrTrampoline": "debug/dwarf",
+ "dwarf.AttrType": "debug/dwarf",
+ "dwarf.AttrUpperBound": "debug/dwarf",
+ "dwarf.AttrUseLocation": "debug/dwarf",
+ "dwarf.AttrUseUTF8": "debug/dwarf",
+ "dwarf.AttrVarParam": "debug/dwarf",
+ "dwarf.AttrVirtuality": "debug/dwarf",
+ "dwarf.AttrVisibility": "debug/dwarf",
+ "dwarf.AttrVtableElemLoc": "debug/dwarf",
+ "dwarf.Class": "debug/dwarf",
+ "dwarf.ClassAddrPtr": "debug/dwarf",
+ "dwarf.ClassAddress": "debug/dwarf",
+ "dwarf.ClassBlock": "debug/dwarf",
+ "dwarf.ClassConstant": "debug/dwarf",
+ "dwarf.ClassExprLoc": "debug/dwarf",
+ "dwarf.ClassFlag": "debug/dwarf",
+ "dwarf.ClassLinePtr": "debug/dwarf",
+ "dwarf.ClassLocList": "debug/dwarf",
+ "dwarf.ClassLocListPtr": "debug/dwarf",
+ "dwarf.ClassMacPtr": "debug/dwarf",
+ "dwarf.ClassRangeListPtr": "debug/dwarf",
+ "dwarf.ClassReference": "debug/dwarf",
+ "dwarf.ClassReferenceAlt": "debug/dwarf",
+ "dwarf.ClassReferenceSig": "debug/dwarf",
+ "dwarf.ClassRngList": "debug/dwarf",
+ "dwarf.ClassRngListsPtr": "debug/dwarf",
+ "dwarf.ClassStrOffsetsPtr": "debug/dwarf",
+ "dwarf.ClassString": "debug/dwarf",
+ "dwarf.ClassStringAlt": "debug/dwarf",
+ "dwarf.ClassUnknown": "debug/dwarf",
+ "dwarf.ErrUnknownPC": "debug/dwarf",
+ "dwarf.LineEntry": "debug/dwarf",
+ "dwarf.LineFile": "debug/dwarf",
+ "dwarf.LineReader": "debug/dwarf",
+ "dwarf.LineReaderPos": "debug/dwarf",
+ "dwarf.TagAccessDeclaration": "debug/dwarf",
+ "dwarf.TagArrayType": "debug/dwarf",
+ "dwarf.TagAtomicType": "debug/dwarf",
+ "dwarf.TagBaseType": "debug/dwarf",
+ "dwarf.TagCallSite": "debug/dwarf",
+ "dwarf.TagCallSiteParameter": "debug/dwarf",
+ "dwarf.TagCatchDwarfBlock": "debug/dwarf",
+ "dwarf.TagClassType": "debug/dwarf",
+ "dwarf.TagCoarrayType": "debug/dwarf",
+ "dwarf.TagCommonDwarfBlock": "debug/dwarf",
+ "dwarf.TagCommonInclusion": "debug/dwarf",
+ "dwarf.TagCompileUnit": "debug/dwarf",
+ "dwarf.TagCondition": "debug/dwarf",
+ "dwarf.TagConstType": "debug/dwarf",
+ "dwarf.TagConstant": "debug/dwarf",
+ "dwarf.TagDwarfProcedure": "debug/dwarf",
+ "dwarf.TagDynamicType": "debug/dwarf",
+ "dwarf.TagEntryPoint": "debug/dwarf",
+ "dwarf.TagEnumerationType": "debug/dwarf",
+ "dwarf.TagEnumerator": "debug/dwarf",
+ "dwarf.TagFileType": "debug/dwarf",
+ "dwarf.TagFormalParameter": "debug/dwarf",
+ "dwarf.TagFriend": "debug/dwarf",
+ "dwarf.TagGenericSubrange": "debug/dwarf",
+ "dwarf.TagImmutableType": "debug/dwarf",
+ "dwarf.TagImportedDeclaration": "debug/dwarf",
+ "dwarf.TagImportedModule": "debug/dwarf",
+ "dwarf.TagImportedUnit": "debug/dwarf",
+ "dwarf.TagInheritance": "debug/dwarf",
+ "dwarf.TagInlinedSubroutine": "debug/dwarf",
+ "dwarf.TagInterfaceType": "debug/dwarf",
+ "dwarf.TagLabel": "debug/dwarf",
+ "dwarf.TagLexDwarfBlock": "debug/dwarf",
+ "dwarf.TagMember": "debug/dwarf",
+ "dwarf.TagModule": "debug/dwarf",
+ "dwarf.TagMutableType": "debug/dwarf",
+ "dwarf.TagNamelist": "debug/dwarf",
+ "dwarf.TagNamelistItem": "debug/dwarf",
+ "dwarf.TagNamespace": "debug/dwarf",
+ "dwarf.TagPackedType": "debug/dwarf",
+ "dwarf.TagPartialUnit": "debug/dwarf",
+ "dwarf.TagPointerType": "debug/dwarf",
+ "dwarf.TagPtrToMemberType": "debug/dwarf",
+ "dwarf.TagReferenceType": "debug/dwarf",
+ "dwarf.TagRestrictType": "debug/dwarf",
+ "dwarf.TagRvalueReferenceType": "debug/dwarf",
+ "dwarf.TagSetType": "debug/dwarf",
+ "dwarf.TagSharedType": "debug/dwarf",
+ "dwarf.TagSkeletonUnit": "debug/dwarf",
+ "dwarf.TagStringType": "debug/dwarf",
+ "dwarf.TagStructType": "debug/dwarf",
+ "dwarf.TagSubprogram": "debug/dwarf",
+ "dwarf.TagSubrangeType": "debug/dwarf",
+ "dwarf.TagSubroutineType": "debug/dwarf",
+ "dwarf.TagTemplateAlias": "debug/dwarf",
+ "dwarf.TagTemplateTypeParameter": "debug/dwarf",
+ "dwarf.TagTemplateValueParameter": "debug/dwarf",
+ "dwarf.TagThrownType": "debug/dwarf",
+ "dwarf.TagTryDwarfBlock": "debug/dwarf",
+ "dwarf.TagTypeUnit": "debug/dwarf",
+ "dwarf.TagTypedef": "debug/dwarf",
+ "dwarf.TagUnionType": "debug/dwarf",
+ "dwarf.TagUnspecifiedParameters": "debug/dwarf",
+ "dwarf.TagUnspecifiedType": "debug/dwarf",
+ "dwarf.TagVariable": "debug/dwarf",
+ "dwarf.TagVariant": "debug/dwarf",
+ "dwarf.TagVariantPart": "debug/dwarf",
+ "dwarf.TagVolatileType": "debug/dwarf",
+ "dwarf.TagWithStmt": "debug/dwarf",
+ "dwarf.UnspecifiedType": "debug/dwarf",
+ "dwarf.UnsupportedType": "debug/dwarf",
+ "ecdsa.SignASN1": "crypto/ecdsa",
+ "ecdsa.VerifyASN1": "crypto/ecdsa",
+ "ed25519.GenerateKey": "crypto/ed25519",
+ "ed25519.NewKeyFromSeed": "crypto/ed25519",
+ "ed25519.PrivateKey": "crypto/ed25519",
+ "ed25519.PrivateKeySize": "crypto/ed25519",
+ "ed25519.PublicKey": "crypto/ed25519",
+ "ed25519.PublicKeySize": "crypto/ed25519",
+ "ed25519.SeedSize": "crypto/ed25519",
+ "ed25519.Sign": "crypto/ed25519",
+ "ed25519.SignatureSize": "crypto/ed25519",
+ "ed25519.Verify": "crypto/ed25519",
+ "elf.ARM_MAGIC_TRAMP_NUMBER": "debug/elf",
+ "elf.COMPRESS_HIOS": "debug/elf",
+ "elf.COMPRESS_HIPROC": "debug/elf",
+ "elf.COMPRESS_LOOS": "debug/elf",
+ "elf.COMPRESS_LOPROC": "debug/elf",
+ "elf.COMPRESS_ZLIB": "debug/elf",
+ "elf.Chdr32": "debug/elf",
+ "elf.Chdr64": "debug/elf",
+ "elf.CompressionType": "debug/elf",
+ "elf.DF_BIND_NOW": "debug/elf",
+ "elf.DF_ORIGIN": "debug/elf",
+ "elf.DF_STATIC_TLS": "debug/elf",
+ "elf.DF_SYMBOLIC": "debug/elf",
+ "elf.DF_TEXTREL": "debug/elf",
+ "elf.DT_ADDRRNGHI": "debug/elf",
+ "elf.DT_ADDRRNGLO": "debug/elf",
+ "elf.DT_AUDIT": "debug/elf",
+ "elf.DT_AUXILIARY": "debug/elf",
+ "elf.DT_BIND_NOW": "debug/elf",
+ "elf.DT_CHECKSUM": "debug/elf",
+ "elf.DT_CONFIG": "debug/elf",
+ "elf.DT_DEBUG": "debug/elf",
+ "elf.DT_DEPAUDIT": "debug/elf",
+ "elf.DT_ENCODING": "debug/elf",
+ "elf.DT_FEATURE": "debug/elf",
+ "elf.DT_FILTER": "debug/elf",
+ "elf.DT_FINI": "debug/elf",
+ "elf.DT_FINI_ARRAY": "debug/elf",
+ "elf.DT_FINI_ARRAYSZ": "debug/elf",
+ "elf.DT_FLAGS": "debug/elf",
+ "elf.DT_FLAGS_1": "debug/elf",
+ "elf.DT_GNU_CONFLICT": "debug/elf",
+ "elf.DT_GNU_CONFLICTSZ": "debug/elf",
+ "elf.DT_GNU_HASH": "debug/elf",
+ "elf.DT_GNU_LIBLIST": "debug/elf",
+ "elf.DT_GNU_LIBLISTSZ": "debug/elf",
+ "elf.DT_GNU_PRELINKED": "debug/elf",
+ "elf.DT_HASH": "debug/elf",
+ "elf.DT_HIOS": "debug/elf",
+ "elf.DT_HIPROC": "debug/elf",
+ "elf.DT_INIT": "debug/elf",
+ "elf.DT_INIT_ARRAY": "debug/elf",
+ "elf.DT_INIT_ARRAYSZ": "debug/elf",
+ "elf.DT_JMPREL": "debug/elf",
+ "elf.DT_LOOS": "debug/elf",
+ "elf.DT_LOPROC": "debug/elf",
+ "elf.DT_MIPS_AUX_DYNAMIC": "debug/elf",
+ "elf.DT_MIPS_BASE_ADDRESS": "debug/elf",
+ "elf.DT_MIPS_COMPACT_SIZE": "debug/elf",
+ "elf.DT_MIPS_CONFLICT": "debug/elf",
+ "elf.DT_MIPS_CONFLICTNO": "debug/elf",
+ "elf.DT_MIPS_CXX_FLAGS": "debug/elf",
+ "elf.DT_MIPS_DELTA_CLASS": "debug/elf",
+ "elf.DT_MIPS_DELTA_CLASSSYM": "debug/elf",
+ "elf.DT_MIPS_DELTA_CLASSSYM_NO": "debug/elf",
+ "elf.DT_MIPS_DELTA_CLASS_NO": "debug/elf",
+ "elf.DT_MIPS_DELTA_INSTANCE": "debug/elf",
+ "elf.DT_MIPS_DELTA_INSTANCE_NO": "debug/elf",
+ "elf.DT_MIPS_DELTA_RELOC": "debug/elf",
+ "elf.DT_MIPS_DELTA_RELOC_NO": "debug/elf",
+ "elf.DT_MIPS_DELTA_SYM": "debug/elf",
+ "elf.DT_MIPS_DELTA_SYM_NO": "debug/elf",
+ "elf.DT_MIPS_DYNSTR_ALIGN": "debug/elf",
+ "elf.DT_MIPS_FLAGS": "debug/elf",
+ "elf.DT_MIPS_GOTSYM": "debug/elf",
+ "elf.DT_MIPS_GP_VALUE": "debug/elf",
+ "elf.DT_MIPS_HIDDEN_GOTIDX": "debug/elf",
+ "elf.DT_MIPS_HIPAGENO": "debug/elf",
+ "elf.DT_MIPS_ICHECKSUM": "debug/elf",
+ "elf.DT_MIPS_INTERFACE": "debug/elf",
+ "elf.DT_MIPS_INTERFACE_SIZE": "debug/elf",
+ "elf.DT_MIPS_IVERSION": "debug/elf",
+ "elf.DT_MIPS_LIBLIST": "debug/elf",
+ "elf.DT_MIPS_LIBLISTNO": "debug/elf",
+ "elf.DT_MIPS_LOCALPAGE_GOTIDX": "debug/elf",
+ "elf.DT_MIPS_LOCAL_GOTIDX": "debug/elf",
+ "elf.DT_MIPS_LOCAL_GOTNO": "debug/elf",
+ "elf.DT_MIPS_MSYM": "debug/elf",
+ "elf.DT_MIPS_OPTIONS": "debug/elf",
+ "elf.DT_MIPS_PERF_SUFFIX": "debug/elf",
+ "elf.DT_MIPS_PIXIE_INIT": "debug/elf",
+ "elf.DT_MIPS_PLTGOT": "debug/elf",
+ "elf.DT_MIPS_PROTECTED_GOTIDX": "debug/elf",
+ "elf.DT_MIPS_RLD_MAP": "debug/elf",
+ "elf.DT_MIPS_RLD_MAP_REL": "debug/elf",
+ "elf.DT_MIPS_RLD_TEXT_RESOLVE_ADDR": "debug/elf",
+ "elf.DT_MIPS_RLD_VERSION": "debug/elf",
+ "elf.DT_MIPS_RWPLT": "debug/elf",
+ "elf.DT_MIPS_SYMBOL_LIB": "debug/elf",
+ "elf.DT_MIPS_SYMTABNO": "debug/elf",
+ "elf.DT_MIPS_TIME_STAMP": "debug/elf",
+ "elf.DT_MIPS_UNREFEXTNO": "debug/elf",
+ "elf.DT_MOVEENT": "debug/elf",
+ "elf.DT_MOVESZ": "debug/elf",
+ "elf.DT_MOVETAB": "debug/elf",
+ "elf.DT_NEEDED": "debug/elf",
+ "elf.DT_NULL": "debug/elf",
+ "elf.DT_PLTGOT": "debug/elf",
+ "elf.DT_PLTPAD": "debug/elf",
+ "elf.DT_PLTPADSZ": "debug/elf",
+ "elf.DT_PLTREL": "debug/elf",
+ "elf.DT_PLTRELSZ": "debug/elf",
+ "elf.DT_POSFLAG_1": "debug/elf",
+ "elf.DT_PPC64_GLINK": "debug/elf",
+ "elf.DT_PPC64_OPD": "debug/elf",
+ "elf.DT_PPC64_OPDSZ": "debug/elf",
+ "elf.DT_PPC64_OPT": "debug/elf",
+ "elf.DT_PPC_GOT": "debug/elf",
+ "elf.DT_PPC_OPT": "debug/elf",
+ "elf.DT_PREINIT_ARRAY": "debug/elf",
+ "elf.DT_PREINIT_ARRAYSZ": "debug/elf",
+ "elf.DT_REL": "debug/elf",
+ "elf.DT_RELA": "debug/elf",
+ "elf.DT_RELACOUNT": "debug/elf",
+ "elf.DT_RELAENT": "debug/elf",
+ "elf.DT_RELASZ": "debug/elf",
+ "elf.DT_RELCOUNT": "debug/elf",
+ "elf.DT_RELENT": "debug/elf",
+ "elf.DT_RELSZ": "debug/elf",
+ "elf.DT_RPATH": "debug/elf",
+ "elf.DT_RUNPATH": "debug/elf",
+ "elf.DT_SONAME": "debug/elf",
+ "elf.DT_SPARC_REGISTER": "debug/elf",
+ "elf.DT_STRSZ": "debug/elf",
+ "elf.DT_STRTAB": "debug/elf",
+ "elf.DT_SYMBOLIC": "debug/elf",
+ "elf.DT_SYMENT": "debug/elf",
+ "elf.DT_SYMINENT": "debug/elf",
+ "elf.DT_SYMINFO": "debug/elf",
+ "elf.DT_SYMINSZ": "debug/elf",
+ "elf.DT_SYMTAB": "debug/elf",
+ "elf.DT_SYMTAB_SHNDX": "debug/elf",
+ "elf.DT_TEXTREL": "debug/elf",
+ "elf.DT_TLSDESC_GOT": "debug/elf",
+ "elf.DT_TLSDESC_PLT": "debug/elf",
+ "elf.DT_USED": "debug/elf",
+ "elf.DT_VALRNGHI": "debug/elf",
+ "elf.DT_VALRNGLO": "debug/elf",
+ "elf.DT_VERDEF": "debug/elf",
+ "elf.DT_VERDEFNUM": "debug/elf",
+ "elf.DT_VERNEED": "debug/elf",
+ "elf.DT_VERNEEDNUM": "debug/elf",
+ "elf.DT_VERSYM": "debug/elf",
+ "elf.EI_ABIVERSION": "debug/elf",
+ "elf.EI_CLASS": "debug/elf",
+ "elf.EI_DATA": "debug/elf",
+ "elf.EI_NIDENT": "debug/elf",
+ "elf.EI_OSABI": "debug/elf",
+ "elf.EI_PAD": "debug/elf",
+ "elf.EI_VERSION": "debug/elf",
+ "elf.ELFCLASS32": "debug/elf",
+ "elf.ELFCLASS64": "debug/elf",
+ "elf.ELFCLASSNONE": "debug/elf",
+ "elf.ELFDATA2LSB": "debug/elf",
+ "elf.ELFDATA2MSB": "debug/elf",
+ "elf.ELFDATANONE": "debug/elf",
+ "elf.ELFMAG": "debug/elf",
+ "elf.ELFOSABI_86OPEN": "debug/elf",
+ "elf.ELFOSABI_AIX": "debug/elf",
+ "elf.ELFOSABI_ARM": "debug/elf",
+ "elf.ELFOSABI_AROS": "debug/elf",
+ "elf.ELFOSABI_CLOUDABI": "debug/elf",
+ "elf.ELFOSABI_FENIXOS": "debug/elf",
+ "elf.ELFOSABI_FREEBSD": "debug/elf",
+ "elf.ELFOSABI_HPUX": "debug/elf",
+ "elf.ELFOSABI_HURD": "debug/elf",
+ "elf.ELFOSABI_IRIX": "debug/elf",
+ "elf.ELFOSABI_LINUX": "debug/elf",
+ "elf.ELFOSABI_MODESTO": "debug/elf",
+ "elf.ELFOSABI_NETBSD": "debug/elf",
+ "elf.ELFOSABI_NONE": "debug/elf",
+ "elf.ELFOSABI_NSK": "debug/elf",
+ "elf.ELFOSABI_OPENBSD": "debug/elf",
+ "elf.ELFOSABI_OPENVMS": "debug/elf",
+ "elf.ELFOSABI_SOLARIS": "debug/elf",
+ "elf.ELFOSABI_STANDALONE": "debug/elf",
+ "elf.ELFOSABI_TRU64": "debug/elf",
+ "elf.EM_386": "debug/elf",
+ "elf.EM_486": "debug/elf",
+ "elf.EM_56800EX": "debug/elf",
+ "elf.EM_68HC05": "debug/elf",
+ "elf.EM_68HC08": "debug/elf",
+ "elf.EM_68HC11": "debug/elf",
+ "elf.EM_68HC12": "debug/elf",
+ "elf.EM_68HC16": "debug/elf",
+ "elf.EM_68K": "debug/elf",
+ "elf.EM_78KOR": "debug/elf",
+ "elf.EM_8051": "debug/elf",
+ "elf.EM_860": "debug/elf",
+ "elf.EM_88K": "debug/elf",
+ "elf.EM_960": "debug/elf",
+ "elf.EM_AARCH64": "debug/elf",
+ "elf.EM_ALPHA": "debug/elf",
+ "elf.EM_ALPHA_STD": "debug/elf",
+ "elf.EM_ALTERA_NIOS2": "debug/elf",
+ "elf.EM_AMDGPU": "debug/elf",
+ "elf.EM_ARC": "debug/elf",
+ "elf.EM_ARCA": "debug/elf",
+ "elf.EM_ARC_COMPACT": "debug/elf",
+ "elf.EM_ARC_COMPACT2": "debug/elf",
+ "elf.EM_ARM": "debug/elf",
+ "elf.EM_AVR": "debug/elf",
+ "elf.EM_AVR32": "debug/elf",
+ "elf.EM_BA1": "debug/elf",
+ "elf.EM_BA2": "debug/elf",
+ "elf.EM_BLACKFIN": "debug/elf",
+ "elf.EM_BPF": "debug/elf",
+ "elf.EM_C166": "debug/elf",
+ "elf.EM_CDP": "debug/elf",
+ "elf.EM_CE": "debug/elf",
+ "elf.EM_CLOUDSHIELD": "debug/elf",
+ "elf.EM_COGE": "debug/elf",
+ "elf.EM_COLDFIRE": "debug/elf",
+ "elf.EM_COOL": "debug/elf",
+ "elf.EM_COREA_1ST": "debug/elf",
+ "elf.EM_COREA_2ND": "debug/elf",
+ "elf.EM_CR": "debug/elf",
+ "elf.EM_CR16": "debug/elf",
+ "elf.EM_CRAYNV2": "debug/elf",
+ "elf.EM_CRIS": "debug/elf",
+ "elf.EM_CRX": "debug/elf",
+ "elf.EM_CSR_KALIMBA": "debug/elf",
+ "elf.EM_CUDA": "debug/elf",
+ "elf.EM_CYPRESS_M8C": "debug/elf",
+ "elf.EM_D10V": "debug/elf",
+ "elf.EM_D30V": "debug/elf",
+ "elf.EM_DSP24": "debug/elf",
+ "elf.EM_DSPIC30F": "debug/elf",
+ "elf.EM_DXP": "debug/elf",
+ "elf.EM_ECOG1": "debug/elf",
+ "elf.EM_ECOG16": "debug/elf",
+ "elf.EM_ECOG1X": "debug/elf",
+ "elf.EM_ECOG2": "debug/elf",
+ "elf.EM_ETPU": "debug/elf",
+ "elf.EM_EXCESS": "debug/elf",
+ "elf.EM_F2MC16": "debug/elf",
+ "elf.EM_FIREPATH": "debug/elf",
+ "elf.EM_FR20": "debug/elf",
+ "elf.EM_FR30": "debug/elf",
+ "elf.EM_FT32": "debug/elf",
+ "elf.EM_FX66": "debug/elf",
+ "elf.EM_H8S": "debug/elf",
+ "elf.EM_H8_300": "debug/elf",
+ "elf.EM_H8_300H": "debug/elf",
+ "elf.EM_H8_500": "debug/elf",
+ "elf.EM_HUANY": "debug/elf",
+ "elf.EM_IA_64": "debug/elf",
+ "elf.EM_INTEL205": "debug/elf",
+ "elf.EM_INTEL206": "debug/elf",
+ "elf.EM_INTEL207": "debug/elf",
+ "elf.EM_INTEL208": "debug/elf",
+ "elf.EM_INTEL209": "debug/elf",
+ "elf.EM_IP2K": "debug/elf",
+ "elf.EM_JAVELIN": "debug/elf",
+ "elf.EM_K10M": "debug/elf",
+ "elf.EM_KM32": "debug/elf",
+ "elf.EM_KMX16": "debug/elf",
+ "elf.EM_KMX32": "debug/elf",
+ "elf.EM_KMX8": "debug/elf",
+ "elf.EM_KVARC": "debug/elf",
+ "elf.EM_L10M": "debug/elf",
+ "elf.EM_LANAI": "debug/elf",
+ "elf.EM_LATTICEMICO32": "debug/elf",
+ "elf.EM_M16C": "debug/elf",
+ "elf.EM_M32": "debug/elf",
+ "elf.EM_M32C": "debug/elf",
+ "elf.EM_M32R": "debug/elf",
+ "elf.EM_MANIK": "debug/elf",
+ "elf.EM_MAX": "debug/elf",
+ "elf.EM_MAXQ30": "debug/elf",
+ "elf.EM_MCHP_PIC": "debug/elf",
+ "elf.EM_MCST_ELBRUS": "debug/elf",
+ "elf.EM_ME16": "debug/elf",
+ "elf.EM_METAG": "debug/elf",
+ "elf.EM_MICROBLAZE": "debug/elf",
+ "elf.EM_MIPS": "debug/elf",
+ "elf.EM_MIPS_RS3_LE": "debug/elf",
+ "elf.EM_MIPS_RS4_BE": "debug/elf",
+ "elf.EM_MIPS_X": "debug/elf",
+ "elf.EM_MMA": "debug/elf",
+ "elf.EM_MMDSP_PLUS": "debug/elf",
+ "elf.EM_MMIX": "debug/elf",
+ "elf.EM_MN10200": "debug/elf",
+ "elf.EM_MN10300": "debug/elf",
+ "elf.EM_MOXIE": "debug/elf",
+ "elf.EM_MSP430": "debug/elf",
+ "elf.EM_NCPU": "debug/elf",
+ "elf.EM_NDR1": "debug/elf",
+ "elf.EM_NDS32": "debug/elf",
+ "elf.EM_NONE": "debug/elf",
+ "elf.EM_NORC": "debug/elf",
+ "elf.EM_NS32K": "debug/elf",
+ "elf.EM_OPEN8": "debug/elf",
+ "elf.EM_OPENRISC": "debug/elf",
+ "elf.EM_PARISC": "debug/elf",
+ "elf.EM_PCP": "debug/elf",
+ "elf.EM_PDP10": "debug/elf",
+ "elf.EM_PDP11": "debug/elf",
+ "elf.EM_PDSP": "debug/elf",
+ "elf.EM_PJ": "debug/elf",
+ "elf.EM_PPC": "debug/elf",
+ "elf.EM_PPC64": "debug/elf",
+ "elf.EM_PRISM": "debug/elf",
+ "elf.EM_QDSP6": "debug/elf",
+ "elf.EM_R32C": "debug/elf",
+ "elf.EM_RCE": "debug/elf",
+ "elf.EM_RH32": "debug/elf",
+ "elf.EM_RISCV": "debug/elf",
+ "elf.EM_RL78": "debug/elf",
+ "elf.EM_RS08": "debug/elf",
+ "elf.EM_RX": "debug/elf",
+ "elf.EM_S370": "debug/elf",
+ "elf.EM_S390": "debug/elf",
+ "elf.EM_SCORE7": "debug/elf",
+ "elf.EM_SEP": "debug/elf",
+ "elf.EM_SE_C17": "debug/elf",
+ "elf.EM_SE_C33": "debug/elf",
+ "elf.EM_SH": "debug/elf",
+ "elf.EM_SHARC": "debug/elf",
+ "elf.EM_SLE9X": "debug/elf",
+ "elf.EM_SNP1K": "debug/elf",
+ "elf.EM_SPARC": "debug/elf",
+ "elf.EM_SPARC32PLUS": "debug/elf",
+ "elf.EM_SPARCV9": "debug/elf",
+ "elf.EM_ST100": "debug/elf",
+ "elf.EM_ST19": "debug/elf",
+ "elf.EM_ST200": "debug/elf",
+ "elf.EM_ST7": "debug/elf",
+ "elf.EM_ST9PLUS": "debug/elf",
+ "elf.EM_STARCORE": "debug/elf",
+ "elf.EM_STM8": "debug/elf",
+ "elf.EM_STXP7X": "debug/elf",
+ "elf.EM_SVX": "debug/elf",
+ "elf.EM_TILE64": "debug/elf",
+ "elf.EM_TILEGX": "debug/elf",
+ "elf.EM_TILEPRO": "debug/elf",
+ "elf.EM_TINYJ": "debug/elf",
+ "elf.EM_TI_ARP32": "debug/elf",
+ "elf.EM_TI_C2000": "debug/elf",
+ "elf.EM_TI_C5500": "debug/elf",
+ "elf.EM_TI_C6000": "debug/elf",
+ "elf.EM_TI_PRU": "debug/elf",
+ "elf.EM_TMM_GPP": "debug/elf",
+ "elf.EM_TPC": "debug/elf",
+ "elf.EM_TRICORE": "debug/elf",
+ "elf.EM_TRIMEDIA": "debug/elf",
+ "elf.EM_TSK3000": "debug/elf",
+ "elf.EM_UNICORE": "debug/elf",
+ "elf.EM_V800": "debug/elf",
+ "elf.EM_V850": "debug/elf",
+ "elf.EM_VAX": "debug/elf",
+ "elf.EM_VIDEOCORE": "debug/elf",
+ "elf.EM_VIDEOCORE3": "debug/elf",
+ "elf.EM_VIDEOCORE5": "debug/elf",
+ "elf.EM_VISIUM": "debug/elf",
+ "elf.EM_VPP500": "debug/elf",
+ "elf.EM_X86_64": "debug/elf",
+ "elf.EM_XCORE": "debug/elf",
+ "elf.EM_XGATE": "debug/elf",
+ "elf.EM_XIMO16": "debug/elf",
+ "elf.EM_XTENSA": "debug/elf",
+ "elf.EM_Z80": "debug/elf",
+ "elf.EM_ZSP": "debug/elf",
+ "elf.ET_CORE": "debug/elf",
+ "elf.ET_DYN": "debug/elf",
+ "elf.ET_EXEC": "debug/elf",
+ "elf.ET_HIOS": "debug/elf",
+ "elf.ET_HIPROC": "debug/elf",
+ "elf.ET_LOOS": "debug/elf",
+ "elf.ET_LOPROC": "debug/elf",
+ "elf.ET_NONE": "debug/elf",
+ "elf.ET_REL": "debug/elf",
+ "elf.EV_CURRENT": "debug/elf",
+ "elf.EV_NONE": "debug/elf",
+ "elf.ErrNoSymbols": "debug/elf",
+ "elf.NT_FPREGSET": "debug/elf",
+ "elf.NT_PRPSINFO": "debug/elf",
+ "elf.NT_PRSTATUS": "debug/elf",
+ "elf.PF_MASKOS": "debug/elf",
+ "elf.PF_MASKPROC": "debug/elf",
+ "elf.PF_R": "debug/elf",
+ "elf.PF_W": "debug/elf",
+ "elf.PF_X": "debug/elf",
+ "elf.PT_AARCH64_ARCHEXT": "debug/elf",
+ "elf.PT_AARCH64_UNWIND": "debug/elf",
+ "elf.PT_ARM_ARCHEXT": "debug/elf",
+ "elf.PT_ARM_EXIDX": "debug/elf",
+ "elf.PT_DYNAMIC": "debug/elf",
+ "elf.PT_GNU_EH_FRAME": "debug/elf",
+ "elf.PT_GNU_MBIND_HI": "debug/elf",
+ "elf.PT_GNU_MBIND_LO": "debug/elf",
+ "elf.PT_GNU_PROPERTY": "debug/elf",
+ "elf.PT_GNU_RELRO": "debug/elf",
+ "elf.PT_GNU_STACK": "debug/elf",
+ "elf.PT_HIOS": "debug/elf",
+ "elf.PT_HIPROC": "debug/elf",
+ "elf.PT_INTERP": "debug/elf",
+ "elf.PT_LOAD": "debug/elf",
+ "elf.PT_LOOS": "debug/elf",
+ "elf.PT_LOPROC": "debug/elf",
+ "elf.PT_MIPS_ABIFLAGS": "debug/elf",
+ "elf.PT_MIPS_OPTIONS": "debug/elf",
+ "elf.PT_MIPS_REGINFO": "debug/elf",
+ "elf.PT_MIPS_RTPROC": "debug/elf",
+ "elf.PT_NOTE": "debug/elf",
+ "elf.PT_NULL": "debug/elf",
+ "elf.PT_OPENBSD_BOOTDATA": "debug/elf",
+ "elf.PT_OPENBSD_RANDOMIZE": "debug/elf",
+ "elf.PT_OPENBSD_WXNEEDED": "debug/elf",
+ "elf.PT_PAX_FLAGS": "debug/elf",
+ "elf.PT_PHDR": "debug/elf",
+ "elf.PT_S390_PGSTE": "debug/elf",
+ "elf.PT_SHLIB": "debug/elf",
+ "elf.PT_SUNWSTACK": "debug/elf",
+ "elf.PT_SUNW_EH_FRAME": "debug/elf",
+ "elf.PT_TLS": "debug/elf",
+ "elf.R_386_16": "debug/elf",
+ "elf.R_386_32": "debug/elf",
+ "elf.R_386_32PLT": "debug/elf",
+ "elf.R_386_8": "debug/elf",
+ "elf.R_386_COPY": "debug/elf",
+ "elf.R_386_GLOB_DAT": "debug/elf",
+ "elf.R_386_GOT32": "debug/elf",
+ "elf.R_386_GOT32X": "debug/elf",
+ "elf.R_386_GOTOFF": "debug/elf",
+ "elf.R_386_GOTPC": "debug/elf",
+ "elf.R_386_IRELATIVE": "debug/elf",
+ "elf.R_386_JMP_SLOT": "debug/elf",
+ "elf.R_386_NONE": "debug/elf",
+ "elf.R_386_PC16": "debug/elf",
+ "elf.R_386_PC32": "debug/elf",
+ "elf.R_386_PC8": "debug/elf",
+ "elf.R_386_PLT32": "debug/elf",
+ "elf.R_386_RELATIVE": "debug/elf",
+ "elf.R_386_SIZE32": "debug/elf",
+ "elf.R_386_TLS_DESC": "debug/elf",
+ "elf.R_386_TLS_DESC_CALL": "debug/elf",
+ "elf.R_386_TLS_DTPMOD32": "debug/elf",
+ "elf.R_386_TLS_DTPOFF32": "debug/elf",
+ "elf.R_386_TLS_GD": "debug/elf",
+ "elf.R_386_TLS_GD_32": "debug/elf",
+ "elf.R_386_TLS_GD_CALL": "debug/elf",
+ "elf.R_386_TLS_GD_POP": "debug/elf",
+ "elf.R_386_TLS_GD_PUSH": "debug/elf",
+ "elf.R_386_TLS_GOTDESC": "debug/elf",
+ "elf.R_386_TLS_GOTIE": "debug/elf",
+ "elf.R_386_TLS_IE": "debug/elf",
+ "elf.R_386_TLS_IE_32": "debug/elf",
+ "elf.R_386_TLS_LDM": "debug/elf",
+ "elf.R_386_TLS_LDM_32": "debug/elf",
+ "elf.R_386_TLS_LDM_CALL": "debug/elf",
+ "elf.R_386_TLS_LDM_POP": "debug/elf",
+ "elf.R_386_TLS_LDM_PUSH": "debug/elf",
+ "elf.R_386_TLS_LDO_32": "debug/elf",
+ "elf.R_386_TLS_LE": "debug/elf",
+ "elf.R_386_TLS_LE_32": "debug/elf",
+ "elf.R_386_TLS_TPOFF": "debug/elf",
+ "elf.R_386_TLS_TPOFF32": "debug/elf",
+ "elf.R_390": "debug/elf",
+ "elf.R_390_12": "debug/elf",
+ "elf.R_390_16": "debug/elf",
+ "elf.R_390_20": "debug/elf",
+ "elf.R_390_32": "debug/elf",
+ "elf.R_390_64": "debug/elf",
+ "elf.R_390_8": "debug/elf",
+ "elf.R_390_COPY": "debug/elf",
+ "elf.R_390_GLOB_DAT": "debug/elf",
+ "elf.R_390_GOT12": "debug/elf",
+ "elf.R_390_GOT16": "debug/elf",
+ "elf.R_390_GOT20": "debug/elf",
+ "elf.R_390_GOT32": "debug/elf",
+ "elf.R_390_GOT64": "debug/elf",
+ "elf.R_390_GOTENT": "debug/elf",
+ "elf.R_390_GOTOFF": "debug/elf",
+ "elf.R_390_GOTOFF16": "debug/elf",
+ "elf.R_390_GOTOFF64": "debug/elf",
+ "elf.R_390_GOTPC": "debug/elf",
+ "elf.R_390_GOTPCDBL": "debug/elf",
+ "elf.R_390_GOTPLT12": "debug/elf",
+ "elf.R_390_GOTPLT16": "debug/elf",
+ "elf.R_390_GOTPLT20": "debug/elf",
+ "elf.R_390_GOTPLT32": "debug/elf",
+ "elf.R_390_GOTPLT64": "debug/elf",
+ "elf.R_390_GOTPLTENT": "debug/elf",
+ "elf.R_390_GOTPLTOFF16": "debug/elf",
+ "elf.R_390_GOTPLTOFF32": "debug/elf",
+ "elf.R_390_GOTPLTOFF64": "debug/elf",
+ "elf.R_390_JMP_SLOT": "debug/elf",
+ "elf.R_390_NONE": "debug/elf",
+ "elf.R_390_PC16": "debug/elf",
+ "elf.R_390_PC16DBL": "debug/elf",
+ "elf.R_390_PC32": "debug/elf",
+ "elf.R_390_PC32DBL": "debug/elf",
+ "elf.R_390_PC64": "debug/elf",
+ "elf.R_390_PLT16DBL": "debug/elf",
+ "elf.R_390_PLT32": "debug/elf",
+ "elf.R_390_PLT32DBL": "debug/elf",
+ "elf.R_390_PLT64": "debug/elf",
+ "elf.R_390_RELATIVE": "debug/elf",
+ "elf.R_390_TLS_DTPMOD": "debug/elf",
+ "elf.R_390_TLS_DTPOFF": "debug/elf",
+ "elf.R_390_TLS_GD32": "debug/elf",
+ "elf.R_390_TLS_GD64": "debug/elf",
+ "elf.R_390_TLS_GDCALL": "debug/elf",
+ "elf.R_390_TLS_GOTIE12": "debug/elf",
+ "elf.R_390_TLS_GOTIE20": "debug/elf",
+ "elf.R_390_TLS_GOTIE32": "debug/elf",
+ "elf.R_390_TLS_GOTIE64": "debug/elf",
+ "elf.R_390_TLS_IE32": "debug/elf",
+ "elf.R_390_TLS_IE64": "debug/elf",
+ "elf.R_390_TLS_IEENT": "debug/elf",
+ "elf.R_390_TLS_LDCALL": "debug/elf",
+ "elf.R_390_TLS_LDM32": "debug/elf",
+ "elf.R_390_TLS_LDM64": "debug/elf",
+ "elf.R_390_TLS_LDO32": "debug/elf",
+ "elf.R_390_TLS_LDO64": "debug/elf",
+ "elf.R_390_TLS_LE32": "debug/elf",
+ "elf.R_390_TLS_LE64": "debug/elf",
+ "elf.R_390_TLS_LOAD": "debug/elf",
+ "elf.R_390_TLS_TPOFF": "debug/elf",
+ "elf.R_AARCH64": "debug/elf",
+ "elf.R_AARCH64_ABS16": "debug/elf",
+ "elf.R_AARCH64_ABS32": "debug/elf",
+ "elf.R_AARCH64_ABS64": "debug/elf",
+ "elf.R_AARCH64_ADD_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_ADR_GOT_PAGE": "debug/elf",
+ "elf.R_AARCH64_ADR_PREL_LO21": "debug/elf",
+ "elf.R_AARCH64_ADR_PREL_PG_HI21": "debug/elf",
+ "elf.R_AARCH64_ADR_PREL_PG_HI21_NC": "debug/elf",
+ "elf.R_AARCH64_CALL26": "debug/elf",
+ "elf.R_AARCH64_CONDBR19": "debug/elf",
+ "elf.R_AARCH64_COPY": "debug/elf",
+ "elf.R_AARCH64_GLOB_DAT": "debug/elf",
+ "elf.R_AARCH64_GOT_LD_PREL19": "debug/elf",
+ "elf.R_AARCH64_IRELATIVE": "debug/elf",
+ "elf.R_AARCH64_JUMP26": "debug/elf",
+ "elf.R_AARCH64_JUMP_SLOT": "debug/elf",
+ "elf.R_AARCH64_LD64_GOTOFF_LO15": "debug/elf",
+ "elf.R_AARCH64_LD64_GOTPAGE_LO15": "debug/elf",
+ "elf.R_AARCH64_LD64_GOT_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_LDST128_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_LDST16_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_LDST32_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_LDST64_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_LDST8_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_LD_PREL_LO19": "debug/elf",
+ "elf.R_AARCH64_MOVW_SABS_G0": "debug/elf",
+ "elf.R_AARCH64_MOVW_SABS_G1": "debug/elf",
+ "elf.R_AARCH64_MOVW_SABS_G2": "debug/elf",
+ "elf.R_AARCH64_MOVW_UABS_G0": "debug/elf",
+ "elf.R_AARCH64_MOVW_UABS_G0_NC": "debug/elf",
+ "elf.R_AARCH64_MOVW_UABS_G1": "debug/elf",
+ "elf.R_AARCH64_MOVW_UABS_G1_NC": "debug/elf",
+ "elf.R_AARCH64_MOVW_UABS_G2": "debug/elf",
+ "elf.R_AARCH64_MOVW_UABS_G2_NC": "debug/elf",
+ "elf.R_AARCH64_MOVW_UABS_G3": "debug/elf",
+ "elf.R_AARCH64_NONE": "debug/elf",
+ "elf.R_AARCH64_NULL": "debug/elf",
+ "elf.R_AARCH64_P32_ABS16": "debug/elf",
+ "elf.R_AARCH64_P32_ABS32": "debug/elf",
+ "elf.R_AARCH64_P32_ADD_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_ADR_GOT_PAGE": "debug/elf",
+ "elf.R_AARCH64_P32_ADR_PREL_LO21": "debug/elf",
+ "elf.R_AARCH64_P32_ADR_PREL_PG_HI21": "debug/elf",
+ "elf.R_AARCH64_P32_CALL26": "debug/elf",
+ "elf.R_AARCH64_P32_CONDBR19": "debug/elf",
+ "elf.R_AARCH64_P32_COPY": "debug/elf",
+ "elf.R_AARCH64_P32_GLOB_DAT": "debug/elf",
+ "elf.R_AARCH64_P32_GOT_LD_PREL19": "debug/elf",
+ "elf.R_AARCH64_P32_IRELATIVE": "debug/elf",
+ "elf.R_AARCH64_P32_JUMP26": "debug/elf",
+ "elf.R_AARCH64_P32_JUMP_SLOT": "debug/elf",
+ "elf.R_AARCH64_P32_LD32_GOT_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_LDST128_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_LDST16_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_LDST32_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_LDST64_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_LDST8_ABS_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_LD_PREL_LO19": "debug/elf",
+ "elf.R_AARCH64_P32_MOVW_SABS_G0": "debug/elf",
+ "elf.R_AARCH64_P32_MOVW_UABS_G0": "debug/elf",
+ "elf.R_AARCH64_P32_MOVW_UABS_G0_NC": "debug/elf",
+ "elf.R_AARCH64_P32_MOVW_UABS_G1": "debug/elf",
+ "elf.R_AARCH64_P32_PREL16": "debug/elf",
+ "elf.R_AARCH64_P32_PREL32": "debug/elf",
+ "elf.R_AARCH64_P32_RELATIVE": "debug/elf",
+ "elf.R_AARCH64_P32_TLSDESC": "debug/elf",
+ "elf.R_AARCH64_P32_TLSDESC_ADD_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_TLSDESC_ADR_PAGE21": "debug/elf",
+ "elf.R_AARCH64_P32_TLSDESC_ADR_PREL21": "debug/elf",
+ "elf.R_AARCH64_P32_TLSDESC_CALL": "debug/elf",
+ "elf.R_AARCH64_P32_TLSDESC_LD32_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_TLSDESC_LD_PREL19": "debug/elf",
+ "elf.R_AARCH64_P32_TLSGD_ADD_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_TLSGD_ADR_PAGE21": "debug/elf",
+ "elf.R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21": "debug/elf",
+ "elf.R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19": "debug/elf",
+ "elf.R_AARCH64_P32_TLSLE_ADD_TPREL_HI12": "debug/elf",
+ "elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12": "debug/elf",
+ "elf.R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0": "debug/elf",
+ "elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC": "debug/elf",
+ "elf.R_AARCH64_P32_TLSLE_MOVW_TPREL_G1": "debug/elf",
+ "elf.R_AARCH64_P32_TLS_DTPMOD": "debug/elf",
+ "elf.R_AARCH64_P32_TLS_DTPREL": "debug/elf",
+ "elf.R_AARCH64_P32_TLS_TPREL": "debug/elf",
+ "elf.R_AARCH64_P32_TSTBR14": "debug/elf",
+ "elf.R_AARCH64_PREL16": "debug/elf",
+ "elf.R_AARCH64_PREL32": "debug/elf",
+ "elf.R_AARCH64_PREL64": "debug/elf",
+ "elf.R_AARCH64_RELATIVE": "debug/elf",
+ "elf.R_AARCH64_TLSDESC": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_ADD": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_ADD_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_ADR_PAGE21": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_ADR_PREL21": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_CALL": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_LD64_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_LDR": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_LD_PREL19": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_OFF_G0_NC": "debug/elf",
+ "elf.R_AARCH64_TLSDESC_OFF_G1": "debug/elf",
+ "elf.R_AARCH64_TLSGD_ADD_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_TLSGD_ADR_PAGE21": "debug/elf",
+ "elf.R_AARCH64_TLSGD_ADR_PREL21": "debug/elf",
+ "elf.R_AARCH64_TLSGD_MOVW_G0_NC": "debug/elf",
+ "elf.R_AARCH64_TLSGD_MOVW_G1": "debug/elf",
+ "elf.R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21": "debug/elf",
+ "elf.R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_TLSIE_LD_GOTTPREL_PREL19": "debug/elf",
+ "elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC": "debug/elf",
+ "elf.R_AARCH64_TLSIE_MOVW_GOTTPREL_G1": "debug/elf",
+ "elf.R_AARCH64_TLSLD_ADR_PAGE21": "debug/elf",
+ "elf.R_AARCH64_TLSLD_ADR_PREL21": "debug/elf",
+ "elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12": "debug/elf",
+ "elf.R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_TLSLE_ADD_TPREL_HI12": "debug/elf",
+ "elf.R_AARCH64_TLSLE_ADD_TPREL_LO12": "debug/elf",
+ "elf.R_AARCH64_TLSLE_ADD_TPREL_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_TLSLE_LDST128_TPREL_LO12": "debug/elf",
+ "elf.R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC": "debug/elf",
+ "elf.R_AARCH64_TLSLE_MOVW_TPREL_G0": "debug/elf",
+ "elf.R_AARCH64_TLSLE_MOVW_TPREL_G0_NC": "debug/elf",
+ "elf.R_AARCH64_TLSLE_MOVW_TPREL_G1": "debug/elf",
+ "elf.R_AARCH64_TLSLE_MOVW_TPREL_G1_NC": "debug/elf",
+ "elf.R_AARCH64_TLSLE_MOVW_TPREL_G2": "debug/elf",
+ "elf.R_AARCH64_TLS_DTPMOD64": "debug/elf",
+ "elf.R_AARCH64_TLS_DTPREL64": "debug/elf",
+ "elf.R_AARCH64_TLS_TPREL64": "debug/elf",
+ "elf.R_AARCH64_TSTBR14": "debug/elf",
+ "elf.R_ALPHA_BRADDR": "debug/elf",
+ "elf.R_ALPHA_COPY": "debug/elf",
+ "elf.R_ALPHA_GLOB_DAT": "debug/elf",
+ "elf.R_ALPHA_GPDISP": "debug/elf",
+ "elf.R_ALPHA_GPREL32": "debug/elf",
+ "elf.R_ALPHA_GPRELHIGH": "debug/elf",
+ "elf.R_ALPHA_GPRELLOW": "debug/elf",
+ "elf.R_ALPHA_GPVALUE": "debug/elf",
+ "elf.R_ALPHA_HINT": "debug/elf",
+ "elf.R_ALPHA_IMMED_BR_HI32": "debug/elf",
+ "elf.R_ALPHA_IMMED_GP_16": "debug/elf",
+ "elf.R_ALPHA_IMMED_GP_HI32": "debug/elf",
+ "elf.R_ALPHA_IMMED_LO32": "debug/elf",
+ "elf.R_ALPHA_IMMED_SCN_HI32": "debug/elf",
+ "elf.R_ALPHA_JMP_SLOT": "debug/elf",
+ "elf.R_ALPHA_LITERAL": "debug/elf",
+ "elf.R_ALPHA_LITUSE": "debug/elf",
+ "elf.R_ALPHA_NONE": "debug/elf",
+ "elf.R_ALPHA_OP_PRSHIFT": "debug/elf",
+ "elf.R_ALPHA_OP_PSUB": "debug/elf",
+ "elf.R_ALPHA_OP_PUSH": "debug/elf",
+ "elf.R_ALPHA_OP_STORE": "debug/elf",
+ "elf.R_ALPHA_REFLONG": "debug/elf",
+ "elf.R_ALPHA_REFQUAD": "debug/elf",
+ "elf.R_ALPHA_RELATIVE": "debug/elf",
+ "elf.R_ALPHA_SREL16": "debug/elf",
+ "elf.R_ALPHA_SREL32": "debug/elf",
+ "elf.R_ALPHA_SREL64": "debug/elf",
+ "elf.R_ARM_ABS12": "debug/elf",
+ "elf.R_ARM_ABS16": "debug/elf",
+ "elf.R_ARM_ABS32": "debug/elf",
+ "elf.R_ARM_ABS32_NOI": "debug/elf",
+ "elf.R_ARM_ABS8": "debug/elf",
+ "elf.R_ARM_ALU_PCREL_15_8": "debug/elf",
+ "elf.R_ARM_ALU_PCREL_23_15": "debug/elf",
+ "elf.R_ARM_ALU_PCREL_7_0": "debug/elf",
+ "elf.R_ARM_ALU_PC_G0": "debug/elf",
+ "elf.R_ARM_ALU_PC_G0_NC": "debug/elf",
+ "elf.R_ARM_ALU_PC_G1": "debug/elf",
+ "elf.R_ARM_ALU_PC_G1_NC": "debug/elf",
+ "elf.R_ARM_ALU_PC_G2": "debug/elf",
+ "elf.R_ARM_ALU_SBREL_19_12_NC": "debug/elf",
+ "elf.R_ARM_ALU_SBREL_27_20_CK": "debug/elf",
+ "elf.R_ARM_ALU_SB_G0": "debug/elf",
+ "elf.R_ARM_ALU_SB_G0_NC": "debug/elf",
+ "elf.R_ARM_ALU_SB_G1": "debug/elf",
+ "elf.R_ARM_ALU_SB_G1_NC": "debug/elf",
+ "elf.R_ARM_ALU_SB_G2": "debug/elf",
+ "elf.R_ARM_AMP_VCALL9": "debug/elf",
+ "elf.R_ARM_BASE_ABS": "debug/elf",
+ "elf.R_ARM_CALL": "debug/elf",
+ "elf.R_ARM_COPY": "debug/elf",
+ "elf.R_ARM_GLOB_DAT": "debug/elf",
+ "elf.R_ARM_GNU_VTENTRY": "debug/elf",
+ "elf.R_ARM_GNU_VTINHERIT": "debug/elf",
+ "elf.R_ARM_GOT32": "debug/elf",
+ "elf.R_ARM_GOTOFF": "debug/elf",
+ "elf.R_ARM_GOTOFF12": "debug/elf",
+ "elf.R_ARM_GOTPC": "debug/elf",
+ "elf.R_ARM_GOTRELAX": "debug/elf",
+ "elf.R_ARM_GOT_ABS": "debug/elf",
+ "elf.R_ARM_GOT_BREL12": "debug/elf",
+ "elf.R_ARM_GOT_PREL": "debug/elf",
+ "elf.R_ARM_IRELATIVE": "debug/elf",
+ "elf.R_ARM_JUMP24": "debug/elf",
+ "elf.R_ARM_JUMP_SLOT": "debug/elf",
+ "elf.R_ARM_LDC_PC_G0": "debug/elf",
+ "elf.R_ARM_LDC_PC_G1": "debug/elf",
+ "elf.R_ARM_LDC_PC_G2": "debug/elf",
+ "elf.R_ARM_LDC_SB_G0": "debug/elf",
+ "elf.R_ARM_LDC_SB_G1": "debug/elf",
+ "elf.R_ARM_LDC_SB_G2": "debug/elf",
+ "elf.R_ARM_LDRS_PC_G0": "debug/elf",
+ "elf.R_ARM_LDRS_PC_G1": "debug/elf",
+ "elf.R_ARM_LDRS_PC_G2": "debug/elf",
+ "elf.R_ARM_LDRS_SB_G0": "debug/elf",
+ "elf.R_ARM_LDRS_SB_G1": "debug/elf",
+ "elf.R_ARM_LDRS_SB_G2": "debug/elf",
+ "elf.R_ARM_LDR_PC_G1": "debug/elf",
+ "elf.R_ARM_LDR_PC_G2": "debug/elf",
+ "elf.R_ARM_LDR_SBREL_11_10_NC": "debug/elf",
+ "elf.R_ARM_LDR_SB_G0": "debug/elf",
+ "elf.R_ARM_LDR_SB_G1": "debug/elf",
+ "elf.R_ARM_LDR_SB_G2": "debug/elf",
+ "elf.R_ARM_ME_TOO": "debug/elf",
+ "elf.R_ARM_MOVT_ABS": "debug/elf",
+ "elf.R_ARM_MOVT_BREL": "debug/elf",
+ "elf.R_ARM_MOVT_PREL": "debug/elf",
+ "elf.R_ARM_MOVW_ABS_NC": "debug/elf",
+ "elf.R_ARM_MOVW_BREL": "debug/elf",
+ "elf.R_ARM_MOVW_BREL_NC": "debug/elf",
+ "elf.R_ARM_MOVW_PREL_NC": "debug/elf",
+ "elf.R_ARM_NONE": "debug/elf",
+ "elf.R_ARM_PC13": "debug/elf",
+ "elf.R_ARM_PC24": "debug/elf",
+ "elf.R_ARM_PLT32": "debug/elf",
+ "elf.R_ARM_PLT32_ABS": "debug/elf",
+ "elf.R_ARM_PREL31": "debug/elf",
+ "elf.R_ARM_PRIVATE_0": "debug/elf",
+ "elf.R_ARM_PRIVATE_1": "debug/elf",
+ "elf.R_ARM_PRIVATE_10": "debug/elf",
+ "elf.R_ARM_PRIVATE_11": "debug/elf",
+ "elf.R_ARM_PRIVATE_12": "debug/elf",
+ "elf.R_ARM_PRIVATE_13": "debug/elf",
+ "elf.R_ARM_PRIVATE_14": "debug/elf",
+ "elf.R_ARM_PRIVATE_15": "debug/elf",
+ "elf.R_ARM_PRIVATE_2": "debug/elf",
+ "elf.R_ARM_PRIVATE_3": "debug/elf",
+ "elf.R_ARM_PRIVATE_4": "debug/elf",
+ "elf.R_ARM_PRIVATE_5": "debug/elf",
+ "elf.R_ARM_PRIVATE_6": "debug/elf",
+ "elf.R_ARM_PRIVATE_7": "debug/elf",
+ "elf.R_ARM_PRIVATE_8": "debug/elf",
+ "elf.R_ARM_PRIVATE_9": "debug/elf",
+ "elf.R_ARM_RABS32": "debug/elf",
+ "elf.R_ARM_RBASE": "debug/elf",
+ "elf.R_ARM_REL32": "debug/elf",
+ "elf.R_ARM_REL32_NOI": "debug/elf",
+ "elf.R_ARM_RELATIVE": "debug/elf",
+ "elf.R_ARM_RPC24": "debug/elf",
+ "elf.R_ARM_RREL32": "debug/elf",
+ "elf.R_ARM_RSBREL32": "debug/elf",
+ "elf.R_ARM_RXPC25": "debug/elf",
+ "elf.R_ARM_SBREL31": "debug/elf",
+ "elf.R_ARM_SBREL32": "debug/elf",
+ "elf.R_ARM_SWI24": "debug/elf",
+ "elf.R_ARM_TARGET1": "debug/elf",
+ "elf.R_ARM_TARGET2": "debug/elf",
+ "elf.R_ARM_THM_ABS5": "debug/elf",
+ "elf.R_ARM_THM_ALU_ABS_G0_NC": "debug/elf",
+ "elf.R_ARM_THM_ALU_ABS_G1_NC": "debug/elf",
+ "elf.R_ARM_THM_ALU_ABS_G2_NC": "debug/elf",
+ "elf.R_ARM_THM_ALU_ABS_G3": "debug/elf",
+ "elf.R_ARM_THM_ALU_PREL_11_0": "debug/elf",
+ "elf.R_ARM_THM_GOT_BREL12": "debug/elf",
+ "elf.R_ARM_THM_JUMP11": "debug/elf",
+ "elf.R_ARM_THM_JUMP19": "debug/elf",
+ "elf.R_ARM_THM_JUMP24": "debug/elf",
+ "elf.R_ARM_THM_JUMP6": "debug/elf",
+ "elf.R_ARM_THM_JUMP8": "debug/elf",
+ "elf.R_ARM_THM_MOVT_ABS": "debug/elf",
+ "elf.R_ARM_THM_MOVT_BREL": "debug/elf",
+ "elf.R_ARM_THM_MOVT_PREL": "debug/elf",
+ "elf.R_ARM_THM_MOVW_ABS_NC": "debug/elf",
+ "elf.R_ARM_THM_MOVW_BREL": "debug/elf",
+ "elf.R_ARM_THM_MOVW_BREL_NC": "debug/elf",
+ "elf.R_ARM_THM_MOVW_PREL_NC": "debug/elf",
+ "elf.R_ARM_THM_PC12": "debug/elf",
+ "elf.R_ARM_THM_PC22": "debug/elf",
+ "elf.R_ARM_THM_PC8": "debug/elf",
+ "elf.R_ARM_THM_RPC22": "debug/elf",
+ "elf.R_ARM_THM_SWI8": "debug/elf",
+ "elf.R_ARM_THM_TLS_CALL": "debug/elf",
+ "elf.R_ARM_THM_TLS_DESCSEQ16": "debug/elf",
+ "elf.R_ARM_THM_TLS_DESCSEQ32": "debug/elf",
+ "elf.R_ARM_THM_XPC22": "debug/elf",
+ "elf.R_ARM_TLS_CALL": "debug/elf",
+ "elf.R_ARM_TLS_DESCSEQ": "debug/elf",
+ "elf.R_ARM_TLS_DTPMOD32": "debug/elf",
+ "elf.R_ARM_TLS_DTPOFF32": "debug/elf",
+ "elf.R_ARM_TLS_GD32": "debug/elf",
+ "elf.R_ARM_TLS_GOTDESC": "debug/elf",
+ "elf.R_ARM_TLS_IE12GP": "debug/elf",
+ "elf.R_ARM_TLS_IE32": "debug/elf",
+ "elf.R_ARM_TLS_LDM32": "debug/elf",
+ "elf.R_ARM_TLS_LDO12": "debug/elf",
+ "elf.R_ARM_TLS_LDO32": "debug/elf",
+ "elf.R_ARM_TLS_LE12": "debug/elf",
+ "elf.R_ARM_TLS_LE32": "debug/elf",
+ "elf.R_ARM_TLS_TPOFF32": "debug/elf",
+ "elf.R_ARM_V4BX": "debug/elf",
+ "elf.R_ARM_XPC25": "debug/elf",
+ "elf.R_MIPS": "debug/elf",
+ "elf.R_MIPS_16": "debug/elf",
+ "elf.R_MIPS_26": "debug/elf",
+ "elf.R_MIPS_32": "debug/elf",
+ "elf.R_MIPS_64": "debug/elf",
+ "elf.R_MIPS_ADD_IMMEDIATE": "debug/elf",
+ "elf.R_MIPS_CALL16": "debug/elf",
+ "elf.R_MIPS_CALL_HI16": "debug/elf",
+ "elf.R_MIPS_CALL_LO16": "debug/elf",
+ "elf.R_MIPS_DELETE": "debug/elf",
+ "elf.R_MIPS_GOT16": "debug/elf",
+ "elf.R_MIPS_GOT_DISP": "debug/elf",
+ "elf.R_MIPS_GOT_HI16": "debug/elf",
+ "elf.R_MIPS_GOT_LO16": "debug/elf",
+ "elf.R_MIPS_GOT_OFST": "debug/elf",
+ "elf.R_MIPS_GOT_PAGE": "debug/elf",
+ "elf.R_MIPS_GPREL16": "debug/elf",
+ "elf.R_MIPS_GPREL32": "debug/elf",
+ "elf.R_MIPS_HI16": "debug/elf",
+ "elf.R_MIPS_HIGHER": "debug/elf",
+ "elf.R_MIPS_HIGHEST": "debug/elf",
+ "elf.R_MIPS_INSERT_A": "debug/elf",
+ "elf.R_MIPS_INSERT_B": "debug/elf",
+ "elf.R_MIPS_JALR": "debug/elf",
+ "elf.R_MIPS_LITERAL": "debug/elf",
+ "elf.R_MIPS_LO16": "debug/elf",
+ "elf.R_MIPS_NONE": "debug/elf",
+ "elf.R_MIPS_PC16": "debug/elf",
+ "elf.R_MIPS_PJUMP": "debug/elf",
+ "elf.R_MIPS_REL16": "debug/elf",
+ "elf.R_MIPS_REL32": "debug/elf",
+ "elf.R_MIPS_RELGOT": "debug/elf",
+ "elf.R_MIPS_SCN_DISP": "debug/elf",
+ "elf.R_MIPS_SHIFT5": "debug/elf",
+ "elf.R_MIPS_SHIFT6": "debug/elf",
+ "elf.R_MIPS_SUB": "debug/elf",
+ "elf.R_MIPS_TLS_DTPMOD32": "debug/elf",
+ "elf.R_MIPS_TLS_DTPMOD64": "debug/elf",
+ "elf.R_MIPS_TLS_DTPREL32": "debug/elf",
+ "elf.R_MIPS_TLS_DTPREL64": "debug/elf",
+ "elf.R_MIPS_TLS_DTPREL_HI16": "debug/elf",
+ "elf.R_MIPS_TLS_DTPREL_LO16": "debug/elf",
+ "elf.R_MIPS_TLS_GD": "debug/elf",
+ "elf.R_MIPS_TLS_GOTTPREL": "debug/elf",
+ "elf.R_MIPS_TLS_LDM": "debug/elf",
+ "elf.R_MIPS_TLS_TPREL32": "debug/elf",
+ "elf.R_MIPS_TLS_TPREL64": "debug/elf",
+ "elf.R_MIPS_TLS_TPREL_HI16": "debug/elf",
+ "elf.R_MIPS_TLS_TPREL_LO16": "debug/elf",
+ "elf.R_PPC64": "debug/elf",
+ "elf.R_PPC64_ADDR14": "debug/elf",
+ "elf.R_PPC64_ADDR14_BRNTAKEN": "debug/elf",
+ "elf.R_PPC64_ADDR14_BRTAKEN": "debug/elf",
+ "elf.R_PPC64_ADDR16": "debug/elf",
+ "elf.R_PPC64_ADDR16_DS": "debug/elf",
+ "elf.R_PPC64_ADDR16_HA": "debug/elf",
+ "elf.R_PPC64_ADDR16_HI": "debug/elf",
+ "elf.R_PPC64_ADDR16_HIGH": "debug/elf",
+ "elf.R_PPC64_ADDR16_HIGHA": "debug/elf",
+ "elf.R_PPC64_ADDR16_HIGHER": "debug/elf",
+ "elf.R_PPC64_ADDR16_HIGHERA": "debug/elf",
+ "elf.R_PPC64_ADDR16_HIGHEST": "debug/elf",
+ "elf.R_PPC64_ADDR16_HIGHESTA": "debug/elf",
+ "elf.R_PPC64_ADDR16_LO": "debug/elf",
+ "elf.R_PPC64_ADDR16_LO_DS": "debug/elf",
+ "elf.R_PPC64_ADDR24": "debug/elf",
+ "elf.R_PPC64_ADDR32": "debug/elf",
+ "elf.R_PPC64_ADDR64": "debug/elf",
+ "elf.R_PPC64_ADDR64_LOCAL": "debug/elf",
+ "elf.R_PPC64_DTPMOD64": "debug/elf",
+ "elf.R_PPC64_DTPREL16": "debug/elf",
+ "elf.R_PPC64_DTPREL16_DS": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HA": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HI": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HIGH": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HIGHA": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HIGHER": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HIGHERA": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HIGHEST": "debug/elf",
+ "elf.R_PPC64_DTPREL16_HIGHESTA": "debug/elf",
+ "elf.R_PPC64_DTPREL16_LO": "debug/elf",
+ "elf.R_PPC64_DTPREL16_LO_DS": "debug/elf",
+ "elf.R_PPC64_DTPREL64": "debug/elf",
+ "elf.R_PPC64_ENTRY": "debug/elf",
+ "elf.R_PPC64_GOT16": "debug/elf",
+ "elf.R_PPC64_GOT16_DS": "debug/elf",
+ "elf.R_PPC64_GOT16_HA": "debug/elf",
+ "elf.R_PPC64_GOT16_HI": "debug/elf",
+ "elf.R_PPC64_GOT16_LO": "debug/elf",
+ "elf.R_PPC64_GOT16_LO_DS": "debug/elf",
+ "elf.R_PPC64_GOT_DTPREL16_DS": "debug/elf",
+ "elf.R_PPC64_GOT_DTPREL16_HA": "debug/elf",
+ "elf.R_PPC64_GOT_DTPREL16_HI": "debug/elf",
+ "elf.R_PPC64_GOT_DTPREL16_LO_DS": "debug/elf",
+ "elf.R_PPC64_GOT_TLSGD16": "debug/elf",
+ "elf.R_PPC64_GOT_TLSGD16_HA": "debug/elf",
+ "elf.R_PPC64_GOT_TLSGD16_HI": "debug/elf",
+ "elf.R_PPC64_GOT_TLSGD16_LO": "debug/elf",
+ "elf.R_PPC64_GOT_TLSLD16": "debug/elf",
+ "elf.R_PPC64_GOT_TLSLD16_HA": "debug/elf",
+ "elf.R_PPC64_GOT_TLSLD16_HI": "debug/elf",
+ "elf.R_PPC64_GOT_TLSLD16_LO": "debug/elf",
+ "elf.R_PPC64_GOT_TPREL16_DS": "debug/elf",
+ "elf.R_PPC64_GOT_TPREL16_HA": "debug/elf",
+ "elf.R_PPC64_GOT_TPREL16_HI": "debug/elf",
+ "elf.R_PPC64_GOT_TPREL16_LO_DS": "debug/elf",
+ "elf.R_PPC64_IRELATIVE": "debug/elf",
+ "elf.R_PPC64_JMP_IREL": "debug/elf",
+ "elf.R_PPC64_JMP_SLOT": "debug/elf",
+ "elf.R_PPC64_NONE": "debug/elf",
+ "elf.R_PPC64_PLT16_LO_DS": "debug/elf",
+ "elf.R_PPC64_PLTGOT16": "debug/elf",
+ "elf.R_PPC64_PLTGOT16_DS": "debug/elf",
+ "elf.R_PPC64_PLTGOT16_HA": "debug/elf",
+ "elf.R_PPC64_PLTGOT16_HI": "debug/elf",
+ "elf.R_PPC64_PLTGOT16_LO": "debug/elf",
+ "elf.R_PPC64_PLTGOT_LO_DS": "debug/elf",
+ "elf.R_PPC64_REL14": "debug/elf",
+ "elf.R_PPC64_REL14_BRNTAKEN": "debug/elf",
+ "elf.R_PPC64_REL14_BRTAKEN": "debug/elf",
+ "elf.R_PPC64_REL16": "debug/elf",
+ "elf.R_PPC64_REL16DX_HA": "debug/elf",
+ "elf.R_PPC64_REL16_HA": "debug/elf",
+ "elf.R_PPC64_REL16_HI": "debug/elf",
+ "elf.R_PPC64_REL16_LO": "debug/elf",
+ "elf.R_PPC64_REL24": "debug/elf",
+ "elf.R_PPC64_REL24_NOTOC": "debug/elf",
+ "elf.R_PPC64_REL32": "debug/elf",
+ "elf.R_PPC64_REL64": "debug/elf",
+ "elf.R_PPC64_SECTOFF_DS": "debug/elf",
+ "elf.R_PPC64_SECTOFF_LO_DS": "debug/elf",
+ "elf.R_PPC64_TLS": "debug/elf",
+ "elf.R_PPC64_TLSGD": "debug/elf",
+ "elf.R_PPC64_TLSLD": "debug/elf",
+ "elf.R_PPC64_TOC": "debug/elf",
+ "elf.R_PPC64_TOC16": "debug/elf",
+ "elf.R_PPC64_TOC16_DS": "debug/elf",
+ "elf.R_PPC64_TOC16_HA": "debug/elf",
+ "elf.R_PPC64_TOC16_HI": "debug/elf",
+ "elf.R_PPC64_TOC16_LO": "debug/elf",
+ "elf.R_PPC64_TOC16_LO_DS": "debug/elf",
+ "elf.R_PPC64_TOCSAVE": "debug/elf",
+ "elf.R_PPC64_TPREL16": "debug/elf",
+ "elf.R_PPC64_TPREL16_DS": "debug/elf",
+ "elf.R_PPC64_TPREL16_HA": "debug/elf",
+ "elf.R_PPC64_TPREL16_HI": "debug/elf",
+ "elf.R_PPC64_TPREL16_HIGH": "debug/elf",
+ "elf.R_PPC64_TPREL16_HIGHA": "debug/elf",
+ "elf.R_PPC64_TPREL16_HIGHER": "debug/elf",
+ "elf.R_PPC64_TPREL16_HIGHERA": "debug/elf",
+ "elf.R_PPC64_TPREL16_HIGHEST": "debug/elf",
+ "elf.R_PPC64_TPREL16_HIGHESTA": "debug/elf",
+ "elf.R_PPC64_TPREL16_LO": "debug/elf",
+ "elf.R_PPC64_TPREL16_LO_DS": "debug/elf",
+ "elf.R_PPC64_TPREL64": "debug/elf",
+ "elf.R_PPC_ADDR14": "debug/elf",
+ "elf.R_PPC_ADDR14_BRNTAKEN": "debug/elf",
+ "elf.R_PPC_ADDR14_BRTAKEN": "debug/elf",
+ "elf.R_PPC_ADDR16": "debug/elf",
+ "elf.R_PPC_ADDR16_HA": "debug/elf",
+ "elf.R_PPC_ADDR16_HI": "debug/elf",
+ "elf.R_PPC_ADDR16_LO": "debug/elf",
+ "elf.R_PPC_ADDR24": "debug/elf",
+ "elf.R_PPC_ADDR32": "debug/elf",
+ "elf.R_PPC_COPY": "debug/elf",
+ "elf.R_PPC_DTPMOD32": "debug/elf",
+ "elf.R_PPC_DTPREL16": "debug/elf",
+ "elf.R_PPC_DTPREL16_HA": "debug/elf",
+ "elf.R_PPC_DTPREL16_HI": "debug/elf",
+ "elf.R_PPC_DTPREL16_LO": "debug/elf",
+ "elf.R_PPC_DTPREL32": "debug/elf",
+ "elf.R_PPC_EMB_BIT_FLD": "debug/elf",
+ "elf.R_PPC_EMB_MRKREF": "debug/elf",
+ "elf.R_PPC_EMB_NADDR16": "debug/elf",
+ "elf.R_PPC_EMB_NADDR16_HA": "debug/elf",
+ "elf.R_PPC_EMB_NADDR16_HI": "debug/elf",
+ "elf.R_PPC_EMB_NADDR16_LO": "debug/elf",
+ "elf.R_PPC_EMB_NADDR32": "debug/elf",
+ "elf.R_PPC_EMB_RELSDA": "debug/elf",
+ "elf.R_PPC_EMB_RELSEC16": "debug/elf",
+ "elf.R_PPC_EMB_RELST_HA": "debug/elf",
+ "elf.R_PPC_EMB_RELST_HI": "debug/elf",
+ "elf.R_PPC_EMB_RELST_LO": "debug/elf",
+ "elf.R_PPC_EMB_SDA21": "debug/elf",
+ "elf.R_PPC_EMB_SDA2I16": "debug/elf",
+ "elf.R_PPC_EMB_SDA2REL": "debug/elf",
+ "elf.R_PPC_EMB_SDAI16": "debug/elf",
+ "elf.R_PPC_GLOB_DAT": "debug/elf",
+ "elf.R_PPC_GOT16": "debug/elf",
+ "elf.R_PPC_GOT16_HA": "debug/elf",
+ "elf.R_PPC_GOT16_HI": "debug/elf",
+ "elf.R_PPC_GOT16_LO": "debug/elf",
+ "elf.R_PPC_GOT_TLSGD16": "debug/elf",
+ "elf.R_PPC_GOT_TLSGD16_HA": "debug/elf",
+ "elf.R_PPC_GOT_TLSGD16_HI": "debug/elf",
+ "elf.R_PPC_GOT_TLSGD16_LO": "debug/elf",
+ "elf.R_PPC_GOT_TLSLD16": "debug/elf",
+ "elf.R_PPC_GOT_TLSLD16_HA": "debug/elf",
+ "elf.R_PPC_GOT_TLSLD16_HI": "debug/elf",
+ "elf.R_PPC_GOT_TLSLD16_LO": "debug/elf",
+ "elf.R_PPC_GOT_TPREL16": "debug/elf",
+ "elf.R_PPC_GOT_TPREL16_HA": "debug/elf",
+ "elf.R_PPC_GOT_TPREL16_HI": "debug/elf",
+ "elf.R_PPC_GOT_TPREL16_LO": "debug/elf",
+ "elf.R_PPC_JMP_SLOT": "debug/elf",
+ "elf.R_PPC_LOCAL24PC": "debug/elf",
+ "elf.R_PPC_NONE": "debug/elf",
+ "elf.R_PPC_PLT16_HA": "debug/elf",
+ "elf.R_PPC_PLT16_HI": "debug/elf",
+ "elf.R_PPC_PLT16_LO": "debug/elf",
+ "elf.R_PPC_PLT32": "debug/elf",
+ "elf.R_PPC_PLTREL24": "debug/elf",
+ "elf.R_PPC_PLTREL32": "debug/elf",
+ "elf.R_PPC_REL14": "debug/elf",
+ "elf.R_PPC_REL14_BRNTAKEN": "debug/elf",
+ "elf.R_PPC_REL14_BRTAKEN": "debug/elf",
+ "elf.R_PPC_REL24": "debug/elf",
+ "elf.R_PPC_REL32": "debug/elf",
+ "elf.R_PPC_RELATIVE": "debug/elf",
+ "elf.R_PPC_SDAREL16": "debug/elf",
+ "elf.R_PPC_SECTOFF": "debug/elf",
+ "elf.R_PPC_SECTOFF_HA": "debug/elf",
+ "elf.R_PPC_SECTOFF_HI": "debug/elf",
+ "elf.R_PPC_SECTOFF_LO": "debug/elf",
+ "elf.R_PPC_TLS": "debug/elf",
+ "elf.R_PPC_TPREL16": "debug/elf",
+ "elf.R_PPC_TPREL16_HA": "debug/elf",
+ "elf.R_PPC_TPREL16_HI": "debug/elf",
+ "elf.R_PPC_TPREL16_LO": "debug/elf",
+ "elf.R_PPC_TPREL32": "debug/elf",
+ "elf.R_PPC_UADDR16": "debug/elf",
+ "elf.R_PPC_UADDR32": "debug/elf",
+ "elf.R_RISCV": "debug/elf",
+ "elf.R_RISCV_32": "debug/elf",
+ "elf.R_RISCV_32_PCREL": "debug/elf",
+ "elf.R_RISCV_64": "debug/elf",
+ "elf.R_RISCV_ADD16": "debug/elf",
+ "elf.R_RISCV_ADD32": "debug/elf",
+ "elf.R_RISCV_ADD64": "debug/elf",
+ "elf.R_RISCV_ADD8": "debug/elf",
+ "elf.R_RISCV_ALIGN": "debug/elf",
+ "elf.R_RISCV_BRANCH": "debug/elf",
+ "elf.R_RISCV_CALL": "debug/elf",
+ "elf.R_RISCV_CALL_PLT": "debug/elf",
+ "elf.R_RISCV_COPY": "debug/elf",
+ "elf.R_RISCV_GNU_VTENTRY": "debug/elf",
+ "elf.R_RISCV_GNU_VTINHERIT": "debug/elf",
+ "elf.R_RISCV_GOT_HI20": "debug/elf",
+ "elf.R_RISCV_GPREL_I": "debug/elf",
+ "elf.R_RISCV_GPREL_S": "debug/elf",
+ "elf.R_RISCV_HI20": "debug/elf",
+ "elf.R_RISCV_JAL": "debug/elf",
+ "elf.R_RISCV_JUMP_SLOT": "debug/elf",
+ "elf.R_RISCV_LO12_I": "debug/elf",
+ "elf.R_RISCV_LO12_S": "debug/elf",
+ "elf.R_RISCV_NONE": "debug/elf",
+ "elf.R_RISCV_PCREL_HI20": "debug/elf",
+ "elf.R_RISCV_PCREL_LO12_I": "debug/elf",
+ "elf.R_RISCV_PCREL_LO12_S": "debug/elf",
+ "elf.R_RISCV_RELATIVE": "debug/elf",
+ "elf.R_RISCV_RELAX": "debug/elf",
+ "elf.R_RISCV_RVC_BRANCH": "debug/elf",
+ "elf.R_RISCV_RVC_JUMP": "debug/elf",
+ "elf.R_RISCV_RVC_LUI": "debug/elf",
+ "elf.R_RISCV_SET16": "debug/elf",
+ "elf.R_RISCV_SET32": "debug/elf",
+ "elf.R_RISCV_SET6": "debug/elf",
+ "elf.R_RISCV_SET8": "debug/elf",
+ "elf.R_RISCV_SUB16": "debug/elf",
+ "elf.R_RISCV_SUB32": "debug/elf",
+ "elf.R_RISCV_SUB6": "debug/elf",
+ "elf.R_RISCV_SUB64": "debug/elf",
+ "elf.R_RISCV_SUB8": "debug/elf",
+ "elf.R_RISCV_TLS_DTPMOD32": "debug/elf",
+ "elf.R_RISCV_TLS_DTPMOD64": "debug/elf",
+ "elf.R_RISCV_TLS_DTPREL32": "debug/elf",
+ "elf.R_RISCV_TLS_DTPREL64": "debug/elf",
+ "elf.R_RISCV_TLS_GD_HI20": "debug/elf",
+ "elf.R_RISCV_TLS_GOT_HI20": "debug/elf",
+ "elf.R_RISCV_TLS_TPREL32": "debug/elf",
+ "elf.R_RISCV_TLS_TPREL64": "debug/elf",
+ "elf.R_RISCV_TPREL_ADD": "debug/elf",
+ "elf.R_RISCV_TPREL_HI20": "debug/elf",
+ "elf.R_RISCV_TPREL_I": "debug/elf",
+ "elf.R_RISCV_TPREL_LO12_I": "debug/elf",
+ "elf.R_RISCV_TPREL_LO12_S": "debug/elf",
+ "elf.R_RISCV_TPREL_S": "debug/elf",
+ "elf.R_SPARC_10": "debug/elf",
+ "elf.R_SPARC_11": "debug/elf",
+ "elf.R_SPARC_13": "debug/elf",
+ "elf.R_SPARC_16": "debug/elf",
+ "elf.R_SPARC_22": "debug/elf",
+ "elf.R_SPARC_32": "debug/elf",
+ "elf.R_SPARC_5": "debug/elf",
+ "elf.R_SPARC_6": "debug/elf",
+ "elf.R_SPARC_64": "debug/elf",
+ "elf.R_SPARC_7": "debug/elf",
+ "elf.R_SPARC_8": "debug/elf",
+ "elf.R_SPARC_COPY": "debug/elf",
+ "elf.R_SPARC_DISP16": "debug/elf",
+ "elf.R_SPARC_DISP32": "debug/elf",
+ "elf.R_SPARC_DISP64": "debug/elf",
+ "elf.R_SPARC_DISP8": "debug/elf",
+ "elf.R_SPARC_GLOB_DAT": "debug/elf",
+ "elf.R_SPARC_GLOB_JMP": "debug/elf",
+ "elf.R_SPARC_GOT10": "debug/elf",
+ "elf.R_SPARC_GOT13": "debug/elf",
+ "elf.R_SPARC_GOT22": "debug/elf",
+ "elf.R_SPARC_H44": "debug/elf",
+ "elf.R_SPARC_HH22": "debug/elf",
+ "elf.R_SPARC_HI22": "debug/elf",
+ "elf.R_SPARC_HIPLT22": "debug/elf",
+ "elf.R_SPARC_HIX22": "debug/elf",
+ "elf.R_SPARC_HM10": "debug/elf",
+ "elf.R_SPARC_JMP_SLOT": "debug/elf",
+ "elf.R_SPARC_L44": "debug/elf",
+ "elf.R_SPARC_LM22": "debug/elf",
+ "elf.R_SPARC_LO10": "debug/elf",
+ "elf.R_SPARC_LOPLT10": "debug/elf",
+ "elf.R_SPARC_LOX10": "debug/elf",
+ "elf.R_SPARC_M44": "debug/elf",
+ "elf.R_SPARC_NONE": "debug/elf",
+ "elf.R_SPARC_OLO10": "debug/elf",
+ "elf.R_SPARC_PC10": "debug/elf",
+ "elf.R_SPARC_PC22": "debug/elf",
+ "elf.R_SPARC_PCPLT10": "debug/elf",
+ "elf.R_SPARC_PCPLT22": "debug/elf",
+ "elf.R_SPARC_PCPLT32": "debug/elf",
+ "elf.R_SPARC_PC_HH22": "debug/elf",
+ "elf.R_SPARC_PC_HM10": "debug/elf",
+ "elf.R_SPARC_PC_LM22": "debug/elf",
+ "elf.R_SPARC_PLT32": "debug/elf",
+ "elf.R_SPARC_PLT64": "debug/elf",
+ "elf.R_SPARC_REGISTER": "debug/elf",
+ "elf.R_SPARC_RELATIVE": "debug/elf",
+ "elf.R_SPARC_UA16": "debug/elf",
+ "elf.R_SPARC_UA32": "debug/elf",
+ "elf.R_SPARC_UA64": "debug/elf",
+ "elf.R_SPARC_WDISP16": "debug/elf",
+ "elf.R_SPARC_WDISP19": "debug/elf",
+ "elf.R_SPARC_WDISP22": "debug/elf",
+ "elf.R_SPARC_WDISP30": "debug/elf",
+ "elf.R_SPARC_WPLT30": "debug/elf",
+ "elf.R_X86_64_16": "debug/elf",
+ "elf.R_X86_64_32": "debug/elf",
+ "elf.R_X86_64_32S": "debug/elf",
+ "elf.R_X86_64_64": "debug/elf",
+ "elf.R_X86_64_8": "debug/elf",
+ "elf.R_X86_64_COPY": "debug/elf",
+ "elf.R_X86_64_DTPMOD64": "debug/elf",
+ "elf.R_X86_64_DTPOFF32": "debug/elf",
+ "elf.R_X86_64_DTPOFF64": "debug/elf",
+ "elf.R_X86_64_GLOB_DAT": "debug/elf",
+ "elf.R_X86_64_GOT32": "debug/elf",
+ "elf.R_X86_64_GOT64": "debug/elf",
+ "elf.R_X86_64_GOTOFF64": "debug/elf",
+ "elf.R_X86_64_GOTPC32": "debug/elf",
+ "elf.R_X86_64_GOTPC32_TLSDESC": "debug/elf",
+ "elf.R_X86_64_GOTPC64": "debug/elf",
+ "elf.R_X86_64_GOTPCREL": "debug/elf",
+ "elf.R_X86_64_GOTPCREL64": "debug/elf",
+ "elf.R_X86_64_GOTPCRELX": "debug/elf",
+ "elf.R_X86_64_GOTPLT64": "debug/elf",
+ "elf.R_X86_64_GOTTPOFF": "debug/elf",
+ "elf.R_X86_64_IRELATIVE": "debug/elf",
+ "elf.R_X86_64_JMP_SLOT": "debug/elf",
+ "elf.R_X86_64_NONE": "debug/elf",
+ "elf.R_X86_64_PC16": "debug/elf",
+ "elf.R_X86_64_PC32": "debug/elf",
+ "elf.R_X86_64_PC32_BND": "debug/elf",
+ "elf.R_X86_64_PC64": "debug/elf",
+ "elf.R_X86_64_PC8": "debug/elf",
+ "elf.R_X86_64_PLT32": "debug/elf",
+ "elf.R_X86_64_PLT32_BND": "debug/elf",
+ "elf.R_X86_64_PLTOFF64": "debug/elf",
+ "elf.R_X86_64_RELATIVE": "debug/elf",
+ "elf.R_X86_64_RELATIVE64": "debug/elf",
+ "elf.R_X86_64_REX_GOTPCRELX": "debug/elf",
+ "elf.R_X86_64_SIZE32": "debug/elf",
+ "elf.R_X86_64_SIZE64": "debug/elf",
+ "elf.R_X86_64_TLSDESC": "debug/elf",
+ "elf.R_X86_64_TLSDESC_CALL": "debug/elf",
+ "elf.R_X86_64_TLSGD": "debug/elf",
+ "elf.R_X86_64_TLSLD": "debug/elf",
+ "elf.R_X86_64_TPOFF32": "debug/elf",
+ "elf.R_X86_64_TPOFF64": "debug/elf",
+ "elf.SHF_ALLOC": "debug/elf",
+ "elf.SHF_COMPRESSED": "debug/elf",
+ "elf.SHF_EXECINSTR": "debug/elf",
+ "elf.SHF_GROUP": "debug/elf",
+ "elf.SHF_INFO_LINK": "debug/elf",
+ "elf.SHF_LINK_ORDER": "debug/elf",
+ "elf.SHF_MASKOS": "debug/elf",
+ "elf.SHF_MASKPROC": "debug/elf",
+ "elf.SHF_MERGE": "debug/elf",
+ "elf.SHF_OS_NONCONFORMING": "debug/elf",
+ "elf.SHF_STRINGS": "debug/elf",
+ "elf.SHF_TLS": "debug/elf",
+ "elf.SHF_WRITE": "debug/elf",
+ "elf.SHN_ABS": "debug/elf",
+ "elf.SHN_COMMON": "debug/elf",
+ "elf.SHN_HIOS": "debug/elf",
+ "elf.SHN_HIPROC": "debug/elf",
+ "elf.SHN_HIRESERVE": "debug/elf",
+ "elf.SHN_LOOS": "debug/elf",
+ "elf.SHN_LOPROC": "debug/elf",
+ "elf.SHN_LORESERVE": "debug/elf",
+ "elf.SHN_UNDEF": "debug/elf",
+ "elf.SHN_XINDEX": "debug/elf",
+ "elf.SHT_DYNAMIC": "debug/elf",
+ "elf.SHT_DYNSYM": "debug/elf",
+ "elf.SHT_FINI_ARRAY": "debug/elf",
+ "elf.SHT_GNU_ATTRIBUTES": "debug/elf",
+ "elf.SHT_GNU_HASH": "debug/elf",
+ "elf.SHT_GNU_LIBLIST": "debug/elf",
+ "elf.SHT_GNU_VERDEF": "debug/elf",
+ "elf.SHT_GNU_VERNEED": "debug/elf",
+ "elf.SHT_GNU_VERSYM": "debug/elf",
+ "elf.SHT_GROUP": "debug/elf",
+ "elf.SHT_HASH": "debug/elf",
+ "elf.SHT_HIOS": "debug/elf",
+ "elf.SHT_HIPROC": "debug/elf",
+ "elf.SHT_HIUSER": "debug/elf",
+ "elf.SHT_INIT_ARRAY": "debug/elf",
+ "elf.SHT_LOOS": "debug/elf",
+ "elf.SHT_LOPROC": "debug/elf",
+ "elf.SHT_LOUSER": "debug/elf",
+ "elf.SHT_MIPS_ABIFLAGS": "debug/elf",
+ "elf.SHT_NOBITS": "debug/elf",
+ "elf.SHT_NOTE": "debug/elf",
+ "elf.SHT_NULL": "debug/elf",
+ "elf.SHT_PREINIT_ARRAY": "debug/elf",
+ "elf.SHT_PROGBITS": "debug/elf",
+ "elf.SHT_REL": "debug/elf",
+ "elf.SHT_RELA": "debug/elf",
+ "elf.SHT_SHLIB": "debug/elf",
+ "elf.SHT_STRTAB": "debug/elf",
+ "elf.SHT_SYMTAB": "debug/elf",
+ "elf.SHT_SYMTAB_SHNDX": "debug/elf",
+ "elf.STB_GLOBAL": "debug/elf",
+ "elf.STB_HIOS": "debug/elf",
+ "elf.STB_HIPROC": "debug/elf",
+ "elf.STB_LOCAL": "debug/elf",
+ "elf.STB_LOOS": "debug/elf",
+ "elf.STB_LOPROC": "debug/elf",
+ "elf.STB_WEAK": "debug/elf",
+ "elf.STT_COMMON": "debug/elf",
+ "elf.STT_FILE": "debug/elf",
+ "elf.STT_FUNC": "debug/elf",
+ "elf.STT_HIOS": "debug/elf",
+ "elf.STT_HIPROC": "debug/elf",
+ "elf.STT_LOOS": "debug/elf",
+ "elf.STT_LOPROC": "debug/elf",
+ "elf.STT_NOTYPE": "debug/elf",
+ "elf.STT_OBJECT": "debug/elf",
+ "elf.STT_SECTION": "debug/elf",
+ "elf.STT_TLS": "debug/elf",
+ "elf.STV_DEFAULT": "debug/elf",
+ "elf.STV_HIDDEN": "debug/elf",
+ "elf.STV_INTERNAL": "debug/elf",
+ "elf.STV_PROTECTED": "debug/elf",
+ "elf.Sym32Size": "debug/elf",
+ "elf.Sym64Size": "debug/elf",
+ "elliptic.MarshalCompressed": "crypto/elliptic",
+ "elliptic.UnmarshalCompressed": "crypto/elliptic",
+ "embed.FS": "embed",
+ "encoding.BinaryMarshaler": "encoding",
+ "encoding.BinaryUnmarshaler": "encoding",
+ "encoding.TextMarshaler": "encoding",
+ "encoding.TextUnmarshaler": "encoding",
+ "errors.As": "errors",
+ "errors.Is": "errors",
+ "errors.Unwrap": "errors",
+ "exec.CommandContext": "os/exec",
+ "expvar.Handler": "expvar",
+ "fcgi.ErrConnClosed": "net/http/fcgi",
+ "fcgi.ErrRequestAborted": "net/http/fcgi",
+ "fcgi.ProcessEnv": "net/http/fcgi",
+ "filepath.ListSeparator": "path/filepath",
+ "filepath.Separator": "path/filepath",
+ "filepath.WalkDir": "path/filepath",
+ "flag.CommandLine": "flag",
+ "flag.ContinueOnError": "flag",
+ "flag.ExitOnError": "flag",
+ "flag.Func": "flag",
+ "flag.Getter": "flag",
+ "flag.PanicOnError": "flag",
+ "flag.UnquoteUsage": "flag",
+ "flate.BestCompression": "compress/flate",
+ "flate.BestSpeed": "compress/flate",
+ "flate.DefaultCompression": "compress/flate",
+ "flate.HuffmanOnly": "compress/flate",
+ "flate.NoCompression": "compress/flate",
+ "flate.Resetter": "compress/flate",
+ "fnv.New128": "hash/fnv",
+ "fnv.New128a": "hash/fnv",
+ "format.Node": "go/format",
+ "format.Source": "go/format",
+ "fs.DirEntry": "io/fs",
+ "fs.ErrClosed": "io/fs",
+ "fs.ErrExist": "io/fs",
+ "fs.ErrInvalid": "io/fs",
+ "fs.ErrNotExist": "io/fs",
+ "fs.ErrPermission": "io/fs",
+ "fs.FS": "io/fs",
+ "fs.File": "io/fs",
+ "fs.FileInfo": "io/fs",
+ "fs.FileInfoToDirEntry": "io/fs",
+ "fs.FileMode": "io/fs",
+ "fs.Glob": "io/fs",
+ "fs.GlobFS": "io/fs",
+ "fs.ModeAppend": "io/fs",
+ "fs.ModeCharDevice": "io/fs",
+ "fs.ModeDevice": "io/fs",
+ "fs.ModeDir": "io/fs",
+ "fs.ModeExclusive": "io/fs",
+ "fs.ModeIrregular": "io/fs",
+ "fs.ModeNamedPipe": "io/fs",
+ "fs.ModePerm": "io/fs",
+ "fs.ModeSetgid": "io/fs",
+ "fs.ModeSetuid": "io/fs",
+ "fs.ModeSocket": "io/fs",
+ "fs.ModeSticky": "io/fs",
+ "fs.ModeSymlink": "io/fs",
+ "fs.ModeTemporary": "io/fs",
+ "fs.ModeType": "io/fs",
+ "fs.PathError": "io/fs",
+ "fs.ReadDir": "io/fs",
+ "fs.ReadDirFS": "io/fs",
+ "fs.ReadDirFile": "io/fs",
+ "fs.ReadFile": "io/fs",
+ "fs.ReadFileFS": "io/fs",
+ "fs.SkipDir": "io/fs",
+ "fs.Stat": "io/fs",
+ "fs.StatFS": "io/fs",
+ "fs.Sub": "io/fs",
+ "fs.SubFS": "io/fs",
+ "fs.ValidPath": "io/fs",
+ "fs.WalkDir": "io/fs",
+ "fs.WalkDirFunc": "io/fs",
+ "fstest.MapFS": "testing/fstest",
+ "fstest.MapFile": "testing/fstest",
+ "fstest.TestFS": "testing/fstest",
+ "gif.DisposalBackground": "image/gif",
+ "gif.DisposalNone": "image/gif",
+ "gif.DisposalPrevious": "image/gif",
+ "gif.Encode": "image/gif",
+ "gif.EncodeAll": "image/gif",
+ "gif.Options": "image/gif",
+ "gzip.BestCompression": "compress/gzip",
+ "gzip.BestSpeed": "compress/gzip",
+ "gzip.DefaultCompression": "compress/gzip",
+ "gzip.HuffmanOnly": "compress/gzip",
+ "gzip.NoCompression": "compress/gzip",
+ "heap.Fix": "container/heap",
+ "hex.NewDecoder": "encoding/hex",
+ "hex.NewEncoder": "encoding/hex",
+ "hmac.Equal": "crypto/hmac",
+ "http.AllowQuerySemicolons": "net/http",
+ "http.CloseNotifier": "net/http",
+ "http.ConnState": "net/http",
+ "http.DefaultMaxHeaderBytes": "net/http",
+ "http.DefaultMaxIdleConnsPerHost": "net/http",
+ "http.ErrAbortHandler": "net/http",
+ "http.ErrServerClosed": "net/http",
+ "http.ErrSkipAltProtocol": "net/http",
+ "http.ErrUseLastResponse": "net/http",
+ "http.FS": "net/http",
+ "http.LocalAddrContextKey": "net/http",
+ "http.MethodConnect": "net/http",
+ "http.MethodDelete": "net/http",
+ "http.MethodGet": "net/http",
+ "http.MethodHead": "net/http",
+ "http.MethodOptions": "net/http",
+ "http.MethodPatch": "net/http",
+ "http.MethodPost": "net/http",
+ "http.MethodPut": "net/http",
+ "http.MethodTrace": "net/http",
+ "http.NewRequestWithContext": "net/http",
+ "http.NoBody": "net/http",
+ "http.ParseTime": "net/http",
+ "http.PushOptions": "net/http",
+ "http.Pusher": "net/http",
+ "http.SameSite": "net/http",
+ "http.SameSiteDefaultMode": "net/http",
+ "http.SameSiteLaxMode": "net/http",
+ "http.SameSiteNoneMode": "net/http",
+ "http.SameSiteStrictMode": "net/http",
+ "http.ServeTLS": "net/http",
+ "http.ServerContextKey": "net/http",
+ "http.StateActive": "net/http",
+ "http.StateClosed": "net/http",
+ "http.StateHijacked": "net/http",
+ "http.StateIdle": "net/http",
+ "http.StateNew": "net/http",
+ "http.StatusAccepted": "net/http",
+ "http.StatusAlreadyReported": "net/http",
+ "http.StatusBadGateway": "net/http",
+ "http.StatusBadRequest": "net/http",
+ "http.StatusConflict": "net/http",
+ "http.StatusContinue": "net/http",
+ "http.StatusCreated": "net/http",
+ "http.StatusEarlyHints": "net/http",
+ "http.StatusExpectationFailed": "net/http",
+ "http.StatusFailedDependency": "net/http",
+ "http.StatusForbidden": "net/http",
+ "http.StatusFound": "net/http",
+ "http.StatusGatewayTimeout": "net/http",
+ "http.StatusGone": "net/http",
+ "http.StatusHTTPVersionNotSupported": "net/http",
+ "http.StatusIMUsed": "net/http",
+ "http.StatusInsufficientStorage": "net/http",
+ "http.StatusInternalServerError": "net/http",
+ "http.StatusLengthRequired": "net/http",
+ "http.StatusLocked": "net/http",
+ "http.StatusLoopDetected": "net/http",
+ "http.StatusMethodNotAllowed": "net/http",
+ "http.StatusMisdirectedRequest": "net/http",
+ "http.StatusMovedPermanently": "net/http",
+ "http.StatusMultiStatus": "net/http",
+ "http.StatusMultipleChoices": "net/http",
+ "http.StatusNetworkAuthenticationRequired": "net/http",
+ "http.StatusNoContent": "net/http",
+ "http.StatusNonAuthoritativeInfo": "net/http",
+ "http.StatusNotAcceptable": "net/http",
+ "http.StatusNotExtended": "net/http",
+ "http.StatusNotFound": "net/http",
+ "http.StatusNotImplemented": "net/http",
+ "http.StatusNotModified": "net/http",
+ "http.StatusOK": "net/http",
+ "http.StatusPartialContent": "net/http",
+ "http.StatusPaymentRequired": "net/http",
+ "http.StatusPermanentRedirect": "net/http",
+ "http.StatusPreconditionFailed": "net/http",
+ "http.StatusPreconditionRequired": "net/http",
+ "http.StatusProcessing": "net/http",
+ "http.StatusProxyAuthRequired": "net/http",
+ "http.StatusRequestEntityTooLarge": "net/http",
+ "http.StatusRequestHeaderFieldsTooLarge": "net/http",
+ "http.StatusRequestTimeout": "net/http",
+ "http.StatusRequestURITooLong": "net/http",
+ "http.StatusRequestedRangeNotSatisfiable": "net/http",
+ "http.StatusResetContent": "net/http",
+ "http.StatusSeeOther": "net/http",
+ "http.StatusServiceUnavailable": "net/http",
+ "http.StatusSwitchingProtocols": "net/http",
+ "http.StatusTeapot": "net/http",
+ "http.StatusTemporaryRedirect": "net/http",
+ "http.StatusTooEarly": "net/http",
+ "http.StatusTooManyRequests": "net/http",
+ "http.StatusUnauthorized": "net/http",
+ "http.StatusUnavailableForLegalReasons": "net/http",
+ "http.StatusUnprocessableEntity": "net/http",
+ "http.StatusUnsupportedMediaType": "net/http",
+ "http.StatusUpgradeRequired": "net/http",
+ "http.StatusUseProxy": "net/http",
+ "http.StatusVariantAlsoNegotiates": "net/http",
+ "http.TimeFormat": "net/http",
+ "http.TrailerPrefix": "net/http",
+ "httptest.DefaultRemoteAddr": "net/http/httptest",
+ "httptest.NewRequest": "net/http/httptest",
+ "httptrace.ClientTrace": "net/http/httptrace",
+ "httptrace.ContextClientTrace": "net/http/httptrace",
+ "httptrace.DNSDoneInfo": "net/http/httptrace",
+ "httptrace.DNSStartInfo": "net/http/httptrace",
+ "httptrace.GotConnInfo": "net/http/httptrace",
+ "httptrace.WithClientTrace": "net/http/httptrace",
+ "httptrace.WroteRequestInfo": "net/http/httptrace",
+ "httputil.BufferPool": "net/http/httputil",
+ "image.CMYK": "image",
+ "image.NYCbCrA": "image",
+ "image.NewCMYK": "image",
+ "image.NewNYCbCrA": "image",
+ "image.RGBA64Image": "image",
+ "image.YCbCrSubsampleRatio410": "image",
+ "image.YCbCrSubsampleRatio411": "image",
+ "image.YCbCrSubsampleRatio420": "image",
+ "image.YCbCrSubsampleRatio422": "image",
+ "image.YCbCrSubsampleRatio440": "image",
+ "image.YCbCrSubsampleRatio444": "image",
+ "importer.Default": "go/importer",
+ "importer.For": "go/importer",
+ "importer.ForCompiler": "go/importer",
+ "importer.Lookup": "go/importer",
+ "io.ByteWriter": "io",
+ "io.CopyBuffer": "io",
+ "io.Discard": "io",
+ "io.ErrNoProgress": "io",
+ "io.NopCloser": "io",
+ "io.ReadAll": "io",
+ "io.ReadSeekCloser": "io",
+ "io.SeekCurrent": "io",
+ "io.SeekEnd": "io",
+ "io.SeekStart": "io",
+ "io.StringWriter": "io",
+ "iotest.ErrReader": "testing/iotest",
+ "iotest.TestReader": "testing/iotest",
+ "jpeg.DefaultQuality": "image/jpeg",
+ "js.CopyBytesToGo": "syscall/js",
+ "js.CopyBytesToJS": "syscall/js",
+ "js.Debugger": "github.com/gopherjs/gopherjs/js",
+ // "js.Error" is ambiguous
+ "js.Func": "syscall/js",
+ "js.FuncOf": "syscall/js",
+ // "js.Global" is ambiguous
+ "js.InternalObject": "github.com/gopherjs/gopherjs/js",
+ "js.Keys": "github.com/gopherjs/gopherjs/js",
+ "js.M": "github.com/gopherjs/gopherjs/js",
+ "js.MakeFunc": "github.com/gopherjs/gopherjs/js",
+ "js.MakeWrapper": "github.com/gopherjs/gopherjs/js",
+ "js.Module": "github.com/gopherjs/gopherjs/js",
+ "js.NewArrayBuffer": "github.com/gopherjs/gopherjs/js",
+ "js.Null": "syscall/js",
+ "js.Object": "github.com/gopherjs/gopherjs/js",
+ "js.S": "github.com/gopherjs/gopherjs/js",
+ "js.Type": "syscall/js",
+ "js.TypeBoolean": "syscall/js",
+ "js.TypeFunction": "syscall/js",
+ "js.TypeNull": "syscall/js",
+ "js.TypeNumber": "syscall/js",
+ "js.TypeObject": "syscall/js",
+ "js.TypeString": "syscall/js",
+ "js.TypeSymbol": "syscall/js",
+ "js.TypeUndefined": "syscall/js",
+ // "js.Undefined" is ambiguous
+ "js.Value": "syscall/js",
+ "js.ValueError": "syscall/js",
+ "js.ValueOf": "syscall/js",
+ "js.Wrapper": "syscall/js",
+ "json.Delim": "encoding/json",
+ "json.Number": "encoding/json",
+ "json.Token": "encoding/json",
+ "json.Valid": "encoding/json",
+ "log.Default": "log",
+ "log.LUTC": "log",
+ "log.Ldate": "log",
+ "log.Llongfile": "log",
+ "log.Lmicroseconds": "log",
+ "log.Lmsgprefix": "log",
+ "log.Lshortfile": "log",
+ "log.LstdFlags": "log",
+ "log.Ltime": "log",
+ "log.Output": "log",
+ "log.Writer": "log",
+ "lzw.LSB": "compress/lzw",
+ "lzw.MSB": "compress/lzw",
+ "lzw.Reader": "compress/lzw",
+ "lzw.Writer": "compress/lzw",
+ "macho.ARM64_RELOC_ADDEND": "debug/macho",
+ "macho.ARM64_RELOC_BRANCH26": "debug/macho",
+ "macho.ARM64_RELOC_GOT_LOAD_PAGE21": "debug/macho",
+ "macho.ARM64_RELOC_GOT_LOAD_PAGEOFF12": "debug/macho",
+ "macho.ARM64_RELOC_PAGE21": "debug/macho",
+ "macho.ARM64_RELOC_PAGEOFF12": "debug/macho",
+ "macho.ARM64_RELOC_POINTER_TO_GOT": "debug/macho",
+ "macho.ARM64_RELOC_SUBTRACTOR": "debug/macho",
+ "macho.ARM64_RELOC_TLVP_LOAD_PAGE21": "debug/macho",
+ "macho.ARM64_RELOC_TLVP_LOAD_PAGEOFF12": "debug/macho",
+ "macho.ARM64_RELOC_UNSIGNED": "debug/macho",
+ "macho.ARM_RELOC_BR24": "debug/macho",
+ "macho.ARM_RELOC_HALF": "debug/macho",
+ "macho.ARM_RELOC_HALF_SECTDIFF": "debug/macho",
+ "macho.ARM_RELOC_LOCAL_SECTDIFF": "debug/macho",
+ "macho.ARM_RELOC_PAIR": "debug/macho",
+ "macho.ARM_RELOC_PB_LA_PTR": "debug/macho",
+ "macho.ARM_RELOC_SECTDIFF": "debug/macho",
+ "macho.ARM_RELOC_VANILLA": "debug/macho",
+ "macho.ARM_THUMB_32BIT_BRANCH": "debug/macho",
+ "macho.ARM_THUMB_RELOC_BR22": "debug/macho",
+ "macho.Cpu386": "debug/macho",
+ "macho.CpuAmd64": "debug/macho",
+ "macho.CpuArm": "debug/macho",
+ "macho.CpuArm64": "debug/macho",
+ "macho.CpuPpc": "debug/macho",
+ "macho.CpuPpc64": "debug/macho",
+ "macho.ErrNotFat": "debug/macho",
+ "macho.FatArch": "debug/macho",
+ "macho.FatArchHeader": "debug/macho",
+ "macho.FatFile": "debug/macho",
+ "macho.FlagAllModsBound": "debug/macho",
+ "macho.FlagAllowStackExecution": "debug/macho",
+ "macho.FlagAppExtensionSafe": "debug/macho",
+ "macho.FlagBindAtLoad": "debug/macho",
+ "macho.FlagBindsToWeak": "debug/macho",
+ "macho.FlagCanonical": "debug/macho",
+ "macho.FlagDeadStrippableDylib": "debug/macho",
+ "macho.FlagDyldLink": "debug/macho",
+ "macho.FlagForceFlat": "debug/macho",
+ "macho.FlagHasTLVDescriptors": "debug/macho",
+ "macho.FlagIncrLink": "debug/macho",
+ "macho.FlagLazyInit": "debug/macho",
+ "macho.FlagNoFixPrebinding": "debug/macho",
+ "macho.FlagNoHeapExecution": "debug/macho",
+ "macho.FlagNoMultiDefs": "debug/macho",
+ "macho.FlagNoReexportedDylibs": "debug/macho",
+ "macho.FlagNoUndefs": "debug/macho",
+ "macho.FlagPIE": "debug/macho",
+ "macho.FlagPrebindable": "debug/macho",
+ "macho.FlagPrebound": "debug/macho",
+ "macho.FlagRootSafe": "debug/macho",
+ "macho.FlagSetuidSafe": "debug/macho",
+ "macho.FlagSplitSegs": "debug/macho",
+ "macho.FlagSubsectionsViaSymbols": "debug/macho",
+ "macho.FlagTwoLevel": "debug/macho",
+ "macho.FlagWeakDefines": "debug/macho",
+ "macho.GENERIC_RELOC_LOCAL_SECTDIFF": "debug/macho",
+ "macho.GENERIC_RELOC_PAIR": "debug/macho",
+ "macho.GENERIC_RELOC_PB_LA_PTR": "debug/macho",
+ "macho.GENERIC_RELOC_SECTDIFF": "debug/macho",
+ "macho.GENERIC_RELOC_TLV": "debug/macho",
+ "macho.GENERIC_RELOC_VANILLA": "debug/macho",
+ "macho.LoadCmdDylib": "debug/macho",
+ "macho.LoadCmdDylinker": "debug/macho",
+ "macho.LoadCmdDysymtab": "debug/macho",
+ "macho.LoadCmdRpath": "debug/macho",
+ "macho.LoadCmdSegment": "debug/macho",
+ "macho.LoadCmdSegment64": "debug/macho",
+ "macho.LoadCmdSymtab": "debug/macho",
+ "macho.LoadCmdThread": "debug/macho",
+ "macho.LoadCmdUnixThread": "debug/macho",
+ "macho.Magic32": "debug/macho",
+ "macho.Magic64": "debug/macho",
+ "macho.MagicFat": "debug/macho",
+ "macho.NewFatFile": "debug/macho",
+ "macho.OpenFat": "debug/macho",
+ "macho.Reloc": "debug/macho",
+ "macho.RelocTypeARM": "debug/macho",
+ "macho.RelocTypeARM64": "debug/macho",
+ "macho.RelocTypeGeneric": "debug/macho",
+ "macho.RelocTypeX86_64": "debug/macho",
+ "macho.Rpath": "debug/macho",
+ "macho.RpathCmd": "debug/macho",
+ "macho.TypeBundle": "debug/macho",
+ "macho.TypeDylib": "debug/macho",
+ "macho.TypeExec": "debug/macho",
+ "macho.TypeObj": "debug/macho",
+ "macho.X86_64_RELOC_BRANCH": "debug/macho",
+ "macho.X86_64_RELOC_GOT": "debug/macho",
+ "macho.X86_64_RELOC_GOT_LOAD": "debug/macho",
+ "macho.X86_64_RELOC_SIGNED": "debug/macho",
+ "macho.X86_64_RELOC_SIGNED_1": "debug/macho",
+ "macho.X86_64_RELOC_SIGNED_2": "debug/macho",
+ "macho.X86_64_RELOC_SIGNED_4": "debug/macho",
+ "macho.X86_64_RELOC_SUBTRACTOR": "debug/macho",
+ "macho.X86_64_RELOC_TLV": "debug/macho",
+ "macho.X86_64_RELOC_UNSIGNED": "debug/macho",
+ "mail.AddressParser": "net/mail",
+ "mail.ParseAddress": "net/mail",
+ "mail.ParseAddressList": "net/mail",
+ "mail.ParseDate": "net/mail",
+ "maphash.Hash": "hash/maphash",
+ "maphash.MakeSeed": "hash/maphash",
+ "maphash.Seed": "hash/maphash",
+ "math.E": "math",
+ "math.Erfcinv": "math",
+ "math.Erfinv": "math",
+ "math.FMA": "math",
+ "math.Ln10": "math",
+ "math.Ln2": "math",
+ "math.Log10E": "math",
+ "math.Log2E": "math",
+ "math.MaxFloat32": "math",
+ "math.MaxFloat64": "math",
+ "math.MaxInt": "math",
+ "math.MaxInt16": "math",
+ "math.MaxInt32": "math",
+ "math.MaxInt64": "math",
+ "math.MaxInt8": "math",
+ "math.MaxUint": "math",
+ "math.MaxUint16": "math",
+ "math.MaxUint32": "math",
+ "math.MaxUint64": "math",
+ "math.MaxUint8": "math",
+ "math.MinInt": "math",
+ "math.MinInt16": "math",
+ "math.MinInt32": "math",
+ "math.MinInt64": "math",
+ "math.MinInt8": "math",
+ "math.Nextafter32": "math",
+ "math.Phi": "math",
+ "math.Pi": "math",
+ "math.Round": "math",
+ "math.RoundToEven": "math",
+ "math.SmallestNonzeroFloat32": "math",
+ "math.SmallestNonzeroFloat64": "math",
+ "math.Sqrt2": "math",
+ "math.SqrtE": "math",
+ "math.SqrtPhi": "math",
+ "math.SqrtPi": "math",
+ "md5.BlockSize": "crypto/md5",
+ "md5.Size": "crypto/md5",
+ "md5.Sum": "crypto/md5",
+ "metrics.All": "runtime/metrics",
+ "metrics.Description": "runtime/metrics",
+ "metrics.Float64Histogram": "runtime/metrics",
+ "metrics.KindBad": "runtime/metrics",
+ "metrics.KindFloat64": "runtime/metrics",
+ "metrics.KindFloat64Histogram": "runtime/metrics",
+ "metrics.KindUint64": "runtime/metrics",
+ "metrics.Read": "runtime/metrics",
+ "metrics.Sample": "runtime/metrics",
+ "metrics.Value": "runtime/metrics",
+ "metrics.ValueKind": "runtime/metrics",
+ "mime.BEncoding": "mime",
+ "mime.ErrInvalidMediaParameter": "mime",
+ "mime.ExtensionsByType": "mime",
+ "mime.QEncoding": "mime",
+ "mime.WordDecoder": "mime",
+ "mime.WordEncoder": "mime",
+ "multipart.ErrMessageTooLarge": "mime/multipart",
+ "net.Buffers": "net",
+ "net.DefaultResolver": "net",
+ "net.Dialer": "net",
+ "net.ErrClosed": "net",
+ "net.FlagBroadcast": "net",
+ "net.FlagLoopback": "net",
+ "net.FlagMulticast": "net",
+ "net.FlagPointToPoint": "net",
+ "net.FlagUp": "net",
+ "net.IPv4len": "net",
+ "net.IPv6len": "net",
+ "net.ListenConfig": "net",
+ "net.ListenUnixgram": "net",
+ "net.LookupNS": "net",
+ "net.NS": "net",
+ "net.Resolver": "net",
+ "os.Chmod": "os",
+ "os.CreateTemp": "os",
+ "os.DevNull": "os",
+ "os.DirEntry": "os",
+ "os.DirFS": "os",
+ "os.ErrClosed": "os",
+ "os.ErrDeadlineExceeded": "os",
+ "os.ErrNoDeadline": "os",
+ "os.ErrProcessDone": "os",
+ "os.Executable": "os",
+ "os.FileInfo": "os",
+ "os.FileMode": "os",
+ "os.IsTimeout": "os",
+ "os.LookupEnv": "os",
+ "os.Lstat": "os",
+ "os.Mkdir": "os",
+ "os.MkdirAll": "os",
+ "os.MkdirTemp": "os",
+ "os.ModeAppend": "os",
+ "os.ModeCharDevice": "os",
+ "os.ModeDevice": "os",
+ "os.ModeDir": "os",
+ "os.ModeExclusive": "os",
+ "os.ModeIrregular": "os",
+ "os.ModeNamedPipe": "os",
+ "os.ModePerm": "os",
+ "os.ModeSetgid": "os",
+ "os.ModeSetuid": "os",
+ "os.ModeSocket": "os",
+ "os.ModeSticky": "os",
+ "os.ModeSymlink": "os",
+ "os.ModeTemporary": "os",
+ "os.ModeType": "os",
+ "os.O_APPEND": "os",
+ "os.O_CREATE": "os",
+ "os.O_EXCL": "os",
+ "os.O_RDONLY": "os",
+ "os.O_RDWR": "os",
+ "os.O_SYNC": "os",
+ "os.O_TRUNC": "os",
+ "os.O_WRONLY": "os",
+ "os.OpenFile": "os",
+ "os.PathError": "os",
+ "os.PathListSeparator": "os",
+ "os.PathSeparator": "os",
+ "os.ReadDir": "os",
+ "os.ReadFile": "os",
+ "os.SEEK_CUR": "os",
+ "os.SEEK_END": "os",
+ "os.SEEK_SET": "os",
+ "os.SameFile": "os",
+ "os.Stat": "os",
+ "os.Unsetenv": "os",
+ "os.UserCacheDir": "os",
+ "os.UserConfigDir": "os",
+ "os.UserHomeDir": "os",
+ "os.WriteFile": "os",
+ "palette.Plan9": "image/color/palette",
+ "palette.WebSafe": "image/color/palette",
+ "parse.ChainNode": "text/template/parse",
+ "parse.CommentNode": "text/template/parse",
+ "parse.DotNode": "text/template/parse",
+ "parse.Mode": "text/template/parse",
+ "parse.NilNode": "text/template/parse",
+ "parse.NodeAction": "text/template/parse",
+ "parse.NodeBool": "text/template/parse",
+ "parse.NodeChain": "text/template/parse",
+ "parse.NodeCommand": "text/template/parse",
+ "parse.NodeComment": "text/template/parse",
+ "parse.NodeDot": "text/template/parse",
+ "parse.NodeField": "text/template/parse",
+ "parse.NodeIdentifier": "text/template/parse",
+ "parse.NodeIf": "text/template/parse",
+ "parse.NodeList": "text/template/parse",
+ "parse.NodeNil": "text/template/parse",
+ "parse.NodeNumber": "text/template/parse",
+ "parse.NodePipe": "text/template/parse",
+ "parse.NodeRange": "text/template/parse",
+ "parse.NodeString": "text/template/parse",
+ "parse.NodeTemplate": "text/template/parse",
+ "parse.NodeText": "text/template/parse",
+ "parse.NodeVariable": "text/template/parse",
+ "parse.NodeWith": "text/template/parse",
+ "parse.ParseComments": "text/template/parse",
+ "parse.Pos": "text/template/parse",
+ "parse.SkipFuncCheck": "text/template/parse",
+ "parser.AllErrors": "go/parser",
+ "parser.DeclarationErrors": "go/parser",
+ "parser.ImportsOnly": "go/parser",
+ "parser.PackageClauseOnly": "go/parser",
+ "parser.ParseComments": "go/parser",
+ "parser.ParseExprFrom": "go/parser",
+ "parser.SkipObjectResolution": "go/parser",
+ "parser.SpuriousErrors": "go/parser",
+ "parser.Trace": "go/parser",
+ "pe.COFFSymbol": "debug/pe",
+ "pe.COFFSymbolSize": "debug/pe",
+ "pe.DataDirectory": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_ARCHITECTURE": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_BASERELOC": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_DEBUG": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_EXCEPTION": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_EXPORT": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_GLOBALPTR": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_IAT": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_IMPORT": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_RESOURCE": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_SECURITY": "debug/pe",
+ "pe.IMAGE_DIRECTORY_ENTRY_TLS": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_APPCONTAINER": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_GUARD_CF": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_NO_BIND": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_NO_ISOLATION": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_NO_SEH": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_NX_COMPAT": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE": "debug/pe",
+ "pe.IMAGE_DLLCHARACTERISTICS_WDM_DRIVER": "debug/pe",
+ "pe.IMAGE_FILE_32BIT_MACHINE": "debug/pe",
+ "pe.IMAGE_FILE_AGGRESIVE_WS_TRIM": "debug/pe",
+ "pe.IMAGE_FILE_BYTES_REVERSED_HI": "debug/pe",
+ "pe.IMAGE_FILE_BYTES_REVERSED_LO": "debug/pe",
+ "pe.IMAGE_FILE_DEBUG_STRIPPED": "debug/pe",
+ "pe.IMAGE_FILE_DLL": "debug/pe",
+ "pe.IMAGE_FILE_EXECUTABLE_IMAGE": "debug/pe",
+ "pe.IMAGE_FILE_LARGE_ADDRESS_AWARE": "debug/pe",
+ "pe.IMAGE_FILE_LINE_NUMS_STRIPPED": "debug/pe",
+ "pe.IMAGE_FILE_LOCAL_SYMS_STRIPPED": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_AM33": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_AMD64": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_ARM": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_ARM64": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_ARMNT": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_EBC": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_I386": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_IA64": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_M32R": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_MIPS16": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_MIPSFPU": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_MIPSFPU16": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_POWERPC": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_POWERPCFP": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_R4000": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_SH3": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_SH3DSP": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_SH4": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_SH5": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_THUMB": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_UNKNOWN": "debug/pe",
+ "pe.IMAGE_FILE_MACHINE_WCEMIPSV2": "debug/pe",
+ "pe.IMAGE_FILE_NET_RUN_FROM_SWAP": "debug/pe",
+ "pe.IMAGE_FILE_RELOCS_STRIPPED": "debug/pe",
+ "pe.IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP": "debug/pe",
+ "pe.IMAGE_FILE_SYSTEM": "debug/pe",
+ "pe.IMAGE_FILE_UP_SYSTEM_ONLY": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_EFI_APPLICATION": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_EFI_ROM": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_NATIVE": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_NATIVE_WINDOWS": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_OS2_CUI": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_POSIX_CUI": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_UNKNOWN": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_WINDOWS_CE_GUI": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_WINDOWS_CUI": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_WINDOWS_GUI": "debug/pe",
+ "pe.IMAGE_SUBSYSTEM_XBOX": "debug/pe",
+ "pe.OptionalHeader32": "debug/pe",
+ "pe.OptionalHeader64": "debug/pe",
+ "pe.Reloc": "debug/pe",
+ "pe.StringTable": "debug/pe",
+ "pe.Symbol": "debug/pe",
+ "pkix.AttributeTypeAndValueSET": "crypto/x509/pkix",
+ "plan9obj.File": "debug/plan9obj",
+ "plan9obj.FileHeader": "debug/plan9obj",
+ "plan9obj.Magic386": "debug/plan9obj",
+ "plan9obj.Magic64": "debug/plan9obj",
+ "plan9obj.MagicAMD64": "debug/plan9obj",
+ "plan9obj.MagicARM": "debug/plan9obj",
+ "plan9obj.NewFile": "debug/plan9obj",
+ "plan9obj.Open": "debug/plan9obj",
+ "plan9obj.Section": "debug/plan9obj",
+ "plan9obj.SectionHeader": "debug/plan9obj",
+ "plan9obj.Sym": "debug/plan9obj",
+ "plugin.Open": "plugin",
+ "plugin.Plugin": "plugin",
+ "plugin.Symbol": "plugin",
+ "png.BestCompression": "image/png",
+ "png.BestSpeed": "image/png",
+ "png.CompressionLevel": "image/png",
+ "png.DefaultCompression": "image/png",
+ "png.Encoder": "image/png",
+ "png.EncoderBuffer": "image/png",
+ "png.EncoderBufferPool": "image/png",
+ "png.NoCompression": "image/png",
+ "pprof.Do": "runtime/pprof",
+ "pprof.ForLabels": "runtime/pprof",
+ "pprof.Label": "runtime/pprof",
+ "pprof.LabelSet": "runtime/pprof",
+ "pprof.Labels": "runtime/pprof",
+ "pprof.SetGoroutineLabels": "runtime/pprof",
+ "pprof.Trace": "net/http/pprof",
+ "pprof.WithLabels": "runtime/pprof",
+ "printer.RawFormat": "go/printer",
+ "printer.SourcePos": "go/printer",
+ "printer.TabIndent": "go/printer",
+ "printer.UseSpaces": "go/printer",
+ "quotedprintable.NewReader": "mime/quotedprintable",
+ "quotedprintable.NewWriter": "mime/quotedprintable",
+ "quotedprintable.Reader": "mime/quotedprintable",
+ "quotedprintable.Writer": "mime/quotedprintable",
+ "rand.Read": "math/rand",
+ "rand.Shuffle": "math/rand",
+ "rand.Source64": "math/rand",
+ "rand.Uint64": "math/rand",
+ "reflect.Array": "reflect",
+ "reflect.ArrayOf": "reflect",
+ "reflect.Bool": "reflect",
+ "reflect.BothDir": "reflect",
+ "reflect.Chan": "reflect",
+ "reflect.ChanOf": "reflect",
+ "reflect.Complex128": "reflect",
+ "reflect.Complex64": "reflect",
+ "reflect.Float32": "reflect",
+ "reflect.Float64": "reflect",
+ "reflect.Func": "reflect",
+ "reflect.FuncOf": "reflect",
+ "reflect.Int": "reflect",
+ "reflect.Int16": "reflect",
+ "reflect.Int32": "reflect",
+ "reflect.Int64": "reflect",
+ "reflect.Int8": "reflect",
+ "reflect.Interface": "reflect",
+ "reflect.Invalid": "reflect",
+ "reflect.MakeFunc": "reflect",
+ "reflect.MakeMapWithSize": "reflect",
+ "reflect.Map": "reflect",
+ "reflect.MapIter": "reflect",
+ "reflect.MapOf": "reflect",
+ "reflect.Ptr": "reflect",
+ "reflect.RecvDir": "reflect",
+ "reflect.Select": "reflect",
+ "reflect.SelectCase": "reflect",
+ "reflect.SelectDefault": "reflect",
+ "reflect.SelectDir": "reflect",
+ "reflect.SelectRecv": "reflect",
+ "reflect.SelectSend": "reflect",
+ "reflect.SendDir": "reflect",
+ "reflect.Slice": "reflect",
+ "reflect.SliceOf": "reflect",
+ "reflect.String": "reflect",
+ "reflect.Struct": "reflect",
+ "reflect.StructOf": "reflect",
+ "reflect.Swapper": "reflect",
+ "reflect.Uint": "reflect",
+ "reflect.Uint16": "reflect",
+ "reflect.Uint32": "reflect",
+ "reflect.Uint64": "reflect",
+ "reflect.Uint8": "reflect",
+ "reflect.Uintptr": "reflect",
+ "reflect.UnsafePointer": "reflect",
+ "reflect.VisibleFields": "reflect",
+ "rpc.DefaultDebugPath": "net/rpc",
+ "rpc.DefaultRPCPath": "net/rpc",
+ "rsa.OAEPOptions": "crypto/rsa",
+ "rsa.PKCS1v15DecryptOptions": "crypto/rsa",
+ "rsa.PSSOptions": "crypto/rsa",
+ "rsa.PSSSaltLengthAuto": "crypto/rsa",
+ "rsa.PSSSaltLengthEqualsHash": "crypto/rsa",
+ "rsa.SignPSS": "crypto/rsa",
+ "rsa.VerifyPSS": "crypto/rsa",
+ "runtime.BlockProfile": "runtime",
+ "runtime.BlockProfileRecord": "runtime",
+ "runtime.CallersFrames": "runtime",
+ "runtime.Compiler": "runtime",
+ "runtime.Frame": "runtime",
+ "runtime.Frames": "runtime",
+ "runtime.GOARCH": "runtime",
+ "runtime.GOOS": "runtime",
+ "runtime.KeepAlive": "runtime",
+ "runtime.MutexProfile": "runtime",
+ "runtime.ReadTrace": "runtime",
+ "runtime.SetBlockProfileRate": "runtime",
+ "runtime.SetCgoTraceback": "runtime",
+ "runtime.SetMutexProfileFraction": "runtime",
+ "runtime.StartTrace": "runtime",
+ "runtime.StopTrace": "runtime",
+ "scanner.Char": "text/scanner",
+ "scanner.Comment": "text/scanner",
+ "scanner.EOF": "text/scanner",
+ "scanner.Float": "text/scanner",
+ "scanner.GoTokens": "text/scanner",
+ "scanner.GoWhitespace": "text/scanner",
+ "scanner.Ident": "text/scanner",
+ "scanner.Int": "text/scanner",
+ "scanner.RawString": "text/scanner",
+ "scanner.ScanChars": "text/scanner",
+ // "scanner.ScanComments" is ambiguous
+ "scanner.ScanFloats": "text/scanner",
+ "scanner.ScanIdents": "text/scanner",
+ "scanner.ScanInts": "text/scanner",
+ "scanner.ScanRawStrings": "text/scanner",
+ "scanner.ScanStrings": "text/scanner",
+ "scanner.SkipComments": "text/scanner",
+ "scanner.String": "text/scanner",
+ "sha1.BlockSize": "crypto/sha1",
+ "sha1.Size": "crypto/sha1",
+ "sha1.Sum": "crypto/sha1",
+ "sha256.BlockSize": "crypto/sha256",
+ "sha256.Size": "crypto/sha256",
+ "sha256.Size224": "crypto/sha256",
+ "sha256.Sum224": "crypto/sha256",
+ "sha256.Sum256": "crypto/sha256",
+ "sha512.BlockSize": "crypto/sha512",
+ "sha512.New512_224": "crypto/sha512",
+ "sha512.New512_256": "crypto/sha512",
+ "sha512.Size": "crypto/sha512",
+ "sha512.Size224": "crypto/sha512",
+ "sha512.Size256": "crypto/sha512",
+ "sha512.Size384": "crypto/sha512",
+ "sha512.Sum384": "crypto/sha512",
+ "sha512.Sum512": "crypto/sha512",
+ "sha512.Sum512_224": "crypto/sha512",
+ "sha512.Sum512_256": "crypto/sha512",
+ "signal.Ignore": "os/signal",
+ "signal.Ignored": "os/signal",
+ "signal.NotifyContext": "os/signal",
+ "signal.Reset": "os/signal",
+ "signal.Stop": "os/signal",
+ "sort.Reverse": "sort",
+ "sort.Slice": "sort",
+ "sort.SliceIsSorted": "sort",
+ "sort.SliceStable": "sort",
+ "sort.Stable": "sort",
+ "sql.ColumnType": "database/sql",
+ "sql.Conn": "database/sql",
+ "sql.DBStats": "database/sql",
+ "sql.Drivers": "database/sql",
+ "sql.ErrConnDone": "database/sql",
+ "sql.IsolationLevel": "database/sql",
+ "sql.LevelDefault": "database/sql",
+ "sql.LevelLinearizable": "database/sql",
+ "sql.LevelReadCommitted": "database/sql",
+ "sql.LevelReadUncommitted": "database/sql",
+ "sql.LevelRepeatableRead": "database/sql",
+ "sql.LevelSerializable": "database/sql",
+ "sql.LevelSnapshot": "database/sql",
+ "sql.LevelWriteCommitted": "database/sql",
+ "sql.Named": "database/sql",
+ "sql.NamedArg": "database/sql",
+ "sql.NullByte": "database/sql",
+ "sql.NullInt16": "database/sql",
+ "sql.NullInt32": "database/sql",
+ "sql.NullTime": "database/sql",
+ "sql.OpenDB": "database/sql",
+ "sql.Out": "database/sql",
+ "sql.TxOptions": "database/sql",
+ "strconv.AppendQuoteRuneToGraphic": "strconv",
+ "strconv.AppendQuoteToGraphic": "strconv",
+ "strconv.FormatComplex": "strconv",
+ "strconv.IntSize": "strconv",
+ "strconv.IsGraphic": "strconv",
+ "strconv.ParseComplex": "strconv",
+ "strconv.QuoteRuneToGraphic": "strconv",
+ "strconv.QuoteToGraphic": "strconv",
+ "strconv.QuotedPrefix": "strconv",
+ "strings.Builder": "strings",
+ "strings.Compare": "strings",
+ "strings.IndexByte": "strings",
+ "strings.LastIndexByte": "strings",
+ "strings.ReplaceAll": "strings",
+ "strings.ToValidUTF8": "strings",
+ "strings.TrimPrefix": "strings",
+ "strings.TrimSuffix": "strings",
+ "subtle.ConstantTimeLessOrEq": "crypto/subtle",
+ "sync.Map": "sync",
+ "sync.Pool": "sync",
+ "syntax.ClassNL": "regexp/syntax",
+ "syntax.DotNL": "regexp/syntax",
+ "syntax.EmptyBeginLine": "regexp/syntax",
+ "syntax.EmptyBeginText": "regexp/syntax",
+ "syntax.EmptyEndLine": "regexp/syntax",
+ "syntax.EmptyEndText": "regexp/syntax",
+ "syntax.EmptyNoWordBoundary": "regexp/syntax",
+ "syntax.EmptyWordBoundary": "regexp/syntax",
+ "syntax.ErrInternalError": "regexp/syntax",
+ "syntax.ErrInvalidCharClass": "regexp/syntax",
+ "syntax.ErrInvalidCharRange": "regexp/syntax",
+ "syntax.ErrInvalidEscape": "regexp/syntax",
+ "syntax.ErrInvalidNamedCapture": "regexp/syntax",
+ "syntax.ErrInvalidPerlOp": "regexp/syntax",
+ "syntax.ErrInvalidRepeatOp": "regexp/syntax",
+ "syntax.ErrInvalidRepeatSize": "regexp/syntax",
+ "syntax.ErrInvalidUTF8": "regexp/syntax",
+ "syntax.ErrMissingBracket": "regexp/syntax",
+ "syntax.ErrMissingParen": "regexp/syntax",
+ "syntax.ErrMissingRepeatArgument": "regexp/syntax",
+ "syntax.ErrTrailingBackslash": "regexp/syntax",
+ "syntax.ErrUnexpectedParen": "regexp/syntax",
+ "syntax.FoldCase": "regexp/syntax",
+ "syntax.InstAlt": "regexp/syntax",
+ "syntax.InstAltMatch": "regexp/syntax",
+ "syntax.InstCapture": "regexp/syntax",
+ "syntax.InstEmptyWidth": "regexp/syntax",
+ "syntax.InstFail": "regexp/syntax",
+ "syntax.InstMatch": "regexp/syntax",
+ "syntax.InstNop": "regexp/syntax",
+ "syntax.InstRune": "regexp/syntax",
+ "syntax.InstRune1": "regexp/syntax",
+ "syntax.InstRuneAny": "regexp/syntax",
+ "syntax.InstRuneAnyNotNL": "regexp/syntax",
+ "syntax.Literal": "regexp/syntax",
+ "syntax.MatchNL": "regexp/syntax",
+ "syntax.NonGreedy": "regexp/syntax",
+ "syntax.OneLine": "regexp/syntax",
+ "syntax.OpAlternate": "regexp/syntax",
+ "syntax.OpAnyChar": "regexp/syntax",
+ "syntax.OpAnyCharNotNL": "regexp/syntax",
+ "syntax.OpBeginLine": "regexp/syntax",
+ "syntax.OpBeginText": "regexp/syntax",
+ "syntax.OpCapture": "regexp/syntax",
+ "syntax.OpCharClass": "regexp/syntax",
+ "syntax.OpConcat": "regexp/syntax",
+ "syntax.OpEmptyMatch": "regexp/syntax",
+ "syntax.OpEndLine": "regexp/syntax",
+ "syntax.OpEndText": "regexp/syntax",
+ "syntax.OpLiteral": "regexp/syntax",
+ "syntax.OpNoMatch": "regexp/syntax",
+ "syntax.OpNoWordBoundary": "regexp/syntax",
+ "syntax.OpPlus": "regexp/syntax",
+ "syntax.OpQuest": "regexp/syntax",
+ "syntax.OpRepeat": "regexp/syntax",
+ "syntax.OpStar": "regexp/syntax",
+ "syntax.OpWordBoundary": "regexp/syntax",
+ "syntax.POSIX": "regexp/syntax",
+ "syntax.Perl": "regexp/syntax",
+ "syntax.PerlX": "regexp/syntax",
+ "syntax.Simple": "regexp/syntax",
+ "syntax.UnicodeGroups": "regexp/syntax",
+ "syntax.WasDollar": "regexp/syntax",
+ "syslog.Dial": "log/syslog",
+ "syslog.LOG_ALERT": "log/syslog",
+ "syslog.LOG_AUTH": "log/syslog",
+ "syslog.LOG_AUTHPRIV": "log/syslog",
+ "syslog.LOG_CRIT": "log/syslog",
+ "syslog.LOG_CRON": "log/syslog",
+ "syslog.LOG_DAEMON": "log/syslog",
+ "syslog.LOG_DEBUG": "log/syslog",
+ "syslog.LOG_EMERG": "log/syslog",
+ "syslog.LOG_ERR": "log/syslog",
+ "syslog.LOG_FTP": "log/syslog",
+ "syslog.LOG_INFO": "log/syslog",
+ "syslog.LOG_KERN": "log/syslog",
+ "syslog.LOG_LOCAL0": "log/syslog",
+ "syslog.LOG_LOCAL1": "log/syslog",
+ "syslog.LOG_LOCAL2": "log/syslog",
+ "syslog.LOG_LOCAL3": "log/syslog",
+ "syslog.LOG_LOCAL4": "log/syslog",
+ "syslog.LOG_LOCAL5": "log/syslog",
+ "syslog.LOG_LOCAL6": "log/syslog",
+ "syslog.LOG_LOCAL7": "log/syslog",
+ "syslog.LOG_LPR": "log/syslog",
+ "syslog.LOG_MAIL": "log/syslog",
+ "syslog.LOG_NEWS": "log/syslog",
+ "syslog.LOG_NOTICE": "log/syslog",
+ "syslog.LOG_SYSLOG": "log/syslog",
+ "syslog.LOG_USER": "log/syslog",
+ "syslog.LOG_UUCP": "log/syslog",
+ "syslog.LOG_WARNING": "log/syslog",
+ "syslog.New": "log/syslog",
+ "syslog.NewLogger": "log/syslog",
+ "syslog.Priority": "log/syslog",
+ "syslog.Writer": "log/syslog",
+ "tabwriter.AlignRight": "text/tabwriter",
+ "tabwriter.Debug": "text/tabwriter",
+ "tabwriter.DiscardEmptyColumns": "text/tabwriter",
+ "tabwriter.Escape": "text/tabwriter",
+ "tabwriter.FilterHTML": "text/tabwriter",
+ "tabwriter.StripEscape": "text/tabwriter",
+ "tabwriter.TabIndent": "text/tabwriter",
+ "tar.FileInfoHeader": "archive/tar",
+ "tar.Format": "archive/tar",
+ "tar.FormatGNU": "archive/tar",
+ "tar.FormatPAX": "archive/tar",
+ "tar.FormatUSTAR": "archive/tar",
+ "tar.FormatUnknown": "archive/tar",
+ "tar.TypeBlock": "archive/tar",
+ "tar.TypeChar": "archive/tar",
+ "tar.TypeCont": "archive/tar",
+ "tar.TypeDir": "archive/tar",
+ "tar.TypeFifo": "archive/tar",
+ "tar.TypeGNULongLink": "archive/tar",
+ "tar.TypeGNULongName": "archive/tar",
+ "tar.TypeGNUSparse": "archive/tar",
+ "tar.TypeLink": "archive/tar",
+ "tar.TypeReg": "archive/tar",
+ "tar.TypeRegA": "archive/tar",
+ "tar.TypeSymlink": "archive/tar",
+ "tar.TypeXGlobalHeader": "archive/tar",
+ "tar.TypeXHeader": "archive/tar",
+ "template.ErrAmbigContext": "html/template",
+ "template.ErrBadHTML": "html/template",
+ "template.ErrBranchEnd": "html/template",
+ "template.ErrEndContext": "html/template",
+ "template.ErrNoSuchTemplate": "html/template",
+ "template.ErrOutputContext": "html/template",
+ "template.ErrPartialCharset": "html/template",
+ "template.ErrPartialEscape": "html/template",
+ "template.ErrPredefinedEscaper": "html/template",
+ "template.ErrRangeLoopReentry": "html/template",
+ "template.ErrSlashAmbig": "html/template",
+ "template.ExecError": "text/template",
+ // "template.IsTrue" is ambiguous
+ "template.OK": "html/template",
+ // "template.ParseFS" is ambiguous
+ "template.Srcset": "html/template",
+ "testing.AllocsPerRun": "testing",
+ "testing.Cover": "testing",
+ "testing.CoverBlock": "testing",
+ "testing.CoverMode": "testing",
+ "testing.Coverage": "testing",
+ "testing.Init": "testing",
+ "testing.M": "testing",
+ "testing.MainStart": "testing",
+ "testing.PB": "testing",
+ "testing.RegisterCover": "testing",
+ "testing.Verbose": "testing",
+ "textproto.TrimBytes": "net/textproto",
+ "textproto.TrimString": "net/textproto",
+ "time.ANSIC": "time",
+ "time.April": "time",
+ "time.August": "time",
+ "time.December": "time",
+ "time.February": "time",
+ "time.Friday": "time",
+ "time.Hour": "time",
+ "time.January": "time",
+ "time.July": "time",
+ "time.June": "time",
+ "time.Kitchen": "time",
+ "time.Layout": "time",
+ "time.LoadLocationFromTZData": "time",
+ "time.March": "time",
+ "time.May": "time",
+ "time.Microsecond": "time",
+ "time.Millisecond": "time",
+ "time.Minute": "time",
+ "time.Monday": "time",
+ "time.Nanosecond": "time",
+ "time.November": "time",
+ "time.October": "time",
+ "time.ParseInLocation": "time",
+ "time.RFC1123": "time",
+ "time.RFC1123Z": "time",
+ "time.RFC3339": "time",
+ "time.RFC3339Nano": "time",
+ "time.RFC822": "time",
+ "time.RFC822Z": "time",
+ "time.RFC850": "time",
+ "time.RubyDate": "time",
+ "time.Saturday": "time",
+ "time.Second": "time",
+ "time.September": "time",
+ "time.Stamp": "time",
+ "time.StampMicro": "time",
+ "time.StampMilli": "time",
+ "time.StampNano": "time",
+ "time.Sunday": "time",
+ "time.Thursday": "time",
+ "time.Tuesday": "time",
+ "time.UnixDate": "time",
+ "time.UnixMicro": "time",
+ "time.UnixMilli": "time",
+ "time.Until": "time",
+ "time.Wednesday": "time",
+ "tls.CertificateRequestInfo": "crypto/tls",
+ "tls.CipherSuite": "crypto/tls",
+ "tls.CipherSuiteName": "crypto/tls",
+ "tls.CipherSuites": "crypto/tls",
+ "tls.ClientHelloInfo": "crypto/tls",
+ "tls.ClientSessionCache": "crypto/tls",
+ "tls.ClientSessionState": "crypto/tls",
+ "tls.CurveID": "crypto/tls",
+ "tls.CurveP256": "crypto/tls",
+ "tls.CurveP384": "crypto/tls",
+ "tls.CurveP521": "crypto/tls",
+ "tls.DialWithDialer": "crypto/tls",
+ "tls.Dialer": "crypto/tls",
+ "tls.ECDSAWithP256AndSHA256": "crypto/tls",
+ "tls.ECDSAWithP384AndSHA384": "crypto/tls",
+ "tls.ECDSAWithP521AndSHA512": "crypto/tls",
+ "tls.ECDSAWithSHA1": "crypto/tls",
+ "tls.Ed25519": "crypto/tls",
+ "tls.InsecureCipherSuites": "crypto/tls",
+ "tls.NewLRUClientSessionCache": "crypto/tls",
+ "tls.NoClientCert": "crypto/tls",
+ "tls.PKCS1WithSHA1": "crypto/tls",
+ "tls.PKCS1WithSHA256": "crypto/tls",
+ "tls.PKCS1WithSHA384": "crypto/tls",
+ "tls.PKCS1WithSHA512": "crypto/tls",
+ "tls.PSSWithSHA256": "crypto/tls",
+ "tls.PSSWithSHA384": "crypto/tls",
+ "tls.PSSWithSHA512": "crypto/tls",
+ "tls.RecordHeaderError": "crypto/tls",
+ "tls.RenegotiateFreelyAsClient": "crypto/tls",
+ "tls.RenegotiateNever": "crypto/tls",
+ "tls.RenegotiateOnceAsClient": "crypto/tls",
+ "tls.RenegotiationSupport": "crypto/tls",
+ "tls.RequestClientCert": "crypto/tls",
+ "tls.RequireAndVerifyClientCert": "crypto/tls",
+ "tls.RequireAnyClientCert": "crypto/tls",
+ "tls.SignatureScheme": "crypto/tls",
+ "tls.TLS_AES_128_GCM_SHA256": "crypto/tls",
+ "tls.TLS_AES_256_GCM_SHA384": "crypto/tls",
+ "tls.TLS_CHACHA20_POLY1305_SHA256": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256": "crypto/tls",
+ "tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256": "crypto/tls",
+ "tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA": "crypto/tls",
+ "tls.TLS_FALLBACK_SCSV": "crypto/tls",
+ "tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA": "crypto/tls",
+ "tls.TLS_RSA_WITH_AES_128_CBC_SHA": "crypto/tls",
+ "tls.TLS_RSA_WITH_AES_128_CBC_SHA256": "crypto/tls",
+ "tls.TLS_RSA_WITH_AES_128_GCM_SHA256": "crypto/tls",
+ "tls.TLS_RSA_WITH_AES_256_CBC_SHA": "crypto/tls",
+ "tls.TLS_RSA_WITH_AES_256_GCM_SHA384": "crypto/tls",
+ "tls.TLS_RSA_WITH_RC4_128_SHA": "crypto/tls",
+ "tls.VerifyClientCertIfGiven": "crypto/tls",
+ "tls.VersionSSL30": "crypto/tls",
+ "tls.VersionTLS10": "crypto/tls",
+ "tls.VersionTLS11": "crypto/tls",
+ "tls.VersionTLS12": "crypto/tls",
+ "tls.VersionTLS13": "crypto/tls",
+ "tls.X25519": "crypto/tls",
+ "token.ADD": "go/token",
+ "token.ADD_ASSIGN": "go/token",
+ "token.AND": "go/token",
+ "token.AND_ASSIGN": "go/token",
+ "token.AND_NOT": "go/token",
+ "token.AND_NOT_ASSIGN": "go/token",
+ "token.ARROW": "go/token",
+ "token.ASSIGN": "go/token",
+ "token.BREAK": "go/token",
+ "token.CASE": "go/token",
+ "token.CHAN": "go/token",
+ "token.CHAR": "go/token",
+ "token.COLON": "go/token",
+ "token.COMMA": "go/token",
+ "token.COMMENT": "go/token",
+ "token.CONST": "go/token",
+ "token.CONTINUE": "go/token",
+ "token.DEC": "go/token",
+ "token.DEFAULT": "go/token",
+ "token.DEFER": "go/token",
+ "token.DEFINE": "go/token",
+ "token.ELLIPSIS": "go/token",
+ "token.ELSE": "go/token",
+ "token.EOF": "go/token",
+ "token.EQL": "go/token",
+ "token.FALLTHROUGH": "go/token",
+ "token.FLOAT": "go/token",
+ "token.FOR": "go/token",
+ "token.FUNC": "go/token",
+ "token.GEQ": "go/token",
+ "token.GO": "go/token",
+ "token.GOTO": "go/token",
+ "token.GTR": "go/token",
+ "token.HighestPrec": "go/token",
+ "token.IDENT": "go/token",
+ "token.IF": "go/token",
+ "token.ILLEGAL": "go/token",
+ "token.IMAG": "go/token",
+ "token.IMPORT": "go/token",
+ "token.INC": "go/token",
+ "token.INT": "go/token",
+ "token.INTERFACE": "go/token",
+ "token.IsExported": "go/token",
+ "token.IsIdentifier": "go/token",
+ "token.IsKeyword": "go/token",
+ "token.LAND": "go/token",
+ "token.LBRACE": "go/token",
+ "token.LBRACK": "go/token",
+ "token.LEQ": "go/token",
+ "token.LOR": "go/token",
+ "token.LPAREN": "go/token",
+ "token.LSS": "go/token",
+ "token.LowestPrec": "go/token",
+ "token.MAP": "go/token",
+ "token.MUL": "go/token",
+ "token.MUL_ASSIGN": "go/token",
+ "token.NEQ": "go/token",
+ "token.NOT": "go/token",
+ "token.NoPos": "go/token",
+ "token.OR": "go/token",
+ "token.OR_ASSIGN": "go/token",
+ "token.PACKAGE": "go/token",
+ "token.PERIOD": "go/token",
+ "token.QUO": "go/token",
+ "token.QUO_ASSIGN": "go/token",
+ "token.RANGE": "go/token",
+ "token.RBRACE": "go/token",
+ "token.RBRACK": "go/token",
+ "token.REM": "go/token",
+ "token.REM_ASSIGN": "go/token",
+ "token.RETURN": "go/token",
+ "token.RPAREN": "go/token",
+ "token.SELECT": "go/token",
+ "token.SEMICOLON": "go/token",
+ "token.SHL": "go/token",
+ "token.SHL_ASSIGN": "go/token",
+ "token.SHR": "go/token",
+ "token.SHR_ASSIGN": "go/token",
+ "token.STRING": "go/token",
+ "token.STRUCT": "go/token",
+ "token.SUB": "go/token",
+ "token.SUB_ASSIGN": "go/token",
+ "token.SWITCH": "go/token",
+ "token.TYPE": "go/token",
+ "token.UnaryPrec": "go/token",
+ "token.VAR": "go/token",
+ "token.XOR": "go/token",
+ "token.XOR_ASSIGN": "go/token",
+ "trace.IsEnabled": "runtime/trace",
+ "trace.Log": "runtime/trace",
+ "trace.Logf": "runtime/trace",
+ "trace.NewTask": "runtime/trace",
+ "trace.Region": "runtime/trace",
+ "trace.Start": "runtime/trace",
+ "trace.StartRegion": "runtime/trace",
+ "trace.Stop": "runtime/trace",
+ "trace.Task": "runtime/trace",
+ "trace.WithRegion": "runtime/trace",
+ "types.Array": "go/types",
+ "types.AssertableTo": "go/types",
+ "types.AssignableTo": "go/types",
+ "types.Basic": "go/types",
+ "types.BasicInfo": "go/types",
+ "types.BasicKind": "go/types",
+ "types.Bool": "go/types",
+ "types.Builtin": "go/types",
+ "types.Byte": "go/types",
+ "types.Chan": "go/types",
+ "types.ChanDir": "go/types",
+ "types.CheckExpr": "go/types",
+ "types.Checker": "go/types",
+ "types.Comparable": "go/types",
+ "types.Complex128": "go/types",
+ "types.Complex64": "go/types",
+ "types.Config": "go/types",
+ "types.Const": "go/types",
+ "types.ConvertibleTo": "go/types",
+ "types.DefPredeclaredTestFuncs": "go/types",
+ "types.Default": "go/types",
+ "types.Error": "go/types",
+ "types.Eval": "go/types",
+ "types.ExprString": "go/types",
+ "types.FieldVal": "go/types",
+ "types.Float32": "go/types",
+ "types.Float64": "go/types",
+ "types.Func": "go/types",
+ "types.Id": "go/types",
+ "types.Identical": "go/types",
+ "types.IdenticalIgnoreTags": "go/types",
+ "types.Implements": "go/types",
+ "types.ImportMode": "go/types",
+ "types.Importer": "go/types",
+ "types.ImporterFrom": "go/types",
+ "types.Info": "go/types",
+ "types.Initializer": "go/types",
+ "types.Int": "go/types",
+ "types.Int16": "go/types",
+ "types.Int32": "go/types",
+ "types.Int64": "go/types",
+ "types.Int8": "go/types",
+ "types.Interface": "go/types",
+ "types.Invalid": "go/types",
+ "types.IsBoolean": "go/types",
+ "types.IsComplex": "go/types",
+ "types.IsConstType": "go/types",
+ "types.IsFloat": "go/types",
+ "types.IsInteger": "go/types",
+ "types.IsInterface": "go/types",
+ "types.IsNumeric": "go/types",
+ "types.IsOrdered": "go/types",
+ "types.IsString": "go/types",
+ "types.IsUnsigned": "go/types",
+ "types.IsUntyped": "go/types",
+ "types.Label": "go/types",
+ "types.LookupFieldOrMethod": "go/types",
+ "types.Map": "go/types",
+ "types.MethodExpr": "go/types",
+ "types.MethodSet": "go/types",
+ "types.MethodVal": "go/types",
+ "types.MissingMethod": "go/types",
+ "types.Named": "go/types",
+ "types.NewArray": "go/types",
+ "types.NewChan": "go/types",
+ "types.NewChecker": "go/types",
+ "types.NewConst": "go/types",
+ "types.NewField": "go/types",
+ "types.NewFunc": "go/types",
+ "types.NewInterface": "go/types",
+ "types.NewInterfaceType": "go/types",
+ "types.NewLabel": "go/types",
+ "types.NewMap": "go/types",
+ "types.NewMethodSet": "go/types",
+ "types.NewNamed": "go/types",
+ "types.NewPackage": "go/types",
+ "types.NewParam": "go/types",
+ "types.NewPkgName": "go/types",
+ "types.NewPointer": "go/types",
+ "types.NewScope": "go/types",
+ "types.NewSignature": "go/types",
+ "types.NewSlice": "go/types",
+ "types.NewStruct": "go/types",
+ "types.NewTuple": "go/types",
+ "types.NewTypeName": "go/types",
+ "types.NewVar": "go/types",
+ "types.Nil": "go/types",
+ "types.ObjectString": "go/types",
+ "types.Package": "go/types",
+ "types.PkgName": "go/types",
+ "types.Pointer": "go/types",
+ "types.Qualifier": "go/types",
+ "types.RecvOnly": "go/types",
+ "types.RelativeTo": "go/types",
+ "types.Rune": "go/types",
+ "types.Scope": "go/types",
+ "types.Selection": "go/types",
+ "types.SelectionKind": "go/types",
+ "types.SelectionString": "go/types",
+ "types.SendOnly": "go/types",
+ "types.SendRecv": "go/types",
+ "types.Signature": "go/types",
+ "types.Sizes": "go/types",
+ "types.SizesFor": "go/types",
+ "types.Slice": "go/types",
+ "types.StdSizes": "go/types",
+ "types.String": "go/types",
+ "types.Struct": "go/types",
+ "types.Tuple": "go/types",
+ "types.Typ": "go/types",
+ "types.Type": "go/types",
+ "types.TypeAndValue": "go/types",
+ "types.TypeName": "go/types",
+ "types.TypeString": "go/types",
+ "types.Uint": "go/types",
+ "types.Uint16": "go/types",
+ "types.Uint32": "go/types",
+ "types.Uint64": "go/types",
+ "types.Uint8": "go/types",
+ "types.Uintptr": "go/types",
+ "types.Universe": "go/types",
+ "types.Unsafe": "go/types",
+ "types.UnsafePointer": "go/types",
+ "types.UntypedBool": "go/types",
+ "types.UntypedComplex": "go/types",
+ "types.UntypedFloat": "go/types",
+ "types.UntypedInt": "go/types",
+ "types.UntypedNil": "go/types",
+ "types.UntypedRune": "go/types",
+ "types.UntypedString": "go/types",
+ "types.Var": "go/types",
+ "types.WriteExpr": "go/types",
+ "types.WriteSignature": "go/types",
+ "types.WriteType": "go/types",
+ "unicode.Adlam": "unicode",
+ "unicode.Ahom": "unicode",
+ "unicode.Anatolian_Hieroglyphs": "unicode",
+ "unicode.Bassa_Vah": "unicode",
+ "unicode.Bhaiksuki": "unicode",
+ "unicode.Caucasian_Albanian": "unicode",
+ "unicode.Chakma": "unicode",
+ "unicode.Chorasmian": "unicode",
+ "unicode.Dives_Akuru": "unicode",
+ "unicode.Dogra": "unicode",
+ "unicode.Duployan": "unicode",
+ "unicode.Elbasan": "unicode",
+ "unicode.Elymaic": "unicode",
+ "unicode.Grantha": "unicode",
+ "unicode.Gunjala_Gondi": "unicode",
+ "unicode.Hanifi_Rohingya": "unicode",
+ "unicode.Hatran": "unicode",
+ "unicode.In": "unicode",
+ "unicode.Khitan_Small_Script": "unicode",
+ "unicode.Khojki": "unicode",
+ "unicode.Khudawadi": "unicode",
+ "unicode.Linear_A": "unicode",
+ "unicode.LowerCase": "unicode",
+ "unicode.Mahajani": "unicode",
+ "unicode.Makasar": "unicode",
+ "unicode.Manichaean": "unicode",
+ "unicode.Marchen": "unicode",
+ "unicode.Masaram_Gondi": "unicode",
+ "unicode.MaxASCII": "unicode",
+ "unicode.MaxCase": "unicode",
+ "unicode.MaxLatin1": "unicode",
+ "unicode.MaxRune": "unicode",
+ "unicode.Medefaidrin": "unicode",
+ "unicode.Mende_Kikakui": "unicode",
+ "unicode.Meroitic_Cursive": "unicode",
+ "unicode.Meroitic_Hieroglyphs": "unicode",
+ "unicode.Miao": "unicode",
+ "unicode.Modi": "unicode",
+ "unicode.Mro": "unicode",
+ "unicode.Multani": "unicode",
+ "unicode.Nabataean": "unicode",
+ "unicode.Nandinagari": "unicode",
+ "unicode.Newa": "unicode",
+ "unicode.Nushu": "unicode",
+ "unicode.Nyiakeng_Puachue_Hmong": "unicode",
+ "unicode.Old_Hungarian": "unicode",
+ "unicode.Old_North_Arabian": "unicode",
+ "unicode.Old_Permic": "unicode",
+ "unicode.Old_Sogdian": "unicode",
+ "unicode.Osage": "unicode",
+ "unicode.Pahawh_Hmong": "unicode",
+ "unicode.Palmyrene": "unicode",
+ "unicode.Pau_Cin_Hau": "unicode",
+ "unicode.Prepended_Concatenation_Mark": "unicode",
+ "unicode.Psalter_Pahlavi": "unicode",
+ "unicode.Regional_Indicator": "unicode",
+ "unicode.ReplacementChar": "unicode",
+ "unicode.Sentence_Terminal": "unicode",
+ "unicode.Sharada": "unicode",
+ "unicode.Siddham": "unicode",
+ "unicode.SignWriting": "unicode",
+ "unicode.Sogdian": "unicode",
+ "unicode.Sora_Sompeng": "unicode",
+ "unicode.Soyombo": "unicode",
+ "unicode.Takri": "unicode",
+ "unicode.Tangut": "unicode",
+ "unicode.Tirhuta": "unicode",
+ "unicode.TitleCase": "unicode",
+ "unicode.UpperCase": "unicode",
+ "unicode.UpperLower": "unicode",
+ "unicode.Version": "unicode",
+ "unicode.Wancho": "unicode",
+ "unicode.Warang_Citi": "unicode",
+ "unicode.Yezidi": "unicode",
+ "unicode.Zanabazar_Square": "unicode",
+ "url.InvalidHostError": "net/url",
+ "url.PathEscape": "net/url",
+ "url.PathUnescape": "net/url",
+ "user.Group": "os/user",
+ "user.LookupGroup": "os/user",
+ "user.LookupGroupId": "os/user",
+ "user.UnknownGroupError": "os/user",
+ "user.UnknownGroupIdError": "os/user",
+ "utf8.MaxRune": "unicode/utf8",
+ "utf8.RuneError": "unicode/utf8",
+ "utf8.RuneSelf": "unicode/utf8",
+ "utf8.UTFMax": "unicode/utf8",
+ "utf8.ValidRune": "unicode/utf8",
+ "x509.CANotAuthorizedForExtKeyUsage": "crypto/x509",
+ "x509.CANotAuthorizedForThisName": "crypto/x509",
+ "x509.CertificateRequest": "crypto/x509",
+ "x509.CreateCertificateRequest": "crypto/x509",
+ "x509.CreateRevocationList": "crypto/x509",
+ "x509.DSA": "crypto/x509",
+ "x509.DSAWithSHA1": "crypto/x509",
+ "x509.DSAWithSHA256": "crypto/x509",
+ "x509.DecryptPEMBlock": "crypto/x509",
+ "x509.ECDSA": "crypto/x509",
+ "x509.ECDSAWithSHA1": "crypto/x509",
+ "x509.ECDSAWithSHA256": "crypto/x509",
+ "x509.ECDSAWithSHA384": "crypto/x509",
+ "x509.ECDSAWithSHA512": "crypto/x509",
+ "x509.Ed25519": "crypto/x509",
+ "x509.EncryptPEMBlock": "crypto/x509",
+ "x509.Expired": "crypto/x509",
+ "x509.ExtKeyUsageAny": "crypto/x509",
+ "x509.ExtKeyUsageClientAuth": "crypto/x509",
+ "x509.ExtKeyUsageCodeSigning": "crypto/x509",
+ "x509.ExtKeyUsageEmailProtection": "crypto/x509",
+ "x509.ExtKeyUsageIPSECEndSystem": "crypto/x509",
+ "x509.ExtKeyUsageIPSECTunnel": "crypto/x509",
+ "x509.ExtKeyUsageIPSECUser": "crypto/x509",
+ "x509.ExtKeyUsageMicrosoftCommercialCodeSigning": "crypto/x509",
+ "x509.ExtKeyUsageMicrosoftKernelCodeSigning": "crypto/x509",
+ "x509.ExtKeyUsageMicrosoftServerGatedCrypto": "crypto/x509",
+ "x509.ExtKeyUsageNetscapeServerGatedCrypto": "crypto/x509",
+ "x509.ExtKeyUsageOCSPSigning": "crypto/x509",
+ "x509.ExtKeyUsageServerAuth": "crypto/x509",
+ "x509.ExtKeyUsageTimeStamping": "crypto/x509",
+ "x509.IncompatibleUsage": "crypto/x509",
+ "x509.IncorrectPasswordError": "crypto/x509",
+ "x509.InsecureAlgorithmError": "crypto/x509",
+ "x509.IsEncryptedPEMBlock": "crypto/x509",
+ "x509.KeyUsageCRLSign": "crypto/x509",
+ "x509.KeyUsageCertSign": "crypto/x509",
+ "x509.KeyUsageContentCommitment": "crypto/x509",
+ "x509.KeyUsageDataEncipherment": "crypto/x509",
+ "x509.KeyUsageDecipherOnly": "crypto/x509",
+ "x509.KeyUsageDigitalSignature": "crypto/x509",
+ "x509.KeyUsageEncipherOnly": "crypto/x509",
+ "x509.KeyUsageKeyAgreement": "crypto/x509",
+ "x509.KeyUsageKeyEncipherment": "crypto/x509",
+ "x509.MD2WithRSA": "crypto/x509",
+ "x509.MD5WithRSA": "crypto/x509",
+ "x509.MarshalECPrivateKey": "crypto/x509",
+ "x509.MarshalPKCS1PublicKey": "crypto/x509",
+ "x509.MarshalPKCS8PrivateKey": "crypto/x509",
+ "x509.NameConstraintsWithoutSANs": "crypto/x509",
+ "x509.NameMismatch": "crypto/x509",
+ "x509.NotAuthorizedToSign": "crypto/x509",
+ "x509.PEMCipher": "crypto/x509",
+ "x509.PEMCipher3DES": "crypto/x509",
+ "x509.PEMCipherAES128": "crypto/x509",
+ "x509.PEMCipherAES192": "crypto/x509",
+ "x509.PEMCipherAES256": "crypto/x509",
+ "x509.PEMCipherDES": "crypto/x509",
+ "x509.ParseCertificateRequest": "crypto/x509",
+ "x509.ParseECPrivateKey": "crypto/x509",
+ "x509.ParsePKCS1PublicKey": "crypto/x509",
+ "x509.PureEd25519": "crypto/x509",
+ "x509.RSA": "crypto/x509",
+ "x509.RevocationList": "crypto/x509",
+ "x509.SHA1WithRSA": "crypto/x509",
+ "x509.SHA256WithRSA": "crypto/x509",
+ "x509.SHA256WithRSAPSS": "crypto/x509",
+ "x509.SHA384WithRSA": "crypto/x509",
+ "x509.SHA384WithRSAPSS": "crypto/x509",
+ "x509.SHA512WithRSA": "crypto/x509",
+ "x509.SHA512WithRSAPSS": "crypto/x509",
+ "x509.SystemCertPool": "crypto/x509",
+ "x509.SystemRootsError": "crypto/x509",
+ "x509.TooManyConstraints": "crypto/x509",
+ "x509.TooManyIntermediates": "crypto/x509",
+ "x509.UnconstrainedName": "crypto/x509",
+ "x509.UnknownPublicKeyAlgorithm": "crypto/x509",
+ "x509.UnknownSignatureAlgorithm": "crypto/x509",
+ "xml.EscapeText": "encoding/xml",
+ "xml.Header": "encoding/xml",
+ "xml.Marshaler": "encoding/xml",
+ "xml.MarshalerAttr": "encoding/xml",
+ "xml.NewTokenDecoder": "encoding/xml",
+ "xml.TokenReader": "encoding/xml",
+ "xml.Unmarshaler": "encoding/xml",
+ "xml.UnmarshalerAttr": "encoding/xml",
+ "zip.Compressor": "archive/zip",
+ "zip.Decompressor": "archive/zip",
+ "zip.Deflate": "archive/zip",
+ "zip.RegisterCompressor": "archive/zip",
+ "zip.RegisterDecompressor": "archive/zip",
+ "zip.Store": "archive/zip",
+ "zlib.BestCompression": "compress/zlib",
+ "zlib.BestSpeed": "compress/zlib",
+ "zlib.DefaultCompression": "compress/zlib",
+ "zlib.HuffmanOnly": "compress/zlib",
+ "zlib.NoCompression": "compress/zlib",
+ "zlib.Resetter": "compress/zlib",
+}
diff --git a/playground/pkg/archive/tar.a.js b/playground/pkg/archive/tar.a.js
index d52d6039..c57451d0 100644
Binary files a/playground/pkg/archive/tar.a.js and b/playground/pkg/archive/tar.a.js differ
diff --git a/playground/pkg/archive/zip.a.js b/playground/pkg/archive/zip.a.js
index 0bfc5523..4ae40972 100644
Binary files a/playground/pkg/archive/zip.a.js and b/playground/pkg/archive/zip.a.js differ
diff --git a/playground/pkg/bufio.a.js b/playground/pkg/bufio.a.js
index 96e98735..51ec2530 100644
Binary files a/playground/pkg/bufio.a.js and b/playground/pkg/bufio.a.js differ
diff --git a/playground/pkg/bytes.a.js b/playground/pkg/bytes.a.js
index 2d68458f..d879db0c 100644
Binary files a/playground/pkg/bytes.a.js and b/playground/pkg/bytes.a.js differ
diff --git a/playground/pkg/compress/bzip2.a.js b/playground/pkg/compress/bzip2.a.js
index 4e40dcf1..33d5add1 100644
Binary files a/playground/pkg/compress/bzip2.a.js and b/playground/pkg/compress/bzip2.a.js differ
diff --git a/playground/pkg/compress/flate.a.js b/playground/pkg/compress/flate.a.js
index 4ff8b753..54d0e788 100644
Binary files a/playground/pkg/compress/flate.a.js and b/playground/pkg/compress/flate.a.js differ
diff --git a/playground/pkg/compress/gzip.a.js b/playground/pkg/compress/gzip.a.js
index d15b5069..aad382a6 100644
Binary files a/playground/pkg/compress/gzip.a.js and b/playground/pkg/compress/gzip.a.js differ
diff --git a/playground/pkg/compress/lzw.a.js b/playground/pkg/compress/lzw.a.js
index 5f64abd7..68ff6922 100644
Binary files a/playground/pkg/compress/lzw.a.js and b/playground/pkg/compress/lzw.a.js differ
diff --git a/playground/pkg/compress/zlib.a.js b/playground/pkg/compress/zlib.a.js
index 2457eb78..5e63248d 100644
Binary files a/playground/pkg/compress/zlib.a.js and b/playground/pkg/compress/zlib.a.js differ
diff --git a/playground/pkg/container/heap.a.js b/playground/pkg/container/heap.a.js
index 47fc458e..fd453b81 100644
Binary files a/playground/pkg/container/heap.a.js and b/playground/pkg/container/heap.a.js differ
diff --git a/playground/pkg/container/list.a.js b/playground/pkg/container/list.a.js
index 51633382..d748fd21 100644
Binary files a/playground/pkg/container/list.a.js and b/playground/pkg/container/list.a.js differ
diff --git a/playground/pkg/container/ring.a.js b/playground/pkg/container/ring.a.js
index d5cd85b8..c61ae3f6 100644
Binary files a/playground/pkg/container/ring.a.js and b/playground/pkg/container/ring.a.js differ
diff --git a/playground/pkg/context.a.js b/playground/pkg/context.a.js
new file mode 100644
index 00000000..72a2ff2f
Binary files /dev/null and b/playground/pkg/context.a.js differ
diff --git a/playground/pkg/crypto.a.js b/playground/pkg/crypto.a.js
index 5953f7e8..3dc0bcf7 100644
Binary files a/playground/pkg/crypto.a.js and b/playground/pkg/crypto.a.js differ
diff --git a/playground/pkg/crypto/aes.a.js b/playground/pkg/crypto/aes.a.js
index c6341f76..4b419d34 100644
Binary files a/playground/pkg/crypto/aes.a.js and b/playground/pkg/crypto/aes.a.js differ
diff --git a/playground/pkg/crypto/cipher.a.js b/playground/pkg/crypto/cipher.a.js
index c7840797..52d6e407 100644
Binary files a/playground/pkg/crypto/cipher.a.js and b/playground/pkg/crypto/cipher.a.js differ
diff --git a/playground/pkg/crypto/des.a.js b/playground/pkg/crypto/des.a.js
index 85469881..21c6b5b0 100644
Binary files a/playground/pkg/crypto/des.a.js and b/playground/pkg/crypto/des.a.js differ
diff --git a/playground/pkg/crypto/dsa.a.js b/playground/pkg/crypto/dsa.a.js
index 3f6e7ad6..a0ac0440 100644
Binary files a/playground/pkg/crypto/dsa.a.js and b/playground/pkg/crypto/dsa.a.js differ
diff --git a/playground/pkg/crypto/ecdsa.a.js b/playground/pkg/crypto/ecdsa.a.js
index 24feb05b..90287af8 100644
Binary files a/playground/pkg/crypto/ecdsa.a.js and b/playground/pkg/crypto/ecdsa.a.js differ
diff --git a/playground/pkg/crypto/ed25519.a.js b/playground/pkg/crypto/ed25519.a.js
new file mode 100644
index 00000000..f3323dfa
Binary files /dev/null and b/playground/pkg/crypto/ed25519.a.js differ
diff --git a/playground/pkg/crypto/ed25519/internal/edwards25519.a.js b/playground/pkg/crypto/ed25519/internal/edwards25519.a.js
new file mode 100644
index 00000000..45162e20
Binary files /dev/null and b/playground/pkg/crypto/ed25519/internal/edwards25519.a.js differ
diff --git a/playground/pkg/crypto/ed25519/internal/edwards25519/field.a.js b/playground/pkg/crypto/ed25519/internal/edwards25519/field.a.js
new file mode 100644
index 00000000..1aac82f1
Binary files /dev/null and b/playground/pkg/crypto/ed25519/internal/edwards25519/field.a.js differ
diff --git a/playground/pkg/crypto/elliptic.a.js b/playground/pkg/crypto/elliptic.a.js
index 5e2a1550..151206f2 100644
Binary files a/playground/pkg/crypto/elliptic.a.js and b/playground/pkg/crypto/elliptic.a.js differ
diff --git a/playground/pkg/crypto/elliptic/internal/fiat.a.js b/playground/pkg/crypto/elliptic/internal/fiat.a.js
new file mode 100644
index 00000000..bd919834
Binary files /dev/null and b/playground/pkg/crypto/elliptic/internal/fiat.a.js differ
diff --git a/playground/pkg/crypto/elliptic/internal/nistec.a.js b/playground/pkg/crypto/elliptic/internal/nistec.a.js
new file mode 100644
index 00000000..e9590007
Binary files /dev/null and b/playground/pkg/crypto/elliptic/internal/nistec.a.js differ
diff --git a/playground/pkg/crypto/hmac.a.js b/playground/pkg/crypto/hmac.a.js
index 0116c2a6..ba25fbf0 100644
Binary files a/playground/pkg/crypto/hmac.a.js and b/playground/pkg/crypto/hmac.a.js differ
diff --git a/playground/pkg/crypto/internal/randutil.a.js b/playground/pkg/crypto/internal/randutil.a.js
new file mode 100644
index 00000000..f58c5628
Binary files /dev/null and b/playground/pkg/crypto/internal/randutil.a.js differ
diff --git a/playground/pkg/crypto/internal/subtle.a.js b/playground/pkg/crypto/internal/subtle.a.js
new file mode 100644
index 00000000..8dbdf17f
Binary files /dev/null and b/playground/pkg/crypto/internal/subtle.a.js differ
diff --git a/playground/pkg/crypto/md5.a.js b/playground/pkg/crypto/md5.a.js
index 36ad6ffe..edf9ee10 100644
Binary files a/playground/pkg/crypto/md5.a.js and b/playground/pkg/crypto/md5.a.js differ
diff --git a/playground/pkg/crypto/rand.a.js b/playground/pkg/crypto/rand.a.js
index 71d30522..bf072eef 100644
Binary files a/playground/pkg/crypto/rand.a.js and b/playground/pkg/crypto/rand.a.js differ
diff --git a/playground/pkg/crypto/rc4.a.js b/playground/pkg/crypto/rc4.a.js
index 11bf98af..a9fe0086 100644
Binary files a/playground/pkg/crypto/rc4.a.js and b/playground/pkg/crypto/rc4.a.js differ
diff --git a/playground/pkg/crypto/rsa.a.js b/playground/pkg/crypto/rsa.a.js
index 40e7e1b7..26f899e0 100644
Binary files a/playground/pkg/crypto/rsa.a.js and b/playground/pkg/crypto/rsa.a.js differ
diff --git a/playground/pkg/crypto/sha1.a.js b/playground/pkg/crypto/sha1.a.js
index 3309e7b0..7e80023a 100644
Binary files a/playground/pkg/crypto/sha1.a.js and b/playground/pkg/crypto/sha1.a.js differ
diff --git a/playground/pkg/crypto/sha256.a.js b/playground/pkg/crypto/sha256.a.js
index 2c988d44..12069bdd 100644
Binary files a/playground/pkg/crypto/sha256.a.js and b/playground/pkg/crypto/sha256.a.js differ
diff --git a/playground/pkg/crypto/sha512.a.js b/playground/pkg/crypto/sha512.a.js
index 16d08f25..84b7fd53 100644
Binary files a/playground/pkg/crypto/sha512.a.js and b/playground/pkg/crypto/sha512.a.js differ
diff --git a/playground/pkg/crypto/subtle.a.js b/playground/pkg/crypto/subtle.a.js
index c85937ae..2a7ea46d 100644
Binary files a/playground/pkg/crypto/subtle.a.js and b/playground/pkg/crypto/subtle.a.js differ
diff --git a/playground/pkg/crypto/tls.a.js b/playground/pkg/crypto/tls.a.js
index 192845ca..a860d2a5 100644
Binary files a/playground/pkg/crypto/tls.a.js and b/playground/pkg/crypto/tls.a.js differ
diff --git a/playground/pkg/crypto/x509.a.js b/playground/pkg/crypto/x509.a.js
index 27441f22..7b55ae70 100644
Binary files a/playground/pkg/crypto/x509.a.js and b/playground/pkg/crypto/x509.a.js differ
diff --git a/playground/pkg/crypto/x509/pkix.a.js b/playground/pkg/crypto/x509/pkix.a.js
index 4c147315..cc32211a 100644
Binary files a/playground/pkg/crypto/x509/pkix.a.js and b/playground/pkg/crypto/x509/pkix.a.js differ
diff --git a/playground/pkg/database/sql.a.js b/playground/pkg/database/sql.a.js
new file mode 100644
index 00000000..6cc67fc4
Binary files /dev/null and b/playground/pkg/database/sql.a.js differ
diff --git a/playground/pkg/database/sql/driver.a.js b/playground/pkg/database/sql/driver.a.js
index 157a7244..ff4ff13b 100644
Binary files a/playground/pkg/database/sql/driver.a.js and b/playground/pkg/database/sql/driver.a.js differ
diff --git a/playground/pkg/debug/buildinfo.a.js b/playground/pkg/debug/buildinfo.a.js
new file mode 100644
index 00000000..eebdc9ec
Binary files /dev/null and b/playground/pkg/debug/buildinfo.a.js differ
diff --git a/playground/pkg/debug/dwarf.a.js b/playground/pkg/debug/dwarf.a.js
index 5f86d4a7..e10b1c7b 100644
Binary files a/playground/pkg/debug/dwarf.a.js and b/playground/pkg/debug/dwarf.a.js differ
diff --git a/playground/pkg/debug/elf.a.js b/playground/pkg/debug/elf.a.js
new file mode 100644
index 00000000..466cbbb1
Binary files /dev/null and b/playground/pkg/debug/elf.a.js differ
diff --git a/playground/pkg/debug/gosym.a.js b/playground/pkg/debug/gosym.a.js
index ff9386d9..21400a92 100644
Binary files a/playground/pkg/debug/gosym.a.js and b/playground/pkg/debug/gosym.a.js differ
diff --git a/playground/pkg/debug/macho.a.js b/playground/pkg/debug/macho.a.js
new file mode 100644
index 00000000..b1b2df7b
Binary files /dev/null and b/playground/pkg/debug/macho.a.js differ
diff --git a/playground/pkg/debug/pe.a.js b/playground/pkg/debug/pe.a.js
index 3aa6c8ec..ee818bec 100644
Binary files a/playground/pkg/debug/pe.a.js and b/playground/pkg/debug/pe.a.js differ
diff --git a/playground/pkg/debug/plan9obj.a.js b/playground/pkg/debug/plan9obj.a.js
new file mode 100644
index 00000000..6a145012
Binary files /dev/null and b/playground/pkg/debug/plan9obj.a.js differ
diff --git a/playground/pkg/embed.a.js b/playground/pkg/embed.a.js
new file mode 100644
index 00000000..fea89b8f
Binary files /dev/null and b/playground/pkg/embed.a.js differ
diff --git a/playground/pkg/encoding.a.js b/playground/pkg/encoding.a.js
index 9b6dea15..78880181 100644
Binary files a/playground/pkg/encoding.a.js and b/playground/pkg/encoding.a.js differ
diff --git a/playground/pkg/encoding/ascii85.a.js b/playground/pkg/encoding/ascii85.a.js
index c5176fa5..f4dd9d81 100644
Binary files a/playground/pkg/encoding/ascii85.a.js and b/playground/pkg/encoding/ascii85.a.js differ
diff --git a/playground/pkg/encoding/asn1.a.js b/playground/pkg/encoding/asn1.a.js
index 66e663aa..fe6e928f 100644
Binary files a/playground/pkg/encoding/asn1.a.js and b/playground/pkg/encoding/asn1.a.js differ
diff --git a/playground/pkg/encoding/base32.a.js b/playground/pkg/encoding/base32.a.js
index ce0c051b..c8d3bd0a 100644
Binary files a/playground/pkg/encoding/base32.a.js and b/playground/pkg/encoding/base32.a.js differ
diff --git a/playground/pkg/encoding/base64.a.js b/playground/pkg/encoding/base64.a.js
index 9ba1ec5f..07a01525 100644
Binary files a/playground/pkg/encoding/base64.a.js and b/playground/pkg/encoding/base64.a.js differ
diff --git a/playground/pkg/encoding/binary.a.js b/playground/pkg/encoding/binary.a.js
index 1e3aa285..c9936a50 100644
Binary files a/playground/pkg/encoding/binary.a.js and b/playground/pkg/encoding/binary.a.js differ
diff --git a/playground/pkg/encoding/csv.a.js b/playground/pkg/encoding/csv.a.js
index 126f5b52..59da578e 100644
Binary files a/playground/pkg/encoding/csv.a.js and b/playground/pkg/encoding/csv.a.js differ
diff --git a/playground/pkg/encoding/gob.a.js b/playground/pkg/encoding/gob.a.js
index ce5719db..e0c37179 100644
Binary files a/playground/pkg/encoding/gob.a.js and b/playground/pkg/encoding/gob.a.js differ
diff --git a/playground/pkg/encoding/hex.a.js b/playground/pkg/encoding/hex.a.js
index 03462b11..fe46897a 100644
Binary files a/playground/pkg/encoding/hex.a.js and b/playground/pkg/encoding/hex.a.js differ
diff --git a/playground/pkg/encoding/json.a.js b/playground/pkg/encoding/json.a.js
index 00983caa..18c8d646 100644
Binary files a/playground/pkg/encoding/json.a.js and b/playground/pkg/encoding/json.a.js differ
diff --git a/playground/pkg/encoding/pem.a.js b/playground/pkg/encoding/pem.a.js
index 6bb64dfa..0e7aa0f2 100644
Binary files a/playground/pkg/encoding/pem.a.js and b/playground/pkg/encoding/pem.a.js differ
diff --git a/playground/pkg/encoding/xml.a.js b/playground/pkg/encoding/xml.a.js
index 517a951f..674396ef 100644
Binary files a/playground/pkg/encoding/xml.a.js and b/playground/pkg/encoding/xml.a.js differ
diff --git a/playground/pkg/errors.a.js b/playground/pkg/errors.a.js
index 67d51737..023cd6ed 100644
Binary files a/playground/pkg/errors.a.js and b/playground/pkg/errors.a.js differ
diff --git a/playground/pkg/expvar.a.js b/playground/pkg/expvar.a.js
new file mode 100644
index 00000000..1a6c48f7
Binary files /dev/null and b/playground/pkg/expvar.a.js differ
diff --git a/playground/pkg/flag.a.js b/playground/pkg/flag.a.js
index 5683d96f..201d0cb0 100644
Binary files a/playground/pkg/flag.a.js and b/playground/pkg/flag.a.js differ
diff --git a/playground/pkg/fmt.a.js b/playground/pkg/fmt.a.js
index 3fe07d53..7fadada8 100644
Binary files a/playground/pkg/fmt.a.js and b/playground/pkg/fmt.a.js differ
diff --git a/playground/pkg/github.com/gopherjs/gopherjs/js.a.js b/playground/pkg/github.com/gopherjs/gopherjs/js.a.js
index 9e375482..33c7c5f5 100644
Binary files a/playground/pkg/github.com/gopherjs/gopherjs/js.a.js and b/playground/pkg/github.com/gopherjs/gopherjs/js.a.js differ
diff --git a/playground/pkg/github.com/gopherjs/gopherjs/nosync.a.js b/playground/pkg/github.com/gopherjs/gopherjs/nosync.a.js
index 97ae8512..c8313c1c 100644
Binary files a/playground/pkg/github.com/gopherjs/gopherjs/nosync.a.js and b/playground/pkg/github.com/gopherjs/gopherjs/nosync.a.js differ
diff --git a/playground/pkg/go/ast.a.js b/playground/pkg/go/ast.a.js
index 3133963a..baae404f 100644
Binary files a/playground/pkg/go/ast.a.js and b/playground/pkg/go/ast.a.js differ
diff --git a/playground/pkg/go/build.a.js b/playground/pkg/go/build.a.js
index 74751e3a..45d0cd8a 100644
Binary files a/playground/pkg/go/build.a.js and b/playground/pkg/go/build.a.js differ
diff --git a/playground/pkg/go/build/constraint.a.js b/playground/pkg/go/build/constraint.a.js
new file mode 100644
index 00000000..a1c27384
Binary files /dev/null and b/playground/pkg/go/build/constraint.a.js differ
diff --git a/playground/pkg/go/constant.a.js b/playground/pkg/go/constant.a.js
new file mode 100644
index 00000000..c66e7379
Binary files /dev/null and b/playground/pkg/go/constant.a.js differ
diff --git a/playground/pkg/go/doc.a.js b/playground/pkg/go/doc.a.js
index dfcc2800..9415ea31 100644
Binary files a/playground/pkg/go/doc.a.js and b/playground/pkg/go/doc.a.js differ
diff --git a/playground/pkg/go/format.a.js b/playground/pkg/go/format.a.js
index 05bf24b7..d9273b0f 100644
Binary files a/playground/pkg/go/format.a.js and b/playground/pkg/go/format.a.js differ
diff --git a/playground/pkg/go/importer.a.js b/playground/pkg/go/importer.a.js
new file mode 100644
index 00000000..3f5247db
Binary files /dev/null and b/playground/pkg/go/importer.a.js differ
diff --git a/playground/pkg/go/internal/gccgoimporter.a.js b/playground/pkg/go/internal/gccgoimporter.a.js
new file mode 100644
index 00000000..44efd40b
Binary files /dev/null and b/playground/pkg/go/internal/gccgoimporter.a.js differ
diff --git a/playground/pkg/go/internal/gcimporter.a.js b/playground/pkg/go/internal/gcimporter.a.js
new file mode 100644
index 00000000..cc944e22
Binary files /dev/null and b/playground/pkg/go/internal/gcimporter.a.js differ
diff --git a/playground/pkg/go/internal/srcimporter.a.js b/playground/pkg/go/internal/srcimporter.a.js
new file mode 100644
index 00000000..9ca60a6e
Binary files /dev/null and b/playground/pkg/go/internal/srcimporter.a.js differ
diff --git a/playground/pkg/go/internal/typeparams.a.js b/playground/pkg/go/internal/typeparams.a.js
new file mode 100644
index 00000000..b13f4584
Binary files /dev/null and b/playground/pkg/go/internal/typeparams.a.js differ
diff --git a/playground/pkg/go/parser.a.js b/playground/pkg/go/parser.a.js
index 7f9036f2..01a3b7b7 100644
Binary files a/playground/pkg/go/parser.a.js and b/playground/pkg/go/parser.a.js differ
diff --git a/playground/pkg/go/printer.a.js b/playground/pkg/go/printer.a.js
index 4066f1b7..04694384 100644
Binary files a/playground/pkg/go/printer.a.js and b/playground/pkg/go/printer.a.js differ
diff --git a/playground/pkg/go/scanner.a.js b/playground/pkg/go/scanner.a.js
index 17884923..fbc22856 100644
Binary files a/playground/pkg/go/scanner.a.js and b/playground/pkg/go/scanner.a.js differ
diff --git a/playground/pkg/go/token.a.js b/playground/pkg/go/token.a.js
index 758f83ed..00317e28 100644
Binary files a/playground/pkg/go/token.a.js and b/playground/pkg/go/token.a.js differ
diff --git a/playground/pkg/go/types.a.js b/playground/pkg/go/types.a.js
new file mode 100644
index 00000000..f6096688
Binary files /dev/null and b/playground/pkg/go/types.a.js differ
diff --git a/playground/pkg/hash.a.js b/playground/pkg/hash.a.js
index c5a7a0ff..f18e8808 100644
Binary files a/playground/pkg/hash.a.js and b/playground/pkg/hash.a.js differ
diff --git a/playground/pkg/hash/adler32.a.js b/playground/pkg/hash/adler32.a.js
index ebb13e5c..547e7ace 100644
Binary files a/playground/pkg/hash/adler32.a.js and b/playground/pkg/hash/adler32.a.js differ
diff --git a/playground/pkg/hash/crc32.a.js b/playground/pkg/hash/crc32.a.js
index e29ffc35..14a444cd 100644
Binary files a/playground/pkg/hash/crc32.a.js and b/playground/pkg/hash/crc32.a.js differ
diff --git a/playground/pkg/hash/crc64.a.js b/playground/pkg/hash/crc64.a.js
index 043a4499..d449281b 100644
Binary files a/playground/pkg/hash/crc64.a.js and b/playground/pkg/hash/crc64.a.js differ
diff --git a/playground/pkg/hash/fnv.a.js b/playground/pkg/hash/fnv.a.js
index d016bf12..497a7327 100644
Binary files a/playground/pkg/hash/fnv.a.js and b/playground/pkg/hash/fnv.a.js differ
diff --git a/playground/pkg/hash/maphash.a.js b/playground/pkg/hash/maphash.a.js
new file mode 100644
index 00000000..b6f4008b
Binary files /dev/null and b/playground/pkg/hash/maphash.a.js differ
diff --git a/playground/pkg/html.a.js b/playground/pkg/html.a.js
index 93c41dc3..6949fd0c 100644
Binary files a/playground/pkg/html.a.js and b/playground/pkg/html.a.js differ
diff --git a/playground/pkg/html/template.a.js b/playground/pkg/html/template.a.js
index ad8c2aec..63aa2ff0 100644
Binary files a/playground/pkg/html/template.a.js and b/playground/pkg/html/template.a.js differ
diff --git a/playground/pkg/image.a.js b/playground/pkg/image.a.js
index d23de88a..5ff35059 100644
Binary files a/playground/pkg/image.a.js and b/playground/pkg/image.a.js differ
diff --git a/playground/pkg/image/color.a.js b/playground/pkg/image/color.a.js
index 47d046de..b68c069e 100644
Binary files a/playground/pkg/image/color.a.js and b/playground/pkg/image/color.a.js differ
diff --git a/playground/pkg/image/color/palette.a.js b/playground/pkg/image/color/palette.a.js
index 35b46133..a8f34e1e 100644
Binary files a/playground/pkg/image/color/palette.a.js and b/playground/pkg/image/color/palette.a.js differ
diff --git a/playground/pkg/image/draw.a.js b/playground/pkg/image/draw.a.js
index fdd8ea0c..62d69fbc 100644
Binary files a/playground/pkg/image/draw.a.js and b/playground/pkg/image/draw.a.js differ
diff --git a/playground/pkg/image/gif.a.js b/playground/pkg/image/gif.a.js
index 694605e0..279ea592 100644
Binary files a/playground/pkg/image/gif.a.js and b/playground/pkg/image/gif.a.js differ
diff --git a/playground/pkg/image/internal/imageutil.a.js b/playground/pkg/image/internal/imageutil.a.js
new file mode 100644
index 00000000..1b00aee6
Binary files /dev/null and b/playground/pkg/image/internal/imageutil.a.js differ
diff --git a/playground/pkg/image/jpeg.a.js b/playground/pkg/image/jpeg.a.js
index 1ff8b40b..2734829c 100644
Binary files a/playground/pkg/image/jpeg.a.js and b/playground/pkg/image/jpeg.a.js differ
diff --git a/playground/pkg/image/png.a.js b/playground/pkg/image/png.a.js
index fd092c98..c0d54a2c 100644
Binary files a/playground/pkg/image/png.a.js and b/playground/pkg/image/png.a.js differ
diff --git a/playground/pkg/index/suffixarray.a.js b/playground/pkg/index/suffixarray.a.js
index 50f33150..8dd9373d 100644
Binary files a/playground/pkg/index/suffixarray.a.js and b/playground/pkg/index/suffixarray.a.js differ
diff --git a/playground/pkg/internal/abi.a.js b/playground/pkg/internal/abi.a.js
new file mode 100644
index 00000000..594cda62
Binary files /dev/null and b/playground/pkg/internal/abi.a.js differ
diff --git a/playground/pkg/internal/buildcfg.a.js b/playground/pkg/internal/buildcfg.a.js
new file mode 100644
index 00000000..06efa923
Binary files /dev/null and b/playground/pkg/internal/buildcfg.a.js differ
diff --git a/playground/pkg/internal/bytealg.a.js b/playground/pkg/internal/bytealg.a.js
new file mode 100644
index 00000000..8ada3c23
Binary files /dev/null and b/playground/pkg/internal/bytealg.a.js differ
diff --git a/playground/pkg/internal/cpu.a.js b/playground/pkg/internal/cpu.a.js
new file mode 100644
index 00000000..aa5cffcf
Binary files /dev/null and b/playground/pkg/internal/cpu.a.js differ
diff --git a/playground/pkg/internal/execabs.a.js b/playground/pkg/internal/execabs.a.js
new file mode 100644
index 00000000..9d52c7b4
Binary files /dev/null and b/playground/pkg/internal/execabs.a.js differ
diff --git a/playground/pkg/internal/fmtsort.a.js b/playground/pkg/internal/fmtsort.a.js
new file mode 100644
index 00000000..c914510d
Binary files /dev/null and b/playground/pkg/internal/fmtsort.a.js differ
diff --git a/playground/pkg/internal/goarch.a.js b/playground/pkg/internal/goarch.a.js
new file mode 100644
index 00000000..1c4cf65f
Binary files /dev/null and b/playground/pkg/internal/goarch.a.js differ
diff --git a/playground/pkg/internal/godebug.a.js b/playground/pkg/internal/godebug.a.js
new file mode 100644
index 00000000..b90cba0b
Binary files /dev/null and b/playground/pkg/internal/godebug.a.js differ
diff --git a/playground/pkg/internal/goexperiment.a.js b/playground/pkg/internal/goexperiment.a.js
new file mode 100644
index 00000000..eca29d3c
Binary files /dev/null and b/playground/pkg/internal/goexperiment.a.js differ
diff --git a/playground/pkg/internal/goroot.a.js b/playground/pkg/internal/goroot.a.js
new file mode 100644
index 00000000..5d99dbf6
Binary files /dev/null and b/playground/pkg/internal/goroot.a.js differ
diff --git a/playground/pkg/internal/goversion.a.js b/playground/pkg/internal/goversion.a.js
new file mode 100644
index 00000000..1099d919
Binary files /dev/null and b/playground/pkg/internal/goversion.a.js differ
diff --git a/playground/pkg/internal/intern.a.js b/playground/pkg/internal/intern.a.js
new file mode 100644
index 00000000..52b17fb0
Binary files /dev/null and b/playground/pkg/internal/intern.a.js differ
diff --git a/playground/pkg/internal/itoa.a.js b/playground/pkg/internal/itoa.a.js
new file mode 100644
index 00000000..8e5595a7
Binary files /dev/null and b/playground/pkg/internal/itoa.a.js differ
diff --git a/playground/pkg/internal/lazyregexp.a.js b/playground/pkg/internal/lazyregexp.a.js
new file mode 100644
index 00000000..7fabbce3
Binary files /dev/null and b/playground/pkg/internal/lazyregexp.a.js differ
diff --git a/playground/pkg/internal/nettrace.a.js b/playground/pkg/internal/nettrace.a.js
new file mode 100644
index 00000000..b30b2952
Binary files /dev/null and b/playground/pkg/internal/nettrace.a.js differ
diff --git a/playground/pkg/internal/oserror.a.js b/playground/pkg/internal/oserror.a.js
new file mode 100644
index 00000000..e5830f4b
Binary files /dev/null and b/playground/pkg/internal/oserror.a.js differ
diff --git a/playground/pkg/internal/poll.a.js b/playground/pkg/internal/poll.a.js
new file mode 100644
index 00000000..dc639759
Binary files /dev/null and b/playground/pkg/internal/poll.a.js differ
diff --git a/playground/pkg/internal/race.a.js b/playground/pkg/internal/race.a.js
new file mode 100644
index 00000000..d9c9a459
Binary files /dev/null and b/playground/pkg/internal/race.a.js differ
diff --git a/playground/pkg/internal/reflectlite.a.js b/playground/pkg/internal/reflectlite.a.js
new file mode 100644
index 00000000..4168b8bb
Binary files /dev/null and b/playground/pkg/internal/reflectlite.a.js differ
diff --git a/playground/pkg/internal/singleflight.a.js b/playground/pkg/internal/singleflight.a.js
new file mode 100644
index 00000000..e3e20d22
Binary files /dev/null and b/playground/pkg/internal/singleflight.a.js differ
diff --git a/playground/pkg/internal/syscall/execenv.a.js b/playground/pkg/internal/syscall/execenv.a.js
new file mode 100644
index 00000000..a7b65e1b
Binary files /dev/null and b/playground/pkg/internal/syscall/execenv.a.js differ
diff --git a/playground/pkg/internal/syscall/unix.a.js b/playground/pkg/internal/syscall/unix.a.js
new file mode 100644
index 00000000..7ee1929a
Binary files /dev/null and b/playground/pkg/internal/syscall/unix.a.js differ
diff --git a/playground/pkg/internal/sysinfo.a.js b/playground/pkg/internal/sysinfo.a.js
new file mode 100644
index 00000000..240ba689
Binary files /dev/null and b/playground/pkg/internal/sysinfo.a.js differ
diff --git a/playground/pkg/internal/testlog.a.js b/playground/pkg/internal/testlog.a.js
new file mode 100644
index 00000000..f2720461
Binary files /dev/null and b/playground/pkg/internal/testlog.a.js differ
diff --git a/playground/pkg/internal/unsafeheader.a.js b/playground/pkg/internal/unsafeheader.a.js
new file mode 100644
index 00000000..06877009
Binary files /dev/null and b/playground/pkg/internal/unsafeheader.a.js differ
diff --git a/playground/pkg/internal/xcoff.a.js b/playground/pkg/internal/xcoff.a.js
new file mode 100644
index 00000000..04ac0e3b
Binary files /dev/null and b/playground/pkg/internal/xcoff.a.js differ
diff --git a/playground/pkg/io.a.js b/playground/pkg/io.a.js
index 67e1b7aa..3a8cbbc9 100644
Binary files a/playground/pkg/io.a.js and b/playground/pkg/io.a.js differ
diff --git a/playground/pkg/io/fs.a.js b/playground/pkg/io/fs.a.js
new file mode 100644
index 00000000..c4157228
Binary files /dev/null and b/playground/pkg/io/fs.a.js differ
diff --git a/playground/pkg/io/ioutil.a.js b/playground/pkg/io/ioutil.a.js
index ae1ae0bf..e288a49c 100644
Binary files a/playground/pkg/io/ioutil.a.js and b/playground/pkg/io/ioutil.a.js differ
diff --git a/playground/pkg/log.a.js b/playground/pkg/log.a.js
index 890c9b4f..df706bd7 100644
Binary files a/playground/pkg/log.a.js and b/playground/pkg/log.a.js differ
diff --git a/playground/pkg/log/syslog.a.js b/playground/pkg/log/syslog.a.js
new file mode 100644
index 00000000..850aafdc
Binary files /dev/null and b/playground/pkg/log/syslog.a.js differ
diff --git a/playground/pkg/math.a.js b/playground/pkg/math.a.js
index 969d3b1b..989153ff 100644
Binary files a/playground/pkg/math.a.js and b/playground/pkg/math.a.js differ
diff --git a/playground/pkg/math/big.a.js b/playground/pkg/math/big.a.js
index 4bf0b885..75b2afeb 100644
Binary files a/playground/pkg/math/big.a.js and b/playground/pkg/math/big.a.js differ
diff --git a/playground/pkg/math/bits.a.js b/playground/pkg/math/bits.a.js
new file mode 100644
index 00000000..bdbf19b0
Binary files /dev/null and b/playground/pkg/math/bits.a.js differ
diff --git a/playground/pkg/math/cmplx.a.js b/playground/pkg/math/cmplx.a.js
index 3fa8c95d..3a2dce52 100644
Binary files a/playground/pkg/math/cmplx.a.js and b/playground/pkg/math/cmplx.a.js differ
diff --git a/playground/pkg/math/rand.a.js b/playground/pkg/math/rand.a.js
index 3450ba11..c2ffdab8 100644
Binary files a/playground/pkg/math/rand.a.js and b/playground/pkg/math/rand.a.js differ
diff --git a/playground/pkg/mime.a.js b/playground/pkg/mime.a.js
index 5b069cfb..03dac9eb 100644
Binary files a/playground/pkg/mime.a.js and b/playground/pkg/mime.a.js differ
diff --git a/playground/pkg/mime/multipart.a.js b/playground/pkg/mime/multipart.a.js
index 60b51826..df9c73eb 100644
Binary files a/playground/pkg/mime/multipart.a.js and b/playground/pkg/mime/multipart.a.js differ
diff --git a/playground/pkg/mime/quotedprintable.a.js b/playground/pkg/mime/quotedprintable.a.js
new file mode 100644
index 00000000..1e77a560
Binary files /dev/null and b/playground/pkg/mime/quotedprintable.a.js differ
diff --git a/playground/pkg/net.a.js b/playground/pkg/net.a.js
index 0bef2696..acea2d50 100644
Binary files a/playground/pkg/net.a.js and b/playground/pkg/net.a.js differ
diff --git a/playground/pkg/net/http.a.js b/playground/pkg/net/http.a.js
index 8799a66d..8b9787ba 100644
Binary files a/playground/pkg/net/http.a.js and b/playground/pkg/net/http.a.js differ
diff --git a/playground/pkg/net/http/cgi.a.js b/playground/pkg/net/http/cgi.a.js
index 07b016bf..7d4d6270 100644
Binary files a/playground/pkg/net/http/cgi.a.js and b/playground/pkg/net/http/cgi.a.js differ
diff --git a/playground/pkg/net/http/cookiejar.a.js b/playground/pkg/net/http/cookiejar.a.js
index 6db139ec..7564ccfe 100644
Binary files a/playground/pkg/net/http/cookiejar.a.js and b/playground/pkg/net/http/cookiejar.a.js differ
diff --git a/playground/pkg/net/http/fcgi.a.js b/playground/pkg/net/http/fcgi.a.js
index a38243bb..fa7f0a46 100644
Binary files a/playground/pkg/net/http/fcgi.a.js and b/playground/pkg/net/http/fcgi.a.js differ
diff --git a/playground/pkg/net/http/httptest.a.js b/playground/pkg/net/http/httptest.a.js
index 25e504ff..f18885c9 100644
Binary files a/playground/pkg/net/http/httptest.a.js and b/playground/pkg/net/http/httptest.a.js differ
diff --git a/playground/pkg/net/http/httptrace.a.js b/playground/pkg/net/http/httptrace.a.js
new file mode 100644
index 00000000..f4b586de
Binary files /dev/null and b/playground/pkg/net/http/httptrace.a.js differ
diff --git a/playground/pkg/net/http/httputil.a.js b/playground/pkg/net/http/httputil.a.js
index ae87e93c..63d50b37 100644
Binary files a/playground/pkg/net/http/httputil.a.js and b/playground/pkg/net/http/httputil.a.js differ
diff --git a/playground/pkg/net/http/internal.a.js b/playground/pkg/net/http/internal.a.js
index f9e94105..09400cbd 100644
Binary files a/playground/pkg/net/http/internal.a.js and b/playground/pkg/net/http/internal.a.js differ
diff --git a/playground/pkg/net/http/internal/ascii.a.js b/playground/pkg/net/http/internal/ascii.a.js
new file mode 100644
index 00000000..8481ec2c
Binary files /dev/null and b/playground/pkg/net/http/internal/ascii.a.js differ
diff --git a/playground/pkg/net/http/internal/testcert.a.js b/playground/pkg/net/http/internal/testcert.a.js
new file mode 100644
index 00000000..729eb04a
Binary files /dev/null and b/playground/pkg/net/http/internal/testcert.a.js differ
diff --git a/playground/pkg/net/mail.a.js b/playground/pkg/net/mail.a.js
index e4f59e0b..a9ab07e5 100644
Binary files a/playground/pkg/net/mail.a.js and b/playground/pkg/net/mail.a.js differ
diff --git a/playground/pkg/net/netip.a.js b/playground/pkg/net/netip.a.js
new file mode 100644
index 00000000..484808de
Binary files /dev/null and b/playground/pkg/net/netip.a.js differ
diff --git a/playground/pkg/net/rpc.a.js b/playground/pkg/net/rpc.a.js
new file mode 100644
index 00000000..a7abeb6d
Binary files /dev/null and b/playground/pkg/net/rpc.a.js differ
diff --git a/playground/pkg/net/rpc/jsonrpc.a.js b/playground/pkg/net/rpc/jsonrpc.a.js
new file mode 100644
index 00000000..f193e6c2
Binary files /dev/null and b/playground/pkg/net/rpc/jsonrpc.a.js differ
diff --git a/playground/pkg/net/smtp.a.js b/playground/pkg/net/smtp.a.js
index 1a649f45..f11cfcfd 100644
Binary files a/playground/pkg/net/smtp.a.js and b/playground/pkg/net/smtp.a.js differ
diff --git a/playground/pkg/net/textproto.a.js b/playground/pkg/net/textproto.a.js
index 748bb920..ae947f30 100644
Binary files a/playground/pkg/net/textproto.a.js and b/playground/pkg/net/textproto.a.js differ
diff --git a/playground/pkg/net/url.a.js b/playground/pkg/net/url.a.js
index e02c8a67..b5645d73 100644
Binary files a/playground/pkg/net/url.a.js and b/playground/pkg/net/url.a.js differ
diff --git a/playground/pkg/os.a.js b/playground/pkg/os.a.js
index d5751834..c8871b17 100644
Binary files a/playground/pkg/os.a.js and b/playground/pkg/os.a.js differ
diff --git a/playground/pkg/os/exec.a.js b/playground/pkg/os/exec.a.js
index 4a6c6e9f..61177872 100644
Binary files a/playground/pkg/os/exec.a.js and b/playground/pkg/os/exec.a.js differ
diff --git a/playground/pkg/os/signal.a.js b/playground/pkg/os/signal.a.js
new file mode 100644
index 00000000..8ebfbdb7
Binary files /dev/null and b/playground/pkg/os/signal.a.js differ
diff --git a/playground/pkg/os/user.a.js b/playground/pkg/os/user.a.js
new file mode 100644
index 00000000..7bab1115
Binary files /dev/null and b/playground/pkg/os/user.a.js differ
diff --git a/playground/pkg/path.a.js b/playground/pkg/path.a.js
index 74f46183..f8d9e879 100644
Binary files a/playground/pkg/path.a.js and b/playground/pkg/path.a.js differ
diff --git a/playground/pkg/path/filepath.a.js b/playground/pkg/path/filepath.a.js
index 184f33f7..37c1a887 100644
Binary files a/playground/pkg/path/filepath.a.js and b/playground/pkg/path/filepath.a.js differ
diff --git a/playground/pkg/reflect.a.js b/playground/pkg/reflect.a.js
index 0901f257..191cd1a5 100644
Binary files a/playground/pkg/reflect.a.js and b/playground/pkg/reflect.a.js differ
diff --git a/playground/pkg/regexp.a.js b/playground/pkg/regexp.a.js
index 58aeeae8..bf82a93f 100644
Binary files a/playground/pkg/regexp.a.js and b/playground/pkg/regexp.a.js differ
diff --git a/playground/pkg/regexp/syntax.a.js b/playground/pkg/regexp/syntax.a.js
index 2a21f7a4..69ba022b 100644
Binary files a/playground/pkg/regexp/syntax.a.js and b/playground/pkg/regexp/syntax.a.js differ
diff --git a/playground/pkg/runtime.a.js b/playground/pkg/runtime.a.js
index 773fac8e..cdecab6f 100644
Binary files a/playground/pkg/runtime.a.js and b/playground/pkg/runtime.a.js differ
diff --git a/playground/pkg/runtime/debug.a.js b/playground/pkg/runtime/debug.a.js
new file mode 100644
index 00000000..e1bf139a
Binary files /dev/null and b/playground/pkg/runtime/debug.a.js differ
diff --git a/playground/pkg/runtime/metrics.a.js b/playground/pkg/runtime/metrics.a.js
new file mode 100644
index 00000000..865d22ea
Binary files /dev/null and b/playground/pkg/runtime/metrics.a.js differ
diff --git a/playground/pkg/runtime/pprof.a.js b/playground/pkg/runtime/pprof.a.js
deleted file mode 100644
index 42f7d043..00000000
Binary files a/playground/pkg/runtime/pprof.a.js and /dev/null differ
diff --git a/playground/pkg/runtime/race.a.js b/playground/pkg/runtime/race.a.js
new file mode 100644
index 00000000..20553017
Binary files /dev/null and b/playground/pkg/runtime/race.a.js differ
diff --git a/playground/pkg/runtime/trace.a.js b/playground/pkg/runtime/trace.a.js
new file mode 100644
index 00000000..21068894
Binary files /dev/null and b/playground/pkg/runtime/trace.a.js differ
diff --git a/playground/pkg/sort.a.js b/playground/pkg/sort.a.js
index 1595234b..c96472e2 100644
Binary files a/playground/pkg/sort.a.js and b/playground/pkg/sort.a.js differ
diff --git a/playground/pkg/strconv.a.js b/playground/pkg/strconv.a.js
index 96016310..5ef88557 100644
Binary files a/playground/pkg/strconv.a.js and b/playground/pkg/strconv.a.js differ
diff --git a/playground/pkg/strings.a.js b/playground/pkg/strings.a.js
index 4a05fc98..0573f51a 100644
Binary files a/playground/pkg/strings.a.js and b/playground/pkg/strings.a.js differ
diff --git a/playground/pkg/sync.a.js b/playground/pkg/sync.a.js
index 23928241..b5f11d51 100644
Binary files a/playground/pkg/sync.a.js and b/playground/pkg/sync.a.js differ
diff --git a/playground/pkg/sync/atomic.a.js b/playground/pkg/sync/atomic.a.js
index 6066ad83..9a825a9f 100644
Binary files a/playground/pkg/sync/atomic.a.js and b/playground/pkg/sync/atomic.a.js differ
diff --git a/playground/pkg/syscall.a.js b/playground/pkg/syscall.a.js
index 80c1390b..41211b20 100644
Binary files a/playground/pkg/syscall.a.js and b/playground/pkg/syscall.a.js differ
diff --git a/playground/pkg/syscall/js.a.js b/playground/pkg/syscall/js.a.js
new file mode 100644
index 00000000..3af1bd9e
Binary files /dev/null and b/playground/pkg/syscall/js.a.js differ
diff --git a/playground/pkg/testing.a.js b/playground/pkg/testing.a.js
index 883db09d..4c549141 100644
Binary files a/playground/pkg/testing.a.js and b/playground/pkg/testing.a.js differ
diff --git a/playground/pkg/testing/fstest.a.js b/playground/pkg/testing/fstest.a.js
new file mode 100644
index 00000000..5525f277
Binary files /dev/null and b/playground/pkg/testing/fstest.a.js differ
diff --git a/playground/pkg/testing/iotest.a.js b/playground/pkg/testing/iotest.a.js
index 24db5145..8f3d4e5c 100644
Binary files a/playground/pkg/testing/iotest.a.js and b/playground/pkg/testing/iotest.a.js differ
diff --git a/playground/pkg/testing/quick.a.js b/playground/pkg/testing/quick.a.js
index e8b10712..42de0fce 100644
Binary files a/playground/pkg/testing/quick.a.js and b/playground/pkg/testing/quick.a.js differ
diff --git a/playground/pkg/text/scanner.a.js b/playground/pkg/text/scanner.a.js
index 136e4eae..b0058914 100644
Binary files a/playground/pkg/text/scanner.a.js and b/playground/pkg/text/scanner.a.js differ
diff --git a/playground/pkg/text/tabwriter.a.js b/playground/pkg/text/tabwriter.a.js
index 9f3f2c19..4421e7a6 100644
Binary files a/playground/pkg/text/tabwriter.a.js and b/playground/pkg/text/tabwriter.a.js differ
diff --git a/playground/pkg/text/template.a.js b/playground/pkg/text/template.a.js
index 3dd3e383..721d35db 100644
Binary files a/playground/pkg/text/template.a.js and b/playground/pkg/text/template.a.js differ
diff --git a/playground/pkg/text/template/parse.a.js b/playground/pkg/text/template/parse.a.js
index 3d4a3033..b0f43ffb 100644
Binary files a/playground/pkg/text/template/parse.a.js and b/playground/pkg/text/template/parse.a.js differ
diff --git a/playground/pkg/time.a.js b/playground/pkg/time.a.js
index e67583b4..a1a61946 100644
Binary files a/playground/pkg/time.a.js and b/playground/pkg/time.a.js differ
diff --git a/playground/pkg/time/tzdata.a.js b/playground/pkg/time/tzdata.a.js
new file mode 100644
index 00000000..f96b2d11
Binary files /dev/null and b/playground/pkg/time/tzdata.a.js differ
diff --git a/playground/pkg/unicode.a.js b/playground/pkg/unicode.a.js
index ef7e042b..2a5fa4d6 100644
Binary files a/playground/pkg/unicode.a.js and b/playground/pkg/unicode.a.js differ
diff --git a/playground/pkg/unicode/utf16.a.js b/playground/pkg/unicode/utf16.a.js
index 8610f245..874473fb 100644
Binary files a/playground/pkg/unicode/utf16.a.js and b/playground/pkg/unicode/utf16.a.js differ
diff --git a/playground/pkg/unicode/utf8.a.js b/playground/pkg/unicode/utf8.a.js
index 2df9b94e..d30b8937 100644
Binary files a/playground/pkg/unicode/utf8.a.js and b/playground/pkg/unicode/utf8.a.js differ
diff --git a/playground/pkg/unsafe.a.js b/playground/pkg/unsafe.a.js
new file mode 100644
index 00000000..d77f65c4
Binary files /dev/null and b/playground/pkg/unsafe.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/chacha20.a.js b/playground/pkg/vendor/golang.org/x/crypto/chacha20.a.js
new file mode 100644
index 00000000..25593ae6
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/chacha20.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/chacha20poly1305.a.js b/playground/pkg/vendor/golang.org/x/crypto/chacha20poly1305.a.js
new file mode 100644
index 00000000..3068478a
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/chacha20poly1305.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/cryptobyte.a.js b/playground/pkg/vendor/golang.org/x/crypto/cryptobyte.a.js
new file mode 100644
index 00000000..4f41fc12
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/cryptobyte.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/cryptobyte/asn1.a.js b/playground/pkg/vendor/golang.org/x/crypto/cryptobyte/asn1.a.js
new file mode 100644
index 00000000..c5a3ca42
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/cryptobyte/asn1.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/curve25519.a.js b/playground/pkg/vendor/golang.org/x/crypto/curve25519.a.js
new file mode 100644
index 00000000..6d2ac32c
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/curve25519.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/curve25519/internal/field.a.js b/playground/pkg/vendor/golang.org/x/crypto/curve25519/internal/field.a.js
new file mode 100644
index 00000000..f6cfc281
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/curve25519/internal/field.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/hkdf.a.js b/playground/pkg/vendor/golang.org/x/crypto/hkdf.a.js
new file mode 100644
index 00000000..7daa3e0f
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/hkdf.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/internal/poly1305.a.js b/playground/pkg/vendor/golang.org/x/crypto/internal/poly1305.a.js
new file mode 100644
index 00000000..2b641fb3
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/internal/poly1305.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/crypto/internal/subtle.a.js b/playground/pkg/vendor/golang.org/x/crypto/internal/subtle.a.js
new file mode 100644
index 00000000..6c332b98
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/crypto/internal/subtle.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/net/dns/dnsmessage.a.js b/playground/pkg/vendor/golang.org/x/net/dns/dnsmessage.a.js
new file mode 100644
index 00000000..c57cc382
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/net/dns/dnsmessage.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/net/http/httpguts.a.js b/playground/pkg/vendor/golang.org/x/net/http/httpguts.a.js
new file mode 100644
index 00000000..6f39213d
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/net/http/httpguts.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/net/http/httpproxy.a.js b/playground/pkg/vendor/golang.org/x/net/http/httpproxy.a.js
new file mode 100644
index 00000000..3d396249
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/net/http/httpproxy.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/net/http2/hpack.a.js b/playground/pkg/vendor/golang.org/x/net/http2/hpack.a.js
new file mode 100644
index 00000000..a4583a97
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/net/http2/hpack.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/net/idna.a.js b/playground/pkg/vendor/golang.org/x/net/idna.a.js
new file mode 100644
index 00000000..87c76940
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/net/idna.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/text/secure/bidirule.a.js b/playground/pkg/vendor/golang.org/x/text/secure/bidirule.a.js
new file mode 100644
index 00000000..f45b3f41
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/text/secure/bidirule.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/text/transform.a.js b/playground/pkg/vendor/golang.org/x/text/transform.a.js
new file mode 100644
index 00000000..ed7719a1
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/text/transform.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/text/unicode/bidi.a.js b/playground/pkg/vendor/golang.org/x/text/unicode/bidi.a.js
new file mode 100644
index 00000000..de22c165
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/text/unicode/bidi.a.js differ
diff --git a/playground/pkg/vendor/golang.org/x/text/unicode/norm.a.js b/playground/pkg/vendor/golang.org/x/text/unicode/norm.a.js
new file mode 100644
index 00000000..68e91e7c
Binary files /dev/null and b/playground/pkg/vendor/golang.org/x/text/unicode/norm.a.js differ
diff --git a/playground/playground.go b/playground/playground.go
index fc338622..a473e12b 100644
--- a/playground/playground.go
+++ b/playground/playground.go
@@ -7,9 +7,12 @@ import (
"go/parser"
"go/scanner"
"go/token"
+ "go/types"
+ "runtime"
"strings"
"time"
+ "github.com/gopherjs/gopherjs.github.io/playground/internal/imports"
"github.com/gopherjs/gopherjs/compiler"
"github.com/gopherjs/gopherjs/js"
"github.com/neelance/go-angularjs"
@@ -21,7 +24,7 @@ type Line map[string]string
var output []Line
-const snippetStoreHost = "snippets.gopherjs.org"
+const snippetStoreHost = "https://snippets.gopherjs.org"
func main() {
var location = dom.GetWindow().Top().Location() // We might be inside an iframe, but want to use the location of topmost window.
@@ -34,7 +37,7 @@ func main() {
if strings.HasPrefix(location.Hash, "#/") {
id := location.Hash[2:]
- req := xhr.NewRequest("GET", "http://"+snippetStoreHost+"/p/"+id)
+ req := xhr.NewRequest("GET", snippetStoreHost+"/p/"+id)
req.ResponseType = xhr.ArrayBuffer
go func() {
err := req.Send(nil)
@@ -52,21 +55,26 @@ func main() {
})
}()
} else {
- scope.Set("code", "package main\n\nimport (\n\t\"fmt\"\n\t\"github.com/gopherjs/gopherjs/js\"\n)\n\nfunc main() {\n\tfmt.Println(\"Hello, playground\")\n\tjs.Global.Call(\"alert\", \"Hello, JavaScript\")\n\tprintln(\"Hello, JS console\")\n}\n")
+ scope.Set("code", "package main\n\nimport (\n\t\"fmt\"\n\t\"syscall/js\"\n)\n\nfunc main() {\n\tfmt.Println(\"Hello, playground\")\n\tjs.Global().Call(\"alert\", \"Hello, JavaScript\")\n\tprintln(\"Hello, JS console\")\n}\n")
close(codeReady)
}
+ scope.Set("imports", true)
scope.Set("shareUrl", "")
scope.Set("showShareUrl", false)
+ scope.Set("version", compiler.Version)
packages := make(map[string]*compiler.Archive)
var pkgsToLoad map[string]struct{}
- importContext := compiler.NewImportContext(func(path string) (*compiler.Archive, error) {
- if pkg, found := packages[path]; found {
- return pkg, nil
- }
- pkgsToLoad[path] = struct{}{}
- return &compiler.Archive{}, nil
- })
+ importContext := &compiler.ImportContext{
+ Packages: make(map[string]*types.Package),
+ Import: func(path string) (*compiler.Archive, error) {
+ if pkg, found := packages[path]; found {
+ return pkg, nil
+ }
+ pkgsToLoad[path] = struct{}{}
+ return &compiler.Archive{}, nil
+ },
+ }
fileSet := token.NewFileSet()
pkgsReceived := 0
@@ -166,13 +174,19 @@ func main() {
}
data := js.Global.Get("Uint8Array").New(req.Response).Interface().([]byte)
- packages[path], err = compiler.ReadArchive(path+".a", path, bytes.NewReader(data), importContext.Packages)
+ packages[path], err = compiler.ReadArchive(path+".a", bytes.NewReader(data))
if err != nil {
scope.Apply(func() {
scope.Set("output", []Line{Line{"type": "err", "content": err.Error()}})
})
return
}
+ if err := packages[path].RegisterTypes(importContext.Packages); err != nil {
+ scope.Apply(func() {
+ scope.Set("output", []Line{Line{"type": "err", "content": err.Error()}})
+ })
+ return
+ }
pkgsReceived++
if pkgsReceived == len(pkgsToLoad) {
run(loadOnly)
@@ -188,7 +202,7 @@ func main() {
jsCode := bytes.NewBuffer(nil)
jsCode.WriteString("try{\n")
- compiler.WriteProgramCode(allPkgs, &compiler.SourceMapFilter{Writer: jsCode})
+ compiler.WriteProgramCode(allPkgs, &compiler.SourceMapFilter{Writer: jsCode}, runtime.Version())
jsCode.WriteString("} catch (err) {\ngoPanicHandler(err.message);\n}\n")
js.Global.Set("$checkForDeadlock", true)
js.Global.Call("eval", js.InternalObject(jsCode.String()))
@@ -200,7 +214,15 @@ func main() {
}()
scope.Set("format", func() {
- out, err := format.Source([]byte(scope.Get("code").String()))
+ code := []byte(scope.Get("code").String())
+ var out []byte
+ var err error
+ switch scope.Get("imports").Bool() {
+ case true:
+ out, err = imports.Process("prog.go", code, nil)
+ case false:
+ out, err = format.Source(code)
+ }
if err != nil {
scope.Set("output", []Line{Line{"type": "err", "content": err.Error()}})
return
@@ -210,7 +232,7 @@ func main() {
})
scope.Set("share", func() {
- req := xhr.NewRequest("POST", "http://"+snippetStoreHost+"/share")
+ req := xhr.NewRequest("POST", snippetStoreHost+"/share")
req.ResponseType = xhr.ArrayBuffer
go func() {
err := req.Send([]byte(scope.Get("code").String())) // Send as binary.
@@ -246,7 +268,7 @@ func main() {
if strings.HasPrefix(location.Hash, "#/") {
id := location.Hash[2:]
- req := xhr.NewRequest("GET", "http://"+snippetStoreHost+"/p/"+id)
+ req := xhr.NewRequest("GET", snippetStoreHost+"/p/"+id)
req.ResponseType = xhr.ArrayBuffer
go func() {
err := req.Send(nil)
diff --git a/playground/playground.js b/playground/playground.js
index d9da09dd..f69fde61 100644
--- a/playground/playground.js
+++ b/playground/playground.js
@@ -1,75005 +1,115 @@
"use strict";
(function() {
-Error.stackTraceLimit = Infinity;
-
-var $global, $module;
-if (typeof window !== "undefined") { /* web page */
- $global = window;
-} else if (typeof self !== "undefined") { /* web worker */
- $global = self;
-} else if (typeof global !== "undefined") { /* Node.js */
- $global = global;
- $global.require = require;
-} else { /* others (e.g. Nashorn) */
- $global = this;
-}
-
-if ($global === undefined || $global.Array === undefined) {
- throw new Error("no global object found");
-}
-if (typeof module !== "undefined") {
- $module = module;
-}
-
-var $packages = {}, $idCounter = 0;
-var $keys = function(m) { return m ? Object.keys(m) : []; };
-var $min = Math.min;
-var $mod = function(x, y) { return x % y; };
-var $parseInt = parseInt;
-var $parseFloat = function(f) {
- if (f !== undefined && f !== null && f.constructor === Number) {
- return f;
- }
- return parseFloat(f);
-};
-var $flushConsole = function() {};
-var $throwRuntimeError; /* set by package "runtime" */
-var $throwNilPointerError = function() { $throwRuntimeError("invalid memory address or nil pointer dereference"); };
-var $call = function(fn, rcvr, args) { return fn.apply(rcvr, args); };
-var $makeFunc = function(fn) { return function() { return fn(new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))); } };
-
-var $froundBuf = new Float32Array(1);
-var $fround = Math.fround || function(f) { $froundBuf[0] = f; return $froundBuf[0]; };
-
-var $mapArray = function(array, f) {
- var newArray = new array.constructor(array.length);
- for (var i = 0; i < array.length; i++) {
- newArray[i] = f(array[i]);
- }
- return newArray;
-};
-
-var $methodVal = function(recv, name) {
- var vals = recv.$methodVals || {};
- recv.$methodVals = vals; /* noop for primitives */
- var f = vals[name];
- if (f !== undefined) {
- return f;
- }
- var method = recv[name];
- f = function() {
- $stackDepthOffset--;
- try {
- return method.apply(recv, arguments);
- } finally {
- $stackDepthOffset++;
- }
- };
- vals[name] = f;
- return f;
-};
-
-var $methodExpr = function(method) {
- if (method.$expr === undefined) {
- method.$expr = function() {
- $stackDepthOffset--;
- try {
- return Function.call.apply(method, arguments);
- } finally {
- $stackDepthOffset++;
- }
- };
- }
- return method.$expr;
-};
-
-var $subslice = function(slice, low, high, max) {
- if (low < 0 || high < low || max < high || high > slice.$capacity || max > slice.$capacity) {
- $throwRuntimeError("slice bounds out of range");
- }
- var s = new slice.constructor(slice.$array);
- s.$offset = slice.$offset + low;
- s.$length = slice.$length - low;
- s.$capacity = slice.$capacity - low;
- if (high !== undefined) {
- s.$length = high - low;
- }
- if (max !== undefined) {
- s.$capacity = max - low;
- }
- return s;
-};
-
-var $sliceToArray = function(slice) {
- if (slice.$length === 0) {
- return [];
- }
- if (slice.$array.constructor !== Array) {
- return slice.$array.subarray(slice.$offset, slice.$offset + slice.$length);
- }
- return slice.$array.slice(slice.$offset, slice.$offset + slice.$length);
-};
-
-var $decodeRune = function(str, pos) {
- var c0 = str.charCodeAt(pos);
-
- if (c0 < 0x80) {
- return [c0, 1];
- }
-
- if (c0 !== c0 || c0 < 0xC0) {
- return [0xFFFD, 1];
- }
-
- var c1 = str.charCodeAt(pos + 1);
- if (c1 !== c1 || c1 < 0x80 || 0xC0 <= c1) {
- return [0xFFFD, 1];
- }
-
- if (c0 < 0xE0) {
- var r = (c0 & 0x1F) << 6 | (c1 & 0x3F);
- if (r <= 0x7F) {
- return [0xFFFD, 1];
- }
- return [r, 2];
- }
-
- var c2 = str.charCodeAt(pos + 2);
- if (c2 !== c2 || c2 < 0x80 || 0xC0 <= c2) {
- return [0xFFFD, 1];
- }
-
- if (c0 < 0xF0) {
- var r = (c0 & 0x0F) << 12 | (c1 & 0x3F) << 6 | (c2 & 0x3F);
- if (r <= 0x7FF) {
- return [0xFFFD, 1];
- }
- if (0xD800 <= r && r <= 0xDFFF) {
- return [0xFFFD, 1];
- }
- return [r, 3];
- }
-
- var c3 = str.charCodeAt(pos + 3);
- if (c3 !== c3 || c3 < 0x80 || 0xC0 <= c3) {
- return [0xFFFD, 1];
- }
-
- if (c0 < 0xF8) {
- var r = (c0 & 0x07) << 18 | (c1 & 0x3F) << 12 | (c2 & 0x3F) << 6 | (c3 & 0x3F);
- if (r <= 0xFFFF || 0x10FFFF < r) {
- return [0xFFFD, 1];
- }
- return [r, 4];
- }
-
- return [0xFFFD, 1];
-};
-
-var $encodeRune = function(r) {
- if (r < 0 || r > 0x10FFFF || (0xD800 <= r && r <= 0xDFFF)) {
- r = 0xFFFD;
- }
- if (r <= 0x7F) {
- return String.fromCharCode(r);
- }
- if (r <= 0x7FF) {
- return String.fromCharCode(0xC0 | r >> 6, 0x80 | (r & 0x3F));
- }
- if (r <= 0xFFFF) {
- return String.fromCharCode(0xE0 | r >> 12, 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F));
- }
- return String.fromCharCode(0xF0 | r >> 18, 0x80 | (r >> 12 & 0x3F), 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F));
-};
-
-var $stringToBytes = function(str) {
- var array = new Uint8Array(str.length);
- for (var i = 0; i < str.length; i++) {
- array[i] = str.charCodeAt(i);
- }
- return array;
-};
-
-var $bytesToString = function(slice) {
- if (slice.$length === 0) {
- return "";
- }
- var str = "";
- for (var i = 0; i < slice.$length; i += 10000) {
- str += String.fromCharCode.apply(undefined, slice.$array.subarray(slice.$offset + i, slice.$offset + Math.min(slice.$length, i + 10000)));
- }
- return str;
-};
-
-var $stringToRunes = function(str) {
- var array = new Int32Array(str.length);
- var rune, j = 0;
- for (var i = 0; i < str.length; i += rune[1], j++) {
- rune = $decodeRune(str, i);
- array[j] = rune[0];
- }
- return array.subarray(0, j);
-};
-
-var $runesToString = function(slice) {
- if (slice.$length === 0) {
- return "";
- }
- var str = "";
- for (var i = 0; i < slice.$length; i++) {
- str += $encodeRune(slice.$array[slice.$offset + i]);
- }
- return str;
-};
-
-var $copyString = function(dst, src) {
- var n = Math.min(src.length, dst.$length);
- for (var i = 0; i < n; i++) {
- dst.$array[dst.$offset + i] = src.charCodeAt(i);
- }
- return n;
-};
-
-var $copySlice = function(dst, src) {
- var n = Math.min(src.$length, dst.$length);
- $internalCopy(dst.$array, src.$array, dst.$offset, src.$offset, n, dst.constructor.elem);
- return n;
-};
-
-var $copy = function(dst, src, typ) {
- switch (typ.kind) {
- case $kindArray:
- $internalCopy(dst, src, 0, 0, src.length, typ.elem);
- break;
- case $kindStruct:
- for (var i = 0; i < typ.fields.length; i++) {
- var f = typ.fields[i];
- switch (f.typ.kind) {
- case $kindArray:
- case $kindStruct:
- $copy(dst[f.prop], src[f.prop], f.typ);
- continue;
- default:
- dst[f.prop] = src[f.prop];
- continue;
- }
- }
- break;
- }
-};
-
-var $internalCopy = function(dst, src, dstOffset, srcOffset, n, elem) {
- if (n === 0 || (dst === src && dstOffset === srcOffset)) {
- return;
- }
-
- if (src.subarray) {
- dst.set(src.subarray(srcOffset, srcOffset + n), dstOffset);
- return;
- }
-
- switch (elem.kind) {
- case $kindArray:
- case $kindStruct:
- if (dst === src && dstOffset > srcOffset) {
- for (var i = n - 1; i >= 0; i--) {
- $copy(dst[dstOffset + i], src[srcOffset + i], elem);
- }
- return;
- }
- for (var i = 0; i < n; i++) {
- $copy(dst[dstOffset + i], src[srcOffset + i], elem);
- }
- return;
- }
-
- if (dst === src && dstOffset > srcOffset) {
- for (var i = n - 1; i >= 0; i--) {
- dst[dstOffset + i] = src[srcOffset + i];
- }
- return;
- }
- for (var i = 0; i < n; i++) {
- dst[dstOffset + i] = src[srcOffset + i];
- }
-};
-
-var $clone = function(src, type) {
- var clone = type.zero();
- $copy(clone, src, type);
- return clone;
-};
-
-var $pointerOfStructConversion = function(obj, type) {
- if(obj.$proxies === undefined) {
- obj.$proxies = {};
- obj.$proxies[obj.constructor.string] = obj;
- }
- var proxy = obj.$proxies[type.string];
- if (proxy === undefined) {
- var properties = {};
- for (var i = 0; i < type.elem.fields.length; i++) {
- (function(fieldProp) {
- properties[fieldProp] = {
- get: function() { return obj[fieldProp]; },
- set: function(value) { obj[fieldProp] = value; },
- };
- })(type.elem.fields[i].prop);
- }
- proxy = Object.create(type.prototype, properties);
- proxy.$val = proxy;
- obj.$proxies[type.string] = proxy;
- proxy.$proxies = obj.$proxies;
- }
- return proxy;
-};
-
-var $append = function(slice) {
- return $internalAppend(slice, arguments, 1, arguments.length - 1);
-};
-
-var $appendSlice = function(slice, toAppend) {
- return $internalAppend(slice, toAppend.$array, toAppend.$offset, toAppend.$length);
-};
-
-var $internalAppend = function(slice, array, offset, length) {
- if (length === 0) {
- return slice;
- }
-
- var newArray = slice.$array;
- var newOffset = slice.$offset;
- var newLength = slice.$length + length;
- var newCapacity = slice.$capacity;
-
- if (newLength > newCapacity) {
- newOffset = 0;
- newCapacity = Math.max(newLength, slice.$capacity < 1024 ? slice.$capacity * 2 : Math.floor(slice.$capacity * 5 / 4));
-
- if (slice.$array.constructor === Array) {
- newArray = slice.$array.slice(slice.$offset, slice.$offset + slice.$length);
- newArray.length = newCapacity;
- var zero = slice.constructor.elem.zero;
- for (var i = slice.$length; i < newCapacity; i++) {
- newArray[i] = zero();
- }
- } else {
- newArray = new slice.$array.constructor(newCapacity);
- newArray.set(slice.$array.subarray(slice.$offset, slice.$offset + slice.$length));
- }
- }
-
- $internalCopy(newArray, array, newOffset + slice.$length, offset, length, slice.constructor.elem);
-
- var newSlice = new slice.constructor(newArray);
- newSlice.$offset = newOffset;
- newSlice.$length = newLength;
- newSlice.$capacity = newCapacity;
- return newSlice;
-};
-
-var $equal = function(a, b, type) {
- if (type === $jsObjectPtr) {
- return a === b;
- }
- switch (type.kind) {
- case $kindComplex64:
- case $kindComplex128:
- return a.$real === b.$real && a.$imag === b.$imag;
- case $kindInt64:
- case $kindUint64:
- return a.$high === b.$high && a.$low === b.$low;
- case $kindArray:
- if (a.length !== b.length) {
- return false;
- }
- for (var i = 0; i < a.length; i++) {
- if (!$equal(a[i], b[i], type.elem)) {
- return false;
- }
- }
- return true;
- case $kindStruct:
- for (var i = 0; i < type.fields.length; i++) {
- var f = type.fields[i];
- if (!$equal(a[f.prop], b[f.prop], f.typ)) {
- return false;
- }
- }
- return true;
- case $kindInterface:
- return $interfaceIsEqual(a, b);
- default:
- return a === b;
- }
-};
-
-var $interfaceIsEqual = function(a, b) {
- if (a === $ifaceNil || b === $ifaceNil) {
- return a === b;
- }
- if (a.constructor !== b.constructor) {
- return false;
- }
- if (a.constructor === $jsObjectPtr) {
- return a.object === b.object;
- }
- if (!a.constructor.comparable) {
- $throwRuntimeError("comparing uncomparable type " + a.constructor.string);
- }
- return $equal(a.$val, b.$val, a.constructor);
-};
-
-var $kindBool = 1;
-var $kindInt = 2;
-var $kindInt8 = 3;
-var $kindInt16 = 4;
-var $kindInt32 = 5;
-var $kindInt64 = 6;
-var $kindUint = 7;
-var $kindUint8 = 8;
-var $kindUint16 = 9;
-var $kindUint32 = 10;
-var $kindUint64 = 11;
-var $kindUintptr = 12;
-var $kindFloat32 = 13;
-var $kindFloat64 = 14;
-var $kindComplex64 = 15;
-var $kindComplex128 = 16;
-var $kindArray = 17;
-var $kindChan = 18;
-var $kindFunc = 19;
-var $kindInterface = 20;
-var $kindMap = 21;
-var $kindPtr = 22;
-var $kindSlice = 23;
-var $kindString = 24;
-var $kindStruct = 25;
-var $kindUnsafePointer = 26;
-
-var $methodSynthesizers = [];
-var $addMethodSynthesizer = function(f) {
- if ($methodSynthesizers === null) {
- f();
- return;
- }
- $methodSynthesizers.push(f);
-};
-var $synthesizeMethods = function() {
- $methodSynthesizers.forEach(function(f) { f(); });
- $methodSynthesizers = null;
-};
-
-var $ifaceKeyFor = function(x) {
- if (x === $ifaceNil) {
- return 'nil';
- }
- var c = x.constructor;
- return c.string + '$' + c.keyFor(x.$val);
-};
-
-var $identity = function(x) { return x; };
-
-var $newType = function(size, kind, string, name, pkg, constructor) {
- var typ;
- switch(kind) {
- case $kindBool:
- case $kindInt:
- case $kindInt8:
- case $kindInt16:
- case $kindInt32:
- case $kindUint:
- case $kindUint8:
- case $kindUint16:
- case $kindUint32:
- case $kindUintptr:
- case $kindString:
- case $kindUnsafePointer:
- typ = function(v) { this.$val = v; };
- break;
-
- case $kindFloat32:
- case $kindFloat64:
- typ = function(v) { this.$val = v; };
- typ.keyFor = function(x) { return $floatKey(x); };
- break;
-
- case $kindInt64:
- typ = function(high, low) {
- this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >> 0;
- this.$low = low >>> 0;
- this.$val = this;
- };
- typ.keyFor = function(x) { return x.$high + "$" + x.$low; };
- break;
-
- case $kindUint64:
- typ = function(high, low) {
- this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >>> 0;
- this.$low = low >>> 0;
- this.$val = this;
- };
- typ.keyFor = function(x) { return x.$high + "$" + x.$low; };
- break;
-
- case $kindComplex64:
- typ = function(real, imag) {
- this.$real = $fround(real);
- this.$imag = $fround(imag);
- this.$val = this;
- };
- typ.keyFor = function(x) { return x.$real + "$" + x.$imag; };
- break;
-
- case $kindComplex128:
- typ = function(real, imag) {
- this.$real = real;
- this.$imag = imag;
- this.$val = this;
- };
- typ.keyFor = function(x) { return x.$real + "$" + x.$imag; };
- break;
-
- case $kindArray:
- typ = function(v) { this.$val = v; };
- typ.ptr = $newType(4, $kindPtr, "*" + string, "", "", function(array) {
- this.$get = function() { return array; };
- this.$set = function(v) { $copy(this, v, typ); };
- this.$val = array;
- });
- typ.init = function(elem, len) {
- typ.elem = elem;
- typ.len = len;
- typ.comparable = elem.comparable;
- typ.keyFor = function(x) {
- return Array.prototype.join.call($mapArray(x, function(e) {
- return String(elem.keyFor(e)).replace(/\\/g, "\\\\").replace(/\$/g, "\\$");
- }), "$");
- };
- typ.ptr.init(typ);
- Object.defineProperty(typ.ptr.nil, "nilCheck", { get: $throwNilPointerError });
- };
- break;
-
- case $kindChan:
- typ = function(capacity) {
- this.$val = this;
- this.$capacity = capacity;
- this.$buffer = [];
- this.$sendQueue = [];
- this.$recvQueue = [];
- this.$closed = false;
- };
- typ.keyFor = function(x) {
- if (x.$id === undefined) {
- $idCounter++;
- x.$id = $idCounter;
- }
- return String(x.$id);
- };
- typ.init = function(elem, sendOnly, recvOnly) {
- typ.elem = elem;
- typ.sendOnly = sendOnly;
- typ.recvOnly = recvOnly;
- typ.nil = new typ(0);
- typ.nil.$sendQueue = typ.nil.$recvQueue = { length: 0, push: function() {}, shift: function() { return undefined; }, indexOf: function() { return -1; } };
- };
- break;
-
- case $kindFunc:
- typ = function(v) { this.$val = v; };
- typ.init = function(params, results, variadic) {
- typ.params = params;
- typ.results = results;
- typ.variadic = variadic;
- typ.comparable = false;
- };
- break;
-
- case $kindInterface:
- typ = { implementedBy: {}, missingMethodFor: {} };
- typ.keyFor = $ifaceKeyFor;
- typ.init = function(methods) {
- typ.methods = methods;
- methods.forEach(function(m) {
- $ifaceNil[m.prop] = $throwNilPointerError;
- });
- };
- break;
-
- case $kindMap:
- typ = function(v) { this.$val = v; };
- typ.init = function(key, elem) {
- typ.key = key;
- typ.elem = elem;
- typ.comparable = false;
- };
- break;
-
- case $kindPtr:
- typ = constructor || function(getter, setter, target) {
- this.$get = getter;
- this.$set = setter;
- this.$target = target;
- this.$val = this;
- };
- typ.keyFor = function(x) {
- if (x.$id === undefined) {
- $idCounter++;
- x.$id = $idCounter;
- }
- return String(x.$id);
- };
- typ.init = function(elem) {
- typ.elem = elem;
- typ.nil = new typ($throwNilPointerError, $throwNilPointerError);
- };
- break;
-
- case $kindSlice:
- typ = function(array) {
- if (array.constructor !== typ.nativeArray) {
- array = new typ.nativeArray(array);
- }
- this.$array = array;
- this.$offset = 0;
- this.$length = array.length;
- this.$capacity = array.length;
- this.$val = this;
- };
- typ.init = function(elem) {
- typ.elem = elem;
- typ.comparable = false;
- typ.nativeArray = $nativeArray(elem.kind);
- typ.nil = new typ([]);
- };
- break;
-
- case $kindStruct:
- typ = function(v) { this.$val = v; };
- typ.ptr = $newType(4, $kindPtr, "*" + string, "", "", constructor);
- typ.ptr.elem = typ;
- typ.ptr.prototype.$get = function() { return this; };
- typ.ptr.prototype.$set = function(v) { $copy(this, v, typ); };
- typ.init = function(fields) {
- typ.fields = fields;
- fields.forEach(function(f) {
- if (!f.typ.comparable) {
- typ.comparable = false;
- }
- });
- typ.keyFor = function(x) {
- var val = x.$val;
- return $mapArray(fields, function(f) {
- return String(f.typ.keyFor(val[f.prop])).replace(/\\/g, "\\\\").replace(/\$/g, "\\$");
- }).join("$");
- };
- /* nil value */
- var properties = {};
- fields.forEach(function(f) {
- properties[f.prop] = { get: $throwNilPointerError, set: $throwNilPointerError };
- });
- typ.ptr.nil = Object.create(constructor.prototype, properties);
- typ.ptr.nil.$val = typ.ptr.nil;
- /* methods for embedded fields */
- $addMethodSynthesizer(function() {
- var synthesizeMethod = function(target, m, f) {
- if (target.prototype[m.prop] !== undefined) { return; }
- target.prototype[m.prop] = function() {
- var v = this.$val[f.prop];
- if (f.typ === $jsObjectPtr) {
- v = new $jsObjectPtr(v);
- }
- if (v.$val === undefined) {
- v = new f.typ(v);
- }
- return v[m.prop].apply(v, arguments);
- };
- };
- fields.forEach(function(f) {
- if (f.name === "") {
- $methodSet(f.typ).forEach(function(m) {
- synthesizeMethod(typ, m, f);
- synthesizeMethod(typ.ptr, m, f);
- });
- $methodSet($ptrType(f.typ)).forEach(function(m) {
- synthesizeMethod(typ.ptr, m, f);
- });
- }
- });
- });
- };
- break;
-
- default:
- $panic(new $String("invalid kind: " + kind));
- }
-
- switch (kind) {
- case $kindBool:
- case $kindMap:
- typ.zero = function() { return false; };
- break;
-
- case $kindInt:
- case $kindInt8:
- case $kindInt16:
- case $kindInt32:
- case $kindUint:
- case $kindUint8 :
- case $kindUint16:
- case $kindUint32:
- case $kindUintptr:
- case $kindUnsafePointer:
- case $kindFloat32:
- case $kindFloat64:
- typ.zero = function() { return 0; };
- break;
-
- case $kindString:
- typ.zero = function() { return ""; };
- break;
-
- case $kindInt64:
- case $kindUint64:
- case $kindComplex64:
- case $kindComplex128:
- var zero = new typ(0, 0);
- typ.zero = function() { return zero; };
- break;
-
- case $kindChan:
- case $kindPtr:
- case $kindSlice:
- typ.zero = function() { return typ.nil; };
- break;
-
- case $kindFunc:
- typ.zero = function() { return $throwNilPointerError; };
- break;
-
- case $kindInterface:
- typ.zero = function() { return $ifaceNil; };
- break;
-
- case $kindArray:
- typ.zero = function() {
- var arrayClass = $nativeArray(typ.elem.kind);
- if (arrayClass !== Array) {
- return new arrayClass(typ.len);
- }
- var array = new Array(typ.len);
- for (var i = 0; i < typ.len; i++) {
- array[i] = typ.elem.zero();
- }
- return array;
- };
- break;
-
- case $kindStruct:
- typ.zero = function() { return new typ.ptr(); };
- break;
-
- default:
- $panic(new $String("invalid kind: " + kind));
- }
-
- typ.size = size;
- typ.kind = kind;
- typ.string = string;
- typ.typeName = name;
- typ.pkg = pkg;
- typ.methods = [];
- typ.methodSetCache = null;
- typ.comparable = true;
- typ.keyFor = typ.keyFor || $identity;
- return typ;
-};
-
-var $methodSet = function(typ) {
- if (typ.methodSetCache !== null) {
- return typ.methodSetCache;
- }
- var base = {};
-
- var isPtr = (typ.kind === $kindPtr);
- if (isPtr && typ.elem.kind === $kindInterface) {
- typ.methodSetCache = [];
- return [];
- }
-
- var current = [{typ: isPtr ? typ.elem : typ, indirect: isPtr}];
-
- var seen = {};
-
- while (current.length > 0) {
- var next = [];
- var mset = [];
-
- current.forEach(function(e) {
- if (seen[e.typ.string]) {
- return;
- }
- seen[e.typ.string] = true;
-
- if(e.typ.typeName !== "") {
- mset = mset.concat(e.typ.methods);
- if (e.indirect) {
- mset = mset.concat($ptrType(e.typ).methods);
- }
- }
-
- switch (e.typ.kind) {
- case $kindStruct:
- e.typ.fields.forEach(function(f) {
- if (f.name === "") {
- var fTyp = f.typ;
- var fIsPtr = (fTyp.kind === $kindPtr);
- next.push({typ: fIsPtr ? fTyp.elem : fTyp, indirect: e.indirect || fIsPtr});
- }
- });
- break;
-
- case $kindInterface:
- mset = mset.concat(e.typ.methods);
- break;
- }
- });
-
- mset.forEach(function(m) {
- if (base[m.name] === undefined) {
- base[m.name] = m;
- }
- });
-
- current = next;
- }
-
- typ.methodSetCache = [];
- Object.keys(base).sort().forEach(function(name) {
- typ.methodSetCache.push(base[name]);
- });
- return typ.methodSetCache;
-};
-
-var $Bool = $newType( 1, $kindBool, "bool", "bool", "", null);
-var $Int = $newType( 4, $kindInt, "int", "int", "", null);
-var $Int8 = $newType( 1, $kindInt8, "int8", "int8", "", null);
-var $Int16 = $newType( 2, $kindInt16, "int16", "int16", "", null);
-var $Int32 = $newType( 4, $kindInt32, "int32", "int32", "", null);
-var $Int64 = $newType( 8, $kindInt64, "int64", "int64", "", null);
-var $Uint = $newType( 4, $kindUint, "uint", "uint", "", null);
-var $Uint8 = $newType( 1, $kindUint8, "uint8", "uint8", "", null);
-var $Uint16 = $newType( 2, $kindUint16, "uint16", "uint16", "", null);
-var $Uint32 = $newType( 4, $kindUint32, "uint32", "uint32", "", null);
-var $Uint64 = $newType( 8, $kindUint64, "uint64", "uint64", "", null);
-var $Uintptr = $newType( 4, $kindUintptr, "uintptr", "uintptr", "", null);
-var $Float32 = $newType( 4, $kindFloat32, "float32", "float32", "", null);
-var $Float64 = $newType( 8, $kindFloat64, "float64", "float64", "", null);
-var $Complex64 = $newType( 8, $kindComplex64, "complex64", "complex64", "", null);
-var $Complex128 = $newType(16, $kindComplex128, "complex128", "complex128", "", null);
-var $String = $newType( 8, $kindString, "string", "string", "", null);
-var $UnsafePointer = $newType( 4, $kindUnsafePointer, "unsafe.Pointer", "Pointer", "", null);
-
-var $nativeArray = function(elemKind) {
- switch (elemKind) {
- case $kindInt:
- return Int32Array;
- case $kindInt8:
- return Int8Array;
- case $kindInt16:
- return Int16Array;
- case $kindInt32:
- return Int32Array;
- case $kindUint:
- return Uint32Array;
- case $kindUint8:
- return Uint8Array;
- case $kindUint16:
- return Uint16Array;
- case $kindUint32:
- return Uint32Array;
- case $kindUintptr:
- return Uint32Array;
- case $kindFloat32:
- return Float32Array;
- case $kindFloat64:
- return Float64Array;
- default:
- return Array;
- }
-};
-var $toNativeArray = function(elemKind, array) {
- var nativeArray = $nativeArray(elemKind);
- if (nativeArray === Array) {
- return array;
- }
- return new nativeArray(array);
-};
-var $arrayTypes = {};
-var $arrayType = function(elem, len) {
- var string = "[" + len + "]" + elem.string;
- var typ = $arrayTypes[string];
- if (typ === undefined) {
- typ = $newType(12, $kindArray, string, "", "", null);
- $arrayTypes[string] = typ;
- typ.init(elem, len);
- }
- return typ;
-};
-
-var $chanType = function(elem, sendOnly, recvOnly) {
- var string = (recvOnly ? "<-" : "") + "chan" + (sendOnly ? "<- " : " ") + elem.string;
- var field = sendOnly ? "SendChan" : (recvOnly ? "RecvChan" : "Chan");
- var typ = elem[field];
- if (typ === undefined) {
- typ = $newType(4, $kindChan, string, "", "", null);
- elem[field] = typ;
- typ.init(elem, sendOnly, recvOnly);
- }
- return typ;
-};
-
-var $funcTypes = {};
-var $funcType = function(params, results, variadic) {
- var paramTypes = $mapArray(params, function(p) { return p.string; });
- if (variadic) {
- paramTypes[paramTypes.length - 1] = "..." + paramTypes[paramTypes.length - 1].substr(2);
- }
- var string = "func(" + paramTypes.join(", ") + ")";
- if (results.length === 1) {
- string += " " + results[0].string;
- } else if (results.length > 1) {
- string += " (" + $mapArray(results, function(r) { return r.string; }).join(", ") + ")";
- }
- var typ = $funcTypes[string];
- if (typ === undefined) {
- typ = $newType(4, $kindFunc, string, "", "", null);
- $funcTypes[string] = typ;
- typ.init(params, results, variadic);
- }
- return typ;
-};
-
-var $interfaceTypes = {};
-var $interfaceType = function(methods) {
- var string = "interface {}";
- if (methods.length !== 0) {
- string = "interface { " + $mapArray(methods, function(m) {
- return (m.pkg !== "" ? m.pkg + "." : "") + m.name + m.typ.string.substr(4);
- }).join("; ") + " }";
- }
- var typ = $interfaceTypes[string];
- if (typ === undefined) {
- typ = $newType(8, $kindInterface, string, "", "", null);
- $interfaceTypes[string] = typ;
- typ.init(methods);
- }
- return typ;
-};
-var $emptyInterface = $interfaceType([]);
-var $ifaceNil = {};
-var $error = $newType(8, $kindInterface, "error", "error", "", null);
-$error.init([{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]);
-
-var $Map = function() {};
-(function() {
- var names = Object.getOwnPropertyNames(Object.prototype);
- for (var i = 0; i < names.length; i++) {
- $Map.prototype[names[i]] = undefined;
- }
-})();
-var $mapTypes = {};
-var $mapType = function(key, elem) {
- var string = "map[" + key.string + "]" + elem.string;
- var typ = $mapTypes[string];
- if (typ === undefined) {
- typ = $newType(4, $kindMap, string, "", "", null);
- $mapTypes[string] = typ;
- typ.init(key, elem);
- }
- return typ;
-};
-
-var $ptrType = function(elem) {
- var typ = elem.ptr;
- if (typ === undefined) {
- typ = $newType(4, $kindPtr, "*" + elem.string, "", "", null);
- elem.ptr = typ;
- typ.init(elem);
- }
- return typ;
-};
-
-var $newDataPointer = function(data, constructor) {
- if (constructor.elem.kind === $kindStruct) {
- return data;
- }
- return new constructor(function() { return data; }, function(v) { data = v; });
-};
-
-var $indexPtr = function(array, index, constructor) {
- array.$ptr = array.$ptr || {};
- return array.$ptr[index] || (array.$ptr[index] = new constructor(function() { return array[index]; }, function(v) { array[index] = v; }));
-};
-
-var $sliceType = function(elem) {
- var typ = elem.Slice;
- if (typ === undefined) {
- typ = $newType(12, $kindSlice, "[]" + elem.string, "", "", null);
- elem.Slice = typ;
- typ.init(elem);
- }
- return typ;
-};
-var $makeSlice = function(typ, length, capacity) {
- capacity = capacity || length;
- var array = new typ.nativeArray(capacity);
- if (typ.nativeArray === Array) {
- for (var i = 0; i < capacity; i++) {
- array[i] = typ.elem.zero();
- }
- }
- var slice = new typ(array);
- slice.$length = length;
- return slice;
-};
-
-var $structTypes = {};
-var $structType = function(fields) {
- var string = "struct { " + $mapArray(fields, function(f) {
- return f.name + " " + f.typ.string + (f.tag !== "" ? (" \"" + f.tag.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + "\"") : "");
- }).join("; ") + " }";
- if (fields.length === 0) {
- string = "struct {}";
- }
- var typ = $structTypes[string];
- if (typ === undefined) {
- typ = $newType(0, $kindStruct, string, "", "", function() {
- this.$val = this;
- for (var i = 0; i < fields.length; i++) {
- var f = fields[i];
- var arg = arguments[i];
- this[f.prop] = arg !== undefined ? arg : f.typ.zero();
- }
- });
- $structTypes[string] = typ;
- typ.init(fields);
- }
- return typ;
-};
-
-var $assertType = function(value, type, returnTuple) {
- var isInterface = (type.kind === $kindInterface), ok, missingMethod = "";
- if (value === $ifaceNil) {
- ok = false;
- } else if (!isInterface) {
- ok = value.constructor === type;
- } else {
- var valueTypeString = value.constructor.string;
- ok = type.implementedBy[valueTypeString];
- if (ok === undefined) {
- ok = true;
- var valueMethodSet = $methodSet(value.constructor);
- var interfaceMethods = type.methods;
- for (var i = 0; i < interfaceMethods.length; i++) {
- var tm = interfaceMethods[i];
- var found = false;
- for (var j = 0; j < valueMethodSet.length; j++) {
- var vm = valueMethodSet[j];
- if (vm.name === tm.name && vm.pkg === tm.pkg && vm.typ === tm.typ) {
- found = true;
- break;
- }
- }
- if (!found) {
- ok = false;
- type.missingMethodFor[valueTypeString] = tm.name;
- break;
- }
- }
- type.implementedBy[valueTypeString] = ok;
- }
- if (!ok) {
- missingMethod = type.missingMethodFor[valueTypeString];
- }
- }
-
- if (!ok) {
- if (returnTuple) {
- return [type.zero(), false];
- }
- $panic(new $packages["runtime"].TypeAssertionError.ptr("", (value === $ifaceNil ? "" : value.constructor.string), type.string, missingMethod));
- }
-
- if (!isInterface) {
- value = value.$val;
- }
- if (type === $jsObjectPtr) {
- value = value.object;
- }
- return returnTuple ? [value, true] : value;
-};
-
-var $floatKey = function(f) {
- if (f !== f) {
- $idCounter++;
- return "NaN$" + $idCounter;
- }
- return String(f);
-};
-
-var $flatten64 = function(x) {
- return x.$high * 4294967296 + x.$low;
-};
-
-var $shiftLeft64 = function(x, y) {
- if (y === 0) {
- return x;
- }
- if (y < 32) {
- return new x.constructor(x.$high << y | x.$low >>> (32 - y), (x.$low << y) >>> 0);
- }
- if (y < 64) {
- return new x.constructor(x.$low << (y - 32), 0);
- }
- return new x.constructor(0, 0);
-};
-
-var $shiftRightInt64 = function(x, y) {
- if (y === 0) {
- return x;
- }
- if (y < 32) {
- return new x.constructor(x.$high >> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0);
- }
- if (y < 64) {
- return new x.constructor(x.$high >> 31, (x.$high >> (y - 32)) >>> 0);
- }
- if (x.$high < 0) {
- return new x.constructor(-1, 4294967295);
- }
- return new x.constructor(0, 0);
-};
-
-var $shiftRightUint64 = function(x, y) {
- if (y === 0) {
- return x;
- }
- if (y < 32) {
- return new x.constructor(x.$high >>> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0);
- }
- if (y < 64) {
- return new x.constructor(0, x.$high >>> (y - 32));
- }
- return new x.constructor(0, 0);
-};
-
-var $mul64 = function(x, y) {
- var high = 0, low = 0;
- if ((y.$low & 1) !== 0) {
- high = x.$high;
- low = x.$low;
- }
- for (var i = 1; i < 32; i++) {
- if ((y.$low & 1<>> (32 - i);
- low += (x.$low << i) >>> 0;
- }
- }
- for (var i = 0; i < 32; i++) {
- if ((y.$high & 1< yHigh) || (xHigh === yHigh && xLow > yLow))) {
- yHigh = (yHigh << 1 | yLow >>> 31) >>> 0;
- yLow = (yLow << 1) >>> 0;
- n++;
- }
- for (var i = 0; i <= n; i++) {
- high = high << 1 | low >>> 31;
- low = (low << 1) >>> 0;
- if ((xHigh > yHigh) || (xHigh === yHigh && xLow >= yLow)) {
- xHigh = xHigh - yHigh;
- xLow = xLow - yLow;
- if (xLow < 0) {
- xHigh--;
- xLow += 4294967296;
- }
- low++;
- if (low === 4294967296) {
- high++;
- low = 0;
- }
- }
- yLow = (yLow >>> 1 | yHigh << (32 - 1)) >>> 0;
- yHigh = yHigh >>> 1;
- }
-
- if (returnRemainder) {
- return new x.constructor(xHigh * rs, xLow * rs);
- }
- return new x.constructor(high * s, low * s);
-};
-
-var $divComplex = function(n, d) {
- var ninf = n.$real === 1/0 || n.$real === -1/0 || n.$imag === 1/0 || n.$imag === -1/0;
- var dinf = d.$real === 1/0 || d.$real === -1/0 || d.$imag === 1/0 || d.$imag === -1/0;
- var nnan = !ninf && (n.$real !== n.$real || n.$imag !== n.$imag);
- var dnan = !dinf && (d.$real !== d.$real || d.$imag !== d.$imag);
- if(nnan || dnan) {
- return new n.constructor(0/0, 0/0);
- }
- if (ninf && !dinf) {
- return new n.constructor(1/0, 1/0);
- }
- if (!ninf && dinf) {
- return new n.constructor(0, 0);
- }
- if (d.$real === 0 && d.$imag === 0) {
- if (n.$real === 0 && n.$imag === 0) {
- return new n.constructor(0/0, 0/0);
- }
- return new n.constructor(1/0, 1/0);
- }
- var a = Math.abs(d.$real);
- var b = Math.abs(d.$imag);
- if (a <= b) {
- var ratio = d.$real / d.$imag;
- var denom = d.$real * ratio + d.$imag;
- return new n.constructor((n.$real * ratio + n.$imag) / denom, (n.$imag * ratio - n.$real) / denom);
- }
- var ratio = d.$imag / d.$real;
- var denom = d.$imag * ratio + d.$real;
- return new n.constructor((n.$imag * ratio + n.$real) / denom, (n.$imag - n.$real * ratio) / denom);
-};
-
-var $stackDepthOffset = 0;
-var $getStackDepth = function() {
- var err = new Error();
- if (err.stack === undefined) {
- return undefined;
- }
- return $stackDepthOffset + err.stack.split("\n").length;
-};
-
-var $panicStackDepth = null, $panicValue;
-var $callDeferred = function(deferred, jsErr, fromPanic) {
- if (!fromPanic && deferred !== null && deferred.index >= $curGoroutine.deferStack.length) {
- throw jsErr;
- }
- if (jsErr !== null) {
- var newErr = null;
- try {
- $curGoroutine.deferStack.push(deferred);
- $panic(new $jsErrorPtr(jsErr));
- } catch (err) {
- newErr = err;
- }
- $curGoroutine.deferStack.pop();
- $callDeferred(deferred, newErr);
- return;
- }
- if ($curGoroutine.asleep) {
- return;
- }
-
- $stackDepthOffset--;
- var outerPanicStackDepth = $panicStackDepth;
- var outerPanicValue = $panicValue;
-
- var localPanicValue = $curGoroutine.panicStack.pop();
- if (localPanicValue !== undefined) {
- $panicStackDepth = $getStackDepth();
- $panicValue = localPanicValue;
- }
-
- try {
- while (true) {
- if (deferred === null) {
- deferred = $curGoroutine.deferStack[$curGoroutine.deferStack.length - 1];
- if (deferred === undefined) {
- if (localPanicValue.Object instanceof Error) {
- throw localPanicValue.Object;
- }
- var msg;
- if (localPanicValue.constructor === $String) {
- msg = localPanicValue.$val;
- } else if (localPanicValue.Error !== undefined) {
- msg = localPanicValue.Error();
- } else if (localPanicValue.String !== undefined) {
- msg = localPanicValue.String();
- } else {
- msg = localPanicValue;
- }
- throw new Error(msg);
- }
- }
- var call = deferred.pop();
- if (call === undefined) {
- $curGoroutine.deferStack.pop();
- if (localPanicValue !== undefined) {
- deferred = null;
- continue;
- }
- return;
- }
- var r = call[0].apply(call[2], call[1]);
- if (r && r.$blk !== undefined) {
- deferred.push([r.$blk, [], r]);
- if (fromPanic) {
- throw null;
- }
- return;
- }
-
- if (localPanicValue !== undefined && $panicStackDepth === null) {
- throw null; /* error was recovered */
- }
- }
- } finally {
- if (localPanicValue !== undefined) {
- if ($panicStackDepth !== null) {
- $curGoroutine.panicStack.push(localPanicValue);
- }
- $panicStackDepth = outerPanicStackDepth;
- $panicValue = outerPanicValue;
- }
- $stackDepthOffset++;
- }
-};
-
-var $panic = function(value) {
- $curGoroutine.panicStack.push(value);
- $callDeferred(null, null, true);
-};
-var $recover = function() {
- if ($panicStackDepth === null || ($panicStackDepth !== undefined && $panicStackDepth !== $getStackDepth() - 2)) {
- return $ifaceNil;
- }
- $panicStackDepth = null;
- return $panicValue;
-};
-var $throw = function(err) { throw err; };
-
-var $dummyGoroutine = { asleep: false, exit: false, deferStack: [], panicStack: [], canBlock: false };
-var $curGoroutine = $dummyGoroutine, $totalGoroutines = 0, $awakeGoroutines = 0, $checkForDeadlock = true;
-var $go = function(fun, args, direct) {
- $totalGoroutines++;
- $awakeGoroutines++;
- var $goroutine = function() {
- var rescheduled = false;
- try {
- $curGoroutine = $goroutine;
- var r = fun.apply(undefined, args);
- if (r && r.$blk !== undefined) {
- fun = function() { return r.$blk(); };
- args = [];
- rescheduled = true;
- return;
- }
- $goroutine.exit = true;
- } catch (err) {
- $goroutine.exit = true;
- throw err;
- } finally {
- $curGoroutine = $dummyGoroutine;
- if ($goroutine.exit && !rescheduled) { /* also set by runtime.Goexit() */
- $totalGoroutines--;
- $goroutine.asleep = true;
- }
- if ($goroutine.asleep && !rescheduled) {
- $awakeGoroutines--;
- if ($awakeGoroutines === 0 && $totalGoroutines !== 0 && $checkForDeadlock) {
- console.error("fatal error: all goroutines are asleep - deadlock!");
- }
- }
- }
- };
- $goroutine.asleep = false;
- $goroutine.exit = false;
- $goroutine.deferStack = [];
- $goroutine.panicStack = [];
- $goroutine.canBlock = true;
- $schedule($goroutine, direct);
-};
-
-var $scheduled = [], $schedulerActive = false;
-var $runScheduled = function() {
- try {
- var r;
- while ((r = $scheduled.shift()) !== undefined) {
- r();
- }
- $schedulerActive = false;
- } finally {
- if ($schedulerActive) {
- setTimeout($runScheduled, 0);
- }
- }
-};
-var $schedule = function(goroutine, direct) {
- if (goroutine.asleep) {
- goroutine.asleep = false;
- $awakeGoroutines++;
- }
-
- if (direct) {
- goroutine();
- return;
- }
-
- $scheduled.push(goroutine);
- if (!$schedulerActive) {
- $schedulerActive = true;
- setTimeout($runScheduled, 0);
- }
-};
-
-var $block = function() {
- if (!$curGoroutine.canBlock) {
- $throwRuntimeError("cannot block in JavaScript callback, fix by wrapping code in goroutine");
- }
- $curGoroutine.asleep = true;
-};
-
-var $send = function(chan, value) {
- if (chan.$closed) {
- $throwRuntimeError("send on closed channel");
- }
- var queuedRecv = chan.$recvQueue.shift();
- if (queuedRecv !== undefined) {
- queuedRecv([value, true]);
- return;
- }
- if (chan.$buffer.length < chan.$capacity) {
- chan.$buffer.push(value);
- return;
- }
-
- var thisGoroutine = $curGoroutine;
- chan.$sendQueue.push(function() {
- $schedule(thisGoroutine);
- return value;
- });
- $block();
- return {
- $blk: function() {
- if (chan.$closed) {
- $throwRuntimeError("send on closed channel");
- }
- },
- };
-};
-var $recv = function(chan) {
- var queuedSend = chan.$sendQueue.shift();
- if (queuedSend !== undefined) {
- chan.$buffer.push(queuedSend());
- }
- var bufferedValue = chan.$buffer.shift();
- if (bufferedValue !== undefined) {
- return [bufferedValue, true];
- }
- if (chan.$closed) {
- return [chan.constructor.elem.zero(), false];
- }
-
- var thisGoroutine = $curGoroutine;
- var f = { $blk: function() { return this.value; } };
- var queueEntry = function(v) {
- f.value = v;
- $schedule(thisGoroutine);
- };
- chan.$recvQueue.push(queueEntry);
- $block();
- return f;
-};
-var $close = function(chan) {
- if (chan.$closed) {
- $throwRuntimeError("close of closed channel");
- }
- chan.$closed = true;
- while (true) {
- var queuedSend = chan.$sendQueue.shift();
- if (queuedSend === undefined) {
- break;
- }
- queuedSend(); /* will panic because of closed channel */
- }
- while (true) {
- var queuedRecv = chan.$recvQueue.shift();
- if (queuedRecv === undefined) {
- break;
- }
- queuedRecv([chan.constructor.elem.zero(), false]);
- }
-};
-var $select = function(comms) {
- var ready = [];
- var selection = -1;
- for (var i = 0; i < comms.length; i++) {
- var comm = comms[i];
- var chan = comm[0];
- switch (comm.length) {
- case 0: /* default */
- selection = i;
- break;
- case 1: /* recv */
- if (chan.$sendQueue.length !== 0 || chan.$buffer.length !== 0 || chan.$closed) {
- ready.push(i);
- }
- break;
- case 2: /* send */
- if (chan.$closed) {
- $throwRuntimeError("send on closed channel");
- }
- if (chan.$recvQueue.length !== 0 || chan.$buffer.length < chan.$capacity) {
- ready.push(i);
- }
- break;
- }
- }
-
- if (ready.length !== 0) {
- selection = ready[Math.floor(Math.random() * ready.length)];
- }
- if (selection !== -1) {
- var comm = comms[selection];
- switch (comm.length) {
- case 0: /* default */
- return [selection];
- case 1: /* recv */
- return [selection, $recv(comm[0])];
- case 2: /* send */
- $send(comm[0], comm[1]);
- return [selection];
- }
- }
-
- var entries = [];
- var thisGoroutine = $curGoroutine;
- var f = { $blk: function() { return this.selection; } };
- var removeFromQueues = function() {
- for (var i = 0; i < entries.length; i++) {
- var entry = entries[i];
- var queue = entry[0];
- var index = queue.indexOf(entry[1]);
- if (index !== -1) {
- queue.splice(index, 1);
- }
- }
- };
- for (var i = 0; i < comms.length; i++) {
- (function(i) {
- var comm = comms[i];
- switch (comm.length) {
- case 1: /* recv */
- var queueEntry = function(value) {
- f.selection = [i, value];
- removeFromQueues();
- $schedule(thisGoroutine);
- };
- entries.push([comm[0].$recvQueue, queueEntry]);
- comm[0].$recvQueue.push(queueEntry);
- break;
- case 2: /* send */
- var queueEntry = function() {
- if (comm[0].$closed) {
- $throwRuntimeError("send on closed channel");
- }
- f.selection = [i];
- removeFromQueues();
- $schedule(thisGoroutine);
- return comm[1];
- };
- entries.push([comm[0].$sendQueue, queueEntry]);
- comm[0].$sendQueue.push(queueEntry);
- break;
- }
- })(i);
- }
- $block();
- return f;
-};
-
-var $jsObjectPtr, $jsErrorPtr;
-
-var $needsExternalization = function(t) {
- switch (t.kind) {
- case $kindBool:
- case $kindInt:
- case $kindInt8:
- case $kindInt16:
- case $kindInt32:
- case $kindUint:
- case $kindUint8:
- case $kindUint16:
- case $kindUint32:
- case $kindUintptr:
- case $kindFloat32:
- case $kindFloat64:
- return false;
- default:
- return t !== $jsObjectPtr;
- }
-};
-
-var $externalize = function(v, t) {
- if (t === $jsObjectPtr) {
- return v;
- }
- switch (t.kind) {
- case $kindBool:
- case $kindInt:
- case $kindInt8:
- case $kindInt16:
- case $kindInt32:
- case $kindUint:
- case $kindUint8:
- case $kindUint16:
- case $kindUint32:
- case $kindUintptr:
- case $kindFloat32:
- case $kindFloat64:
- return v;
- case $kindInt64:
- case $kindUint64:
- return $flatten64(v);
- case $kindArray:
- if ($needsExternalization(t.elem)) {
- return $mapArray(v, function(e) { return $externalize(e, t.elem); });
- }
- return v;
- case $kindFunc:
- return $externalizeFunction(v, t, false);
- case $kindInterface:
- if (v === $ifaceNil) {
- return null;
- }
- if (v.constructor === $jsObjectPtr) {
- return v.$val.object;
- }
- return $externalize(v.$val, v.constructor);
- case $kindMap:
- var m = {};
- var keys = $keys(v);
- for (var i = 0; i < keys.length; i++) {
- var entry = v[keys[i]];
- m[$externalize(entry.k, t.key)] = $externalize(entry.v, t.elem);
- }
- return m;
- case $kindPtr:
- if (v === t.nil) {
- return null;
- }
- return $externalize(v.$get(), t.elem);
- case $kindSlice:
- if ($needsExternalization(t.elem)) {
- return $mapArray($sliceToArray(v), function(e) { return $externalize(e, t.elem); });
- }
- return $sliceToArray(v);
- case $kindString:
- if (v.search(/^[\x00-\x7F]*$/) !== -1) {
- return v;
- }
- var s = "", r;
- for (var i = 0; i < v.length; i += r[1]) {
- r = $decodeRune(v, i);
- s += String.fromCharCode(r[0]);
- }
- return s;
- case $kindStruct:
- var timePkg = $packages["time"];
- if (timePkg && v.constructor === timePkg.Time.ptr) {
- var milli = $div64(v.UnixNano(), new $Int64(0, 1000000));
- return new Date($flatten64(milli));
- }
-
- var noJsObject = {};
- var searchJsObject = function(v, t) {
- if (t === $jsObjectPtr) {
- return v;
- }
- switch (t.kind) {
- case $kindPtr:
- if (v === t.nil) {
- return noJsObject;
- }
- return searchJsObject(v.$get(), t.elem);
- case $kindStruct:
- var f = t.fields[0];
- return searchJsObject(v[f.prop], f.typ);
- case $kindInterface:
- return searchJsObject(v.$val, v.constructor);
- default:
- return noJsObject;
- }
- };
- var o = searchJsObject(v, t);
- if (o !== noJsObject) {
- return o;
- }
-
- o = {};
- for (var i = 0; i < t.fields.length; i++) {
- var f = t.fields[i];
- if (f.pkg !== "") { /* not exported */
- continue;
- }
- o[f.name] = $externalize(v[f.prop], f.typ);
- }
- return o;
- }
- $panic(new $String("cannot externalize " + t.string));
-};
-
-var $externalizeFunction = function(v, t, passThis) {
- if (v === $throwNilPointerError) {
- return null;
- }
- if (v.$externalizeWrapper === undefined) {
- $checkForDeadlock = false;
- v.$externalizeWrapper = function() {
- var args = [];
- for (var i = 0; i < t.params.length; i++) {
- if (t.variadic && i === t.params.length - 1) {
- var vt = t.params[i].elem, varargs = [];
- for (var j = i; j < arguments.length; j++) {
- varargs.push($internalize(arguments[j], vt));
- }
- args.push(new (t.params[i])(varargs));
- break;
- }
- args.push($internalize(arguments[i], t.params[i]));
- }
- var canBlock = $curGoroutine.canBlock;
- $curGoroutine.canBlock = false;
- try {
- var result = v.apply(passThis ? this : undefined, args);
- } finally {
- $curGoroutine.canBlock = canBlock;
- }
- switch (t.results.length) {
- case 0:
- return;
- case 1:
- return $externalize(result, t.results[0]);
- default:
- for (var i = 0; i < t.results.length; i++) {
- result[i] = $externalize(result[i], t.results[i]);
- }
- return result;
- }
- };
- }
- return v.$externalizeWrapper;
-};
-
-var $internalize = function(v, t, recv) {
- if (t === $jsObjectPtr) {
- return v;
- }
- if (t === $jsObjectPtr.elem) {
- $panic(new $String("cannot internalize js.Object, use *js.Object instead"));
- }
- switch (t.kind) {
- case $kindBool:
- return !!v;
- case $kindInt:
- return parseInt(v);
- case $kindInt8:
- return parseInt(v) << 24 >> 24;
- case $kindInt16:
- return parseInt(v) << 16 >> 16;
- case $kindInt32:
- return parseInt(v) >> 0;
- case $kindUint:
- return parseInt(v);
- case $kindUint8:
- return parseInt(v) << 24 >>> 24;
- case $kindUint16:
- return parseInt(v) << 16 >>> 16;
- case $kindUint32:
- case $kindUintptr:
- return parseInt(v) >>> 0;
- case $kindInt64:
- case $kindUint64:
- return new t(0, v);
- case $kindFloat32:
- case $kindFloat64:
- return parseFloat(v);
- case $kindArray:
- if (v.length !== t.len) {
- $throwRuntimeError("got array with wrong size from JavaScript native");
- }
- return $mapArray(v, function(e) { return $internalize(e, t.elem); });
- case $kindFunc:
- return function() {
- var args = [];
- for (var i = 0; i < t.params.length; i++) {
- if (t.variadic && i === t.params.length - 1) {
- var vt = t.params[i].elem, varargs = arguments[i];
- for (var j = 0; j < varargs.$length; j++) {
- args.push($externalize(varargs.$array[varargs.$offset + j], vt));
- }
- break;
- }
- args.push($externalize(arguments[i], t.params[i]));
- }
- var result = v.apply(recv, args);
- switch (t.results.length) {
- case 0:
- return;
- case 1:
- return $internalize(result, t.results[0]);
- default:
- for (var i = 0; i < t.results.length; i++) {
- result[i] = $internalize(result[i], t.results[i]);
- }
- return result;
- }
- };
- case $kindInterface:
- if (t.methods.length !== 0) {
- $panic(new $String("cannot internalize " + t.string));
- }
- if (v === null) {
- return $ifaceNil;
- }
- if (v === undefined) {
- return new $jsObjectPtr(undefined);
- }
- switch (v.constructor) {
- case Int8Array:
- return new ($sliceType($Int8))(v);
- case Int16Array:
- return new ($sliceType($Int16))(v);
- case Int32Array:
- return new ($sliceType($Int))(v);
- case Uint8Array:
- return new ($sliceType($Uint8))(v);
- case Uint16Array:
- return new ($sliceType($Uint16))(v);
- case Uint32Array:
- return new ($sliceType($Uint))(v);
- case Float32Array:
- return new ($sliceType($Float32))(v);
- case Float64Array:
- return new ($sliceType($Float64))(v);
- case Array:
- return $internalize(v, $sliceType($emptyInterface));
- case Boolean:
- return new $Bool(!!v);
- case Date:
- var timePkg = $packages["time"];
- if (timePkg) {
- return new timePkg.Time(timePkg.Unix(new $Int64(0, 0), new $Int64(0, v.getTime() * 1000000)));
- }
- case Function:
- var funcType = $funcType([$sliceType($emptyInterface)], [$jsObjectPtr], true);
- return new funcType($internalize(v, funcType));
- case Number:
- return new $Float64(parseFloat(v));
- case String:
- return new $String($internalize(v, $String));
- default:
- if ($global.Node && v instanceof $global.Node) {
- return new $jsObjectPtr(v);
- }
- var mapType = $mapType($String, $emptyInterface);
- return new mapType($internalize(v, mapType));
- }
- case $kindMap:
- var m = new $Map();
- var keys = $keys(v);
- for (var i = 0; i < keys.length; i++) {
- var k = $internalize(keys[i], t.key);
- m[t.key.keyFor(k)] = { k: k, v: $internalize(v[keys[i]], t.elem) };
- }
- return m;
- case $kindPtr:
- if (t.elem.kind === $kindStruct) {
- return $internalize(v, t.elem);
- }
- case $kindSlice:
- return new t($mapArray(v, function(e) { return $internalize(e, t.elem); }));
- case $kindString:
- v = String(v);
- if (v.search(/^[\x00-\x7F]*$/) !== -1) {
- return v;
- }
- var s = "";
- for (var i = 0; i < v.length; i++) {
- s += $encodeRune(v.charCodeAt(i));
- }
- return s;
- case $kindStruct:
- var noJsObject = {};
- var searchJsObject = function(t) {
- if (t === $jsObjectPtr) {
- return v;
- }
- if (t === $jsObjectPtr.elem) {
- $panic(new $String("cannot internalize js.Object, use *js.Object instead"));
- }
- switch (t.kind) {
- case $kindPtr:
- return searchJsObject(t.elem);
- case $kindStruct:
- var f = t.fields[0];
- var o = searchJsObject(f.typ);
- if (o !== noJsObject) {
- var n = new t.ptr();
- n[f.prop] = o;
- return n;
- }
- return noJsObject;
- default:
- return noJsObject;
- }
- };
- var o = searchJsObject(t);
- if (o !== noJsObject) {
- return o;
- }
- }
- $panic(new $String("cannot internalize " + t.string));
-};
-
-$packages["github.com/gopherjs/gopherjs/js"] = (function() {
- var $pkg = {}, $init, Object, Error, S, sliceType, ptrType, ptrType$1, init;
- Object = $pkg.Object = $newType(0, $kindStruct, "js.Object", "Object", "github.com/gopherjs/gopherjs/js", function(object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = null;
- return;
- }
- this.object = object_;
- });
- Error = $pkg.Error = $newType(0, $kindStruct, "js.Error", "Error", "github.com/gopherjs/gopherjs/js", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- S = $pkg.S = $newType(12, $kindSlice, "js.S", "S", "github.com/gopherjs/gopherjs/js", null);
- sliceType = $sliceType($emptyInterface);
- ptrType = $ptrType(Object);
- ptrType$1 = $ptrType(Error);
- Object.ptr.prototype.Get = function(key) {
- var $ptr, key, o;
- o = this;
- return o.object[$externalize(key, $String)];
- };
- Object.prototype.Get = function(key) { return this.$val.Get(key); };
- Object.ptr.prototype.Set = function(key, value) {
- var $ptr, key, o, value;
- o = this;
- o.object[$externalize(key, $String)] = $externalize(value, $emptyInterface);
- };
- Object.prototype.Set = function(key, value) { return this.$val.Set(key, value); };
- Object.ptr.prototype.Delete = function(key) {
- var $ptr, key, o;
- o = this;
- delete o.object[$externalize(key, $String)];
- };
- Object.prototype.Delete = function(key) { return this.$val.Delete(key); };
- Object.ptr.prototype.Length = function() {
- var $ptr, o;
- o = this;
- return $parseInt(o.object.length);
- };
- Object.prototype.Length = function() { return this.$val.Length(); };
- Object.ptr.prototype.Index = function(i) {
- var $ptr, i, o;
- o = this;
- return o.object[i];
- };
- Object.prototype.Index = function(i) { return this.$val.Index(i); };
- Object.ptr.prototype.SetIndex = function(i, value) {
- var $ptr, i, o, value;
- o = this;
- o.object[i] = $externalize(value, $emptyInterface);
- };
- Object.prototype.SetIndex = function(i, value) { return this.$val.SetIndex(i, value); };
- Object.ptr.prototype.Call = function(name, args) {
- var $ptr, args, name, o, obj;
- o = this;
- return (obj = o.object, obj[$externalize(name, $String)].apply(obj, $externalize(args, sliceType)));
- };
- Object.prototype.Call = function(name, args) { return this.$val.Call(name, args); };
- Object.ptr.prototype.Invoke = function(args) {
- var $ptr, args, o;
- o = this;
- return o.object.apply(undefined, $externalize(args, sliceType));
- };
- Object.prototype.Invoke = function(args) { return this.$val.Invoke(args); };
- Object.ptr.prototype.New = function(args) {
- var $ptr, args, o;
- o = this;
- return new ($global.Function.prototype.bind.apply(o.object, [undefined].concat($externalize(args, sliceType))));
- };
- Object.prototype.New = function(args) { return this.$val.New(args); };
- Object.ptr.prototype.Bool = function() {
- var $ptr, o;
- o = this;
- return !!(o.object);
- };
- Object.prototype.Bool = function() { return this.$val.Bool(); };
- Object.ptr.prototype.String = function() {
- var $ptr, o;
- o = this;
- return $internalize(o.object, $String);
- };
- Object.prototype.String = function() { return this.$val.String(); };
- Object.ptr.prototype.Int = function() {
- var $ptr, o;
- o = this;
- return $parseInt(o.object) >> 0;
- };
- Object.prototype.Int = function() { return this.$val.Int(); };
- Object.ptr.prototype.Int64 = function() {
- var $ptr, o;
- o = this;
- return $internalize(o.object, $Int64);
- };
- Object.prototype.Int64 = function() { return this.$val.Int64(); };
- Object.ptr.prototype.Uint64 = function() {
- var $ptr, o;
- o = this;
- return $internalize(o.object, $Uint64);
- };
- Object.prototype.Uint64 = function() { return this.$val.Uint64(); };
- Object.ptr.prototype.Float = function() {
- var $ptr, o;
- o = this;
- return $parseFloat(o.object);
- };
- Object.prototype.Float = function() { return this.$val.Float(); };
- Object.ptr.prototype.Interface = function() {
- var $ptr, o;
- o = this;
- return $internalize(o.object, $emptyInterface);
- };
- Object.prototype.Interface = function() { return this.$val.Interface(); };
- Object.ptr.prototype.Unsafe = function() {
- var $ptr, o;
- o = this;
- return o.object;
- };
- Object.prototype.Unsafe = function() { return this.$val.Unsafe(); };
- Error.ptr.prototype.Error = function() {
- var $ptr, err;
- err = this;
- return "JavaScript error: " + $internalize(err.Object.message, $String);
- };
- Error.prototype.Error = function() { return this.$val.Error(); };
- Error.ptr.prototype.Stack = function() {
- var $ptr, err;
- err = this;
- return $internalize(err.Object.stack, $String);
- };
- Error.prototype.Stack = function() { return this.$val.Stack(); };
- init = function() {
- var $ptr, e;
- e = new Error.ptr(null);
- };
- ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [ptrType], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String, $emptyInterface], [], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [ptrType], false)}, {prop: "SetIndex", name: "SetIndex", pkg: "", typ: $funcType([$Int, $emptyInterface], [], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([$String, sliceType], [ptrType], true)}, {prop: "Invoke", name: "Invoke", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "New", name: "New", pkg: "", typ: $funcType([sliceType], [ptrType], true)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Unsafe", name: "Unsafe", pkg: "", typ: $funcType([], [$Uintptr], false)}];
- ptrType$1.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Stack", name: "Stack", pkg: "", typ: $funcType([], [$String], false)}];
- Object.init([{prop: "object", name: "object", pkg: "github.com/gopherjs/gopherjs/js", typ: ptrType, tag: ""}]);
- Error.init([{prop: "Object", name: "", pkg: "", typ: ptrType, tag: ""}]);
- S.init($emptyInterface);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- init();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["runtime"] = (function() {
- var $pkg = {}, $init, js, Error, TypeAssertionError, errorString, ptrType$5, init, GOROOT, GOMAXPROCS, SetFinalizer;
- js = $packages["github.com/gopherjs/gopherjs/js"];
- Error = $pkg.Error = $newType(8, $kindInterface, "runtime.Error", "Error", "runtime", null);
- TypeAssertionError = $pkg.TypeAssertionError = $newType(0, $kindStruct, "runtime.TypeAssertionError", "TypeAssertionError", "runtime", function(interfaceString_, concreteString_, assertedString_, missingMethod_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.interfaceString = "";
- this.concreteString = "";
- this.assertedString = "";
- this.missingMethod = "";
- return;
- }
- this.interfaceString = interfaceString_;
- this.concreteString = concreteString_;
- this.assertedString = assertedString_;
- this.missingMethod = missingMethod_;
- });
- errorString = $pkg.errorString = $newType(8, $kindString, "runtime.errorString", "errorString", "runtime", null);
- ptrType$5 = $ptrType(TypeAssertionError);
- init = function() {
- var $ptr, e, jsPkg;
- jsPkg = $packages[$externalize("github.com/gopherjs/gopherjs/js", $String)];
- $jsObjectPtr = jsPkg.Object.ptr;
- $jsErrorPtr = jsPkg.Error.ptr;
- $throwRuntimeError = (function(msg) {
- var $ptr, msg;
- $panic(new errorString(msg));
- });
- e = $ifaceNil;
- e = new TypeAssertionError.ptr("", "", "", "");
- };
- GOROOT = function() {
- var $ptr, goroot, process;
- process = $global.process;
- if (process === undefined) {
- return "/";
- }
- goroot = process.env.GOROOT;
- if (!(goroot === undefined)) {
- return $internalize(goroot, $String);
- }
- return "/usr/local/Cellar/go/1.4.2/libexec";
- };
- $pkg.GOROOT = GOROOT;
- GOMAXPROCS = function(n) {
- var $ptr, n;
- return 1;
- };
- $pkg.GOMAXPROCS = GOMAXPROCS;
- SetFinalizer = function(x, f) {
- var $ptr, f, x;
- };
- $pkg.SetFinalizer = SetFinalizer;
- TypeAssertionError.ptr.prototype.RuntimeError = function() {
- var $ptr;
- };
- TypeAssertionError.prototype.RuntimeError = function() { return this.$val.RuntimeError(); };
- TypeAssertionError.ptr.prototype.Error = function() {
- var $ptr, e, inter;
- e = this;
- inter = e.interfaceString;
- if (inter === "") {
- inter = "interface";
- }
- if (e.concreteString === "") {
- return "interface conversion: " + inter + " is nil, not " + e.assertedString;
- }
- if (e.missingMethod === "") {
- return "interface conversion: " + inter + " is " + e.concreteString + ", not " + e.assertedString;
- }
- return "interface conversion: " + e.concreteString + " is not " + e.assertedString + ": missing method " + e.missingMethod;
- };
- TypeAssertionError.prototype.Error = function() { return this.$val.Error(); };
- errorString.prototype.RuntimeError = function() {
- var $ptr, e;
- e = this.$val;
- };
- $ptrType(errorString).prototype.RuntimeError = function() { return new errorString(this.$get()).RuntimeError(); };
- errorString.prototype.Error = function() {
- var $ptr, e;
- e = this.$val;
- return "runtime error: " + e;
- };
- $ptrType(errorString).prototype.Error = function() { return new errorString(this.$get()).Error(); };
- ptrType$5.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- errorString.methods = [{prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- Error.init([{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}]);
- TypeAssertionError.init([{prop: "interfaceString", name: "interfaceString", pkg: "runtime", typ: $String, tag: ""}, {prop: "concreteString", name: "concreteString", pkg: "runtime", typ: $String, tag: ""}, {prop: "assertedString", name: "assertedString", pkg: "runtime", typ: $String, tag: ""}, {prop: "missingMethod", name: "missingMethod", pkg: "runtime", typ: $String, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- init();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["errors"] = (function() {
- var $pkg = {}, $init, errorString, ptrType, New;
- errorString = $pkg.errorString = $newType(0, $kindStruct, "errors.errorString", "errorString", "errors", function(s_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.s = "";
- return;
- }
- this.s = s_;
- });
- ptrType = $ptrType(errorString);
- New = function(text) {
- var $ptr, text;
- return new errorString.ptr(text);
- };
- $pkg.New = New;
- errorString.ptr.prototype.Error = function() {
- var $ptr, e;
- e = this;
- return e.s;
- };
- errorString.prototype.Error = function() { return this.$val.Error(); };
- ptrType.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- errorString.init([{prop: "s", name: "s", pkg: "errors", typ: $String, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["sync/atomic"] = (function() {
- var $pkg = {}, $init, js, Value, ptrType, CompareAndSwapInt32, AddInt32, LoadUint32, StoreInt32, StoreUint32;
- js = $packages["github.com/gopherjs/gopherjs/js"];
- Value = $pkg.Value = $newType(0, $kindStruct, "atomic.Value", "Value", "sync/atomic", function(v_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.v = $ifaceNil;
- return;
- }
- this.v = v_;
- });
- ptrType = $ptrType(Value);
- CompareAndSwapInt32 = function(addr, old, new$1) {
- var $ptr, addr, new$1, old;
- if (addr.$get() === old) {
- addr.$set(new$1);
- return true;
- }
- return false;
- };
- $pkg.CompareAndSwapInt32 = CompareAndSwapInt32;
- AddInt32 = function(addr, delta) {
- var $ptr, addr, delta, new$1;
- new$1 = addr.$get() + delta >> 0;
- addr.$set(new$1);
- return new$1;
- };
- $pkg.AddInt32 = AddInt32;
- LoadUint32 = function(addr) {
- var $ptr, addr;
- return addr.$get();
- };
- $pkg.LoadUint32 = LoadUint32;
- StoreInt32 = function(addr, val) {
- var $ptr, addr, val;
- addr.$set(val);
- };
- $pkg.StoreInt32 = StoreInt32;
- StoreUint32 = function(addr, val) {
- var $ptr, addr, val;
- addr.$set(val);
- };
- $pkg.StoreUint32 = StoreUint32;
- Value.ptr.prototype.Load = function() {
- var $ptr, v, x;
- x = $ifaceNil;
- v = this;
- x = v.v;
- return x;
- };
- Value.prototype.Load = function() { return this.$val.Load(); };
- Value.ptr.prototype.Store = function(x) {
- var $ptr, v, x;
- v = this;
- if ($interfaceIsEqual(x, $ifaceNil)) {
- $panic(new $String("sync/atomic: store of nil value into Value"));
- }
- if (!($interfaceIsEqual(v.v, $ifaceNil)) && !(x.constructor === v.v.constructor)) {
- $panic(new $String("sync/atomic: store of inconsistently typed value into Value"));
- }
- v.v = x;
- };
- Value.prototype.Store = function(x) { return this.$val.Store(x); };
- ptrType.methods = [{prop: "Load", name: "Load", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Store", name: "Store", pkg: "", typ: $funcType([$emptyInterface], [], false)}];
- Value.init([{prop: "v", name: "v", pkg: "sync/atomic", typ: $emptyInterface, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["sync"] = (function() {
- var $pkg = {}, $init, runtime, atomic, Pool, Mutex, Locker, Once, poolLocal, syncSema, RWMutex, rlocker, ptrType, sliceType, chanType, ptrType$1, sliceType$1, ptrType$4, ptrType$6, sliceType$3, ptrType$7, ptrType$8, funcType, ptrType$10, funcType$1, ptrType$11, arrayType, semWaiters, allPools, runtime_Syncsemcheck, runtime_registerPoolCleanup, runtime_Semacquire, runtime_Semrelease, poolCleanup, init, indexLocal, raceEnable, init$1;
- runtime = $packages["runtime"];
- atomic = $packages["sync/atomic"];
- Pool = $pkg.Pool = $newType(0, $kindStruct, "sync.Pool", "Pool", "sync", function(local_, localSize_, store_, New_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.local = 0;
- this.localSize = 0;
- this.store = sliceType$3.nil;
- this.New = $throwNilPointerError;
- return;
- }
- this.local = local_;
- this.localSize = localSize_;
- this.store = store_;
- this.New = New_;
- });
- Mutex = $pkg.Mutex = $newType(0, $kindStruct, "sync.Mutex", "Mutex", "sync", function(state_, sema_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.state = 0;
- this.sema = 0;
- return;
- }
- this.state = state_;
- this.sema = sema_;
- });
- Locker = $pkg.Locker = $newType(8, $kindInterface, "sync.Locker", "Locker", "sync", null);
- Once = $pkg.Once = $newType(0, $kindStruct, "sync.Once", "Once", "sync", function(m_, done_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.m = new Mutex.ptr();
- this.done = 0;
- return;
- }
- this.m = m_;
- this.done = done_;
- });
- poolLocal = $pkg.poolLocal = $newType(0, $kindStruct, "sync.poolLocal", "poolLocal", "sync", function(private$0_, shared_, Mutex_, pad_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.private$0 = $ifaceNil;
- this.shared = sliceType$3.nil;
- this.Mutex = new Mutex.ptr();
- this.pad = arrayType.zero();
- return;
- }
- this.private$0 = private$0_;
- this.shared = shared_;
- this.Mutex = Mutex_;
- this.pad = pad_;
- });
- syncSema = $pkg.syncSema = $newType(0, $kindStruct, "sync.syncSema", "syncSema", "sync", function(lock_, head_, tail_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.lock = 0;
- this.head = 0;
- this.tail = 0;
- return;
- }
- this.lock = lock_;
- this.head = head_;
- this.tail = tail_;
- });
- RWMutex = $pkg.RWMutex = $newType(0, $kindStruct, "sync.RWMutex", "RWMutex", "sync", function(w_, writerSem_, readerSem_, readerCount_, readerWait_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.w = new Mutex.ptr();
- this.writerSem = 0;
- this.readerSem = 0;
- this.readerCount = 0;
- this.readerWait = 0;
- return;
- }
- this.w = w_;
- this.writerSem = writerSem_;
- this.readerSem = readerSem_;
- this.readerCount = readerCount_;
- this.readerWait = readerWait_;
- });
- rlocker = $pkg.rlocker = $newType(0, $kindStruct, "sync.rlocker", "rlocker", "sync", function(w_, writerSem_, readerSem_, readerCount_, readerWait_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.w = new Mutex.ptr();
- this.writerSem = 0;
- this.readerSem = 0;
- this.readerCount = 0;
- this.readerWait = 0;
- return;
- }
- this.w = w_;
- this.writerSem = writerSem_;
- this.readerSem = readerSem_;
- this.readerCount = readerCount_;
- this.readerWait = readerWait_;
- });
- ptrType = $ptrType(Pool);
- sliceType = $sliceType(ptrType);
- chanType = $chanType($Bool, false, false);
- ptrType$1 = $ptrType($Uint32);
- sliceType$1 = $sliceType(chanType);
- ptrType$4 = $ptrType($Int32);
- ptrType$6 = $ptrType(poolLocal);
- sliceType$3 = $sliceType($emptyInterface);
- ptrType$7 = $ptrType(rlocker);
- ptrType$8 = $ptrType(RWMutex);
- funcType = $funcType([], [$emptyInterface], false);
- ptrType$10 = $ptrType(Mutex);
- funcType$1 = $funcType([], [], false);
- ptrType$11 = $ptrType(Once);
- arrayType = $arrayType($Uint8, 128);
- runtime_Syncsemcheck = function(size) {
- var $ptr, size;
- };
- Pool.ptr.prototype.Get = function() {
- var $ptr, _r, p, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (p.store.$length === 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.store.$length === 0) { */ case 1:
- /* */ if (!(p.New === $throwNilPointerError)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(p.New === $throwNilPointerError)) { */ case 3:
- _r = p.New(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 4:
- return $ifaceNil;
- /* } */ case 2:
- x$2 = (x = p.store, x$1 = p.store.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0));
- return x$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Pool.prototype.Get = function() { return this.$val.Get(); };
- Pool.ptr.prototype.Put = function(x) {
- var $ptr, p, x;
- p = this;
- if ($interfaceIsEqual(x, $ifaceNil)) {
- return;
- }
- p.store = $append(p.store, x);
- };
- Pool.prototype.Put = function(x) { return this.$val.Put(x); };
- runtime_registerPoolCleanup = function(cleanup) {
- var $ptr, cleanup;
- };
- runtime_Semacquire = function(s) {
- var $ptr, _entry, _key, _r, ch, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r = $f._r; ch = $f.ch; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (s.$get() === 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (s.$get() === 0) { */ case 1:
- ch = new chanType(0);
- _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: $append((_entry = semWaiters[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : sliceType$1.nil), ch) };
- _r = $recv(ch); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r[0];
- /* } */ case 2:
- s.$set(s.$get() - (1) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: runtime_Semacquire }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r = _r; $f.ch = ch; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- runtime_Semrelease = function(s) {
- var $ptr, _entry, _key, ch, s, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; ch = $f.ch; s = $f.s; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s.$set(s.$get() + (1) >>> 0);
- w = (_entry = semWaiters[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.v : sliceType$1.nil);
- if (w.$length === 0) {
- return;
- }
- ch = (0 >= w.$length ? $throwRuntimeError("index out of range") : w.$array[w.$offset + 0]);
- w = $subslice(w, 1);
- _key = s; (semWaiters || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key)] = { k: _key, v: w };
- if (w.$length === 0) {
- delete semWaiters[ptrType$1.keyFor(s)];
- }
- $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f.ch = ch; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- Mutex.ptr.prototype.Lock = function() {
- var $ptr, awoke, m, new$1, old, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; awoke = $f.awoke; m = $f.m; new$1 = $f.new$1; old = $f.old; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), 0, 1)) {
- return;
- }
- awoke = false;
- /* while (true) { */ case 1:
- old = m.state;
- new$1 = old | 1;
- if (!(((old & 1) === 0))) {
- new$1 = old + 4 >> 0;
- }
- if (awoke) {
- new$1 = (new$1 & ~(2)) >> 0;
- }
- /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 3:
- if ((old & 1) === 0) {
- /* break; */ $s = 2; continue;
- }
- $r = runtime_Semacquire((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m)))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- awoke = true;
- /* } */ case 4:
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Lock }; } $f.$ptr = $ptr; $f.awoke = awoke; $f.m = m; $f.new$1 = new$1; $f.old = old; $f.$s = $s; $f.$r = $r; return $f;
- };
- Mutex.prototype.Lock = function() { return this.$val.Lock(); };
- Mutex.ptr.prototype.Unlock = function() {
- var $ptr, m, new$1, old, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; m = $f.m; new$1 = $f.new$1; old = $f.old; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- new$1 = atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), -1);
- if ((((new$1 + 1 >> 0)) & 1) === 0) {
- $panic(new $String("sync: unlock of unlocked mutex"));
- }
- old = new$1;
- /* while (true) { */ case 1:
- if (((old >> 2 >> 0) === 0) || !(((old & 3) === 0))) {
- return;
- }
- new$1 = ((old - 4 >> 0)) | 2;
- /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 3:
- $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m)))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 4:
- old = m.state;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Unlock }; } $f.$ptr = $ptr; $f.m = m; $f.new$1 = new$1; $f.old = old; $f.$s = $s; $f.$r = $r; return $f;
- };
- Mutex.prototype.Unlock = function() { return this.$val.Unlock(); };
- Once.ptr.prototype.Do = function(f) {
- var $ptr, f, o, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; o = $f.o; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- o = this;
- if (atomic.LoadUint32((o.$ptr_done || (o.$ptr_done = new ptrType$1(function() { return this.$target.done; }, function($v) { this.$target.done = $v; }, o)))) === 1) {
- return;
- }
- $r = o.m.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(o.m, "Unlock"), []]);
- /* */ if (o.done === 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (o.done === 0) { */ case 2:
- $deferred.push([atomic.StoreUint32, [(o.$ptr_done || (o.$ptr_done = new ptrType$1(function() { return this.$target.done; }, function($v) { this.$target.done = $v; }, o))), 1]]);
- $r = f(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Once.ptr.prototype.Do }; } $f.$ptr = $ptr; $f.f = f; $f.o = o; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Once.prototype.Do = function(f) { return this.$val.Do(f); };
- poolCleanup = function() {
- var $ptr, _i, _i$1, _ref, _ref$1, i, i$1, j, l, p, x;
- _ref = allPools;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- p = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= allPools.$length) ? $throwRuntimeError("index out of range") : allPools.$array[allPools.$offset + i] = ptrType.nil);
- i$1 = 0;
- while (true) {
- if (!(i$1 < (p.localSize >> 0))) { break; }
- l = indexLocal(p.local, i$1);
- l.private$0 = $ifaceNil;
- _ref$1 = l.shared;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- j = _i$1;
- (x = l.shared, ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j] = $ifaceNil));
- _i$1++;
- }
- l.shared = sliceType$3.nil;
- i$1 = i$1 + (1) >> 0;
- }
- p.local = 0;
- p.localSize = 0;
- _i++;
- }
- allPools = new sliceType([]);
- };
- init = function() {
- var $ptr;
- runtime_registerPoolCleanup(poolCleanup);
- };
- indexLocal = function(l, i) {
- var $ptr, i, l, x;
- return (x = l, (x.nilCheck, ((i < 0 || i >= x.length) ? $throwRuntimeError("index out of range") : x[i])));
- };
- raceEnable = function() {
- var $ptr;
- };
- init$1 = function() {
- var $ptr, s;
- s = $clone(new syncSema.ptr(), syncSema);
- runtime_Syncsemcheck(12);
- };
- RWMutex.ptr.prototype.RLock = function() {
- var $ptr, rw, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- rw = this;
- /* */ if (atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$4(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1) < 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$4(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1) < 0) { */ case 1:
- $r = runtime_Semacquire((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw)))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RLock }; } $f.$ptr = $ptr; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f;
- };
- RWMutex.prototype.RLock = function() { return this.$val.RLock(); };
- RWMutex.ptr.prototype.RUnlock = function() {
- var $ptr, r, rw, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- rw = this;
- r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$4(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), -1);
- /* */ if (r < 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (r < 0) { */ case 1:
- if (((r + 1 >> 0) === 0) || ((r + 1 >> 0) === -1073741824)) {
- raceEnable();
- $panic(new $String("sync: RUnlock of unlocked RWMutex"));
- }
- /* */ if (atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$4(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), -1) === 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$4(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), -1) === 0) { */ case 3:
- $r = runtime_Semrelease((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw)))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RUnlock }; } $f.$ptr = $ptr; $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f;
- };
- RWMutex.prototype.RUnlock = function() { return this.$val.RUnlock(); };
- RWMutex.ptr.prototype.Lock = function() {
- var $ptr, r, rw, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- rw = this;
- $r = rw.w.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$4(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), -1073741824) + 1073741824 >> 0;
- /* */ if (!((r === 0)) && !((atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$4(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), r) === 0))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((r === 0)) && !((atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$4(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), r) === 0))) { */ case 2:
- $r = runtime_Semacquire((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw)))); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Lock }; } $f.$ptr = $ptr; $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f;
- };
- RWMutex.prototype.Lock = function() { return this.$val.Lock(); };
- RWMutex.ptr.prototype.Unlock = function() {
- var $ptr, i, r, rw, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- rw = this;
- r = atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$4(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1073741824);
- if (r >= 1073741824) {
- raceEnable();
- $panic(new $String("sync: Unlock of unlocked RWMutex"));
- }
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < (r >> 0))) { break; } */ if(!(i < (r >> 0))) { $s = 2; continue; }
- $r = runtime_Semrelease((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw)))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- $r = rw.w.Unlock(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Unlock }; } $f.$ptr = $ptr; $f.i = i; $f.r = r; $f.rw = rw; $f.$s = $s; $f.$r = $r; return $f;
- };
- RWMutex.prototype.Unlock = function() { return this.$val.Unlock(); };
- RWMutex.ptr.prototype.RLocker = function() {
- var $ptr, rw;
- rw = this;
- return $pointerOfStructConversion(rw, ptrType$7);
- };
- RWMutex.prototype.RLocker = function() { return this.$val.RLocker(); };
- rlocker.ptr.prototype.Lock = function() {
- var $ptr, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- $r = $pointerOfStructConversion(r, ptrType$8).RLock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Lock }; } $f.$ptr = $ptr; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- rlocker.prototype.Lock = function() { return this.$val.Lock(); };
- rlocker.ptr.prototype.Unlock = function() {
- var $ptr, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- $r = $pointerOfStructConversion(r, ptrType$8).RUnlock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Unlock }; } $f.$ptr = $ptr; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- rlocker.prototype.Unlock = function() { return this.$val.Unlock(); };
- ptrType.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Put", name: "Put", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "getSlow", name: "getSlow", pkg: "sync", typ: $funcType([], [$emptyInterface], false)}, {prop: "pin", name: "pin", pkg: "sync", typ: $funcType([], [ptrType$6], false)}, {prop: "pinSlow", name: "pinSlow", pkg: "sync", typ: $funcType([], [ptrType$6], false)}];
- ptrType$10.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}];
- ptrType$11.methods = [{prop: "Do", name: "Do", pkg: "", typ: $funcType([funcType$1], [], false)}];
- ptrType$8.methods = [{prop: "RLock", name: "RLock", pkg: "", typ: $funcType([], [], false)}, {prop: "RUnlock", name: "RUnlock", pkg: "", typ: $funcType([], [], false)}, {prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}, {prop: "RLocker", name: "RLocker", pkg: "", typ: $funcType([], [Locker], false)}];
- ptrType$7.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}];
- Pool.init([{prop: "local", name: "local", pkg: "sync", typ: $UnsafePointer, tag: ""}, {prop: "localSize", name: "localSize", pkg: "sync", typ: $Uintptr, tag: ""}, {prop: "store", name: "store", pkg: "sync", typ: sliceType$3, tag: ""}, {prop: "New", name: "New", pkg: "", typ: funcType, tag: ""}]);
- Mutex.init([{prop: "state", name: "state", pkg: "sync", typ: $Int32, tag: ""}, {prop: "sema", name: "sema", pkg: "sync", typ: $Uint32, tag: ""}]);
- Locker.init([{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]);
- Once.init([{prop: "m", name: "m", pkg: "sync", typ: Mutex, tag: ""}, {prop: "done", name: "done", pkg: "sync", typ: $Uint32, tag: ""}]);
- poolLocal.init([{prop: "private$0", name: "private", pkg: "sync", typ: $emptyInterface, tag: ""}, {prop: "shared", name: "shared", pkg: "sync", typ: sliceType$3, tag: ""}, {prop: "Mutex", name: "", pkg: "", typ: Mutex, tag: ""}, {prop: "pad", name: "pad", pkg: "sync", typ: arrayType, tag: ""}]);
- syncSema.init([{prop: "lock", name: "lock", pkg: "sync", typ: $Uintptr, tag: ""}, {prop: "head", name: "head", pkg: "sync", typ: $UnsafePointer, tag: ""}, {prop: "tail", name: "tail", pkg: "sync", typ: $UnsafePointer, tag: ""}]);
- RWMutex.init([{prop: "w", name: "w", pkg: "sync", typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", pkg: "sync", typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", pkg: "sync", typ: $Int32, tag: ""}]);
- rlocker.init([{prop: "w", name: "w", pkg: "sync", typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", pkg: "sync", typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", pkg: "sync", typ: $Int32, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = runtime.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = atomic.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- allPools = sliceType.nil;
- semWaiters = new $Map();
- init();
- init$1();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["io"] = (function() {
- var $pkg = {}, $init, errors, sync, Reader, Writer, ReaderFrom, WriterTo, ByteReader, RuneReader, RuneScanner, stringWriter, sliceType, errWhence, errOffset, WriteString, ReadAtLeast, ReadFull, Copy;
- errors = $packages["errors"];
- sync = $packages["sync"];
- Reader = $pkg.Reader = $newType(8, $kindInterface, "io.Reader", "Reader", "io", null);
- Writer = $pkg.Writer = $newType(8, $kindInterface, "io.Writer", "Writer", "io", null);
- ReaderFrom = $pkg.ReaderFrom = $newType(8, $kindInterface, "io.ReaderFrom", "ReaderFrom", "io", null);
- WriterTo = $pkg.WriterTo = $newType(8, $kindInterface, "io.WriterTo", "WriterTo", "io", null);
- ByteReader = $pkg.ByteReader = $newType(8, $kindInterface, "io.ByteReader", "ByteReader", "io", null);
- RuneReader = $pkg.RuneReader = $newType(8, $kindInterface, "io.RuneReader", "RuneReader", "io", null);
- RuneScanner = $pkg.RuneScanner = $newType(8, $kindInterface, "io.RuneScanner", "RuneScanner", "io", null);
- stringWriter = $pkg.stringWriter = $newType(8, $kindInterface, "io.stringWriter", "stringWriter", "io", null);
- sliceType = $sliceType($Uint8);
- WriteString = function(w, s) {
- var $ptr, _r, _r$1, _tuple, _tuple$1, _tuple$2, err, n, ok, s, sw, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; err = $f.err; n = $f.n; ok = $f.ok; s = $f.s; sw = $f.sw; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _tuple = $assertType(w, stringWriter, true); sw = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _r = sw.WriteString(s); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = _r; n = _tuple$1[0]; err = _tuple$1[1];
- return [n, err];
- /* } */ case 2:
- _r$1 = w.Write(new sliceType($stringToBytes(s))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$2 = _r$1; n = _tuple$2[0]; err = _tuple$2[1];
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: WriteString }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.err = err; $f.n = n; $f.ok = ok; $f.s = s; $f.sw = sw; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.WriteString = WriteString;
- ReadAtLeast = function(r, buf, min) {
- var $ptr, _r, _tmp, _tmp$1, _tuple, buf, err, min, n, nn, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; buf = $f.buf; err = $f.err; min = $f.min; n = $f.n; nn = $f.nn; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- if (buf.$length < min) {
- _tmp = 0; _tmp$1 = $pkg.ErrShortBuffer; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- /* while (true) { */ case 1:
- /* if (!(n < min && $interfaceIsEqual(err, $ifaceNil))) { break; } */ if(!(n < min && $interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- nn = 0;
- _r = r.Read($subslice(buf, n)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; nn = _tuple[0]; err = _tuple[1];
- n = n + (nn) >> 0;
- /* } */ $s = 1; continue; case 2:
- if (n >= min) {
- err = $ifaceNil;
- } else if (n > 0 && $interfaceIsEqual(err, $pkg.EOF)) {
- err = $pkg.ErrUnexpectedEOF;
- }
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ReadAtLeast }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.min = min; $f.n = n; $f.nn = nn; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ReadAtLeast = ReadAtLeast;
- ReadFull = function(r, buf) {
- var $ptr, _r, _tuple, buf, err, n, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; buf = $f.buf; err = $f.err; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _r = ReadAtLeast(r, buf, buf.$length); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; n = _tuple[0]; err = _tuple[1];
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ReadFull }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ReadFull = ReadFull;
- Copy = function(dst, src) {
- var $ptr, _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, buf, dst, er, err, ew, nr, nw, ok, ok$1, rt, src, written, wt, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; buf = $f.buf; dst = $f.dst; er = $f.er; err = $f.err; ew = $f.ew; nr = $f.nr; nw = $f.nw; ok = $f.ok; ok$1 = $f.ok$1; rt = $f.rt; src = $f.src; written = $f.written; wt = $f.wt; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- written = new $Int64(0, 0);
- err = $ifaceNil;
- _tuple = $assertType(src, WriterTo, true); wt = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _r = wt.WriteTo(dst); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = _r; written = _tuple$1[0]; err = _tuple$1[1];
- return [written, err];
- /* } */ case 2:
- _tuple$2 = $assertType(dst, ReaderFrom, true); rt = _tuple$2[0]; ok$1 = _tuple$2[1];
- /* */ if (ok$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (ok$1) { */ case 4:
- _r$1 = rt.ReadFrom(src); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$3 = _r$1; written = _tuple$3[0]; err = _tuple$3[1];
- return [written, err];
- /* } */ case 5:
- buf = $makeSlice(sliceType, 32768);
- /* while (true) { */ case 7:
- _r$2 = src.Read(buf); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$4 = _r$2; nr = _tuple$4[0]; er = _tuple$4[1];
- /* */ if (nr > 0) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (nr > 0) { */ case 10:
- _r$3 = dst.Write($subslice(buf, 0, nr)); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$5 = _r$3; nw = _tuple$5[0]; ew = _tuple$5[1];
- if (nw > 0) {
- written = (x = new $Int64(0, nw), new $Int64(written.$high + x.$high, written.$low + x.$low));
- }
- if (!($interfaceIsEqual(ew, $ifaceNil))) {
- err = ew;
- /* break; */ $s = 8; continue;
- }
- if (!((nr === nw))) {
- err = $pkg.ErrShortWrite;
- /* break; */ $s = 8; continue;
- }
- /* } */ case 11:
- if ($interfaceIsEqual(er, $pkg.EOF)) {
- /* break; */ $s = 8; continue;
- }
- if (!($interfaceIsEqual(er, $ifaceNil))) {
- err = er;
- /* break; */ $s = 8; continue;
- }
- /* } */ $s = 7; continue; case 8:
- _tmp = written; _tmp$1 = err; written = _tmp; err = _tmp$1;
- return [written, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Copy }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.buf = buf; $f.dst = dst; $f.er = er; $f.err = err; $f.ew = ew; $f.nr = nr; $f.nw = nw; $f.ok = ok; $f.ok$1 = ok$1; $f.rt = rt; $f.src = src; $f.written = written; $f.wt = wt; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Copy = Copy;
- Reader.init([{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]);
- Writer.init([{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]);
- ReaderFrom.init([{prop: "ReadFrom", name: "ReadFrom", pkg: "", typ: $funcType([Reader], [$Int64, $error], false)}]);
- WriterTo.init([{prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([Writer], [$Int64, $error], false)}]);
- ByteReader.init([{prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}]);
- RuneReader.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}]);
- RuneScanner.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}]);
- stringWriter.init([{prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.ErrShortWrite = errors.New("short write");
- $pkg.ErrShortBuffer = errors.New("short buffer");
- $pkg.EOF = errors.New("EOF");
- $pkg.ErrUnexpectedEOF = errors.New("unexpected EOF");
- $pkg.ErrNoProgress = errors.New("multiple Read calls return no data or error");
- errWhence = errors.New("Seek: invalid whence");
- errOffset = errors.New("Seek: invalid offset");
- $pkg.ErrClosedPipe = errors.New("io: read/write on closed pipe");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["unicode"] = (function() {
- var $pkg = {}, $init, RangeTable, Range16, Range32, CaseRange, d, foldPair, sliceType, sliceType$1, ptrType, sliceType$2, sliceType$3, sliceType$4, _L, _Lu, _M, _N, _Nd, _P, _S, _Zs, _White_Space, _CaseRanges, properties, caseOrbit, to, IsDigit, IsGraphic, In, IsLetter, IsSpace, is16, is32, Is, isExcludingLatin, IsUpper, To, ToUpper, ToLower, SimpleFold;
- RangeTable = $pkg.RangeTable = $newType(0, $kindStruct, "unicode.RangeTable", "RangeTable", "unicode", function(R16_, R32_, LatinOffset_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.R16 = sliceType.nil;
- this.R32 = sliceType$1.nil;
- this.LatinOffset = 0;
- return;
- }
- this.R16 = R16_;
- this.R32 = R32_;
- this.LatinOffset = LatinOffset_;
- });
- Range16 = $pkg.Range16 = $newType(0, $kindStruct, "unicode.Range16", "Range16", "unicode", function(Lo_, Hi_, Stride_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lo = 0;
- this.Hi = 0;
- this.Stride = 0;
- return;
- }
- this.Lo = Lo_;
- this.Hi = Hi_;
- this.Stride = Stride_;
- });
- Range32 = $pkg.Range32 = $newType(0, $kindStruct, "unicode.Range32", "Range32", "unicode", function(Lo_, Hi_, Stride_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lo = 0;
- this.Hi = 0;
- this.Stride = 0;
- return;
- }
- this.Lo = Lo_;
- this.Hi = Hi_;
- this.Stride = Stride_;
- });
- CaseRange = $pkg.CaseRange = $newType(0, $kindStruct, "unicode.CaseRange", "CaseRange", "unicode", function(Lo_, Hi_, Delta_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lo = 0;
- this.Hi = 0;
- this.Delta = d.zero();
- return;
- }
- this.Lo = Lo_;
- this.Hi = Hi_;
- this.Delta = Delta_;
- });
- d = $pkg.d = $newType(12, $kindArray, "unicode.d", "d", "unicode", null);
- foldPair = $pkg.foldPair = $newType(0, $kindStruct, "unicode.foldPair", "foldPair", "unicode", function(From_, To_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.From = 0;
- this.To = 0;
- return;
- }
- this.From = From_;
- this.To = To_;
- });
- sliceType = $sliceType(Range16);
- sliceType$1 = $sliceType(Range32);
- ptrType = $ptrType(RangeTable);
- sliceType$2 = $sliceType(ptrType);
- sliceType$3 = $sliceType(CaseRange);
- sliceType$4 = $sliceType(foldPair);
- to = function(_case, r, caseRange) {
- var $ptr, _case, _q, caseRange, cr, delta, hi, lo, m, r, x;
- if (_case < 0 || 3 <= _case) {
- return 65533;
- }
- lo = 0;
- hi = caseRange.$length;
- while (true) {
- if (!(lo < hi)) { break; }
- m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- cr = ((m < 0 || m >= caseRange.$length) ? $throwRuntimeError("index out of range") : caseRange.$array[caseRange.$offset + m]);
- if ((cr.Lo >> 0) <= r && r <= (cr.Hi >> 0)) {
- delta = (x = cr.Delta, ((_case < 0 || _case >= x.length) ? $throwRuntimeError("index out of range") : x[_case]));
- if (delta > 1114111) {
- return (cr.Lo >> 0) + ((((((r - (cr.Lo >> 0) >> 0)) & ~1) >> 0) | ((_case & 1) >> 0))) >> 0;
- }
- return r + delta >> 0;
- }
- if (r < (cr.Lo >> 0)) {
- hi = m;
- } else {
- lo = m + 1 >> 0;
- }
- }
- return r;
- };
- IsDigit = function(r) {
- var $ptr, r;
- if (r <= 255) {
- return 48 <= r && r <= 57;
- }
- return isExcludingLatin($pkg.Digit, r);
- };
- $pkg.IsDigit = IsDigit;
- IsGraphic = function(r) {
- var $ptr, r, x;
- if ((r >>> 0) <= 255) {
- return !(((((x = (r << 24 >>> 24), ((x < 0 || x >= properties.length) ? $throwRuntimeError("index out of range") : properties[x])) & 144) >>> 0) === 0));
- }
- return In(r, $pkg.GraphicRanges);
- };
- $pkg.IsGraphic = IsGraphic;
- In = function(r, ranges) {
- var $ptr, _i, _ref, inside, r, ranges;
- _ref = ranges;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- inside = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (Is(inside, r)) {
- return true;
- }
- _i++;
- }
- return false;
- };
- $pkg.In = In;
- IsLetter = function(r) {
- var $ptr, r, x;
- if ((r >>> 0) <= 255) {
- return !(((((x = (r << 24 >>> 24), ((x < 0 || x >= properties.length) ? $throwRuntimeError("index out of range") : properties[x])) & 96) >>> 0) === 0));
- }
- return isExcludingLatin($pkg.Letter, r);
- };
- $pkg.IsLetter = IsLetter;
- IsSpace = function(r) {
- var $ptr, _ref, r;
- if ((r >>> 0) <= 255) {
- _ref = r;
- if (_ref === 9 || _ref === 10 || _ref === 11 || _ref === 12 || _ref === 13 || _ref === 32 || _ref === 133 || _ref === 160) {
- return true;
- }
- return false;
- }
- return isExcludingLatin($pkg.White_Space, r);
- };
- $pkg.IsSpace = IsSpace;
- is16 = function(ranges, r) {
- var $ptr, _i, _q, _r, _r$1, _ref, hi, i, lo, m, r, range_, range_$1, ranges;
- if (ranges.$length <= 18 || r <= 255) {
- _ref = ranges;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- range_ = ((i < 0 || i >= ranges.$length) ? $throwRuntimeError("index out of range") : ranges.$array[ranges.$offset + i]);
- if (r < range_.Lo) {
- return false;
- }
- if (r <= range_.Hi) {
- return (_r = ((r - range_.Lo << 16 >>> 16)) % range_.Stride, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0;
- }
- _i++;
- }
- return false;
- }
- lo = 0;
- hi = ranges.$length;
- while (true) {
- if (!(lo < hi)) { break; }
- m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- range_$1 = ((m < 0 || m >= ranges.$length) ? $throwRuntimeError("index out of range") : ranges.$array[ranges.$offset + m]);
- if (range_$1.Lo <= r && r <= range_$1.Hi) {
- return (_r$1 = ((r - range_$1.Lo << 16 >>> 16)) % range_$1.Stride, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0;
- }
- if (r < range_$1.Lo) {
- hi = m;
- } else {
- lo = m + 1 >> 0;
- }
- }
- return false;
- };
- is32 = function(ranges, r) {
- var $ptr, _i, _q, _r, _r$1, _ref, hi, i, lo, m, r, range_, range_$1, ranges;
- if (ranges.$length <= 18) {
- _ref = ranges;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- range_ = ((i < 0 || i >= ranges.$length) ? $throwRuntimeError("index out of range") : ranges.$array[ranges.$offset + i]);
- if (r < range_.Lo) {
- return false;
- }
- if (r <= range_.Hi) {
- return (_r = ((r - range_.Lo >>> 0)) % range_.Stride, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0;
- }
- _i++;
- }
- return false;
- }
- lo = 0;
- hi = ranges.$length;
- while (true) {
- if (!(lo < hi)) { break; }
- m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- range_$1 = $clone(((m < 0 || m >= ranges.$length) ? $throwRuntimeError("index out of range") : ranges.$array[ranges.$offset + m]), Range32);
- if (range_$1.Lo <= r && r <= range_$1.Hi) {
- return (_r$1 = ((r - range_$1.Lo >>> 0)) % range_$1.Stride, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0;
- }
- if (r < range_$1.Lo) {
- hi = m;
- } else {
- lo = m + 1 >> 0;
- }
- }
- return false;
- };
- Is = function(rangeTab, r) {
- var $ptr, r, r16, r32, rangeTab, x;
- r16 = rangeTab.R16;
- if (r16.$length > 0 && r <= ((x = r16.$length - 1 >> 0, ((x < 0 || x >= r16.$length) ? $throwRuntimeError("index out of range") : r16.$array[r16.$offset + x])).Hi >> 0)) {
- return is16(r16, (r << 16 >>> 16));
- }
- r32 = rangeTab.R32;
- if (r32.$length > 0 && r >= ((0 >= r32.$length ? $throwRuntimeError("index out of range") : r32.$array[r32.$offset + 0]).Lo >> 0)) {
- return is32(r32, (r >>> 0));
- }
- return false;
- };
- $pkg.Is = Is;
- isExcludingLatin = function(rangeTab, r) {
- var $ptr, off, r, r16, r32, rangeTab, x;
- r16 = rangeTab.R16;
- off = rangeTab.LatinOffset;
- if (r16.$length > off && r <= ((x = r16.$length - 1 >> 0, ((x < 0 || x >= r16.$length) ? $throwRuntimeError("index out of range") : r16.$array[r16.$offset + x])).Hi >> 0)) {
- return is16($subslice(r16, off), (r << 16 >>> 16));
- }
- r32 = rangeTab.R32;
- if (r32.$length > 0 && r >= ((0 >= r32.$length ? $throwRuntimeError("index out of range") : r32.$array[r32.$offset + 0]).Lo >> 0)) {
- return is32(r32, (r >>> 0));
- }
- return false;
- };
- IsUpper = function(r) {
- var $ptr, r, x;
- if ((r >>> 0) <= 255) {
- return (((x = (r << 24 >>> 24), ((x < 0 || x >= properties.length) ? $throwRuntimeError("index out of range") : properties[x])) & 96) >>> 0) === 32;
- }
- return isExcludingLatin($pkg.Upper, r);
- };
- $pkg.IsUpper = IsUpper;
- To = function(_case, r) {
- var $ptr, _case, r;
- return to(_case, r, $pkg.CaseRanges);
- };
- $pkg.To = To;
- ToUpper = function(r) {
- var $ptr, r;
- if (r <= 127) {
- if (97 <= r && r <= 122) {
- r = r - (32) >> 0;
- }
- return r;
- }
- return To(0, r);
- };
- $pkg.ToUpper = ToUpper;
- ToLower = function(r) {
- var $ptr, r;
- if (r <= 127) {
- if (65 <= r && r <= 90) {
- r = r + (32) >> 0;
- }
- return r;
- }
- return To(1, r);
- };
- $pkg.ToLower = ToLower;
- SimpleFold = function(r) {
- var $ptr, _q, hi, l, lo, m, r;
- lo = 0;
- hi = caseOrbit.$length;
- while (true) {
- if (!(lo < hi)) { break; }
- m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- if ((((m < 0 || m >= caseOrbit.$length) ? $throwRuntimeError("index out of range") : caseOrbit.$array[caseOrbit.$offset + m]).From >> 0) < r) {
- lo = m + 1 >> 0;
- } else {
- hi = m;
- }
- }
- if (lo < caseOrbit.$length && ((((lo < 0 || lo >= caseOrbit.$length) ? $throwRuntimeError("index out of range") : caseOrbit.$array[caseOrbit.$offset + lo]).From >> 0) === r)) {
- return (((lo < 0 || lo >= caseOrbit.$length) ? $throwRuntimeError("index out of range") : caseOrbit.$array[caseOrbit.$offset + lo]).To >> 0);
- }
- l = ToLower(r);
- if (!((l === r))) {
- return l;
- }
- return ToUpper(r);
- };
- $pkg.SimpleFold = SimpleFold;
- RangeTable.init([{prop: "R16", name: "R16", pkg: "", typ: sliceType, tag: ""}, {prop: "R32", name: "R32", pkg: "", typ: sliceType$1, tag: ""}, {prop: "LatinOffset", name: "LatinOffset", pkg: "", typ: $Int, tag: ""}]);
- Range16.init([{prop: "Lo", name: "Lo", pkg: "", typ: $Uint16, tag: ""}, {prop: "Hi", name: "Hi", pkg: "", typ: $Uint16, tag: ""}, {prop: "Stride", name: "Stride", pkg: "", typ: $Uint16, tag: ""}]);
- Range32.init([{prop: "Lo", name: "Lo", pkg: "", typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", pkg: "", typ: $Uint32, tag: ""}, {prop: "Stride", name: "Stride", pkg: "", typ: $Uint32, tag: ""}]);
- CaseRange.init([{prop: "Lo", name: "Lo", pkg: "", typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", pkg: "", typ: $Uint32, tag: ""}, {prop: "Delta", name: "Delta", pkg: "", typ: d, tag: ""}]);
- d.init($Int32, 3);
- foldPair.init([{prop: "From", name: "From", pkg: "", typ: $Uint16, tag: ""}, {prop: "To", name: "To", pkg: "", typ: $Uint16, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _L = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(97, 122, 1), new Range16.ptr(170, 181, 11), new Range16.ptr(186, 192, 6), new Range16.ptr(193, 214, 1), new Range16.ptr(216, 246, 1), new Range16.ptr(248, 705, 1), new Range16.ptr(710, 721, 1), new Range16.ptr(736, 740, 1), new Range16.ptr(748, 750, 2), new Range16.ptr(880, 884, 1), new Range16.ptr(886, 887, 1), new Range16.ptr(890, 893, 1), new Range16.ptr(895, 902, 7), new Range16.ptr(904, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 929, 1), new Range16.ptr(931, 1013, 1), new Range16.ptr(1015, 1153, 1), new Range16.ptr(1162, 1327, 1), new Range16.ptr(1329, 1366, 1), new Range16.ptr(1369, 1377, 8), new Range16.ptr(1378, 1415, 1), new Range16.ptr(1488, 1514, 1), new Range16.ptr(1520, 1522, 1), new Range16.ptr(1568, 1610, 1), new Range16.ptr(1646, 1647, 1), new Range16.ptr(1649, 1747, 1), new Range16.ptr(1749, 1765, 16), new Range16.ptr(1766, 1774, 8), new Range16.ptr(1775, 1786, 11), new Range16.ptr(1787, 1788, 1), new Range16.ptr(1791, 1808, 17), new Range16.ptr(1810, 1839, 1), new Range16.ptr(1869, 1957, 1), new Range16.ptr(1969, 1994, 25), new Range16.ptr(1995, 2026, 1), new Range16.ptr(2036, 2037, 1), new Range16.ptr(2042, 2048, 6), new Range16.ptr(2049, 2069, 1), new Range16.ptr(2074, 2084, 10), new Range16.ptr(2088, 2112, 24), new Range16.ptr(2113, 2136, 1), new Range16.ptr(2208, 2226, 1), new Range16.ptr(2308, 2361, 1), new Range16.ptr(2365, 2384, 19), new Range16.ptr(2392, 2401, 1), new Range16.ptr(2417, 2432, 1), new Range16.ptr(2437, 2444, 1), new Range16.ptr(2447, 2448, 1), new Range16.ptr(2451, 2472, 1), new Range16.ptr(2474, 2480, 1), new Range16.ptr(2482, 2486, 4), new Range16.ptr(2487, 2489, 1), new Range16.ptr(2493, 2510, 17), new Range16.ptr(2524, 2525, 1), new Range16.ptr(2527, 2529, 1), new Range16.ptr(2544, 2545, 1), new Range16.ptr(2565, 2570, 1), new Range16.ptr(2575, 2576, 1), new Range16.ptr(2579, 2600, 1), new Range16.ptr(2602, 2608, 1), new Range16.ptr(2610, 2611, 1), new Range16.ptr(2613, 2614, 1), new Range16.ptr(2616, 2617, 1), new Range16.ptr(2649, 2652, 1), new Range16.ptr(2654, 2674, 20), new Range16.ptr(2675, 2676, 1), new Range16.ptr(2693, 2701, 1), new Range16.ptr(2703, 2705, 1), new Range16.ptr(2707, 2728, 1), new Range16.ptr(2730, 2736, 1), new Range16.ptr(2738, 2739, 1), new Range16.ptr(2741, 2745, 1), new Range16.ptr(2749, 2768, 19), new Range16.ptr(2784, 2785, 1), new Range16.ptr(2821, 2828, 1), new Range16.ptr(2831, 2832, 1), new Range16.ptr(2835, 2856, 1), new Range16.ptr(2858, 2864, 1), new Range16.ptr(2866, 2867, 1), new Range16.ptr(2869, 2873, 1), new Range16.ptr(2877, 2908, 31), new Range16.ptr(2909, 2911, 2), new Range16.ptr(2912, 2913, 1), new Range16.ptr(2929, 2947, 18), new Range16.ptr(2949, 2954, 1), new Range16.ptr(2958, 2960, 1), new Range16.ptr(2962, 2965, 1), new Range16.ptr(2969, 2970, 1), new Range16.ptr(2972, 2974, 2), new Range16.ptr(2975, 2979, 4), new Range16.ptr(2980, 2984, 4), new Range16.ptr(2985, 2986, 1), new Range16.ptr(2990, 3001, 1), new Range16.ptr(3024, 3077, 53), new Range16.ptr(3078, 3084, 1), new Range16.ptr(3086, 3088, 1), new Range16.ptr(3090, 3112, 1), new Range16.ptr(3114, 3129, 1), new Range16.ptr(3133, 3160, 27), new Range16.ptr(3161, 3168, 7), new Range16.ptr(3169, 3205, 36), new Range16.ptr(3206, 3212, 1), new Range16.ptr(3214, 3216, 1), new Range16.ptr(3218, 3240, 1), new Range16.ptr(3242, 3251, 1), new Range16.ptr(3253, 3257, 1), new Range16.ptr(3261, 3294, 33), new Range16.ptr(3296, 3297, 1), new Range16.ptr(3313, 3314, 1), new Range16.ptr(3333, 3340, 1), new Range16.ptr(3342, 3344, 1), new Range16.ptr(3346, 3386, 1), new Range16.ptr(3389, 3406, 17), new Range16.ptr(3424, 3425, 1), new Range16.ptr(3450, 3455, 1), new Range16.ptr(3461, 3478, 1), new Range16.ptr(3482, 3505, 1), new Range16.ptr(3507, 3515, 1), new Range16.ptr(3517, 3520, 3), new Range16.ptr(3521, 3526, 1), new Range16.ptr(3585, 3632, 1), new Range16.ptr(3634, 3635, 1), new Range16.ptr(3648, 3654, 1), new Range16.ptr(3713, 3714, 1), new Range16.ptr(3716, 3719, 3), new Range16.ptr(3720, 3722, 2), new Range16.ptr(3725, 3732, 7), new Range16.ptr(3733, 3735, 1), new Range16.ptr(3737, 3743, 1), new Range16.ptr(3745, 3747, 1), new Range16.ptr(3749, 3751, 2), new Range16.ptr(3754, 3755, 1), new Range16.ptr(3757, 3760, 1), new Range16.ptr(3762, 3763, 1), new Range16.ptr(3773, 3776, 3), new Range16.ptr(3777, 3780, 1), new Range16.ptr(3782, 3804, 22), new Range16.ptr(3805, 3807, 1), new Range16.ptr(3840, 3904, 64), new Range16.ptr(3905, 3911, 1), new Range16.ptr(3913, 3948, 1), new Range16.ptr(3976, 3980, 1), new Range16.ptr(4096, 4138, 1), new Range16.ptr(4159, 4176, 17), new Range16.ptr(4177, 4181, 1), new Range16.ptr(4186, 4189, 1), new Range16.ptr(4193, 4197, 4), new Range16.ptr(4198, 4206, 8), new Range16.ptr(4207, 4208, 1), new Range16.ptr(4213, 4225, 1), new Range16.ptr(4238, 4256, 18), new Range16.ptr(4257, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(4304, 4346, 1), new Range16.ptr(4348, 4680, 1), new Range16.ptr(4682, 4685, 1), new Range16.ptr(4688, 4694, 1), new Range16.ptr(4696, 4698, 2), new Range16.ptr(4699, 4701, 1), new Range16.ptr(4704, 4744, 1), new Range16.ptr(4746, 4749, 1), new Range16.ptr(4752, 4784, 1), new Range16.ptr(4786, 4789, 1), new Range16.ptr(4792, 4798, 1), new Range16.ptr(4800, 4802, 2), new Range16.ptr(4803, 4805, 1), new Range16.ptr(4808, 4822, 1), new Range16.ptr(4824, 4880, 1), new Range16.ptr(4882, 4885, 1), new Range16.ptr(4888, 4954, 1), new Range16.ptr(4992, 5007, 1), new Range16.ptr(5024, 5108, 1), new Range16.ptr(5121, 5740, 1), new Range16.ptr(5743, 5759, 1), new Range16.ptr(5761, 5786, 1), new Range16.ptr(5792, 5866, 1), new Range16.ptr(5873, 5880, 1), new Range16.ptr(5888, 5900, 1), new Range16.ptr(5902, 5905, 1), new Range16.ptr(5920, 5937, 1), new Range16.ptr(5952, 5969, 1), new Range16.ptr(5984, 5996, 1), new Range16.ptr(5998, 6000, 1), new Range16.ptr(6016, 6067, 1), new Range16.ptr(6103, 6108, 5), new Range16.ptr(6176, 6263, 1), new Range16.ptr(6272, 6312, 1), new Range16.ptr(6314, 6320, 6), new Range16.ptr(6321, 6389, 1), new Range16.ptr(6400, 6430, 1), new Range16.ptr(6480, 6509, 1), new Range16.ptr(6512, 6516, 1), new Range16.ptr(6528, 6571, 1), new Range16.ptr(6593, 6599, 1), new Range16.ptr(6656, 6678, 1), new Range16.ptr(6688, 6740, 1), new Range16.ptr(6823, 6917, 94), new Range16.ptr(6918, 6963, 1), new Range16.ptr(6981, 6987, 1), new Range16.ptr(7043, 7072, 1), new Range16.ptr(7086, 7087, 1), new Range16.ptr(7098, 7141, 1), new Range16.ptr(7168, 7203, 1), new Range16.ptr(7245, 7247, 1), new Range16.ptr(7258, 7293, 1), new Range16.ptr(7401, 7404, 1), new Range16.ptr(7406, 7409, 1), new Range16.ptr(7413, 7414, 1), new Range16.ptr(7424, 7615, 1), new Range16.ptr(7680, 7957, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7968, 8005, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8016, 8023, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8032, 8061, 1), new Range16.ptr(8064, 8116, 1), new Range16.ptr(8118, 8124, 1), new Range16.ptr(8126, 8130, 4), new Range16.ptr(8131, 8132, 1), new Range16.ptr(8134, 8140, 1), new Range16.ptr(8144, 8147, 1), new Range16.ptr(8150, 8155, 1), new Range16.ptr(8160, 8172, 1), new Range16.ptr(8178, 8180, 1), new Range16.ptr(8182, 8188, 1), new Range16.ptr(8305, 8319, 14), new Range16.ptr(8336, 8348, 1), new Range16.ptr(8450, 8455, 5), new Range16.ptr(8458, 8467, 1), new Range16.ptr(8469, 8473, 4), new Range16.ptr(8474, 8477, 1), new Range16.ptr(8484, 8490, 2), new Range16.ptr(8491, 8493, 1), new Range16.ptr(8495, 8505, 1), new Range16.ptr(8508, 8511, 1), new Range16.ptr(8517, 8521, 1), new Range16.ptr(8526, 8579, 53), new Range16.ptr(8580, 11264, 2684), new Range16.ptr(11265, 11310, 1), new Range16.ptr(11312, 11358, 1), new Range16.ptr(11360, 11492, 1), new Range16.ptr(11499, 11502, 1), new Range16.ptr(11506, 11507, 1), new Range16.ptr(11520, 11557, 1), new Range16.ptr(11559, 11565, 6), new Range16.ptr(11568, 11623, 1), new Range16.ptr(11631, 11648, 17), new Range16.ptr(11649, 11670, 1), new Range16.ptr(11680, 11686, 1), new Range16.ptr(11688, 11694, 1), new Range16.ptr(11696, 11702, 1), new Range16.ptr(11704, 11710, 1), new Range16.ptr(11712, 11718, 1), new Range16.ptr(11720, 11726, 1), new Range16.ptr(11728, 11734, 1), new Range16.ptr(11736, 11742, 1), new Range16.ptr(11823, 12293, 470), new Range16.ptr(12294, 12337, 43), new Range16.ptr(12338, 12341, 1), new Range16.ptr(12347, 12348, 1), new Range16.ptr(12353, 12438, 1), new Range16.ptr(12445, 12447, 1), new Range16.ptr(12449, 12538, 1), new Range16.ptr(12540, 12543, 1), new Range16.ptr(12549, 12589, 1), new Range16.ptr(12593, 12686, 1), new Range16.ptr(12704, 12730, 1), new Range16.ptr(12784, 12799, 1), new Range16.ptr(13312, 19893, 1), new Range16.ptr(19968, 40908, 1), new Range16.ptr(40960, 42124, 1), new Range16.ptr(42192, 42237, 1), new Range16.ptr(42240, 42508, 1), new Range16.ptr(42512, 42527, 1), new Range16.ptr(42538, 42539, 1), new Range16.ptr(42560, 42606, 1), new Range16.ptr(42623, 42653, 1), new Range16.ptr(42656, 42725, 1), new Range16.ptr(42775, 42783, 1), new Range16.ptr(42786, 42888, 1), new Range16.ptr(42891, 42894, 1), new Range16.ptr(42896, 42925, 1), new Range16.ptr(42928, 42929, 1), new Range16.ptr(42999, 43009, 1), new Range16.ptr(43011, 43013, 1), new Range16.ptr(43015, 43018, 1), new Range16.ptr(43020, 43042, 1), new Range16.ptr(43072, 43123, 1), new Range16.ptr(43138, 43187, 1), new Range16.ptr(43250, 43255, 1), new Range16.ptr(43259, 43274, 15), new Range16.ptr(43275, 43301, 1), new Range16.ptr(43312, 43334, 1), new Range16.ptr(43360, 43388, 1), new Range16.ptr(43396, 43442, 1), new Range16.ptr(43471, 43488, 17), new Range16.ptr(43489, 43492, 1), new Range16.ptr(43494, 43503, 1), new Range16.ptr(43514, 43518, 1), new Range16.ptr(43520, 43560, 1), new Range16.ptr(43584, 43586, 1), new Range16.ptr(43588, 43595, 1), new Range16.ptr(43616, 43638, 1), new Range16.ptr(43642, 43646, 4), new Range16.ptr(43647, 43695, 1), new Range16.ptr(43697, 43701, 4), new Range16.ptr(43702, 43705, 3), new Range16.ptr(43706, 43709, 1), new Range16.ptr(43712, 43714, 2), new Range16.ptr(43739, 43741, 1), new Range16.ptr(43744, 43754, 1), new Range16.ptr(43762, 43764, 1), new Range16.ptr(43777, 43782, 1), new Range16.ptr(43785, 43790, 1), new Range16.ptr(43793, 43798, 1), new Range16.ptr(43808, 43814, 1), new Range16.ptr(43816, 43822, 1), new Range16.ptr(43824, 43866, 1), new Range16.ptr(43868, 43871, 1), new Range16.ptr(43876, 43877, 1), new Range16.ptr(43968, 44002, 1), new Range16.ptr(44032, 55203, 1), new Range16.ptr(55216, 55238, 1), new Range16.ptr(55243, 55291, 1), new Range16.ptr(63744, 64109, 1), new Range16.ptr(64112, 64217, 1), new Range16.ptr(64256, 64262, 1), new Range16.ptr(64275, 64279, 1), new Range16.ptr(64285, 64287, 2), new Range16.ptr(64288, 64296, 1), new Range16.ptr(64298, 64310, 1), new Range16.ptr(64312, 64316, 1), new Range16.ptr(64318, 64320, 2), new Range16.ptr(64321, 64323, 2), new Range16.ptr(64324, 64326, 2), new Range16.ptr(64327, 64433, 1), new Range16.ptr(64467, 64829, 1), new Range16.ptr(64848, 64911, 1), new Range16.ptr(64914, 64967, 1), new Range16.ptr(65008, 65019, 1), new Range16.ptr(65136, 65140, 1), new Range16.ptr(65142, 65276, 1), new Range16.ptr(65313, 65338, 1), new Range16.ptr(65345, 65370, 1), new Range16.ptr(65382, 65470, 1), new Range16.ptr(65474, 65479, 1), new Range16.ptr(65482, 65487, 1), new Range16.ptr(65490, 65495, 1), new Range16.ptr(65498, 65500, 1)]), new sliceType$1([new Range32.ptr(65536, 65547, 1), new Range32.ptr(65549, 65574, 1), new Range32.ptr(65576, 65594, 1), new Range32.ptr(65596, 65597, 1), new Range32.ptr(65599, 65613, 1), new Range32.ptr(65616, 65629, 1), new Range32.ptr(65664, 65786, 1), new Range32.ptr(66176, 66204, 1), new Range32.ptr(66208, 66256, 1), new Range32.ptr(66304, 66335, 1), new Range32.ptr(66352, 66368, 1), new Range32.ptr(66370, 66377, 1), new Range32.ptr(66384, 66421, 1), new Range32.ptr(66432, 66461, 1), new Range32.ptr(66464, 66499, 1), new Range32.ptr(66504, 66511, 1), new Range32.ptr(66560, 66717, 1), new Range32.ptr(66816, 66855, 1), new Range32.ptr(66864, 66915, 1), new Range32.ptr(67072, 67382, 1), new Range32.ptr(67392, 67413, 1), new Range32.ptr(67424, 67431, 1), new Range32.ptr(67584, 67589, 1), new Range32.ptr(67592, 67594, 2), new Range32.ptr(67595, 67637, 1), new Range32.ptr(67639, 67640, 1), new Range32.ptr(67644, 67647, 3), new Range32.ptr(67648, 67669, 1), new Range32.ptr(67680, 67702, 1), new Range32.ptr(67712, 67742, 1), new Range32.ptr(67840, 67861, 1), new Range32.ptr(67872, 67897, 1), new Range32.ptr(67968, 68023, 1), new Range32.ptr(68030, 68031, 1), new Range32.ptr(68096, 68112, 16), new Range32.ptr(68113, 68115, 1), new Range32.ptr(68117, 68119, 1), new Range32.ptr(68121, 68147, 1), new Range32.ptr(68192, 68220, 1), new Range32.ptr(68224, 68252, 1), new Range32.ptr(68288, 68295, 1), new Range32.ptr(68297, 68324, 1), new Range32.ptr(68352, 68405, 1), new Range32.ptr(68416, 68437, 1), new Range32.ptr(68448, 68466, 1), new Range32.ptr(68480, 68497, 1), new Range32.ptr(68608, 68680, 1), new Range32.ptr(69635, 69687, 1), new Range32.ptr(69763, 69807, 1), new Range32.ptr(69840, 69864, 1), new Range32.ptr(69891, 69926, 1), new Range32.ptr(69968, 70002, 1), new Range32.ptr(70006, 70019, 13), new Range32.ptr(70020, 70066, 1), new Range32.ptr(70081, 70084, 1), new Range32.ptr(70106, 70144, 38), new Range32.ptr(70145, 70161, 1), new Range32.ptr(70163, 70187, 1), new Range32.ptr(70320, 70366, 1), new Range32.ptr(70405, 70412, 1), new Range32.ptr(70415, 70416, 1), new Range32.ptr(70419, 70440, 1), new Range32.ptr(70442, 70448, 1), new Range32.ptr(70450, 70451, 1), new Range32.ptr(70453, 70457, 1), new Range32.ptr(70461, 70493, 32), new Range32.ptr(70494, 70497, 1), new Range32.ptr(70784, 70831, 1), new Range32.ptr(70852, 70853, 1), new Range32.ptr(70855, 71040, 185), new Range32.ptr(71041, 71086, 1), new Range32.ptr(71168, 71215, 1), new Range32.ptr(71236, 71296, 60), new Range32.ptr(71297, 71338, 1), new Range32.ptr(71840, 71903, 1), new Range32.ptr(71935, 72384, 449), new Range32.ptr(72385, 72440, 1), new Range32.ptr(73728, 74648, 1), new Range32.ptr(77824, 78894, 1), new Range32.ptr(92160, 92728, 1), new Range32.ptr(92736, 92766, 1), new Range32.ptr(92880, 92909, 1), new Range32.ptr(92928, 92975, 1), new Range32.ptr(92992, 92995, 1), new Range32.ptr(93027, 93047, 1), new Range32.ptr(93053, 93071, 1), new Range32.ptr(93952, 94020, 1), new Range32.ptr(94032, 94099, 67), new Range32.ptr(94100, 94111, 1), new Range32.ptr(110592, 110593, 1), new Range32.ptr(113664, 113770, 1), new Range32.ptr(113776, 113788, 1), new Range32.ptr(113792, 113800, 1), new Range32.ptr(113808, 113817, 1), new Range32.ptr(119808, 119892, 1), new Range32.ptr(119894, 119964, 1), new Range32.ptr(119966, 119967, 1), new Range32.ptr(119970, 119973, 3), new Range32.ptr(119974, 119977, 3), new Range32.ptr(119978, 119980, 1), new Range32.ptr(119982, 119993, 1), new Range32.ptr(119995, 119997, 2), new Range32.ptr(119998, 120003, 1), new Range32.ptr(120005, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120094, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120138, 4), new Range32.ptr(120139, 120144, 1), new Range32.ptr(120146, 120485, 1), new Range32.ptr(120488, 120512, 1), new Range32.ptr(120514, 120538, 1), new Range32.ptr(120540, 120570, 1), new Range32.ptr(120572, 120596, 1), new Range32.ptr(120598, 120628, 1), new Range32.ptr(120630, 120654, 1), new Range32.ptr(120656, 120686, 1), new Range32.ptr(120688, 120712, 1), new Range32.ptr(120714, 120744, 1), new Range32.ptr(120746, 120770, 1), new Range32.ptr(120772, 120779, 1), new Range32.ptr(124928, 125124, 1), new Range32.ptr(126464, 126467, 1), new Range32.ptr(126469, 126495, 1), new Range32.ptr(126497, 126498, 1), new Range32.ptr(126500, 126503, 3), new Range32.ptr(126505, 126514, 1), new Range32.ptr(126516, 126519, 1), new Range32.ptr(126521, 126523, 2), new Range32.ptr(126530, 126535, 5), new Range32.ptr(126537, 126541, 2), new Range32.ptr(126542, 126543, 1), new Range32.ptr(126545, 126546, 1), new Range32.ptr(126548, 126551, 3), new Range32.ptr(126553, 126561, 2), new Range32.ptr(126562, 126564, 2), new Range32.ptr(126567, 126570, 1), new Range32.ptr(126572, 126578, 1), new Range32.ptr(126580, 126583, 1), new Range32.ptr(126585, 126588, 1), new Range32.ptr(126590, 126592, 2), new Range32.ptr(126593, 126601, 1), new Range32.ptr(126603, 126619, 1), new Range32.ptr(126625, 126627, 1), new Range32.ptr(126629, 126633, 1), new Range32.ptr(126635, 126651, 1), new Range32.ptr(131072, 173782, 1), new Range32.ptr(173824, 177972, 1), new Range32.ptr(177984, 178205, 1), new Range32.ptr(194560, 195101, 1)]), 6);
- _Lu = new RangeTable.ptr(new sliceType([new Range16.ptr(65, 90, 1), new Range16.ptr(192, 214, 1), new Range16.ptr(216, 222, 1), new Range16.ptr(256, 310, 2), new Range16.ptr(313, 327, 2), new Range16.ptr(330, 376, 2), new Range16.ptr(377, 381, 2), new Range16.ptr(385, 386, 1), new Range16.ptr(388, 390, 2), new Range16.ptr(391, 393, 2), new Range16.ptr(394, 395, 1), new Range16.ptr(398, 401, 1), new Range16.ptr(403, 404, 1), new Range16.ptr(406, 408, 1), new Range16.ptr(412, 413, 1), new Range16.ptr(415, 416, 1), new Range16.ptr(418, 422, 2), new Range16.ptr(423, 425, 2), new Range16.ptr(428, 430, 2), new Range16.ptr(431, 433, 2), new Range16.ptr(434, 435, 1), new Range16.ptr(437, 439, 2), new Range16.ptr(440, 444, 4), new Range16.ptr(452, 461, 3), new Range16.ptr(463, 475, 2), new Range16.ptr(478, 494, 2), new Range16.ptr(497, 500, 3), new Range16.ptr(502, 504, 1), new Range16.ptr(506, 562, 2), new Range16.ptr(570, 571, 1), new Range16.ptr(573, 574, 1), new Range16.ptr(577, 579, 2), new Range16.ptr(580, 582, 1), new Range16.ptr(584, 590, 2), new Range16.ptr(880, 882, 2), new Range16.ptr(886, 895, 9), new Range16.ptr(902, 904, 2), new Range16.ptr(905, 906, 1), new Range16.ptr(908, 910, 2), new Range16.ptr(911, 913, 2), new Range16.ptr(914, 929, 1), new Range16.ptr(931, 939, 1), new Range16.ptr(975, 978, 3), new Range16.ptr(979, 980, 1), new Range16.ptr(984, 1006, 2), new Range16.ptr(1012, 1015, 3), new Range16.ptr(1017, 1018, 1), new Range16.ptr(1021, 1071, 1), new Range16.ptr(1120, 1152, 2), new Range16.ptr(1162, 1216, 2), new Range16.ptr(1217, 1229, 2), new Range16.ptr(1232, 1326, 2), new Range16.ptr(1329, 1366, 1), new Range16.ptr(4256, 4293, 1), new Range16.ptr(4295, 4301, 6), new Range16.ptr(7680, 7828, 2), new Range16.ptr(7838, 7934, 2), new Range16.ptr(7944, 7951, 1), new Range16.ptr(7960, 7965, 1), new Range16.ptr(7976, 7983, 1), new Range16.ptr(7992, 7999, 1), new Range16.ptr(8008, 8013, 1), new Range16.ptr(8025, 8031, 2), new Range16.ptr(8040, 8047, 1), new Range16.ptr(8120, 8123, 1), new Range16.ptr(8136, 8139, 1), new Range16.ptr(8152, 8155, 1), new Range16.ptr(8168, 8172, 1), new Range16.ptr(8184, 8187, 1), new Range16.ptr(8450, 8455, 5), new Range16.ptr(8459, 8461, 1), new Range16.ptr(8464, 8466, 1), new Range16.ptr(8469, 8473, 4), new Range16.ptr(8474, 8477, 1), new Range16.ptr(8484, 8490, 2), new Range16.ptr(8491, 8493, 1), new Range16.ptr(8496, 8499, 1), new Range16.ptr(8510, 8511, 1), new Range16.ptr(8517, 8579, 62), new Range16.ptr(11264, 11310, 1), new Range16.ptr(11360, 11362, 2), new Range16.ptr(11363, 11364, 1), new Range16.ptr(11367, 11373, 2), new Range16.ptr(11374, 11376, 1), new Range16.ptr(11378, 11381, 3), new Range16.ptr(11390, 11392, 1), new Range16.ptr(11394, 11490, 2), new Range16.ptr(11499, 11501, 2), new Range16.ptr(11506, 42560, 31054), new Range16.ptr(42562, 42604, 2), new Range16.ptr(42624, 42650, 2), new Range16.ptr(42786, 42798, 2), new Range16.ptr(42802, 42862, 2), new Range16.ptr(42873, 42877, 2), new Range16.ptr(42878, 42886, 2), new Range16.ptr(42891, 42893, 2), new Range16.ptr(42896, 42898, 2), new Range16.ptr(42902, 42922, 2), new Range16.ptr(42923, 42925, 1), new Range16.ptr(42928, 42929, 1), new Range16.ptr(65313, 65338, 1)]), new sliceType$1([new Range32.ptr(66560, 66599, 1), new Range32.ptr(71840, 71871, 1), new Range32.ptr(119808, 119833, 1), new Range32.ptr(119860, 119885, 1), new Range32.ptr(119912, 119937, 1), new Range32.ptr(119964, 119966, 2), new Range32.ptr(119967, 119973, 3), new Range32.ptr(119974, 119977, 3), new Range32.ptr(119978, 119980, 1), new Range32.ptr(119982, 119989, 1), new Range32.ptr(120016, 120041, 1), new Range32.ptr(120068, 120069, 1), new Range32.ptr(120071, 120074, 1), new Range32.ptr(120077, 120084, 1), new Range32.ptr(120086, 120092, 1), new Range32.ptr(120120, 120121, 1), new Range32.ptr(120123, 120126, 1), new Range32.ptr(120128, 120132, 1), new Range32.ptr(120134, 120138, 4), new Range32.ptr(120139, 120144, 1), new Range32.ptr(120172, 120197, 1), new Range32.ptr(120224, 120249, 1), new Range32.ptr(120276, 120301, 1), new Range32.ptr(120328, 120353, 1), new Range32.ptr(120380, 120405, 1), new Range32.ptr(120432, 120457, 1), new Range32.ptr(120488, 120512, 1), new Range32.ptr(120546, 120570, 1), new Range32.ptr(120604, 120628, 1), new Range32.ptr(120662, 120686, 1), new Range32.ptr(120720, 120744, 1), new Range32.ptr(120778, 120778, 1)]), 3);
- _M = new RangeTable.ptr(new sliceType([new Range16.ptr(768, 879, 1), new Range16.ptr(1155, 1161, 1), new Range16.ptr(1425, 1469, 1), new Range16.ptr(1471, 1473, 2), new Range16.ptr(1474, 1476, 2), new Range16.ptr(1477, 1479, 2), new Range16.ptr(1552, 1562, 1), new Range16.ptr(1611, 1631, 1), new Range16.ptr(1648, 1750, 102), new Range16.ptr(1751, 1756, 1), new Range16.ptr(1759, 1764, 1), new Range16.ptr(1767, 1768, 1), new Range16.ptr(1770, 1773, 1), new Range16.ptr(1809, 1840, 31), new Range16.ptr(1841, 1866, 1), new Range16.ptr(1958, 1968, 1), new Range16.ptr(2027, 2035, 1), new Range16.ptr(2070, 2073, 1), new Range16.ptr(2075, 2083, 1), new Range16.ptr(2085, 2087, 1), new Range16.ptr(2089, 2093, 1), new Range16.ptr(2137, 2139, 1), new Range16.ptr(2276, 2307, 1), new Range16.ptr(2362, 2364, 1), new Range16.ptr(2366, 2383, 1), new Range16.ptr(2385, 2391, 1), new Range16.ptr(2402, 2403, 1), new Range16.ptr(2433, 2435, 1), new Range16.ptr(2492, 2494, 2), new Range16.ptr(2495, 2500, 1), new Range16.ptr(2503, 2504, 1), new Range16.ptr(2507, 2509, 1), new Range16.ptr(2519, 2530, 11), new Range16.ptr(2531, 2561, 30), new Range16.ptr(2562, 2563, 1), new Range16.ptr(2620, 2622, 2), new Range16.ptr(2623, 2626, 1), new Range16.ptr(2631, 2632, 1), new Range16.ptr(2635, 2637, 1), new Range16.ptr(2641, 2672, 31), new Range16.ptr(2673, 2677, 4), new Range16.ptr(2689, 2691, 1), new Range16.ptr(2748, 2750, 2), new Range16.ptr(2751, 2757, 1), new Range16.ptr(2759, 2761, 1), new Range16.ptr(2763, 2765, 1), new Range16.ptr(2786, 2787, 1), new Range16.ptr(2817, 2819, 1), new Range16.ptr(2876, 2878, 2), new Range16.ptr(2879, 2884, 1), new Range16.ptr(2887, 2888, 1), new Range16.ptr(2891, 2893, 1), new Range16.ptr(2902, 2903, 1), new Range16.ptr(2914, 2915, 1), new Range16.ptr(2946, 3006, 60), new Range16.ptr(3007, 3010, 1), new Range16.ptr(3014, 3016, 1), new Range16.ptr(3018, 3021, 1), new Range16.ptr(3031, 3072, 41), new Range16.ptr(3073, 3075, 1), new Range16.ptr(3134, 3140, 1), new Range16.ptr(3142, 3144, 1), new Range16.ptr(3146, 3149, 1), new Range16.ptr(3157, 3158, 1), new Range16.ptr(3170, 3171, 1), new Range16.ptr(3201, 3203, 1), new Range16.ptr(3260, 3262, 2), new Range16.ptr(3263, 3268, 1), new Range16.ptr(3270, 3272, 1), new Range16.ptr(3274, 3277, 1), new Range16.ptr(3285, 3286, 1), new Range16.ptr(3298, 3299, 1), new Range16.ptr(3329, 3331, 1), new Range16.ptr(3390, 3396, 1), new Range16.ptr(3398, 3400, 1), new Range16.ptr(3402, 3405, 1), new Range16.ptr(3415, 3426, 11), new Range16.ptr(3427, 3458, 31), new Range16.ptr(3459, 3530, 71), new Range16.ptr(3535, 3540, 1), new Range16.ptr(3542, 3544, 2), new Range16.ptr(3545, 3551, 1), new Range16.ptr(3570, 3571, 1), new Range16.ptr(3633, 3636, 3), new Range16.ptr(3637, 3642, 1), new Range16.ptr(3655, 3662, 1), new Range16.ptr(3761, 3764, 3), new Range16.ptr(3765, 3769, 1), new Range16.ptr(3771, 3772, 1), new Range16.ptr(3784, 3789, 1), new Range16.ptr(3864, 3865, 1), new Range16.ptr(3893, 3897, 2), new Range16.ptr(3902, 3903, 1), new Range16.ptr(3953, 3972, 1), new Range16.ptr(3974, 3975, 1), new Range16.ptr(3981, 3991, 1), new Range16.ptr(3993, 4028, 1), new Range16.ptr(4038, 4139, 101), new Range16.ptr(4140, 4158, 1), new Range16.ptr(4182, 4185, 1), new Range16.ptr(4190, 4192, 1), new Range16.ptr(4194, 4196, 1), new Range16.ptr(4199, 4205, 1), new Range16.ptr(4209, 4212, 1), new Range16.ptr(4226, 4237, 1), new Range16.ptr(4239, 4250, 11), new Range16.ptr(4251, 4253, 1), new Range16.ptr(4957, 4959, 1), new Range16.ptr(5906, 5908, 1), new Range16.ptr(5938, 5940, 1), new Range16.ptr(5970, 5971, 1), new Range16.ptr(6002, 6003, 1), new Range16.ptr(6068, 6099, 1), new Range16.ptr(6109, 6155, 46), new Range16.ptr(6156, 6157, 1), new Range16.ptr(6313, 6432, 119), new Range16.ptr(6433, 6443, 1), new Range16.ptr(6448, 6459, 1), new Range16.ptr(6576, 6592, 1), new Range16.ptr(6600, 6601, 1), new Range16.ptr(6679, 6683, 1), new Range16.ptr(6741, 6750, 1), new Range16.ptr(6752, 6780, 1), new Range16.ptr(6783, 6832, 49), new Range16.ptr(6833, 6846, 1), new Range16.ptr(6912, 6916, 1), new Range16.ptr(6964, 6980, 1), new Range16.ptr(7019, 7027, 1), new Range16.ptr(7040, 7042, 1), new Range16.ptr(7073, 7085, 1), new Range16.ptr(7142, 7155, 1), new Range16.ptr(7204, 7223, 1), new Range16.ptr(7376, 7378, 1), new Range16.ptr(7380, 7400, 1), new Range16.ptr(7405, 7410, 5), new Range16.ptr(7411, 7412, 1), new Range16.ptr(7416, 7417, 1), new Range16.ptr(7616, 7669, 1), new Range16.ptr(7676, 7679, 1), new Range16.ptr(8400, 8432, 1), new Range16.ptr(11503, 11505, 1), new Range16.ptr(11647, 11744, 97), new Range16.ptr(11745, 11775, 1), new Range16.ptr(12330, 12335, 1), new Range16.ptr(12441, 12442, 1), new Range16.ptr(42607, 42610, 1), new Range16.ptr(42612, 42621, 1), new Range16.ptr(42655, 42736, 81), new Range16.ptr(42737, 43010, 273), new Range16.ptr(43014, 43019, 5), new Range16.ptr(43043, 43047, 1), new Range16.ptr(43136, 43137, 1), new Range16.ptr(43188, 43204, 1), new Range16.ptr(43232, 43249, 1), new Range16.ptr(43302, 43309, 1), new Range16.ptr(43335, 43347, 1), new Range16.ptr(43392, 43395, 1), new Range16.ptr(43443, 43456, 1), new Range16.ptr(43493, 43561, 68), new Range16.ptr(43562, 43574, 1), new Range16.ptr(43587, 43596, 9), new Range16.ptr(43597, 43643, 46), new Range16.ptr(43644, 43645, 1), new Range16.ptr(43696, 43698, 2), new Range16.ptr(43699, 43700, 1), new Range16.ptr(43703, 43704, 1), new Range16.ptr(43710, 43711, 1), new Range16.ptr(43713, 43755, 42), new Range16.ptr(43756, 43759, 1), new Range16.ptr(43765, 43766, 1), new Range16.ptr(44003, 44010, 1), new Range16.ptr(44012, 44013, 1), new Range16.ptr(64286, 65024, 738), new Range16.ptr(65025, 65039, 1), new Range16.ptr(65056, 65069, 1)]), new sliceType$1([new Range32.ptr(66045, 66272, 227), new Range32.ptr(66422, 66426, 1), new Range32.ptr(68097, 68099, 1), new Range32.ptr(68101, 68102, 1), new Range32.ptr(68108, 68111, 1), new Range32.ptr(68152, 68154, 1), new Range32.ptr(68159, 68325, 166), new Range32.ptr(68326, 69632, 1306), new Range32.ptr(69633, 69634, 1), new Range32.ptr(69688, 69702, 1), new Range32.ptr(69759, 69762, 1), new Range32.ptr(69808, 69818, 1), new Range32.ptr(69888, 69890, 1), new Range32.ptr(69927, 69940, 1), new Range32.ptr(70003, 70016, 13), new Range32.ptr(70017, 70018, 1), new Range32.ptr(70067, 70080, 1), new Range32.ptr(70188, 70199, 1), new Range32.ptr(70367, 70378, 1), new Range32.ptr(70401, 70403, 1), new Range32.ptr(70460, 70462, 2), new Range32.ptr(70463, 70468, 1), new Range32.ptr(70471, 70472, 1), new Range32.ptr(70475, 70477, 1), new Range32.ptr(70487, 70498, 11), new Range32.ptr(70499, 70502, 3), new Range32.ptr(70503, 70508, 1), new Range32.ptr(70512, 70516, 1), new Range32.ptr(70832, 70851, 1), new Range32.ptr(71087, 71093, 1), new Range32.ptr(71096, 71104, 1), new Range32.ptr(71216, 71232, 1), new Range32.ptr(71339, 71351, 1), new Range32.ptr(92912, 92916, 1), new Range32.ptr(92976, 92982, 1), new Range32.ptr(94033, 94078, 1), new Range32.ptr(94095, 94098, 1), new Range32.ptr(113821, 113822, 1), new Range32.ptr(119141, 119145, 1), new Range32.ptr(119149, 119154, 1), new Range32.ptr(119163, 119170, 1), new Range32.ptr(119173, 119179, 1), new Range32.ptr(119210, 119213, 1), new Range32.ptr(119362, 119364, 1), new Range32.ptr(125136, 125142, 1), new Range32.ptr(917760, 917999, 1)]), 0);
- _N = new RangeTable.ptr(new sliceType([new Range16.ptr(48, 57, 1), new Range16.ptr(178, 179, 1), new Range16.ptr(185, 188, 3), new Range16.ptr(189, 190, 1), new Range16.ptr(1632, 1641, 1), new Range16.ptr(1776, 1785, 1), new Range16.ptr(1984, 1993, 1), new Range16.ptr(2406, 2415, 1), new Range16.ptr(2534, 2543, 1), new Range16.ptr(2548, 2553, 1), new Range16.ptr(2662, 2671, 1), new Range16.ptr(2790, 2799, 1), new Range16.ptr(2918, 2927, 1), new Range16.ptr(2930, 2935, 1), new Range16.ptr(3046, 3058, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3192, 3198, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3430, 3445, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3664, 3673, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3872, 3891, 1), new Range16.ptr(4160, 4169, 1), new Range16.ptr(4240, 4249, 1), new Range16.ptr(4969, 4988, 1), new Range16.ptr(5870, 5872, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6128, 6137, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6470, 6479, 1), new Range16.ptr(6608, 6618, 1), new Range16.ptr(6784, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6992, 7001, 1), new Range16.ptr(7088, 7097, 1), new Range16.ptr(7232, 7241, 1), new Range16.ptr(7248, 7257, 1), new Range16.ptr(8304, 8308, 4), new Range16.ptr(8309, 8313, 1), new Range16.ptr(8320, 8329, 1), new Range16.ptr(8528, 8578, 1), new Range16.ptr(8581, 8585, 1), new Range16.ptr(9312, 9371, 1), new Range16.ptr(9450, 9471, 1), new Range16.ptr(10102, 10131, 1), new Range16.ptr(11517, 12295, 778), new Range16.ptr(12321, 12329, 1), new Range16.ptr(12344, 12346, 1), new Range16.ptr(12690, 12693, 1), new Range16.ptr(12832, 12841, 1), new Range16.ptr(12872, 12879, 1), new Range16.ptr(12881, 12895, 1), new Range16.ptr(12928, 12937, 1), new Range16.ptr(12977, 12991, 1), new Range16.ptr(42528, 42537, 1), new Range16.ptr(42726, 42735, 1), new Range16.ptr(43056, 43061, 1), new Range16.ptr(43216, 43225, 1), new Range16.ptr(43264, 43273, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43504, 43513, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(44016, 44025, 1), new Range16.ptr(65296, 65305, 1)]), new sliceType$1([new Range32.ptr(65799, 65843, 1), new Range32.ptr(65856, 65912, 1), new Range32.ptr(65930, 65931, 1), new Range32.ptr(66273, 66299, 1), new Range32.ptr(66336, 66339, 1), new Range32.ptr(66369, 66378, 9), new Range32.ptr(66513, 66517, 1), new Range32.ptr(66720, 66729, 1), new Range32.ptr(67672, 67679, 1), new Range32.ptr(67705, 67711, 1), new Range32.ptr(67751, 67759, 1), new Range32.ptr(67862, 67867, 1), new Range32.ptr(68160, 68167, 1), new Range32.ptr(68221, 68222, 1), new Range32.ptr(68253, 68255, 1), new Range32.ptr(68331, 68335, 1), new Range32.ptr(68440, 68447, 1), new Range32.ptr(68472, 68479, 1), new Range32.ptr(68521, 68527, 1), new Range32.ptr(69216, 69246, 1), new Range32.ptr(69714, 69743, 1), new Range32.ptr(69872, 69881, 1), new Range32.ptr(69942, 69951, 1), new Range32.ptr(70096, 70105, 1), new Range32.ptr(70113, 70132, 1), new Range32.ptr(70384, 70393, 1), new Range32.ptr(70864, 70873, 1), new Range32.ptr(71248, 71257, 1), new Range32.ptr(71360, 71369, 1), new Range32.ptr(71904, 71922, 1), new Range32.ptr(74752, 74862, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(93019, 93025, 1), new Range32.ptr(119648, 119665, 1), new Range32.ptr(120782, 120831, 1), new Range32.ptr(125127, 125135, 1), new Range32.ptr(127232, 127244, 1)]), 4);
- _Nd = new RangeTable.ptr(new sliceType([new Range16.ptr(48, 57, 1), new Range16.ptr(1632, 1641, 1), new Range16.ptr(1776, 1785, 1), new Range16.ptr(1984, 1993, 1), new Range16.ptr(2406, 2415, 1), new Range16.ptr(2534, 2543, 1), new Range16.ptr(2662, 2671, 1), new Range16.ptr(2790, 2799, 1), new Range16.ptr(2918, 2927, 1), new Range16.ptr(3046, 3055, 1), new Range16.ptr(3174, 3183, 1), new Range16.ptr(3302, 3311, 1), new Range16.ptr(3430, 3439, 1), new Range16.ptr(3558, 3567, 1), new Range16.ptr(3664, 3673, 1), new Range16.ptr(3792, 3801, 1), new Range16.ptr(3872, 3881, 1), new Range16.ptr(4160, 4169, 1), new Range16.ptr(4240, 4249, 1), new Range16.ptr(6112, 6121, 1), new Range16.ptr(6160, 6169, 1), new Range16.ptr(6470, 6479, 1), new Range16.ptr(6608, 6617, 1), new Range16.ptr(6784, 6793, 1), new Range16.ptr(6800, 6809, 1), new Range16.ptr(6992, 7001, 1), new Range16.ptr(7088, 7097, 1), new Range16.ptr(7232, 7241, 1), new Range16.ptr(7248, 7257, 1), new Range16.ptr(42528, 42537, 1), new Range16.ptr(43216, 43225, 1), new Range16.ptr(43264, 43273, 1), new Range16.ptr(43472, 43481, 1), new Range16.ptr(43504, 43513, 1), new Range16.ptr(43600, 43609, 1), new Range16.ptr(44016, 44025, 1), new Range16.ptr(65296, 65305, 1)]), new sliceType$1([new Range32.ptr(66720, 66729, 1), new Range32.ptr(69734, 69743, 1), new Range32.ptr(69872, 69881, 1), new Range32.ptr(69942, 69951, 1), new Range32.ptr(70096, 70105, 1), new Range32.ptr(70384, 70393, 1), new Range32.ptr(70864, 70873, 1), new Range32.ptr(71248, 71257, 1), new Range32.ptr(71360, 71369, 1), new Range32.ptr(71904, 71913, 1), new Range32.ptr(92768, 92777, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(120782, 120831, 1)]), 1);
- _P = new RangeTable.ptr(new sliceType([new Range16.ptr(33, 35, 1), new Range16.ptr(37, 42, 1), new Range16.ptr(44, 47, 1), new Range16.ptr(58, 59, 1), new Range16.ptr(63, 64, 1), new Range16.ptr(91, 93, 1), new Range16.ptr(95, 123, 28), new Range16.ptr(125, 161, 36), new Range16.ptr(167, 171, 4), new Range16.ptr(182, 183, 1), new Range16.ptr(187, 191, 4), new Range16.ptr(894, 903, 9), new Range16.ptr(1370, 1375, 1), new Range16.ptr(1417, 1418, 1), new Range16.ptr(1470, 1472, 2), new Range16.ptr(1475, 1478, 3), new Range16.ptr(1523, 1524, 1), new Range16.ptr(1545, 1546, 1), new Range16.ptr(1548, 1549, 1), new Range16.ptr(1563, 1566, 3), new Range16.ptr(1567, 1642, 75), new Range16.ptr(1643, 1645, 1), new Range16.ptr(1748, 1792, 44), new Range16.ptr(1793, 1805, 1), new Range16.ptr(2039, 2041, 1), new Range16.ptr(2096, 2110, 1), new Range16.ptr(2142, 2404, 262), new Range16.ptr(2405, 2416, 11), new Range16.ptr(2800, 3572, 772), new Range16.ptr(3663, 3674, 11), new Range16.ptr(3675, 3844, 169), new Range16.ptr(3845, 3858, 1), new Range16.ptr(3860, 3898, 38), new Range16.ptr(3899, 3901, 1), new Range16.ptr(3973, 4048, 75), new Range16.ptr(4049, 4052, 1), new Range16.ptr(4057, 4058, 1), new Range16.ptr(4170, 4175, 1), new Range16.ptr(4347, 4960, 613), new Range16.ptr(4961, 4968, 1), new Range16.ptr(5120, 5741, 621), new Range16.ptr(5742, 5787, 45), new Range16.ptr(5788, 5867, 79), new Range16.ptr(5868, 5869, 1), new Range16.ptr(5941, 5942, 1), new Range16.ptr(6100, 6102, 1), new Range16.ptr(6104, 6106, 1), new Range16.ptr(6144, 6154, 1), new Range16.ptr(6468, 6469, 1), new Range16.ptr(6686, 6687, 1), new Range16.ptr(6816, 6822, 1), new Range16.ptr(6824, 6829, 1), new Range16.ptr(7002, 7008, 1), new Range16.ptr(7164, 7167, 1), new Range16.ptr(7227, 7231, 1), new Range16.ptr(7294, 7295, 1), new Range16.ptr(7360, 7367, 1), new Range16.ptr(7379, 8208, 829), new Range16.ptr(8209, 8231, 1), new Range16.ptr(8240, 8259, 1), new Range16.ptr(8261, 8273, 1), new Range16.ptr(8275, 8286, 1), new Range16.ptr(8317, 8318, 1), new Range16.ptr(8333, 8334, 1), new Range16.ptr(8968, 8971, 1), new Range16.ptr(9001, 9002, 1), new Range16.ptr(10088, 10101, 1), new Range16.ptr(10181, 10182, 1), new Range16.ptr(10214, 10223, 1), new Range16.ptr(10627, 10648, 1), new Range16.ptr(10712, 10715, 1), new Range16.ptr(10748, 10749, 1), new Range16.ptr(11513, 11516, 1), new Range16.ptr(11518, 11519, 1), new Range16.ptr(11632, 11776, 144), new Range16.ptr(11777, 11822, 1), new Range16.ptr(11824, 11842, 1), new Range16.ptr(12289, 12291, 1), new Range16.ptr(12296, 12305, 1), new Range16.ptr(12308, 12319, 1), new Range16.ptr(12336, 12349, 13), new Range16.ptr(12448, 12539, 91), new Range16.ptr(42238, 42239, 1), new Range16.ptr(42509, 42511, 1), new Range16.ptr(42611, 42622, 11), new Range16.ptr(42738, 42743, 1), new Range16.ptr(43124, 43127, 1), new Range16.ptr(43214, 43215, 1), new Range16.ptr(43256, 43258, 1), new Range16.ptr(43310, 43311, 1), new Range16.ptr(43359, 43457, 98), new Range16.ptr(43458, 43469, 1), new Range16.ptr(43486, 43487, 1), new Range16.ptr(43612, 43615, 1), new Range16.ptr(43742, 43743, 1), new Range16.ptr(43760, 43761, 1), new Range16.ptr(44011, 64830, 20819), new Range16.ptr(64831, 65040, 209), new Range16.ptr(65041, 65049, 1), new Range16.ptr(65072, 65106, 1), new Range16.ptr(65108, 65121, 1), new Range16.ptr(65123, 65128, 5), new Range16.ptr(65130, 65131, 1), new Range16.ptr(65281, 65283, 1), new Range16.ptr(65285, 65290, 1), new Range16.ptr(65292, 65295, 1), new Range16.ptr(65306, 65307, 1), new Range16.ptr(65311, 65312, 1), new Range16.ptr(65339, 65341, 1), new Range16.ptr(65343, 65371, 28), new Range16.ptr(65373, 65375, 2), new Range16.ptr(65376, 65381, 1)]), new sliceType$1([new Range32.ptr(65792, 65794, 1), new Range32.ptr(66463, 66512, 49), new Range32.ptr(66927, 67671, 744), new Range32.ptr(67871, 67903, 32), new Range32.ptr(68176, 68184, 1), new Range32.ptr(68223, 68336, 113), new Range32.ptr(68337, 68342, 1), new Range32.ptr(68409, 68415, 1), new Range32.ptr(68505, 68508, 1), new Range32.ptr(69703, 69709, 1), new Range32.ptr(69819, 69820, 1), new Range32.ptr(69822, 69825, 1), new Range32.ptr(69952, 69955, 1), new Range32.ptr(70004, 70005, 1), new Range32.ptr(70085, 70088, 1), new Range32.ptr(70093, 70200, 107), new Range32.ptr(70201, 70205, 1), new Range32.ptr(70854, 71105, 251), new Range32.ptr(71106, 71113, 1), new Range32.ptr(71233, 71235, 1), new Range32.ptr(74864, 74868, 1), new Range32.ptr(92782, 92783, 1), new Range32.ptr(92917, 92983, 66), new Range32.ptr(92984, 92987, 1), new Range32.ptr(92996, 113823, 20827)]), 11);
- _S = new RangeTable.ptr(new sliceType([new Range16.ptr(36, 43, 7), new Range16.ptr(60, 62, 1), new Range16.ptr(94, 96, 2), new Range16.ptr(124, 126, 2), new Range16.ptr(162, 166, 1), new Range16.ptr(168, 169, 1), new Range16.ptr(172, 174, 2), new Range16.ptr(175, 177, 1), new Range16.ptr(180, 184, 4), new Range16.ptr(215, 247, 32), new Range16.ptr(706, 709, 1), new Range16.ptr(722, 735, 1), new Range16.ptr(741, 747, 1), new Range16.ptr(749, 751, 2), new Range16.ptr(752, 767, 1), new Range16.ptr(885, 900, 15), new Range16.ptr(901, 1014, 113), new Range16.ptr(1154, 1421, 267), new Range16.ptr(1422, 1423, 1), new Range16.ptr(1542, 1544, 1), new Range16.ptr(1547, 1550, 3), new Range16.ptr(1551, 1758, 207), new Range16.ptr(1769, 1789, 20), new Range16.ptr(1790, 2038, 248), new Range16.ptr(2546, 2547, 1), new Range16.ptr(2554, 2555, 1), new Range16.ptr(2801, 2928, 127), new Range16.ptr(3059, 3066, 1), new Range16.ptr(3199, 3449, 250), new Range16.ptr(3647, 3841, 194), new Range16.ptr(3842, 3843, 1), new Range16.ptr(3859, 3861, 2), new Range16.ptr(3862, 3863, 1), new Range16.ptr(3866, 3871, 1), new Range16.ptr(3892, 3896, 2), new Range16.ptr(4030, 4037, 1), new Range16.ptr(4039, 4044, 1), new Range16.ptr(4046, 4047, 1), new Range16.ptr(4053, 4056, 1), new Range16.ptr(4254, 4255, 1), new Range16.ptr(5008, 5017, 1), new Range16.ptr(6107, 6464, 357), new Range16.ptr(6622, 6655, 1), new Range16.ptr(7009, 7018, 1), new Range16.ptr(7028, 7036, 1), new Range16.ptr(8125, 8127, 2), new Range16.ptr(8128, 8129, 1), new Range16.ptr(8141, 8143, 1), new Range16.ptr(8157, 8159, 1), new Range16.ptr(8173, 8175, 1), new Range16.ptr(8189, 8190, 1), new Range16.ptr(8260, 8274, 14), new Range16.ptr(8314, 8316, 1), new Range16.ptr(8330, 8332, 1), new Range16.ptr(8352, 8381, 1), new Range16.ptr(8448, 8449, 1), new Range16.ptr(8451, 8454, 1), new Range16.ptr(8456, 8457, 1), new Range16.ptr(8468, 8470, 2), new Range16.ptr(8471, 8472, 1), new Range16.ptr(8478, 8483, 1), new Range16.ptr(8485, 8489, 2), new Range16.ptr(8494, 8506, 12), new Range16.ptr(8507, 8512, 5), new Range16.ptr(8513, 8516, 1), new Range16.ptr(8522, 8525, 1), new Range16.ptr(8527, 8592, 65), new Range16.ptr(8593, 8967, 1), new Range16.ptr(8972, 9000, 1), new Range16.ptr(9003, 9210, 1), new Range16.ptr(9216, 9254, 1), new Range16.ptr(9280, 9290, 1), new Range16.ptr(9372, 9449, 1), new Range16.ptr(9472, 10087, 1), new Range16.ptr(10132, 10180, 1), new Range16.ptr(10183, 10213, 1), new Range16.ptr(10224, 10626, 1), new Range16.ptr(10649, 10711, 1), new Range16.ptr(10716, 10747, 1), new Range16.ptr(10750, 11123, 1), new Range16.ptr(11126, 11157, 1), new Range16.ptr(11160, 11193, 1), new Range16.ptr(11197, 11208, 1), new Range16.ptr(11210, 11217, 1), new Range16.ptr(11493, 11498, 1), new Range16.ptr(11904, 11929, 1), new Range16.ptr(11931, 12019, 1), new Range16.ptr(12032, 12245, 1), new Range16.ptr(12272, 12283, 1), new Range16.ptr(12292, 12306, 14), new Range16.ptr(12307, 12320, 13), new Range16.ptr(12342, 12343, 1), new Range16.ptr(12350, 12351, 1), new Range16.ptr(12443, 12444, 1), new Range16.ptr(12688, 12689, 1), new Range16.ptr(12694, 12703, 1), new Range16.ptr(12736, 12771, 1), new Range16.ptr(12800, 12830, 1), new Range16.ptr(12842, 12871, 1), new Range16.ptr(12880, 12896, 16), new Range16.ptr(12897, 12927, 1), new Range16.ptr(12938, 12976, 1), new Range16.ptr(12992, 13054, 1), new Range16.ptr(13056, 13311, 1), new Range16.ptr(19904, 19967, 1), new Range16.ptr(42128, 42182, 1), new Range16.ptr(42752, 42774, 1), new Range16.ptr(42784, 42785, 1), new Range16.ptr(42889, 42890, 1), new Range16.ptr(43048, 43051, 1), new Range16.ptr(43062, 43065, 1), new Range16.ptr(43639, 43641, 1), new Range16.ptr(43867, 64297, 20430), new Range16.ptr(64434, 64449, 1), new Range16.ptr(65020, 65021, 1), new Range16.ptr(65122, 65124, 2), new Range16.ptr(65125, 65126, 1), new Range16.ptr(65129, 65284, 155), new Range16.ptr(65291, 65308, 17), new Range16.ptr(65309, 65310, 1), new Range16.ptr(65342, 65344, 2), new Range16.ptr(65372, 65374, 2), new Range16.ptr(65504, 65510, 1), new Range16.ptr(65512, 65518, 1), new Range16.ptr(65532, 65533, 1)]), new sliceType$1([new Range32.ptr(65847, 65855, 1), new Range32.ptr(65913, 65929, 1), new Range32.ptr(65932, 65936, 4), new Range32.ptr(65937, 65947, 1), new Range32.ptr(65952, 66000, 48), new Range32.ptr(66001, 66044, 1), new Range32.ptr(67703, 67704, 1), new Range32.ptr(68296, 92988, 24692), new Range32.ptr(92989, 92991, 1), new Range32.ptr(92997, 113820, 20823), new Range32.ptr(118784, 119029, 1), new Range32.ptr(119040, 119078, 1), new Range32.ptr(119081, 119140, 1), new Range32.ptr(119146, 119148, 1), new Range32.ptr(119171, 119172, 1), new Range32.ptr(119180, 119209, 1), new Range32.ptr(119214, 119261, 1), new Range32.ptr(119296, 119361, 1), new Range32.ptr(119365, 119552, 187), new Range32.ptr(119553, 119638, 1), new Range32.ptr(120513, 120539, 26), new Range32.ptr(120571, 120597, 26), new Range32.ptr(120629, 120655, 26), new Range32.ptr(120687, 120713, 26), new Range32.ptr(120745, 120771, 26), new Range32.ptr(126704, 126705, 1), new Range32.ptr(126976, 127019, 1), new Range32.ptr(127024, 127123, 1), new Range32.ptr(127136, 127150, 1), new Range32.ptr(127153, 127167, 1), new Range32.ptr(127169, 127183, 1), new Range32.ptr(127185, 127221, 1), new Range32.ptr(127248, 127278, 1), new Range32.ptr(127280, 127339, 1), new Range32.ptr(127344, 127386, 1), new Range32.ptr(127462, 127490, 1), new Range32.ptr(127504, 127546, 1), new Range32.ptr(127552, 127560, 1), new Range32.ptr(127568, 127569, 1), new Range32.ptr(127744, 127788, 1), new Range32.ptr(127792, 127869, 1), new Range32.ptr(127872, 127950, 1), new Range32.ptr(127956, 127991, 1), new Range32.ptr(128000, 128254, 1), new Range32.ptr(128256, 128330, 1), new Range32.ptr(128336, 128377, 1), new Range32.ptr(128379, 128419, 1), new Range32.ptr(128421, 128578, 1), new Range32.ptr(128581, 128719, 1), new Range32.ptr(128736, 128748, 1), new Range32.ptr(128752, 128755, 1), new Range32.ptr(128768, 128883, 1), new Range32.ptr(128896, 128980, 1), new Range32.ptr(129024, 129035, 1), new Range32.ptr(129040, 129095, 1), new Range32.ptr(129104, 129113, 1), new Range32.ptr(129120, 129159, 1), new Range32.ptr(129168, 129197, 1)]), 10);
- _Zs = new RangeTable.ptr(new sliceType([new Range16.ptr(32, 160, 128), new Range16.ptr(5760, 8192, 2432), new Range16.ptr(8193, 8202, 1), new Range16.ptr(8239, 8287, 48), new Range16.ptr(12288, 12288, 1)]), sliceType$1.nil, 1);
- $pkg.Digit = _Nd;
- $pkg.Letter = _L;
- $pkg.L = _L;
- $pkg.M = _M;
- $pkg.N = _N;
- $pkg.P = _P;
- $pkg.S = _S;
- $pkg.Upper = _Lu;
- $pkg.Zs = _Zs;
- $pkg.GraphicRanges = new sliceType$2([$pkg.L, $pkg.M, $pkg.N, $pkg.P, $pkg.S, $pkg.Zs]);
- _White_Space = new RangeTable.ptr(new sliceType([new Range16.ptr(9, 13, 1), new Range16.ptr(32, 32, 1), new Range16.ptr(133, 133, 1), new Range16.ptr(160, 160, 1), new Range16.ptr(5760, 5760, 1), new Range16.ptr(8192, 8202, 1), new Range16.ptr(8232, 8233, 1), new Range16.ptr(8239, 8239, 1), new Range16.ptr(8287, 8287, 1), new Range16.ptr(12288, 12288, 1)]), sliceType$1.nil, 4);
- $pkg.White_Space = _White_Space;
- _CaseRanges = new sliceType$3([new CaseRange.ptr(65, 90, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(97, 122, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(181, 181, $toNativeArray($kindInt32, [743, 0, 743])), new CaseRange.ptr(192, 214, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(216, 222, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(224, 246, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(248, 254, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(255, 255, $toNativeArray($kindInt32, [121, 0, 121])), new CaseRange.ptr(256, 303, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(304, 304, $toNativeArray($kindInt32, [0, -199, 0])), new CaseRange.ptr(305, 305, $toNativeArray($kindInt32, [-232, 0, -232])), new CaseRange.ptr(306, 311, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(313, 328, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(330, 375, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(376, 376, $toNativeArray($kindInt32, [0, -121, 0])), new CaseRange.ptr(377, 382, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(383, 383, $toNativeArray($kindInt32, [-300, 0, -300])), new CaseRange.ptr(384, 384, $toNativeArray($kindInt32, [195, 0, 195])), new CaseRange.ptr(385, 385, $toNativeArray($kindInt32, [0, 210, 0])), new CaseRange.ptr(386, 389, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(390, 390, $toNativeArray($kindInt32, [0, 206, 0])), new CaseRange.ptr(391, 392, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(393, 394, $toNativeArray($kindInt32, [0, 205, 0])), new CaseRange.ptr(395, 396, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(398, 398, $toNativeArray($kindInt32, [0, 79, 0])), new CaseRange.ptr(399, 399, $toNativeArray($kindInt32, [0, 202, 0])), new CaseRange.ptr(400, 400, $toNativeArray($kindInt32, [0, 203, 0])), new CaseRange.ptr(401, 402, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(403, 403, $toNativeArray($kindInt32, [0, 205, 0])), new CaseRange.ptr(404, 404, $toNativeArray($kindInt32, [0, 207, 0])), new CaseRange.ptr(405, 405, $toNativeArray($kindInt32, [97, 0, 97])), new CaseRange.ptr(406, 406, $toNativeArray($kindInt32, [0, 211, 0])), new CaseRange.ptr(407, 407, $toNativeArray($kindInt32, [0, 209, 0])), new CaseRange.ptr(408, 409, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(410, 410, $toNativeArray($kindInt32, [163, 0, 163])), new CaseRange.ptr(412, 412, $toNativeArray($kindInt32, [0, 211, 0])), new CaseRange.ptr(413, 413, $toNativeArray($kindInt32, [0, 213, 0])), new CaseRange.ptr(414, 414, $toNativeArray($kindInt32, [130, 0, 130])), new CaseRange.ptr(415, 415, $toNativeArray($kindInt32, [0, 214, 0])), new CaseRange.ptr(416, 421, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(422, 422, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(423, 424, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(425, 425, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(428, 429, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(430, 430, $toNativeArray($kindInt32, [0, 218, 0])), new CaseRange.ptr(431, 432, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(433, 434, $toNativeArray($kindInt32, [0, 217, 0])), new CaseRange.ptr(435, 438, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(439, 439, $toNativeArray($kindInt32, [0, 219, 0])), new CaseRange.ptr(440, 441, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(444, 445, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(447, 447, $toNativeArray($kindInt32, [56, 0, 56])), new CaseRange.ptr(452, 452, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(453, 453, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(454, 454, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(455, 455, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(456, 456, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(457, 457, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(458, 458, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(459, 459, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(460, 460, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(461, 476, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(477, 477, $toNativeArray($kindInt32, [-79, 0, -79])), new CaseRange.ptr(478, 495, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(497, 497, $toNativeArray($kindInt32, [0, 2, 1])), new CaseRange.ptr(498, 498, $toNativeArray($kindInt32, [-1, 1, 0])), new CaseRange.ptr(499, 499, $toNativeArray($kindInt32, [-2, 0, -1])), new CaseRange.ptr(500, 501, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(502, 502, $toNativeArray($kindInt32, [0, -97, 0])), new CaseRange.ptr(503, 503, $toNativeArray($kindInt32, [0, -56, 0])), new CaseRange.ptr(504, 543, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(544, 544, $toNativeArray($kindInt32, [0, -130, 0])), new CaseRange.ptr(546, 563, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(570, 570, $toNativeArray($kindInt32, [0, 10795, 0])), new CaseRange.ptr(571, 572, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(573, 573, $toNativeArray($kindInt32, [0, -163, 0])), new CaseRange.ptr(574, 574, $toNativeArray($kindInt32, [0, 10792, 0])), new CaseRange.ptr(575, 576, $toNativeArray($kindInt32, [10815, 0, 10815])), new CaseRange.ptr(577, 578, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(579, 579, $toNativeArray($kindInt32, [0, -195, 0])), new CaseRange.ptr(580, 580, $toNativeArray($kindInt32, [0, 69, 0])), new CaseRange.ptr(581, 581, $toNativeArray($kindInt32, [0, 71, 0])), new CaseRange.ptr(582, 591, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(592, 592, $toNativeArray($kindInt32, [10783, 0, 10783])), new CaseRange.ptr(593, 593, $toNativeArray($kindInt32, [10780, 0, 10780])), new CaseRange.ptr(594, 594, $toNativeArray($kindInt32, [10782, 0, 10782])), new CaseRange.ptr(595, 595, $toNativeArray($kindInt32, [-210, 0, -210])), new CaseRange.ptr(596, 596, $toNativeArray($kindInt32, [-206, 0, -206])), new CaseRange.ptr(598, 599, $toNativeArray($kindInt32, [-205, 0, -205])), new CaseRange.ptr(601, 601, $toNativeArray($kindInt32, [-202, 0, -202])), new CaseRange.ptr(603, 603, $toNativeArray($kindInt32, [-203, 0, -203])), new CaseRange.ptr(604, 604, $toNativeArray($kindInt32, [42319, 0, 42319])), new CaseRange.ptr(608, 608, $toNativeArray($kindInt32, [-205, 0, -205])), new CaseRange.ptr(609, 609, $toNativeArray($kindInt32, [42315, 0, 42315])), new CaseRange.ptr(611, 611, $toNativeArray($kindInt32, [-207, 0, -207])), new CaseRange.ptr(613, 613, $toNativeArray($kindInt32, [42280, 0, 42280])), new CaseRange.ptr(614, 614, $toNativeArray($kindInt32, [42308, 0, 42308])), new CaseRange.ptr(616, 616, $toNativeArray($kindInt32, [-209, 0, -209])), new CaseRange.ptr(617, 617, $toNativeArray($kindInt32, [-211, 0, -211])), new CaseRange.ptr(619, 619, $toNativeArray($kindInt32, [10743, 0, 10743])), new CaseRange.ptr(620, 620, $toNativeArray($kindInt32, [42305, 0, 42305])), new CaseRange.ptr(623, 623, $toNativeArray($kindInt32, [-211, 0, -211])), new CaseRange.ptr(625, 625, $toNativeArray($kindInt32, [10749, 0, 10749])), new CaseRange.ptr(626, 626, $toNativeArray($kindInt32, [-213, 0, -213])), new CaseRange.ptr(629, 629, $toNativeArray($kindInt32, [-214, 0, -214])), new CaseRange.ptr(637, 637, $toNativeArray($kindInt32, [10727, 0, 10727])), new CaseRange.ptr(640, 640, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(643, 643, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(647, 647, $toNativeArray($kindInt32, [42282, 0, 42282])), new CaseRange.ptr(648, 648, $toNativeArray($kindInt32, [-218, 0, -218])), new CaseRange.ptr(649, 649, $toNativeArray($kindInt32, [-69, 0, -69])), new CaseRange.ptr(650, 651, $toNativeArray($kindInt32, [-217, 0, -217])), new CaseRange.ptr(652, 652, $toNativeArray($kindInt32, [-71, 0, -71])), new CaseRange.ptr(658, 658, $toNativeArray($kindInt32, [-219, 0, -219])), new CaseRange.ptr(670, 670, $toNativeArray($kindInt32, [42258, 0, 42258])), new CaseRange.ptr(837, 837, $toNativeArray($kindInt32, [84, 0, 84])), new CaseRange.ptr(880, 883, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(886, 887, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(891, 893, $toNativeArray($kindInt32, [130, 0, 130])), new CaseRange.ptr(895, 895, $toNativeArray($kindInt32, [0, 116, 0])), new CaseRange.ptr(902, 902, $toNativeArray($kindInt32, [0, 38, 0])), new CaseRange.ptr(904, 906, $toNativeArray($kindInt32, [0, 37, 0])), new CaseRange.ptr(908, 908, $toNativeArray($kindInt32, [0, 64, 0])), new CaseRange.ptr(910, 911, $toNativeArray($kindInt32, [0, 63, 0])), new CaseRange.ptr(913, 929, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(931, 939, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(940, 940, $toNativeArray($kindInt32, [-38, 0, -38])), new CaseRange.ptr(941, 943, $toNativeArray($kindInt32, [-37, 0, -37])), new CaseRange.ptr(945, 961, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(962, 962, $toNativeArray($kindInt32, [-31, 0, -31])), new CaseRange.ptr(963, 971, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(972, 972, $toNativeArray($kindInt32, [-64, 0, -64])), new CaseRange.ptr(973, 974, $toNativeArray($kindInt32, [-63, 0, -63])), new CaseRange.ptr(975, 975, $toNativeArray($kindInt32, [0, 8, 0])), new CaseRange.ptr(976, 976, $toNativeArray($kindInt32, [-62, 0, -62])), new CaseRange.ptr(977, 977, $toNativeArray($kindInt32, [-57, 0, -57])), new CaseRange.ptr(981, 981, $toNativeArray($kindInt32, [-47, 0, -47])), new CaseRange.ptr(982, 982, $toNativeArray($kindInt32, [-54, 0, -54])), new CaseRange.ptr(983, 983, $toNativeArray($kindInt32, [-8, 0, -8])), new CaseRange.ptr(984, 1007, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1008, 1008, $toNativeArray($kindInt32, [-86, 0, -86])), new CaseRange.ptr(1009, 1009, $toNativeArray($kindInt32, [-80, 0, -80])), new CaseRange.ptr(1010, 1010, $toNativeArray($kindInt32, [7, 0, 7])), new CaseRange.ptr(1011, 1011, $toNativeArray($kindInt32, [-116, 0, -116])), new CaseRange.ptr(1012, 1012, $toNativeArray($kindInt32, [0, -60, 0])), new CaseRange.ptr(1013, 1013, $toNativeArray($kindInt32, [-96, 0, -96])), new CaseRange.ptr(1015, 1016, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1017, 1017, $toNativeArray($kindInt32, [0, -7, 0])), new CaseRange.ptr(1018, 1019, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1021, 1023, $toNativeArray($kindInt32, [0, -130, 0])), new CaseRange.ptr(1024, 1039, $toNativeArray($kindInt32, [0, 80, 0])), new CaseRange.ptr(1040, 1071, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(1072, 1103, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(1104, 1119, $toNativeArray($kindInt32, [-80, 0, -80])), new CaseRange.ptr(1120, 1153, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1162, 1215, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1216, 1216, $toNativeArray($kindInt32, [0, 15, 0])), new CaseRange.ptr(1217, 1230, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1231, 1231, $toNativeArray($kindInt32, [-15, 0, -15])), new CaseRange.ptr(1232, 1327, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(1329, 1366, $toNativeArray($kindInt32, [0, 48, 0])), new CaseRange.ptr(1377, 1414, $toNativeArray($kindInt32, [-48, 0, -48])), new CaseRange.ptr(4256, 4293, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(4295, 4295, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(4301, 4301, $toNativeArray($kindInt32, [0, 7264, 0])), new CaseRange.ptr(7545, 7545, $toNativeArray($kindInt32, [35332, 0, 35332])), new CaseRange.ptr(7549, 7549, $toNativeArray($kindInt32, [3814, 0, 3814])), new CaseRange.ptr(7680, 7829, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(7835, 7835, $toNativeArray($kindInt32, [-59, 0, -59])), new CaseRange.ptr(7838, 7838, $toNativeArray($kindInt32, [0, -7615, 0])), new CaseRange.ptr(7840, 7935, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(7936, 7943, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7944, 7951, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7952, 7957, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7960, 7965, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7968, 7975, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7976, 7983, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(7984, 7991, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(7992, 7999, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8000, 8005, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8008, 8013, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8017, 8017, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8019, 8019, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8021, 8021, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8023, 8023, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8025, 8025, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8027, 8027, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8029, 8029, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8031, 8031, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8032, 8039, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8040, 8047, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8048, 8049, $toNativeArray($kindInt32, [74, 0, 74])), new CaseRange.ptr(8050, 8053, $toNativeArray($kindInt32, [86, 0, 86])), new CaseRange.ptr(8054, 8055, $toNativeArray($kindInt32, [100, 0, 100])), new CaseRange.ptr(8056, 8057, $toNativeArray($kindInt32, [128, 0, 128])), new CaseRange.ptr(8058, 8059, $toNativeArray($kindInt32, [112, 0, 112])), new CaseRange.ptr(8060, 8061, $toNativeArray($kindInt32, [126, 0, 126])), new CaseRange.ptr(8064, 8071, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8072, 8079, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8080, 8087, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8088, 8095, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8096, 8103, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8104, 8111, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8112, 8113, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8115, 8115, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8120, 8121, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8122, 8123, $toNativeArray($kindInt32, [0, -74, 0])), new CaseRange.ptr(8124, 8124, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8126, 8126, $toNativeArray($kindInt32, [-7205, 0, -7205])), new CaseRange.ptr(8131, 8131, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8136, 8139, $toNativeArray($kindInt32, [0, -86, 0])), new CaseRange.ptr(8140, 8140, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8144, 8145, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8152, 8153, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8154, 8155, $toNativeArray($kindInt32, [0, -100, 0])), new CaseRange.ptr(8160, 8161, $toNativeArray($kindInt32, [8, 0, 8])), new CaseRange.ptr(8165, 8165, $toNativeArray($kindInt32, [7, 0, 7])), new CaseRange.ptr(8168, 8169, $toNativeArray($kindInt32, [0, -8, 0])), new CaseRange.ptr(8170, 8171, $toNativeArray($kindInt32, [0, -112, 0])), new CaseRange.ptr(8172, 8172, $toNativeArray($kindInt32, [0, -7, 0])), new CaseRange.ptr(8179, 8179, $toNativeArray($kindInt32, [9, 0, 9])), new CaseRange.ptr(8184, 8185, $toNativeArray($kindInt32, [0, -128, 0])), new CaseRange.ptr(8186, 8187, $toNativeArray($kindInt32, [0, -126, 0])), new CaseRange.ptr(8188, 8188, $toNativeArray($kindInt32, [0, -9, 0])), new CaseRange.ptr(8486, 8486, $toNativeArray($kindInt32, [0, -7517, 0])), new CaseRange.ptr(8490, 8490, $toNativeArray($kindInt32, [0, -8383, 0])), new CaseRange.ptr(8491, 8491, $toNativeArray($kindInt32, [0, -8262, 0])), new CaseRange.ptr(8498, 8498, $toNativeArray($kindInt32, [0, 28, 0])), new CaseRange.ptr(8526, 8526, $toNativeArray($kindInt32, [-28, 0, -28])), new CaseRange.ptr(8544, 8559, $toNativeArray($kindInt32, [0, 16, 0])), new CaseRange.ptr(8560, 8575, $toNativeArray($kindInt32, [-16, 0, -16])), new CaseRange.ptr(8579, 8580, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(9398, 9423, $toNativeArray($kindInt32, [0, 26, 0])), new CaseRange.ptr(9424, 9449, $toNativeArray($kindInt32, [-26, 0, -26])), new CaseRange.ptr(11264, 11310, $toNativeArray($kindInt32, [0, 48, 0])), new CaseRange.ptr(11312, 11358, $toNativeArray($kindInt32, [-48, 0, -48])), new CaseRange.ptr(11360, 11361, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11362, 11362, $toNativeArray($kindInt32, [0, -10743, 0])), new CaseRange.ptr(11363, 11363, $toNativeArray($kindInt32, [0, -3814, 0])), new CaseRange.ptr(11364, 11364, $toNativeArray($kindInt32, [0, -10727, 0])), new CaseRange.ptr(11365, 11365, $toNativeArray($kindInt32, [-10795, 0, -10795])), new CaseRange.ptr(11366, 11366, $toNativeArray($kindInt32, [-10792, 0, -10792])), new CaseRange.ptr(11367, 11372, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11373, 11373, $toNativeArray($kindInt32, [0, -10780, 0])), new CaseRange.ptr(11374, 11374, $toNativeArray($kindInt32, [0, -10749, 0])), new CaseRange.ptr(11375, 11375, $toNativeArray($kindInt32, [0, -10783, 0])), new CaseRange.ptr(11376, 11376, $toNativeArray($kindInt32, [0, -10782, 0])), new CaseRange.ptr(11378, 11379, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11381, 11382, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11390, 11391, $toNativeArray($kindInt32, [0, -10815, 0])), new CaseRange.ptr(11392, 11491, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11499, 11502, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11506, 11507, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(11520, 11557, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(11559, 11559, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(11565, 11565, $toNativeArray($kindInt32, [-7264, 0, -7264])), new CaseRange.ptr(42560, 42605, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42624, 42651, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42786, 42799, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42802, 42863, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42873, 42876, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42877, 42877, $toNativeArray($kindInt32, [0, -35332, 0])), new CaseRange.ptr(42878, 42887, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42891, 42892, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42893, 42893, $toNativeArray($kindInt32, [0, -42280, 0])), new CaseRange.ptr(42896, 42899, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42902, 42921, $toNativeArray($kindInt32, [1114112, 1114112, 1114112])), new CaseRange.ptr(42922, 42922, $toNativeArray($kindInt32, [0, -42308, 0])), new CaseRange.ptr(42923, 42923, $toNativeArray($kindInt32, [0, -42319, 0])), new CaseRange.ptr(42924, 42924, $toNativeArray($kindInt32, [0, -42315, 0])), new CaseRange.ptr(42925, 42925, $toNativeArray($kindInt32, [0, -42305, 0])), new CaseRange.ptr(42928, 42928, $toNativeArray($kindInt32, [0, -42258, 0])), new CaseRange.ptr(42929, 42929, $toNativeArray($kindInt32, [0, -42282, 0])), new CaseRange.ptr(65313, 65338, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(65345, 65370, $toNativeArray($kindInt32, [-32, 0, -32])), new CaseRange.ptr(66560, 66599, $toNativeArray($kindInt32, [0, 40, 0])), new CaseRange.ptr(66600, 66639, $toNativeArray($kindInt32, [-40, 0, -40])), new CaseRange.ptr(71840, 71871, $toNativeArray($kindInt32, [0, 32, 0])), new CaseRange.ptr(71872, 71903, $toNativeArray($kindInt32, [-32, 0, -32]))]);
- $pkg.CaseRanges = _CaseRanges;
- properties = $toNativeArray($kindUint8, [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 144, 130, 130, 130, 136, 130, 130, 130, 130, 130, 130, 136, 130, 130, 130, 130, 132, 132, 132, 132, 132, 132, 132, 132, 132, 132, 130, 130, 136, 136, 136, 130, 130, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 130, 130, 130, 136, 130, 136, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 130, 136, 130, 136, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 16, 130, 136, 136, 136, 136, 136, 130, 136, 136, 224, 130, 136, 0, 136, 136, 136, 136, 132, 132, 136, 192, 130, 130, 136, 132, 224, 130, 132, 132, 132, 130, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 136, 160, 160, 160, 160, 160, 160, 160, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 136, 192, 192, 192, 192, 192, 192, 192, 192]);
- caseOrbit = new sliceType$4([new foldPair.ptr(75, 107), new foldPair.ptr(83, 115), new foldPair.ptr(107, 8490), new foldPair.ptr(115, 383), new foldPair.ptr(181, 924), new foldPair.ptr(197, 229), new foldPair.ptr(223, 7838), new foldPair.ptr(229, 8491), new foldPair.ptr(304, 304), new foldPair.ptr(305, 305), new foldPair.ptr(383, 83), new foldPair.ptr(452, 453), new foldPair.ptr(453, 454), new foldPair.ptr(454, 452), new foldPair.ptr(455, 456), new foldPair.ptr(456, 457), new foldPair.ptr(457, 455), new foldPair.ptr(458, 459), new foldPair.ptr(459, 460), new foldPair.ptr(460, 458), new foldPair.ptr(497, 498), new foldPair.ptr(498, 499), new foldPair.ptr(499, 497), new foldPair.ptr(837, 921), new foldPair.ptr(914, 946), new foldPair.ptr(917, 949), new foldPair.ptr(920, 952), new foldPair.ptr(921, 953), new foldPair.ptr(922, 954), new foldPair.ptr(924, 956), new foldPair.ptr(928, 960), new foldPair.ptr(929, 961), new foldPair.ptr(931, 962), new foldPair.ptr(934, 966), new foldPair.ptr(937, 969), new foldPair.ptr(946, 976), new foldPair.ptr(949, 1013), new foldPair.ptr(952, 977), new foldPair.ptr(953, 8126), new foldPair.ptr(954, 1008), new foldPair.ptr(956, 181), new foldPair.ptr(960, 982), new foldPair.ptr(961, 1009), new foldPair.ptr(962, 963), new foldPair.ptr(963, 931), new foldPair.ptr(966, 981), new foldPair.ptr(969, 8486), new foldPair.ptr(976, 914), new foldPair.ptr(977, 1012), new foldPair.ptr(981, 934), new foldPair.ptr(982, 928), new foldPair.ptr(1008, 922), new foldPair.ptr(1009, 929), new foldPair.ptr(1012, 920), new foldPair.ptr(1013, 917), new foldPair.ptr(7776, 7777), new foldPair.ptr(7777, 7835), new foldPair.ptr(7835, 7776), new foldPair.ptr(7838, 223), new foldPair.ptr(8126, 837), new foldPair.ptr(8486, 937), new foldPair.ptr(8490, 75), new foldPair.ptr(8491, 197)]);
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["unicode/utf8"] = (function() {
- var $pkg = {}, $init, decodeRuneInternal, decodeRuneInStringInternal, FullRune, DecodeRune, DecodeRuneInString, DecodeLastRune, DecodeLastRuneInString, RuneLen, EncodeRune, RuneCount, RuneCountInString, RuneStart;
- decodeRuneInternal = function(p) {
- var $ptr, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$6, _tmp$7, _tmp$8, _tmp$9, c0, c1, c2, c3, n, p, r, short$1, size;
- r = 0;
- size = 0;
- short$1 = false;
- n = p.$length;
- if (n < 1) {
- _tmp = 65533; _tmp$1 = 0; _tmp$2 = true; r = _tmp; size = _tmp$1; short$1 = _tmp$2;
- return [r, size, short$1];
- }
- c0 = (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0]);
- if (c0 < 128) {
- _tmp$3 = (c0 >> 0); _tmp$4 = 1; _tmp$5 = false; r = _tmp$3; size = _tmp$4; short$1 = _tmp$5;
- return [r, size, short$1];
- }
- if (c0 < 192) {
- _tmp$6 = 65533; _tmp$7 = 1; _tmp$8 = false; r = _tmp$6; size = _tmp$7; short$1 = _tmp$8;
- return [r, size, short$1];
- }
- if (n < 2) {
- _tmp$9 = 65533; _tmp$10 = 1; _tmp$11 = true; r = _tmp$9; size = _tmp$10; short$1 = _tmp$11;
- return [r, size, short$1];
- }
- c1 = (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1]);
- if (c1 < 128 || 192 <= c1) {
- _tmp$12 = 65533; _tmp$13 = 1; _tmp$14 = false; r = _tmp$12; size = _tmp$13; short$1 = _tmp$14;
- return [r, size, short$1];
- }
- if (c0 < 224) {
- r = ((((c0 & 31) >>> 0) >> 0) << 6 >> 0) | (((c1 & 63) >>> 0) >> 0);
- if (r <= 127) {
- _tmp$15 = 65533; _tmp$16 = 1; _tmp$17 = false; r = _tmp$15; size = _tmp$16; short$1 = _tmp$17;
- return [r, size, short$1];
- }
- _tmp$18 = r; _tmp$19 = 2; _tmp$20 = false; r = _tmp$18; size = _tmp$19; short$1 = _tmp$20;
- return [r, size, short$1];
- }
- if (n < 3) {
- _tmp$21 = 65533; _tmp$22 = 1; _tmp$23 = true; r = _tmp$21; size = _tmp$22; short$1 = _tmp$23;
- return [r, size, short$1];
- }
- c2 = (2 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 2]);
- if (c2 < 128 || 192 <= c2) {
- _tmp$24 = 65533; _tmp$25 = 1; _tmp$26 = false; r = _tmp$24; size = _tmp$25; short$1 = _tmp$26;
- return [r, size, short$1];
- }
- if (c0 < 240) {
- r = (((((c0 & 15) >>> 0) >> 0) << 12 >> 0) | ((((c1 & 63) >>> 0) >> 0) << 6 >> 0)) | (((c2 & 63) >>> 0) >> 0);
- if (r <= 2047) {
- _tmp$27 = 65533; _tmp$28 = 1; _tmp$29 = false; r = _tmp$27; size = _tmp$28; short$1 = _tmp$29;
- return [r, size, short$1];
- }
- if (55296 <= r && r <= 57343) {
- _tmp$30 = 65533; _tmp$31 = 1; _tmp$32 = false; r = _tmp$30; size = _tmp$31; short$1 = _tmp$32;
- return [r, size, short$1];
- }
- _tmp$33 = r; _tmp$34 = 3; _tmp$35 = false; r = _tmp$33; size = _tmp$34; short$1 = _tmp$35;
- return [r, size, short$1];
- }
- if (n < 4) {
- _tmp$36 = 65533; _tmp$37 = 1; _tmp$38 = true; r = _tmp$36; size = _tmp$37; short$1 = _tmp$38;
- return [r, size, short$1];
- }
- c3 = (3 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 3]);
- if (c3 < 128 || 192 <= c3) {
- _tmp$39 = 65533; _tmp$40 = 1; _tmp$41 = false; r = _tmp$39; size = _tmp$40; short$1 = _tmp$41;
- return [r, size, short$1];
- }
- if (c0 < 248) {
- r = ((((((c0 & 7) >>> 0) >> 0) << 18 >> 0) | ((((c1 & 63) >>> 0) >> 0) << 12 >> 0)) | ((((c2 & 63) >>> 0) >> 0) << 6 >> 0)) | (((c3 & 63) >>> 0) >> 0);
- if (r <= 65535 || 1114111 < r) {
- _tmp$42 = 65533; _tmp$43 = 1; _tmp$44 = false; r = _tmp$42; size = _tmp$43; short$1 = _tmp$44;
- return [r, size, short$1];
- }
- _tmp$45 = r; _tmp$46 = 4; _tmp$47 = false; r = _tmp$45; size = _tmp$46; short$1 = _tmp$47;
- return [r, size, short$1];
- }
- _tmp$48 = 65533; _tmp$49 = 1; _tmp$50 = false; r = _tmp$48; size = _tmp$49; short$1 = _tmp$50;
- return [r, size, short$1];
- };
- decodeRuneInStringInternal = function(s) {
- var $ptr, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$6, _tmp$7, _tmp$8, _tmp$9, c0, c1, c2, c3, n, r, s, short$1, size;
- r = 0;
- size = 0;
- short$1 = false;
- n = s.length;
- if (n < 1) {
- _tmp = 65533; _tmp$1 = 0; _tmp$2 = true; r = _tmp; size = _tmp$1; short$1 = _tmp$2;
- return [r, size, short$1];
- }
- c0 = s.charCodeAt(0);
- if (c0 < 128) {
- _tmp$3 = (c0 >> 0); _tmp$4 = 1; _tmp$5 = false; r = _tmp$3; size = _tmp$4; short$1 = _tmp$5;
- return [r, size, short$1];
- }
- if (c0 < 192) {
- _tmp$6 = 65533; _tmp$7 = 1; _tmp$8 = false; r = _tmp$6; size = _tmp$7; short$1 = _tmp$8;
- return [r, size, short$1];
- }
- if (n < 2) {
- _tmp$9 = 65533; _tmp$10 = 1; _tmp$11 = true; r = _tmp$9; size = _tmp$10; short$1 = _tmp$11;
- return [r, size, short$1];
- }
- c1 = s.charCodeAt(1);
- if (c1 < 128 || 192 <= c1) {
- _tmp$12 = 65533; _tmp$13 = 1; _tmp$14 = false; r = _tmp$12; size = _tmp$13; short$1 = _tmp$14;
- return [r, size, short$1];
- }
- if (c0 < 224) {
- r = ((((c0 & 31) >>> 0) >> 0) << 6 >> 0) | (((c1 & 63) >>> 0) >> 0);
- if (r <= 127) {
- _tmp$15 = 65533; _tmp$16 = 1; _tmp$17 = false; r = _tmp$15; size = _tmp$16; short$1 = _tmp$17;
- return [r, size, short$1];
- }
- _tmp$18 = r; _tmp$19 = 2; _tmp$20 = false; r = _tmp$18; size = _tmp$19; short$1 = _tmp$20;
- return [r, size, short$1];
- }
- if (n < 3) {
- _tmp$21 = 65533; _tmp$22 = 1; _tmp$23 = true; r = _tmp$21; size = _tmp$22; short$1 = _tmp$23;
- return [r, size, short$1];
- }
- c2 = s.charCodeAt(2);
- if (c2 < 128 || 192 <= c2) {
- _tmp$24 = 65533; _tmp$25 = 1; _tmp$26 = false; r = _tmp$24; size = _tmp$25; short$1 = _tmp$26;
- return [r, size, short$1];
- }
- if (c0 < 240) {
- r = (((((c0 & 15) >>> 0) >> 0) << 12 >> 0) | ((((c1 & 63) >>> 0) >> 0) << 6 >> 0)) | (((c2 & 63) >>> 0) >> 0);
- if (r <= 2047) {
- _tmp$27 = 65533; _tmp$28 = 1; _tmp$29 = false; r = _tmp$27; size = _tmp$28; short$1 = _tmp$29;
- return [r, size, short$1];
- }
- if (55296 <= r && r <= 57343) {
- _tmp$30 = 65533; _tmp$31 = 1; _tmp$32 = false; r = _tmp$30; size = _tmp$31; short$1 = _tmp$32;
- return [r, size, short$1];
- }
- _tmp$33 = r; _tmp$34 = 3; _tmp$35 = false; r = _tmp$33; size = _tmp$34; short$1 = _tmp$35;
- return [r, size, short$1];
- }
- if (n < 4) {
- _tmp$36 = 65533; _tmp$37 = 1; _tmp$38 = true; r = _tmp$36; size = _tmp$37; short$1 = _tmp$38;
- return [r, size, short$1];
- }
- c3 = s.charCodeAt(3);
- if (c3 < 128 || 192 <= c3) {
- _tmp$39 = 65533; _tmp$40 = 1; _tmp$41 = false; r = _tmp$39; size = _tmp$40; short$1 = _tmp$41;
- return [r, size, short$1];
- }
- if (c0 < 248) {
- r = ((((((c0 & 7) >>> 0) >> 0) << 18 >> 0) | ((((c1 & 63) >>> 0) >> 0) << 12 >> 0)) | ((((c2 & 63) >>> 0) >> 0) << 6 >> 0)) | (((c3 & 63) >>> 0) >> 0);
- if (r <= 65535 || 1114111 < r) {
- _tmp$42 = 65533; _tmp$43 = 1; _tmp$44 = false; r = _tmp$42; size = _tmp$43; short$1 = _tmp$44;
- return [r, size, short$1];
- }
- _tmp$45 = r; _tmp$46 = 4; _tmp$47 = false; r = _tmp$45; size = _tmp$46; short$1 = _tmp$47;
- return [r, size, short$1];
- }
- _tmp$48 = 65533; _tmp$49 = 1; _tmp$50 = false; r = _tmp$48; size = _tmp$49; short$1 = _tmp$50;
- return [r, size, short$1];
- };
- FullRune = function(p) {
- var $ptr, _tuple, p, short$1;
- _tuple = decodeRuneInternal(p); short$1 = _tuple[2];
- return !short$1;
- };
- $pkg.FullRune = FullRune;
- DecodeRune = function(p) {
- var $ptr, _tuple, p, r, size;
- r = 0;
- size = 0;
- _tuple = decodeRuneInternal(p); r = _tuple[0]; size = _tuple[1];
- return [r, size];
- };
- $pkg.DecodeRune = DecodeRune;
- DecodeRuneInString = function(s) {
- var $ptr, _tuple, r, s, size;
- r = 0;
- size = 0;
- _tuple = decodeRuneInStringInternal(s); r = _tuple[0]; size = _tuple[1];
- return [r, size];
- };
- $pkg.DecodeRuneInString = DecodeRuneInString;
- DecodeLastRune = function(p) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, end, lim, p, r, size, start;
- r = 0;
- size = 0;
- end = p.$length;
- if (end === 0) {
- _tmp = 65533; _tmp$1 = 0; r = _tmp; size = _tmp$1;
- return [r, size];
- }
- start = end - 1 >> 0;
- r = (((start < 0 || start >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + start]) >> 0);
- if (r < 128) {
- _tmp$2 = r; _tmp$3 = 1; r = _tmp$2; size = _tmp$3;
- return [r, size];
- }
- lim = end - 4 >> 0;
- if (lim < 0) {
- lim = 0;
- }
- start = start - (1) >> 0;
- while (true) {
- if (!(start >= lim)) { break; }
- if (RuneStart(((start < 0 || start >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + start]))) {
- break;
- }
- start = start - (1) >> 0;
- }
- if (start < 0) {
- start = 0;
- }
- _tuple = DecodeRune($subslice(p, start, end)); r = _tuple[0]; size = _tuple[1];
- if (!(((start + size >> 0) === end))) {
- _tmp$4 = 65533; _tmp$5 = 1; r = _tmp$4; size = _tmp$5;
- return [r, size];
- }
- _tmp$6 = r; _tmp$7 = size; r = _tmp$6; size = _tmp$7;
- return [r, size];
- };
- $pkg.DecodeLastRune = DecodeLastRune;
- DecodeLastRuneInString = function(s) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, end, lim, r, s, size, start;
- r = 0;
- size = 0;
- end = s.length;
- if (end === 0) {
- _tmp = 65533; _tmp$1 = 0; r = _tmp; size = _tmp$1;
- return [r, size];
- }
- start = end - 1 >> 0;
- r = (s.charCodeAt(start) >> 0);
- if (r < 128) {
- _tmp$2 = r; _tmp$3 = 1; r = _tmp$2; size = _tmp$3;
- return [r, size];
- }
- lim = end - 4 >> 0;
- if (lim < 0) {
- lim = 0;
- }
- start = start - (1) >> 0;
- while (true) {
- if (!(start >= lim)) { break; }
- if (RuneStart(s.charCodeAt(start))) {
- break;
- }
- start = start - (1) >> 0;
- }
- if (start < 0) {
- start = 0;
- }
- _tuple = DecodeRuneInString(s.substring(start, end)); r = _tuple[0]; size = _tuple[1];
- if (!(((start + size >> 0) === end))) {
- _tmp$4 = 65533; _tmp$5 = 1; r = _tmp$4; size = _tmp$5;
- return [r, size];
- }
- _tmp$6 = r; _tmp$7 = size; r = _tmp$6; size = _tmp$7;
- return [r, size];
- };
- $pkg.DecodeLastRuneInString = DecodeLastRuneInString;
- RuneLen = function(r) {
- var $ptr, r;
- if (r < 0) {
- return -1;
- } else if (r <= 127) {
- return 1;
- } else if (r <= 2047) {
- return 2;
- } else if (55296 <= r && r <= 57343) {
- return -1;
- } else if (r <= 65535) {
- return 3;
- } else if (r <= 1114111) {
- return 4;
- }
- return -1;
- };
- $pkg.RuneLen = RuneLen;
- EncodeRune = function(p, r) {
- var $ptr, i, p, r;
- i = (r >>> 0);
- if (i <= 127) {
- (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = (r << 24 >>> 24));
- return 1;
- } else if (i <= 2047) {
- (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = (192 | ((r >> 6 >> 0) << 24 >>> 24)) >>> 0);
- (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = (128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0);
- return 2;
- } else if (i > 1114111 || 55296 <= i && i <= 57343) {
- r = 65533;
- (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = (224 | ((r >> 12 >> 0) << 24 >>> 24)) >>> 0);
- (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = (128 | ((((r >> 6 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0);
- (2 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 2] = (128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0);
- return 3;
- } else if (i <= 65535) {
- (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = (224 | ((r >> 12 >> 0) << 24 >>> 24)) >>> 0);
- (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = (128 | ((((r >> 6 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0);
- (2 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 2] = (128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0);
- return 3;
- } else {
- (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = (240 | ((r >> 18 >> 0) << 24 >>> 24)) >>> 0);
- (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = (128 | ((((r >> 12 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0);
- (2 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 2] = (128 | ((((r >> 6 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0);
- (3 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 3] = (128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0);
- return 4;
- }
- };
- $pkg.EncodeRune = EncodeRune;
- RuneCount = function(p) {
- var $ptr, _tuple, i, n, p, size;
- i = 0;
- n = 0;
- n = 0;
- while (true) {
- if (!(i < p.$length)) { break; }
- if (((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i]) < 128) {
- i = i + (1) >> 0;
- } else {
- _tuple = DecodeRune($subslice(p, i)); size = _tuple[1];
- i = i + (size) >> 0;
- }
- n = n + (1) >> 0;
- }
- return n;
- };
- $pkg.RuneCount = RuneCount;
- RuneCountInString = function(s) {
- var $ptr, _i, _ref, _rune, n, s;
- n = 0;
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- n = n + (1) >> 0;
- _i += _rune[1];
- }
- return n;
- };
- $pkg.RuneCountInString = RuneCountInString;
- RuneStart = function(b) {
- var $ptr, b;
- return !((((b & 192) >>> 0) === 128));
- };
- $pkg.RuneStart = RuneStart;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["bytes"] = (function() {
- var $pkg = {}, $init, errors, io, unicode, utf8, Buffer, readOp, Reader, ptrType, sliceType, arrayType, arrayType$1, ptrType$1, IndexByte, Equal, makeSlice, NewBuffer, Index, LastIndex, IndexAny, HasPrefix, Map, TrimLeftFunc, TrimRightFunc, TrimFunc, indexFunc, lastIndexFunc, TrimSpace, EqualFold, NewReader;
- errors = $packages["errors"];
- io = $packages["io"];
- unicode = $packages["unicode"];
- utf8 = $packages["unicode/utf8"];
- Buffer = $pkg.Buffer = $newType(0, $kindStruct, "bytes.Buffer", "Buffer", "bytes", function(buf_, off_, runeBytes_, bootstrap_, lastRead_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.buf = sliceType.nil;
- this.off = 0;
- this.runeBytes = arrayType.zero();
- this.bootstrap = arrayType$1.zero();
- this.lastRead = 0;
- return;
- }
- this.buf = buf_;
- this.off = off_;
- this.runeBytes = runeBytes_;
- this.bootstrap = bootstrap_;
- this.lastRead = lastRead_;
- });
- readOp = $pkg.readOp = $newType(4, $kindInt, "bytes.readOp", "readOp", "bytes", null);
- Reader = $pkg.Reader = $newType(0, $kindStruct, "bytes.Reader", "Reader", "bytes", function(s_, i_, prevRune_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.s = sliceType.nil;
- this.i = new $Int64(0, 0);
- this.prevRune = 0;
- return;
- }
- this.s = s_;
- this.i = i_;
- this.prevRune = prevRune_;
- });
- ptrType = $ptrType(Buffer);
- sliceType = $sliceType($Uint8);
- arrayType = $arrayType($Uint8, 4);
- arrayType$1 = $arrayType($Uint8, 64);
- ptrType$1 = $ptrType(Reader);
- IndexByte = function(s, c) {
- var $ptr, _i, _ref, b, c, i, s;
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (b === c) {
- return i;
- }
- _i++;
- }
- return -1;
- };
- $pkg.IndexByte = IndexByte;
- Equal = function(a, b) {
- var $ptr, _i, _ref, a, b, c, i;
- if (!((a.$length === b.$length))) {
- return false;
- }
- _ref = a;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!((c === ((i < 0 || i >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + i])))) {
- return false;
- }
- _i++;
- }
- return true;
- };
- $pkg.Equal = Equal;
- Buffer.ptr.prototype.Bytes = function() {
- var $ptr, b;
- b = this;
- return $subslice(b.buf, b.off);
- };
- Buffer.prototype.Bytes = function() { return this.$val.Bytes(); };
- Buffer.ptr.prototype.String = function() {
- var $ptr, b;
- b = this;
- if (b === ptrType.nil) {
- return "";
- }
- return $bytesToString($subslice(b.buf, b.off));
- };
- Buffer.prototype.String = function() { return this.$val.String(); };
- Buffer.ptr.prototype.Len = function() {
- var $ptr, b;
- b = this;
- return b.buf.$length - b.off >> 0;
- };
- Buffer.prototype.Len = function() { return this.$val.Len(); };
- Buffer.ptr.prototype.Truncate = function(n) {
- var $ptr, b, n;
- b = this;
- b.lastRead = 0;
- if (n < 0 || n > b.Len()) {
- $panic(new $String("bytes.Buffer: truncation out of range"));
- } else if (n === 0) {
- b.off = 0;
- }
- b.buf = $subslice(b.buf, 0, (b.off + n >> 0));
- };
- Buffer.prototype.Truncate = function(n) { return this.$val.Truncate(n); };
- Buffer.ptr.prototype.Reset = function() {
- var $ptr, b;
- b = this;
- b.Truncate(0);
- };
- Buffer.prototype.Reset = function() { return this.$val.Reset(); };
- Buffer.ptr.prototype.grow = function(n) {
- var $ptr, _q, b, buf, m, n;
- b = this;
- m = b.Len();
- if ((m === 0) && !((b.off === 0))) {
- b.Truncate(0);
- }
- if ((b.buf.$length + n >> 0) > b.buf.$capacity) {
- buf = sliceType.nil;
- if (b.buf === sliceType.nil && n <= 64) {
- buf = $subslice(new sliceType(b.bootstrap), 0);
- } else if ((m + n >> 0) <= (_q = b.buf.$capacity / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))) {
- $copySlice(b.buf, $subslice(b.buf, b.off));
- buf = $subslice(b.buf, 0, m);
- } else {
- buf = makeSlice((2 * b.buf.$capacity >> 0) + n >> 0);
- $copySlice(buf, $subslice(b.buf, b.off));
- }
- b.buf = buf;
- b.off = 0;
- }
- b.buf = $subslice(b.buf, 0, ((b.off + m >> 0) + n >> 0));
- return b.off + m >> 0;
- };
- Buffer.prototype.grow = function(n) { return this.$val.grow(n); };
- Buffer.ptr.prototype.Grow = function(n) {
- var $ptr, b, m, n;
- b = this;
- if (n < 0) {
- $panic(new $String("bytes.Buffer.Grow: negative count"));
- }
- m = b.grow(n);
- b.buf = $subslice(b.buf, 0, m);
- };
- Buffer.prototype.Grow = function(n) { return this.$val.Grow(n); };
- Buffer.ptr.prototype.Write = function(p) {
- var $ptr, _tmp, _tmp$1, b, err, m, n, p;
- n = 0;
- err = $ifaceNil;
- b = this;
- b.lastRead = 0;
- m = b.grow(p.$length);
- _tmp = $copySlice($subslice(b.buf, m), p); _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- };
- Buffer.prototype.Write = function(p) { return this.$val.Write(p); };
- Buffer.ptr.prototype.WriteString = function(s) {
- var $ptr, _tmp, _tmp$1, b, err, m, n, s;
- n = 0;
- err = $ifaceNil;
- b = this;
- b.lastRead = 0;
- m = b.grow(s.length);
- _tmp = $copyString($subslice(b.buf, m), s); _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- };
- Buffer.prototype.WriteString = function(s) { return this.$val.WriteString(s); };
- Buffer.ptr.prototype.ReadFrom = function(r) {
- var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, free, m, n, newBuf, r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; free = $f.free; m = $f.m; n = $f.n; newBuf = $f.newBuf; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = new $Int64(0, 0);
- err = $ifaceNil;
- b = this;
- b.lastRead = 0;
- if (b.off >= b.buf.$length) {
- b.Truncate(0);
- }
- /* while (true) { */ case 1:
- free = b.buf.$capacity - b.buf.$length >> 0;
- if (free < 512) {
- newBuf = b.buf;
- if ((b.off + free >> 0) < 512) {
- newBuf = makeSlice((2 * b.buf.$capacity >> 0) + 512 >> 0);
- }
- $copySlice(newBuf, $subslice(b.buf, b.off));
- b.buf = $subslice(newBuf, 0, (b.buf.$length - b.off >> 0));
- b.off = 0;
- }
- _r = r.Read($subslice(b.buf, b.buf.$length, b.buf.$capacity)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; m = _tuple[0]; e = _tuple[1];
- b.buf = $subslice(b.buf, 0, (b.buf.$length + m >> 0));
- n = (x = new $Int64(0, m), new $Int64(n.$high + x.$high, n.$low + x.$low));
- if ($interfaceIsEqual(e, io.EOF)) {
- /* break; */ $s = 2; continue;
- }
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- _tmp = n; _tmp$1 = e; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- /* } */ $s = 1; continue; case 2:
- _tmp$2 = n; _tmp$3 = $ifaceNil; n = _tmp$2; err = _tmp$3;
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.ReadFrom }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.free = free; $f.m = m; $f.n = n; $f.newBuf = newBuf; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Buffer.prototype.ReadFrom = function(r) { return this.$val.ReadFrom(r); };
- makeSlice = function(n) {
- var $ptr, n, $deferred;
- /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- $deferred.push([(function() {
- var $ptr;
- if (!($interfaceIsEqual($recover(), $ifaceNil))) {
- $panic($pkg.ErrTooLarge);
- }
- }), []]);
- return $makeSlice(sliceType, n);
- /* */ } catch(err) { $err = err; return sliceType.nil; } finally { $callDeferred($deferred, $err); }
- };
- Buffer.ptr.prototype.WriteTo = function(w) {
- var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, m, n, nBytes, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; n = $f.n; nBytes = $f.nBytes; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = new $Int64(0, 0);
- err = $ifaceNil;
- b = this;
- b.lastRead = 0;
- /* */ if (b.off < b.buf.$length) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (b.off < b.buf.$length) { */ case 1:
- nBytes = b.Len();
- _r = w.Write($subslice(b.buf, b.off)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; m = _tuple[0]; e = _tuple[1];
- if (m > nBytes) {
- $panic(new $String("bytes.Buffer.WriteTo: invalid Write count"));
- }
- b.off = b.off + (m) >> 0;
- n = new $Int64(0, m);
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- _tmp = n; _tmp$1 = e; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- if (!((m === nBytes))) {
- _tmp$2 = n; _tmp$3 = io.ErrShortWrite; n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- /* } */ case 2:
- b.Truncate(0);
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.WriteTo }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.n = n; $f.nBytes = nBytes; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- Buffer.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); };
- Buffer.ptr.prototype.WriteByte = function(c) {
- var $ptr, b, c, m, x;
- b = this;
- b.lastRead = 0;
- m = b.grow(1);
- (x = b.buf, ((m < 0 || m >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + m] = c));
- return $ifaceNil;
- };
- Buffer.prototype.WriteByte = function(c) { return this.$val.WriteByte(c); };
- Buffer.ptr.prototype.WriteRune = function(r) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, r;
- n = 0;
- err = $ifaceNil;
- b = this;
- if (r < 128) {
- b.WriteByte((r << 24 >>> 24));
- _tmp = 1; _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- n = utf8.EncodeRune($subslice(new sliceType(b.runeBytes), 0), r);
- b.Write($subslice(new sliceType(b.runeBytes), 0, n));
- _tmp$2 = n; _tmp$3 = $ifaceNil; n = _tmp$2; err = _tmp$3;
- return [n, err];
- };
- Buffer.prototype.WriteRune = function(r) { return this.$val.WriteRune(r); };
- Buffer.ptr.prototype.Read = function(p) {
- var $ptr, _tmp, _tmp$1, b, err, n, p;
- n = 0;
- err = $ifaceNil;
- b = this;
- b.lastRead = 0;
- if (b.off >= b.buf.$length) {
- b.Truncate(0);
- if (p.$length === 0) {
- return [n, err];
- }
- _tmp = 0; _tmp$1 = io.EOF; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- n = $copySlice(p, $subslice(b.buf, b.off));
- b.off = b.off + (n) >> 0;
- if (n > 0) {
- b.lastRead = 2;
- }
- return [n, err];
- };
- Buffer.prototype.Read = function(p) { return this.$val.Read(p); };
- Buffer.ptr.prototype.Next = function(n) {
- var $ptr, b, data, m, n;
- b = this;
- b.lastRead = 0;
- m = b.Len();
- if (n > m) {
- n = m;
- }
- data = $subslice(b.buf, b.off, (b.off + n >> 0));
- b.off = b.off + (n) >> 0;
- if (n > 0) {
- b.lastRead = 2;
- }
- return data;
- };
- Buffer.prototype.Next = function(n) { return this.$val.Next(n); };
- Buffer.ptr.prototype.ReadByte = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, c, err, x, x$1;
- c = 0;
- err = $ifaceNil;
- b = this;
- b.lastRead = 0;
- if (b.off >= b.buf.$length) {
- b.Truncate(0);
- _tmp = 0; _tmp$1 = io.EOF; c = _tmp; err = _tmp$1;
- return [c, err];
- }
- c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- b.off = b.off + (1) >> 0;
- b.lastRead = 2;
- _tmp$2 = c; _tmp$3 = $ifaceNil; c = _tmp$2; err = _tmp$3;
- return [c, err];
- };
- Buffer.prototype.ReadByte = function() { return this.$val.ReadByte(); };
- Buffer.ptr.prototype.ReadRune = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, b, c, err, n, r, size, x, x$1;
- r = 0;
- size = 0;
- err = $ifaceNil;
- b = this;
- b.lastRead = 0;
- if (b.off >= b.buf.$length) {
- b.Truncate(0);
- _tmp = 0; _tmp$1 = 0; _tmp$2 = io.EOF; r = _tmp; size = _tmp$1; err = _tmp$2;
- return [r, size, err];
- }
- b.lastRead = 1;
- c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- if (c < 128) {
- b.off = b.off + (1) >> 0;
- _tmp$3 = (c >> 0); _tmp$4 = 1; _tmp$5 = $ifaceNil; r = _tmp$3; size = _tmp$4; err = _tmp$5;
- return [r, size, err];
- }
- _tuple = utf8.DecodeRune($subslice(b.buf, b.off)); r = _tuple[0]; n = _tuple[1];
- b.off = b.off + (n) >> 0;
- _tmp$6 = r; _tmp$7 = n; _tmp$8 = $ifaceNil; r = _tmp$6; size = _tmp$7; err = _tmp$8;
- return [r, size, err];
- };
- Buffer.prototype.ReadRune = function() { return this.$val.ReadRune(); };
- Buffer.ptr.prototype.UnreadRune = function() {
- var $ptr, _tuple, b, n;
- b = this;
- if (!((b.lastRead === 1))) {
- return errors.New("bytes.Buffer: UnreadRune: previous operation was not ReadRune");
- }
- b.lastRead = 0;
- if (b.off > 0) {
- _tuple = utf8.DecodeLastRune($subslice(b.buf, 0, b.off)); n = _tuple[1];
- b.off = b.off - (n) >> 0;
- }
- return $ifaceNil;
- };
- Buffer.prototype.UnreadRune = function() { return this.$val.UnreadRune(); };
- Buffer.ptr.prototype.UnreadByte = function() {
- var $ptr, b;
- b = this;
- if (!((b.lastRead === 1)) && !((b.lastRead === 2))) {
- return errors.New("bytes.Buffer: UnreadByte: previous operation was not a read");
- }
- b.lastRead = 0;
- if (b.off > 0) {
- b.off = b.off - (1) >> 0;
- }
- return $ifaceNil;
- };
- Buffer.prototype.UnreadByte = function() { return this.$val.UnreadByte(); };
- Buffer.ptr.prototype.ReadBytes = function(delim) {
- var $ptr, _tuple, b, delim, err, line, slice;
- line = sliceType.nil;
- err = $ifaceNil;
- b = this;
- _tuple = b.readSlice(delim); slice = _tuple[0]; err = _tuple[1];
- line = $appendSlice(line, slice);
- return [line, err];
- };
- Buffer.prototype.ReadBytes = function(delim) { return this.$val.ReadBytes(delim); };
- Buffer.ptr.prototype.readSlice = function(delim) {
- var $ptr, _tmp, _tmp$1, b, delim, end, err, i, line;
- line = sliceType.nil;
- err = $ifaceNil;
- b = this;
- i = IndexByte($subslice(b.buf, b.off), delim);
- end = (b.off + i >> 0) + 1 >> 0;
- if (i < 0) {
- end = b.buf.$length;
- err = io.EOF;
- }
- line = $subslice(b.buf, b.off, end);
- b.off = end;
- b.lastRead = 2;
- _tmp = line; _tmp$1 = err; line = _tmp; err = _tmp$1;
- return [line, err];
- };
- Buffer.prototype.readSlice = function(delim) { return this.$val.readSlice(delim); };
- Buffer.ptr.prototype.ReadString = function(delim) {
- var $ptr, _tmp, _tmp$1, _tuple, b, delim, err, line, slice;
- line = "";
- err = $ifaceNil;
- b = this;
- _tuple = b.readSlice(delim); slice = _tuple[0]; err = _tuple[1];
- _tmp = $bytesToString(slice); _tmp$1 = err; line = _tmp; err = _tmp$1;
- return [line, err];
- };
- Buffer.prototype.ReadString = function(delim) { return this.$val.ReadString(delim); };
- NewBuffer = function(buf) {
- var $ptr, buf;
- return new Buffer.ptr(buf, 0, arrayType.zero(), arrayType$1.zero(), 0);
- };
- $pkg.NewBuffer = NewBuffer;
- Index = function(s, sep) {
- var $ptr, c, i, n, o, s, sep, t;
- n = sep.$length;
- if (n === 0) {
- return 0;
- }
- if (n > s.$length) {
- return -1;
- }
- c = (0 >= sep.$length ? $throwRuntimeError("index out of range") : sep.$array[sep.$offset + 0]);
- if (n === 1) {
- return IndexByte(s, c);
- }
- i = 0;
- t = $subslice(s, 0, ((s.$length - n >> 0) + 1 >> 0));
- while (true) {
- if (!(i < t.$length)) { break; }
- if (!((((i < 0 || i >= t.$length) ? $throwRuntimeError("index out of range") : t.$array[t.$offset + i]) === c))) {
- o = IndexByte($subslice(t, i), c);
- if (o < 0) {
- break;
- }
- i = i + (o) >> 0;
- }
- if (Equal($subslice(s, i, (i + n >> 0)), sep)) {
- return i;
- }
- i = i + (1) >> 0;
- }
- return -1;
- };
- $pkg.Index = Index;
- LastIndex = function(s, sep) {
- var $ptr, c, i, n, s, sep;
- n = sep.$length;
- if (n === 0) {
- return s.$length;
- }
- c = (0 >= sep.$length ? $throwRuntimeError("index out of range") : sep.$array[sep.$offset + 0]);
- i = s.$length - n >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- if ((((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i]) === c) && ((n === 1) || Equal($subslice(s, i, (i + n >> 0)), sep))) {
- return i;
- }
- i = i - (1) >> 0;
- }
- return -1;
- };
- $pkg.LastIndex = LastIndex;
- IndexAny = function(s, chars) {
- var $ptr, _i, _ref, _rune, _tuple, ch, chars, i, r, s, width;
- if (chars.length > 0) {
- r = 0;
- width = 0;
- i = 0;
- while (true) {
- if (!(i < s.$length)) { break; }
- r = (((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i]) >> 0);
- if (r < 128) {
- width = 1;
- } else {
- _tuple = utf8.DecodeRune($subslice(s, i)); r = _tuple[0]; width = _tuple[1];
- }
- _ref = chars;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- ch = _rune[0];
- if (r === ch) {
- return i;
- }
- _i += _rune[1];
- }
- i = i + (width) >> 0;
- }
- }
- return -1;
- };
- $pkg.IndexAny = IndexAny;
- HasPrefix = function(s, prefix) {
- var $ptr, prefix, s;
- return s.$length >= prefix.$length && Equal($subslice(s, 0, prefix.$length), prefix);
- };
- $pkg.HasPrefix = HasPrefix;
- Map = function(mapping, s) {
- var $ptr, _r, _tuple, b, i, mapping, maxbytes, nb, nbytes, r, rl, s, wid, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; b = $f.b; i = $f.i; mapping = $f.mapping; maxbytes = $f.maxbytes; nb = $f.nb; nbytes = $f.nbytes; r = $f.r; rl = $f.rl; s = $f.s; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- maxbytes = s.$length;
- nbytes = 0;
- b = $makeSlice(sliceType, maxbytes);
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < s.$length)) { break; } */ if(!(i < s.$length)) { $s = 2; continue; }
- wid = 1;
- r = (((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i]) >> 0);
- if (r >= 128) {
- _tuple = utf8.DecodeRune($subslice(s, i)); r = _tuple[0]; wid = _tuple[1];
- }
- _r = mapping(r); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- r = _r;
- if (r >= 0) {
- rl = utf8.RuneLen(r);
- if (rl < 0) {
- rl = 3;
- }
- if ((nbytes + rl >> 0) > maxbytes) {
- maxbytes = (maxbytes * 2 >> 0) + 4 >> 0;
- nb = $makeSlice(sliceType, maxbytes);
- $copySlice(nb, $subslice(b, 0, nbytes));
- b = nb;
- }
- nbytes = nbytes + (utf8.EncodeRune($subslice(b, nbytes, maxbytes), r)) >> 0;
- }
- i = i + (wid) >> 0;
- /* } */ $s = 1; continue; case 2:
- return $subslice(b, 0, nbytes);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.i = i; $f.mapping = mapping; $f.maxbytes = maxbytes; $f.nb = nb; $f.nbytes = nbytes; $f.r = r; $f.rl = rl; $f.s = s; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Map = Map;
- TrimLeftFunc = function(s, f) {
- var $ptr, _r, f, i, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; i = $f.i; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = indexFunc(s, f, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- i = _r;
- if (i === -1) {
- return sliceType.nil;
- }
- return $subslice(s, i);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimLeftFunc }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.i = i; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimLeftFunc = TrimLeftFunc;
- TrimRightFunc = function(s, f) {
- var $ptr, _r, _tuple, f, i, s, wid, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; i = $f.i; s = $f.s; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = lastIndexFunc(s, f, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- i = _r;
- if (i >= 0 && ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i]) >= 128) {
- _tuple = utf8.DecodeRune($subslice(s, i)); wid = _tuple[1];
- i = i + (wid) >> 0;
- } else {
- i = i + (1) >> 0;
- }
- return $subslice(s, 0, i);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimRightFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.s = s; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimRightFunc = TrimRightFunc;
- TrimFunc = function(s, f) {
- var $ptr, _r, _r$1, f, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; f = $f.f; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = TrimLeftFunc(s, f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = TrimRightFunc(_r, f); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimFunc = TrimFunc;
- indexFunc = function(s, f, truth) {
- var $ptr, _r, _tuple, f, r, s, start, truth, wid, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; r = $f.r; s = $f.s; start = $f.start; truth = $f.truth; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- start = 0;
- /* while (true) { */ case 1:
- /* if (!(start < s.$length)) { break; } */ if(!(start < s.$length)) { $s = 2; continue; }
- wid = 1;
- r = (((start < 0 || start >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + start]) >> 0);
- if (r >= 128) {
- _tuple = utf8.DecodeRune($subslice(s, start)); r = _tuple[0]; wid = _tuple[1];
- }
- _r = f(r); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r === truth) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_r === truth) { */ case 3:
- return start;
- /* } */ case 4:
- start = start + (wid) >> 0;
- /* } */ $s = 1; continue; case 2:
- return -1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: indexFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.r = r; $f.s = s; $f.start = start; $f.truth = truth; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f;
- };
- lastIndexFunc = function(s, f, truth) {
- var $ptr, _r, _tmp, _tmp$1, _tuple, f, i, r, s, size, truth, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; f = $f.f; i = $f.i; r = $f.r; s = $f.s; size = $f.size; truth = $f.truth; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = s.$length;
- /* while (true) { */ case 1:
- /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 2; continue; }
- _tmp = ((x = i - 1 >> 0, ((x < 0 || x >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + x])) >> 0); _tmp$1 = 1; r = _tmp; size = _tmp$1;
- if (r >= 128) {
- _tuple = utf8.DecodeLastRune($subslice(s, 0, i)); r = _tuple[0]; size = _tuple[1];
- }
- i = i - (size) >> 0;
- _r = f(r); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r === truth) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_r === truth) { */ case 3:
- return i;
- /* } */ case 4:
- /* } */ $s = 1; continue; case 2:
- return -1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: lastIndexFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.r = r; $f.s = s; $f.size = size; $f.truth = truth; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- TrimSpace = function(s) {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = TrimFunc(s, unicode.IsSpace); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimSpace }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimSpace = TrimSpace;
- EqualFold = function(s, t) {
- var $ptr, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, r, r$1, r$2, s, size, size$1, sr, t, tr;
- while (true) {
- if (!(!((s.$length === 0)) && !((t.$length === 0)))) { break; }
- _tmp = 0; _tmp$1 = 0; sr = _tmp; tr = _tmp$1;
- if ((0 >= s.$length ? $throwRuntimeError("index out of range") : s.$array[s.$offset + 0]) < 128) {
- _tmp$2 = ((0 >= s.$length ? $throwRuntimeError("index out of range") : s.$array[s.$offset + 0]) >> 0); _tmp$3 = $subslice(s, 1); sr = _tmp$2; s = _tmp$3;
- } else {
- _tuple = utf8.DecodeRune(s); r = _tuple[0]; size = _tuple[1];
- _tmp$4 = r; _tmp$5 = $subslice(s, size); sr = _tmp$4; s = _tmp$5;
- }
- if ((0 >= t.$length ? $throwRuntimeError("index out of range") : t.$array[t.$offset + 0]) < 128) {
- _tmp$6 = ((0 >= t.$length ? $throwRuntimeError("index out of range") : t.$array[t.$offset + 0]) >> 0); _tmp$7 = $subslice(t, 1); tr = _tmp$6; t = _tmp$7;
- } else {
- _tuple$1 = utf8.DecodeRune(t); r$1 = _tuple$1[0]; size$1 = _tuple$1[1];
- _tmp$8 = r$1; _tmp$9 = $subslice(t, size$1); tr = _tmp$8; t = _tmp$9;
- }
- if (tr === sr) {
- continue;
- }
- if (tr < sr) {
- _tmp$10 = sr; _tmp$11 = tr; tr = _tmp$10; sr = _tmp$11;
- }
- if (tr < 128 && 65 <= sr && sr <= 90) {
- if (tr === ((sr + 97 >> 0) - 65 >> 0)) {
- continue;
- }
- return false;
- }
- r$2 = unicode.SimpleFold(sr);
- while (true) {
- if (!(!((r$2 === sr)) && r$2 < tr)) { break; }
- r$2 = unicode.SimpleFold(r$2);
- }
- if (r$2 === tr) {
- continue;
- }
- return false;
- }
- return s.$length === t.$length;
- };
- $pkg.EqualFold = EqualFold;
- Reader.ptr.prototype.Len = function() {
- var $ptr, r, x, x$1, x$2, x$3, x$4;
- r = this;
- if ((x = r.i, x$1 = new $Int64(0, r.s.$length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- return 0;
- }
- return ((x$2 = (x$3 = new $Int64(0, r.s.$length), x$4 = r.i, new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0);
- };
- Reader.prototype.Len = function() { return this.$val.Len(); };
- Reader.ptr.prototype.Read = function(b) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, r, x, x$1, x$2, x$3;
- n = 0;
- err = $ifaceNil;
- r = this;
- if (b.$length === 0) {
- _tmp = 0; _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- if ((x = r.i, x$1 = new $Int64(0, r.s.$length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- _tmp$2 = 0; _tmp$3 = io.EOF; n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- r.prevRune = -1;
- n = $copySlice(b, $subslice(r.s, $flatten64(r.i)));
- r.i = (x$2 = r.i, x$3 = new $Int64(0, n), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low));
- return [n, err];
- };
- Reader.prototype.Read = function(b) { return this.$val.Read(b); };
- Reader.ptr.prototype.ReadAt = function(b, off) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, off, r, x;
- n = 0;
- err = $ifaceNil;
- r = this;
- if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) {
- _tmp = 0; _tmp$1 = errors.New("bytes.Reader.ReadAt: negative offset"); n = _tmp; err = _tmp$1;
- return [n, err];
- }
- if ((x = new $Int64(0, r.s.$length), (off.$high > x.$high || (off.$high === x.$high && off.$low >= x.$low)))) {
- _tmp$2 = 0; _tmp$3 = io.EOF; n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- n = $copySlice(b, $subslice(r.s, $flatten64(off)));
- if (n < b.$length) {
- err = io.EOF;
- }
- return [n, err];
- };
- Reader.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); };
- Reader.ptr.prototype.ReadByte = function() {
- var $ptr, _tmp, _tmp$1, b, err, r, x, x$1, x$2, x$3, x$4, x$5;
- b = 0;
- err = $ifaceNil;
- r = this;
- r.prevRune = -1;
- if ((x = r.i, x$1 = new $Int64(0, r.s.$length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- _tmp = 0; _tmp$1 = io.EOF; b = _tmp; err = _tmp$1;
- return [b, err];
- }
- b = (x$2 = r.s, x$3 = r.i, (($flatten64(x$3) < 0 || $flatten64(x$3) >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + $flatten64(x$3)]));
- r.i = (x$4 = r.i, x$5 = new $Int64(0, 1), new $Int64(x$4.$high + x$5.$high, x$4.$low + x$5.$low));
- return [b, err];
- };
- Reader.prototype.ReadByte = function() { return this.$val.ReadByte(); };
- Reader.ptr.prototype.UnreadByte = function() {
- var $ptr, r, x, x$1, x$2;
- r = this;
- r.prevRune = -1;
- if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) {
- return errors.New("bytes.Reader.UnreadByte: at beginning of slice");
- }
- r.i = (x$1 = r.i, x$2 = new $Int64(0, 1), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low));
- return $ifaceNil;
- };
- Reader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); };
- Reader.ptr.prototype.ReadRune = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, ch, err, r, size, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8;
- ch = 0;
- size = 0;
- err = $ifaceNil;
- r = this;
- if ((x = r.i, x$1 = new $Int64(0, r.s.$length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- r.prevRune = -1;
- _tmp = 0; _tmp$1 = 0; _tmp$2 = io.EOF; ch = _tmp; size = _tmp$1; err = _tmp$2;
- return [ch, size, err];
- }
- r.prevRune = ((x$2 = r.i, x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0);
- c = (x$3 = r.s, x$4 = r.i, (($flatten64(x$4) < 0 || $flatten64(x$4) >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + $flatten64(x$4)]));
- if (c < 128) {
- r.i = (x$5 = r.i, x$6 = new $Int64(0, 1), new $Int64(x$5.$high + x$6.$high, x$5.$low + x$6.$low));
- _tmp$3 = (c >> 0); _tmp$4 = 1; _tmp$5 = $ifaceNil; ch = _tmp$3; size = _tmp$4; err = _tmp$5;
- return [ch, size, err];
- }
- _tuple = utf8.DecodeRune($subslice(r.s, $flatten64(r.i))); ch = _tuple[0]; size = _tuple[1];
- r.i = (x$7 = r.i, x$8 = new $Int64(0, size), new $Int64(x$7.$high + x$8.$high, x$7.$low + x$8.$low));
- return [ch, size, err];
- };
- Reader.prototype.ReadRune = function() { return this.$val.ReadRune(); };
- Reader.ptr.prototype.UnreadRune = function() {
- var $ptr, r;
- r = this;
- if (r.prevRune < 0) {
- return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune");
- }
- r.i = new $Int64(0, r.prevRune);
- r.prevRune = -1;
- return $ifaceNil;
- };
- Reader.prototype.UnreadRune = function() { return this.$val.UnreadRune(); };
- Reader.ptr.prototype.Seek = function(offset, whence) {
- var $ptr, _ref, abs, offset, r, whence, x, x$1;
- r = this;
- r.prevRune = -1;
- abs = new $Int64(0, 0);
- _ref = whence;
- if (_ref === 0) {
- abs = offset;
- } else if (_ref === 1) {
- abs = (x = r.i, new $Int64(x.$high + offset.$high, x.$low + offset.$low));
- } else if (_ref === 2) {
- abs = (x$1 = new $Int64(0, r.s.$length), new $Int64(x$1.$high + offset.$high, x$1.$low + offset.$low));
- } else {
- return [new $Int64(0, 0), errors.New("bytes.Reader.Seek: invalid whence")];
- }
- if ((abs.$high < 0 || (abs.$high === 0 && abs.$low < 0))) {
- return [new $Int64(0, 0), errors.New("bytes.Reader.Seek: negative position")];
- }
- r.i = abs;
- return [abs, $ifaceNil];
- };
- Reader.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); };
- Reader.ptr.prototype.WriteTo = function(w) {
- var $ptr, _r, _tmp, _tmp$1, _tuple, b, err, m, n, r, w, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; err = $f.err; m = $f.m; n = $f.n; r = $f.r; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = new $Int64(0, 0);
- err = $ifaceNil;
- r = this;
- r.prevRune = -1;
- if ((x = r.i, x$1 = new $Int64(0, r.s.$length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- _tmp = new $Int64(0, 0); _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- b = $subslice(r.s, $flatten64(r.i));
- _r = w.Write(b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; m = _tuple[0]; err = _tuple[1];
- if (m > b.$length) {
- $panic(new $String("bytes.Reader.WriteTo: invalid Write count"));
- }
- r.i = (x$2 = r.i, x$3 = new $Int64(0, m), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low));
- n = new $Int64(0, m);
- if (!((m === b.$length)) && $interfaceIsEqual(err, $ifaceNil)) {
- err = io.ErrShortWrite;
- }
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.WriteTo }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.m = m; $f.n = n; $f.r = r; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); };
- NewReader = function(b) {
- var $ptr, b;
- return new Reader.ptr(b, new $Int64(0, 0), -1);
- };
- $pkg.NewReader = NewReader;
- ptrType.methods = [{prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "grow", name: "grow", pkg: "bytes", typ: $funcType([$Int], [$Int], false)}, {prop: "Grow", name: "Grow", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "ReadFrom", name: "ReadFrom", pkg: "", typ: $funcType([io.Reader], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [$error], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [$Int, $error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "Next", name: "Next", pkg: "", typ: $funcType([$Int], [sliceType], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadBytes", name: "ReadBytes", pkg: "", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "readSlice", name: "readSlice", pkg: "bytes", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "ReadString", name: "ReadString", pkg: "", typ: $funcType([$Uint8], [$String, $error], false)}];
- ptrType$1.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType, $Int64], [$Int, $error], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}];
- Buffer.init([{prop: "buf", name: "buf", pkg: "bytes", typ: sliceType, tag: ""}, {prop: "off", name: "off", pkg: "bytes", typ: $Int, tag: ""}, {prop: "runeBytes", name: "runeBytes", pkg: "bytes", typ: arrayType, tag: ""}, {prop: "bootstrap", name: "bootstrap", pkg: "bytes", typ: arrayType$1, tag: ""}, {prop: "lastRead", name: "lastRead", pkg: "bytes", typ: readOp, tag: ""}]);
- Reader.init([{prop: "s", name: "s", pkg: "bytes", typ: sliceType, tag: ""}, {prop: "i", name: "i", pkg: "bytes", typ: $Int64, tag: ""}, {prop: "prevRune", name: "prevRune", pkg: "bytes", typ: $Int, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.ErrTooLarge = errors.New("bytes.Buffer: too large");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["math"] = (function() {
- var $pkg = {}, $init, js, arrayType, arrayType$1, arrayType$2, structType, arrayType$3, math, zero, posInf, negInf, nan, buf, pow10tab, Abs, Exp, Frexp, Inf, IsInf, IsNaN, Ldexp, Log, Log2, NaN, init, Float32bits, Float32frombits, Float64bits, Float64frombits, abs, normalize, frexp, log2, init$1;
- js = $packages["github.com/gopherjs/gopherjs/js"];
- arrayType = $arrayType($Uint32, 2);
- arrayType$1 = $arrayType($Float32, 2);
- arrayType$2 = $arrayType($Float64, 1);
- structType = $structType([{prop: "uint32array", name: "uint32array", pkg: "math", typ: arrayType, tag: ""}, {prop: "float32array", name: "float32array", pkg: "math", typ: arrayType$1, tag: ""}, {prop: "float64array", name: "float64array", pkg: "math", typ: arrayType$2, tag: ""}]);
- arrayType$3 = $arrayType($Float64, 70);
- Abs = function(x) {
- var $ptr, x;
- return abs(x);
- };
- $pkg.Abs = Abs;
- Exp = function(x) {
- var $ptr, x;
- return $parseFloat(math.exp(x));
- };
- $pkg.Exp = Exp;
- Frexp = function(f) {
- var $ptr, _tuple, exp$1, f, frac;
- frac = 0;
- exp$1 = 0;
- _tuple = frexp(f); frac = _tuple[0]; exp$1 = _tuple[1];
- return [frac, exp$1];
- };
- $pkg.Frexp = Frexp;
- Inf = function(sign) {
- var $ptr, sign;
- if (sign >= 0) {
- return posInf;
- } else {
- return negInf;
- }
- };
- $pkg.Inf = Inf;
- IsInf = function(f, sign) {
- var $ptr, f, sign;
- if (f === posInf) {
- return sign >= 0;
- }
- if (f === negInf) {
- return sign <= 0;
- }
- return false;
- };
- $pkg.IsInf = IsInf;
- IsNaN = function(f) {
- var $ptr, f, is;
- is = false;
- is = !((f === f));
- return is;
- };
- $pkg.IsNaN = IsNaN;
- Ldexp = function(frac, exp$1) {
- var $ptr, exp$1, frac;
- if (frac === 0) {
- return frac;
- }
- if (exp$1 >= 1024) {
- return frac * $parseFloat(math.pow(2, 1023)) * $parseFloat(math.pow(2, exp$1 - 1023 >> 0));
- }
- if (exp$1 <= -1024) {
- return frac * $parseFloat(math.pow(2, -1023)) * $parseFloat(math.pow(2, exp$1 + 1023 >> 0));
- }
- return frac * $parseFloat(math.pow(2, exp$1));
- };
- $pkg.Ldexp = Ldexp;
- Log = function(x) {
- var $ptr, x;
- if (!((x === x))) {
- return nan;
- }
- return $parseFloat(math.log(x));
- };
- $pkg.Log = Log;
- Log2 = function(x) {
- var $ptr, x;
- return log2(x);
- };
- $pkg.Log2 = Log2;
- NaN = function() {
- var $ptr;
- return nan;
- };
- $pkg.NaN = NaN;
- init = function() {
- var $ptr, ab;
- ab = new ($global.ArrayBuffer)(8);
- buf.uint32array = new ($global.Uint32Array)(ab);
- buf.float32array = new ($global.Float32Array)(ab);
- buf.float64array = new ($global.Float64Array)(ab);
- };
- Float32bits = function(f) {
- var $ptr, f;
- buf.float32array[0] = f;
- return buf.uint32array[0];
- };
- $pkg.Float32bits = Float32bits;
- Float32frombits = function(b) {
- var $ptr, b;
- buf.uint32array[0] = b;
- return buf.float32array[0];
- };
- $pkg.Float32frombits = Float32frombits;
- Float64bits = function(f) {
- var $ptr, f, x, x$1;
- buf.float64array[0] = f;
- return (x = $shiftLeft64(new $Uint64(0, buf.uint32array[1]), 32), x$1 = new $Uint64(0, buf.uint32array[0]), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low));
- };
- $pkg.Float64bits = Float64bits;
- Float64frombits = function(b) {
- var $ptr, b;
- buf.uint32array[0] = (b.$low >>> 0);
- buf.uint32array[1] = ($shiftRightUint64(b, 32).$low >>> 0);
- return buf.float64array[0];
- };
- $pkg.Float64frombits = Float64frombits;
- abs = function(x) {
- var $ptr, x;
- if (x < 0) {
- return -x;
- } else if (x === 0) {
- return 0;
- }
- return x;
- };
- normalize = function(x) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, exp$1, x, y;
- y = 0;
- exp$1 = 0;
- if (Abs(x) < 2.2250738585072014e-308) {
- _tmp = x * 4.503599627370496e+15; _tmp$1 = -52; y = _tmp; exp$1 = _tmp$1;
- return [y, exp$1];
- }
- _tmp$2 = x; _tmp$3 = 0; y = _tmp$2; exp$1 = _tmp$3;
- return [y, exp$1];
- };
- frexp = function(f) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, exp$1, f, frac, x, x$1, x$2, x$3;
- frac = 0;
- exp$1 = 0;
- if (f === 0) {
- _tmp = f; _tmp$1 = 0; frac = _tmp; exp$1 = _tmp$1;
- return [frac, exp$1];
- } else if (IsInf(f, 0) || IsNaN(f)) {
- _tmp$2 = f; _tmp$3 = 0; frac = _tmp$2; exp$1 = _tmp$3;
- return [frac, exp$1];
- }
- _tuple = normalize(f); f = _tuple[0]; exp$1 = _tuple[1];
- x = Float64bits(f);
- exp$1 = exp$1 + (((((x$1 = $shiftRightUint64(x, 52), new $Uint64(x$1.$high & 0, (x$1.$low & 2047) >>> 0)).$low >> 0) - 1023 >> 0) + 1 >> 0)) >> 0;
- x = (x$2 = new $Uint64(2146435072, 0), new $Uint64(x.$high & ~x$2.$high, (x.$low & ~x$2.$low) >>> 0));
- x = (x$3 = new $Uint64(1071644672, 0), new $Uint64(x.$high | x$3.$high, (x.$low | x$3.$low) >>> 0));
- frac = Float64frombits(x);
- return [frac, exp$1];
- };
- log2 = function(x) {
- var $ptr, _tuple, exp$1, frac, x;
- _tuple = Frexp(x); frac = _tuple[0]; exp$1 = _tuple[1];
- return Log(frac) * 1.4426950408889634 + exp$1;
- };
- init$1 = function() {
- var $ptr, _q, i, m, x;
- pow10tab[0] = 1;
- pow10tab[1] = 10;
- i = 2;
- while (true) {
- if (!(i < 70)) { break; }
- m = (_q = i / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- ((i < 0 || i >= pow10tab.length) ? $throwRuntimeError("index out of range") : pow10tab[i] = ((m < 0 || m >= pow10tab.length) ? $throwRuntimeError("index out of range") : pow10tab[m]) * (x = i - m >> 0, ((x < 0 || x >= pow10tab.length) ? $throwRuntimeError("index out of range") : pow10tab[x])));
- i = i + (1) >> 0;
- }
- };
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- buf = new structType.ptr();
- pow10tab = arrayType$3.zero();
- math = $global.Math;
- zero = 0;
- posInf = 1 / zero;
- negInf = -1 / zero;
- nan = 0 / zero;
- init();
- init$1();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["strconv"] = (function() {
- var $pkg = {}, $init, errors, math, utf8, NumError, decimal, leftCheat, extFloat, floatInfo, decimalSlice, sliceType, sliceType$1, sliceType$2, sliceType$3, sliceType$4, sliceType$5, sliceType$6, ptrType, arrayType, arrayType$1, ptrType$1, arrayType$2, arrayType$3, arrayType$4, arrayType$5, arrayType$6, ptrType$2, ptrType$3, ptrType$4, optimize, powtab, float64pow10, float32pow10, leftcheats, smallPowersOfTen, powersOfTen, uint64pow10, float32info, nonAsciiName, float64info, nonAsciiName$1, isPrint16, isNotPrint16, isPrint32, isNotPrint32, shifts, ParseBool, FormatBool, equalIgnoreCase, special, readFloat, atof64exact, atof32exact, atof32, atof64, ParseFloat, syntaxError, rangeError, cutoff64, ParseUint, ParseInt, Atoi, digitZero, trim, rightShift, prefixIsLessThan, leftShift, shouldRoundUp, frexp10Many, adjustLastDigitFixed, adjustLastDigit, FormatFloat, AppendFloat, genericFtoa, bigFtoa, formatDigits, roundShortest, fmtE, fmtF, fmtB, max, FormatUint, FormatInt, Itoa, AppendInt, AppendUint, formatBits, quoteWith, Quote, QuoteToASCII, QuoteRune, AppendQuoteRune, QuoteRuneToASCII, AppendQuoteRuneToASCII, CanBackquote, unhex, UnquoteChar, Unquote, contains, bsearch16, bsearch32, IsPrint;
- errors = $packages["errors"];
- math = $packages["math"];
- utf8 = $packages["unicode/utf8"];
- NumError = $pkg.NumError = $newType(0, $kindStruct, "strconv.NumError", "NumError", "strconv", function(Func_, Num_, Err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Func = "";
- this.Num = "";
- this.Err = $ifaceNil;
- return;
- }
- this.Func = Func_;
- this.Num = Num_;
- this.Err = Err_;
- });
- decimal = $pkg.decimal = $newType(0, $kindStruct, "strconv.decimal", "decimal", "strconv", function(d_, nd_, dp_, neg_, trunc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.d = arrayType$6.zero();
- this.nd = 0;
- this.dp = 0;
- this.neg = false;
- this.trunc = false;
- return;
- }
- this.d = d_;
- this.nd = nd_;
- this.dp = dp_;
- this.neg = neg_;
- this.trunc = trunc_;
- });
- leftCheat = $pkg.leftCheat = $newType(0, $kindStruct, "strconv.leftCheat", "leftCheat", "strconv", function(delta_, cutoff_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.delta = 0;
- this.cutoff = "";
- return;
- }
- this.delta = delta_;
- this.cutoff = cutoff_;
- });
- extFloat = $pkg.extFloat = $newType(0, $kindStruct, "strconv.extFloat", "extFloat", "strconv", function(mant_, exp_, neg_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.mant = new $Uint64(0, 0);
- this.exp = 0;
- this.neg = false;
- return;
- }
- this.mant = mant_;
- this.exp = exp_;
- this.neg = neg_;
- });
- floatInfo = $pkg.floatInfo = $newType(0, $kindStruct, "strconv.floatInfo", "floatInfo", "strconv", function(mantbits_, expbits_, bias_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.mantbits = 0;
- this.expbits = 0;
- this.bias = 0;
- return;
- }
- this.mantbits = mantbits_;
- this.expbits = expbits_;
- this.bias = bias_;
- });
- decimalSlice = $pkg.decimalSlice = $newType(0, $kindStruct, "strconv.decimalSlice", "decimalSlice", "strconv", function(d_, nd_, dp_, neg_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.d = sliceType$6.nil;
- this.nd = 0;
- this.dp = 0;
- this.neg = false;
- return;
- }
- this.d = d_;
- this.nd = nd_;
- this.dp = dp_;
- this.neg = neg_;
- });
- sliceType = $sliceType($Int);
- sliceType$1 = $sliceType($Float64);
- sliceType$2 = $sliceType($Float32);
- sliceType$3 = $sliceType(leftCheat);
- sliceType$4 = $sliceType($Uint16);
- sliceType$5 = $sliceType($Uint32);
- sliceType$6 = $sliceType($Uint8);
- ptrType = $ptrType(NumError);
- arrayType = $arrayType($Uint8, 24);
- arrayType$1 = $arrayType($Uint8, 32);
- ptrType$1 = $ptrType(floatInfo);
- arrayType$2 = $arrayType($Uint8, 3);
- arrayType$3 = $arrayType($Uint8, 50);
- arrayType$4 = $arrayType($Uint8, 65);
- arrayType$5 = $arrayType($Uint8, 4);
- arrayType$6 = $arrayType($Uint8, 800);
- ptrType$2 = $ptrType(decimal);
- ptrType$3 = $ptrType(decimalSlice);
- ptrType$4 = $ptrType(extFloat);
- ParseBool = function(str) {
- var $ptr, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, err, str, value;
- value = false;
- err = $ifaceNil;
- _ref = str;
- if (_ref === "1" || _ref === "t" || _ref === "T" || _ref === "true" || _ref === "TRUE" || _ref === "True") {
- _tmp = true; _tmp$1 = $ifaceNil; value = _tmp; err = _tmp$1;
- return [value, err];
- } else if (_ref === "0" || _ref === "f" || _ref === "F" || _ref === "false" || _ref === "FALSE" || _ref === "False") {
- _tmp$2 = false; _tmp$3 = $ifaceNil; value = _tmp$2; err = _tmp$3;
- return [value, err];
- }
- _tmp$4 = false; _tmp$5 = syntaxError("ParseBool", str); value = _tmp$4; err = _tmp$5;
- return [value, err];
- };
- $pkg.ParseBool = ParseBool;
- FormatBool = function(b) {
- var $ptr, b;
- if (b) {
- return "true";
- }
- return "false";
- };
- $pkg.FormatBool = FormatBool;
- equalIgnoreCase = function(s1, s2) {
- var $ptr, c1, c2, i, s1, s2;
- if (!((s1.length === s2.length))) {
- return false;
- }
- i = 0;
- while (true) {
- if (!(i < s1.length)) { break; }
- c1 = s1.charCodeAt(i);
- if (65 <= c1 && c1 <= 90) {
- c1 = c1 + (32) << 24 >>> 24;
- }
- c2 = s2.charCodeAt(i);
- if (65 <= c2 && c2 <= 90) {
- c2 = c2 + (32) << 24 >>> 24;
- }
- if (!((c1 === c2))) {
- return false;
- }
- i = i + (1) >> 0;
- }
- return true;
- };
- special = function(s) {
- var $ptr, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, f, ok, s;
- f = 0;
- ok = false;
- if (s.length === 0) {
- return [f, ok];
- }
- _ref = s.charCodeAt(0);
- if (_ref === 43) {
- if (equalIgnoreCase(s, "+inf") || equalIgnoreCase(s, "+infinity")) {
- _tmp = math.Inf(1); _tmp$1 = true; f = _tmp; ok = _tmp$1;
- return [f, ok];
- }
- } else if (_ref === 45) {
- if (equalIgnoreCase(s, "-inf") || equalIgnoreCase(s, "-infinity")) {
- _tmp$2 = math.Inf(-1); _tmp$3 = true; f = _tmp$2; ok = _tmp$3;
- return [f, ok];
- }
- } else if (_ref === 110 || _ref === 78) {
- if (equalIgnoreCase(s, "nan")) {
- _tmp$4 = math.NaN(); _tmp$5 = true; f = _tmp$4; ok = _tmp$5;
- return [f, ok];
- }
- } else if (_ref === 105 || _ref === 73) {
- if (equalIgnoreCase(s, "inf") || equalIgnoreCase(s, "infinity")) {
- _tmp$6 = math.Inf(1); _tmp$7 = true; f = _tmp$6; ok = _tmp$7;
- return [f, ok];
- }
- } else {
- return [f, ok];
- }
- return [f, ok];
- };
- decimal.ptr.prototype.set = function(s) {
- var $ptr, b, e, esign, i, ok, s, sawdigits, sawdot, x, x$1;
- ok = false;
- b = this;
- i = 0;
- b.neg = false;
- b.trunc = false;
- if (i >= s.length) {
- return ok;
- }
- if (s.charCodeAt(i) === 43) {
- i = i + (1) >> 0;
- } else if (s.charCodeAt(i) === 45) {
- b.neg = true;
- i = i + (1) >> 0;
- }
- sawdot = false;
- sawdigits = false;
- while (true) {
- if (!(i < s.length)) { break; }
- if (s.charCodeAt(i) === 46) {
- if (sawdot) {
- return ok;
- }
- sawdot = true;
- b.dp = b.nd;
- i = i + (1) >> 0;
- continue;
- } else if (48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57) {
- sawdigits = true;
- if ((s.charCodeAt(i) === 48) && (b.nd === 0)) {
- b.dp = b.dp - (1) >> 0;
- i = i + (1) >> 0;
- continue;
- }
- if (b.nd < 800) {
- (x = b.d, x$1 = b.nd, ((x$1 < 0 || x$1 >= x.length) ? $throwRuntimeError("index out of range") : x[x$1] = s.charCodeAt(i)));
- b.nd = b.nd + (1) >> 0;
- } else if (!((s.charCodeAt(i) === 48))) {
- b.trunc = true;
- }
- i = i + (1) >> 0;
- continue;
- }
- break;
- }
- if (!sawdigits) {
- return ok;
- }
- if (!sawdot) {
- b.dp = b.nd;
- }
- if (i < s.length && ((s.charCodeAt(i) === 101) || (s.charCodeAt(i) === 69))) {
- i = i + (1) >> 0;
- if (i >= s.length) {
- return ok;
- }
- esign = 1;
- if (s.charCodeAt(i) === 43) {
- i = i + (1) >> 0;
- } else if (s.charCodeAt(i) === 45) {
- i = i + (1) >> 0;
- esign = -1;
- }
- if (i >= s.length || s.charCodeAt(i) < 48 || s.charCodeAt(i) > 57) {
- return ok;
- }
- e = 0;
- while (true) {
- if (!(i < s.length && 48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57)) { break; }
- if (e < 10000) {
- e = ((e * 10 >> 0) + (s.charCodeAt(i) >> 0) >> 0) - 48 >> 0;
- }
- i = i + (1) >> 0;
- }
- b.dp = b.dp + ((e * esign >> 0)) >> 0;
- }
- if (!((i === s.length))) {
- return ok;
- }
- ok = true;
- return ok;
- };
- decimal.prototype.set = function(s) { return this.$val.set(s); };
- readFloat = function(s) {
- var $ptr, c, dp, e, esign, exp, i, mantissa, nd, ndMant, neg, ok, s, sawdigits, sawdot, trunc, x;
- mantissa = new $Uint64(0, 0);
- exp = 0;
- neg = false;
- trunc = false;
- ok = false;
- i = 0;
- if (i >= s.length) {
- return [mantissa, exp, neg, trunc, ok];
- }
- if (s.charCodeAt(i) === 43) {
- i = i + (1) >> 0;
- } else if (s.charCodeAt(i) === 45) {
- neg = true;
- i = i + (1) >> 0;
- }
- sawdot = false;
- sawdigits = false;
- nd = 0;
- ndMant = 0;
- dp = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- c = s.charCodeAt(i);
- if (c === 46) {
- if (sawdot) {
- return [mantissa, exp, neg, trunc, ok];
- }
- sawdot = true;
- dp = nd;
- i = i + (1) >> 0;
- continue;
- } else if (48 <= c && c <= 57) {
- sawdigits = true;
- if ((c === 48) && (nd === 0)) {
- dp = dp - (1) >> 0;
- i = i + (1) >> 0;
- continue;
- }
- nd = nd + (1) >> 0;
- if (ndMant < 19) {
- mantissa = $mul64(mantissa, (new $Uint64(0, 10)));
- mantissa = (x = new $Uint64(0, (c - 48 << 24 >>> 24)), new $Uint64(mantissa.$high + x.$high, mantissa.$low + x.$low));
- ndMant = ndMant + (1) >> 0;
- } else if (!((s.charCodeAt(i) === 48))) {
- trunc = true;
- }
- i = i + (1) >> 0;
- continue;
- }
- break;
- }
- if (!sawdigits) {
- return [mantissa, exp, neg, trunc, ok];
- }
- if (!sawdot) {
- dp = nd;
- }
- if (i < s.length && ((s.charCodeAt(i) === 101) || (s.charCodeAt(i) === 69))) {
- i = i + (1) >> 0;
- if (i >= s.length) {
- return [mantissa, exp, neg, trunc, ok];
- }
- esign = 1;
- if (s.charCodeAt(i) === 43) {
- i = i + (1) >> 0;
- } else if (s.charCodeAt(i) === 45) {
- i = i + (1) >> 0;
- esign = -1;
- }
- if (i >= s.length || s.charCodeAt(i) < 48 || s.charCodeAt(i) > 57) {
- return [mantissa, exp, neg, trunc, ok];
- }
- e = 0;
- while (true) {
- if (!(i < s.length && 48 <= s.charCodeAt(i) && s.charCodeAt(i) <= 57)) { break; }
- if (e < 10000) {
- e = ((e * 10 >> 0) + (s.charCodeAt(i) >> 0) >> 0) - 48 >> 0;
- }
- i = i + (1) >> 0;
- }
- dp = dp + ((e * esign >> 0)) >> 0;
- }
- if (!((i === s.length))) {
- return [mantissa, exp, neg, trunc, ok];
- }
- exp = dp - ndMant >> 0;
- ok = true;
- return [mantissa, exp, neg, trunc, ok];
- };
- decimal.ptr.prototype.floatBits = function(flt) {
- var $ptr, _tmp, _tmp$1, b, bits, d, exp, flt, mant, n, n$1, n$2, overflow, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y, y$1, y$2, y$3, $s;
- /* */ $s = 0; s: while (true) { switch ($s) { case 0:
- b = new $Uint64(0, 0);
- overflow = false;
- d = this;
- exp = 0;
- mant = new $Uint64(0, 0);
- /* */ if (d.nd === 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (d.nd === 0) { */ case 1:
- mant = new $Uint64(0, 0);
- exp = flt.bias;
- /* goto out */ $s = 3; continue;
- /* } */ case 2:
- /* */ if (d.dp > 310) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (d.dp > 310) { */ case 4:
- /* goto overflow */ $s = 6; continue;
- /* } */ case 5:
- /* */ if (d.dp < -330) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (d.dp < -330) { */ case 7:
- mant = new $Uint64(0, 0);
- exp = flt.bias;
- /* goto out */ $s = 3; continue;
- /* } */ case 8:
- exp = 0;
- while (true) {
- if (!(d.dp > 0)) { break; }
- n = 0;
- if (d.dp >= powtab.$length) {
- n = 27;
- } else {
- n = (x = d.dp, ((x < 0 || x >= powtab.$length) ? $throwRuntimeError("index out of range") : powtab.$array[powtab.$offset + x]));
- }
- d.Shift(-n);
- exp = exp + (n) >> 0;
- }
- while (true) {
- if (!(d.dp < 0 || (d.dp === 0) && d.d[0] < 53)) { break; }
- n$1 = 0;
- if (-d.dp >= powtab.$length) {
- n$1 = 27;
- } else {
- n$1 = (x$1 = -d.dp, ((x$1 < 0 || x$1 >= powtab.$length) ? $throwRuntimeError("index out of range") : powtab.$array[powtab.$offset + x$1]));
- }
- d.Shift(n$1);
- exp = exp - (n$1) >> 0;
- }
- exp = exp - (1) >> 0;
- if (exp < (flt.bias + 1 >> 0)) {
- n$2 = (flt.bias + 1 >> 0) - exp >> 0;
- d.Shift(-n$2);
- exp = exp + (n$2) >> 0;
- }
- /* */ if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) { */ case 9:
- /* goto overflow */ $s = 6; continue;
- /* } */ case 10:
- d.Shift(((1 + flt.mantbits >>> 0) >> 0));
- mant = d.RoundedInteger();
- /* */ if ((x$2 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ((x$2 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) { */ case 11:
- mant = $shiftRightUint64(mant, (1));
- exp = exp + (1) >> 0;
- /* */ if ((exp - flt.bias >> 0) >= (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if ((exp - flt.bias >> 0) >= (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0)) { */ case 13:
- /* goto overflow */ $s = 6; continue;
- /* } */ case 14:
- /* } */ case 12:
- if ((x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high & x$4.$high, (mant.$low & x$4.$low) >>> 0)), (x$3.$high === 0 && x$3.$low === 0))) {
- exp = flt.bias;
- }
- /* goto out */ $s = 3; continue;
- /* overflow: */ case 6:
- mant = new $Uint64(0, 0);
- exp = (((y$2 = flt.expbits, y$2 < 32 ? (1 << y$2) : 0) >> 0) - 1 >> 0) + flt.bias >> 0;
- overflow = true;
- /* out: */ case 3:
- bits = (x$5 = (x$6 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$6.$high - 0, x$6.$low - 1)), new $Uint64(mant.$high & x$5.$high, (mant.$low & x$5.$low) >>> 0));
- bits = (x$7 = $shiftLeft64(new $Uint64(0, (((exp - flt.bias >> 0)) & ((((y$3 = flt.expbits, y$3 < 32 ? (1 << y$3) : 0) >> 0) - 1 >> 0)))), flt.mantbits), new $Uint64(bits.$high | x$7.$high, (bits.$low | x$7.$low) >>> 0));
- if (d.neg) {
- bits = (x$8 = $shiftLeft64($shiftLeft64(new $Uint64(0, 1), flt.mantbits), flt.expbits), new $Uint64(bits.$high | x$8.$high, (bits.$low | x$8.$low) >>> 0));
- }
- _tmp = bits; _tmp$1 = overflow; b = _tmp; overflow = _tmp$1;
- return [b, overflow];
- /* */ $s = -1; case -1: } return; }
- };
- decimal.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); };
- atof64exact = function(mantissa, exp, neg) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, exp, f, mantissa, neg, ok, x, x$1, x$2;
- f = 0;
- ok = false;
- if (!((x = $shiftRightUint64(mantissa, float64info.mantbits), (x.$high === 0 && x.$low === 0)))) {
- return [f, ok];
- }
- f = $flatten64(mantissa);
- if (neg) {
- f = -f;
- }
- if (exp === 0) {
- _tmp = f; _tmp$1 = true; f = _tmp; ok = _tmp$1;
- return [f, ok];
- } else if (exp > 0 && exp <= 37) {
- if (exp > 22) {
- f = f * ((x$1 = exp - 22 >> 0, ((x$1 < 0 || x$1 >= float64pow10.$length) ? $throwRuntimeError("index out of range") : float64pow10.$array[float64pow10.$offset + x$1])));
- exp = 22;
- }
- if (f > 1e+15 || f < -1e+15) {
- return [f, ok];
- }
- _tmp$2 = f * ((exp < 0 || exp >= float64pow10.$length) ? $throwRuntimeError("index out of range") : float64pow10.$array[float64pow10.$offset + exp]); _tmp$3 = true; f = _tmp$2; ok = _tmp$3;
- return [f, ok];
- } else if (exp < 0 && exp >= -22) {
- _tmp$4 = f / (x$2 = -exp, ((x$2 < 0 || x$2 >= float64pow10.$length) ? $throwRuntimeError("index out of range") : float64pow10.$array[float64pow10.$offset + x$2])); _tmp$5 = true; f = _tmp$4; ok = _tmp$5;
- return [f, ok];
- }
- return [f, ok];
- };
- atof32exact = function(mantissa, exp, neg) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, exp, f, mantissa, neg, ok, x, x$1, x$2;
- f = 0;
- ok = false;
- if (!((x = $shiftRightUint64(mantissa, float32info.mantbits), (x.$high === 0 && x.$low === 0)))) {
- return [f, ok];
- }
- f = $flatten64(mantissa);
- if (neg) {
- f = -f;
- }
- if (exp === 0) {
- _tmp = f; _tmp$1 = true; f = _tmp; ok = _tmp$1;
- return [f, ok];
- } else if (exp > 0 && exp <= 17) {
- if (exp > 10) {
- f = $fround(f * ((x$1 = exp - 10 >> 0, ((x$1 < 0 || x$1 >= float32pow10.$length) ? $throwRuntimeError("index out of range") : float32pow10.$array[float32pow10.$offset + x$1]))));
- exp = 10;
- }
- if (f > 1e+07 || f < -1e+07) {
- return [f, ok];
- }
- _tmp$2 = $fround(f * ((exp < 0 || exp >= float32pow10.$length) ? $throwRuntimeError("index out of range") : float32pow10.$array[float32pow10.$offset + exp])); _tmp$3 = true; f = _tmp$2; ok = _tmp$3;
- return [f, ok];
- } else if (exp < 0 && exp >= -10) {
- _tmp$4 = $fround(f / (x$2 = -exp, ((x$2 < 0 || x$2 >= float32pow10.$length) ? $throwRuntimeError("index out of range") : float32pow10.$array[float32pow10.$offset + x$2]))); _tmp$5 = true; f = _tmp$4; ok = _tmp$5;
- return [f, ok];
- }
- return [f, ok];
- };
- atof32 = function(s) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, b, b$1, d, err, exp, ext, f, f$1, mantissa, neg, ok, ok$1, ok$2, ok$3, ovf, ovf$1, s, trunc, val;
- f = 0;
- err = $ifaceNil;
- _tuple = special(s); val = _tuple[0]; ok = _tuple[1];
- if (ok) {
- _tmp = $fround(val); _tmp$1 = $ifaceNil; f = _tmp; err = _tmp$1;
- return [f, err];
- }
- if (optimize) {
- _tuple$1 = readFloat(s); mantissa = _tuple$1[0]; exp = _tuple$1[1]; neg = _tuple$1[2]; trunc = _tuple$1[3]; ok$1 = _tuple$1[4];
- if (ok$1) {
- if (!trunc) {
- _tuple$2 = atof32exact(mantissa, exp, neg); f$1 = _tuple$2[0]; ok$2 = _tuple$2[1];
- if (ok$2) {
- _tmp$2 = f$1; _tmp$3 = $ifaceNil; f = _tmp$2; err = _tmp$3;
- return [f, err];
- }
- }
- ext = new extFloat.ptr();
- ok$3 = ext.AssignDecimal(mantissa, exp, neg, trunc, float32info);
- if (ok$3) {
- _tuple$3 = ext.floatBits(float32info); b = _tuple$3[0]; ovf = _tuple$3[1];
- f = math.Float32frombits((b.$low >>> 0));
- if (ovf) {
- err = rangeError("ParseFloat", s);
- }
- _tmp$4 = f; _tmp$5 = err; f = _tmp$4; err = _tmp$5;
- return [f, err];
- }
- }
- }
- d = $clone(new decimal.ptr(), decimal);
- if (!d.set(s)) {
- _tmp$6 = 0; _tmp$7 = syntaxError("ParseFloat", s); f = _tmp$6; err = _tmp$7;
- return [f, err];
- }
- _tuple$4 = d.floatBits(float32info); b$1 = _tuple$4[0]; ovf$1 = _tuple$4[1];
- f = math.Float32frombits((b$1.$low >>> 0));
- if (ovf$1) {
- err = rangeError("ParseFloat", s);
- }
- _tmp$8 = f; _tmp$9 = err; f = _tmp$8; err = _tmp$9;
- return [f, err];
- };
- atof64 = function(s) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, b, b$1, d, err, exp, ext, f, f$1, mantissa, neg, ok, ok$1, ok$2, ok$3, ovf, ovf$1, s, trunc, val;
- f = 0;
- err = $ifaceNil;
- _tuple = special(s); val = _tuple[0]; ok = _tuple[1];
- if (ok) {
- _tmp = val; _tmp$1 = $ifaceNil; f = _tmp; err = _tmp$1;
- return [f, err];
- }
- if (optimize) {
- _tuple$1 = readFloat(s); mantissa = _tuple$1[0]; exp = _tuple$1[1]; neg = _tuple$1[2]; trunc = _tuple$1[3]; ok$1 = _tuple$1[4];
- if (ok$1) {
- if (!trunc) {
- _tuple$2 = atof64exact(mantissa, exp, neg); f$1 = _tuple$2[0]; ok$2 = _tuple$2[1];
- if (ok$2) {
- _tmp$2 = f$1; _tmp$3 = $ifaceNil; f = _tmp$2; err = _tmp$3;
- return [f, err];
- }
- }
- ext = new extFloat.ptr();
- ok$3 = ext.AssignDecimal(mantissa, exp, neg, trunc, float64info);
- if (ok$3) {
- _tuple$3 = ext.floatBits(float64info); b = _tuple$3[0]; ovf = _tuple$3[1];
- f = math.Float64frombits(b);
- if (ovf) {
- err = rangeError("ParseFloat", s);
- }
- _tmp$4 = f; _tmp$5 = err; f = _tmp$4; err = _tmp$5;
- return [f, err];
- }
- }
- }
- d = $clone(new decimal.ptr(), decimal);
- if (!d.set(s)) {
- _tmp$6 = 0; _tmp$7 = syntaxError("ParseFloat", s); f = _tmp$6; err = _tmp$7;
- return [f, err];
- }
- _tuple$4 = d.floatBits(float64info); b$1 = _tuple$4[0]; ovf$1 = _tuple$4[1];
- f = math.Float64frombits(b$1);
- if (ovf$1) {
- err = rangeError("ParseFloat", s);
- }
- _tmp$8 = f; _tmp$9 = err; f = _tmp$8; err = _tmp$9;
- return [f, err];
- };
- ParseFloat = function(s, bitSize) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, bitSize, err, err1, err1$1, f, f1, f1$1, s;
- f = 0;
- err = $ifaceNil;
- if (bitSize === 32) {
- _tuple = atof32(s); f1 = _tuple[0]; err1 = _tuple[1];
- _tmp = f1; _tmp$1 = err1; f = _tmp; err = _tmp$1;
- return [f, err];
- }
- _tuple$1 = atof64(s); f1$1 = _tuple$1[0]; err1$1 = _tuple$1[1];
- _tmp$2 = f1$1; _tmp$3 = err1$1; f = _tmp$2; err = _tmp$3;
- return [f, err];
- };
- $pkg.ParseFloat = ParseFloat;
- NumError.ptr.prototype.Error = function() {
- var $ptr, _r, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return "strconv." + e.Func + ": " + "parsing " + Quote(e.Num) + ": " + _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: NumError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- NumError.prototype.Error = function() { return this.$val.Error(); };
- syntaxError = function(fn, str) {
- var $ptr, fn, str;
- return new NumError.ptr(fn, str, $pkg.ErrSyntax);
- };
- rangeError = function(fn, str) {
- var $ptr, fn, str;
- return new NumError.ptr(fn, str, $pkg.ErrRange);
- };
- cutoff64 = function(base) {
- var $ptr, base, x;
- if (base < 2) {
- return new $Uint64(0, 0);
- }
- return (x = $div64(new $Uint64(4294967295, 4294967295), new $Uint64(0, base), false), new $Uint64(x.$high + 0, x.$low + 1));
- };
- ParseUint = function(s, base, bitSize) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, base, bitSize, cutoff, d, err, i, maxVal, n, n1, s, s0, v, x, x$1, $s;
- /* */ $s = 0; s: while (true) { switch ($s) { case 0:
- n = new $Uint64(0, 0);
- err = $ifaceNil;
- _tmp = new $Uint64(0, 0); _tmp$1 = new $Uint64(0, 0); cutoff = _tmp; maxVal = _tmp$1;
- if (bitSize === 0) {
- bitSize = 32;
- }
- s0 = s;
- /* */ if (s.length < 1) { $s = 1; continue; }
- /* */ if (2 <= base && base <= 36) { $s = 2; continue; }
- /* */ if (base === 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (s.length < 1) { */ case 1:
- err = $pkg.ErrSyntax;
- /* goto Error */ $s = 6; continue;
- $s = 5; continue;
- /* } else if (2 <= base && base <= 36) { */ case 2:
- $s = 5; continue;
- /* } else if (base === 0) { */ case 3:
- /* */ if ((s.charCodeAt(0) === 48) && s.length > 1 && ((s.charCodeAt(1) === 120) || (s.charCodeAt(1) === 88))) { $s = 7; continue; }
- /* */ if (s.charCodeAt(0) === 48) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ((s.charCodeAt(0) === 48) && s.length > 1 && ((s.charCodeAt(1) === 120) || (s.charCodeAt(1) === 88))) { */ case 7:
- base = 16;
- s = s.substring(2);
- /* */ if (s.length < 1) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (s.length < 1) { */ case 11:
- err = $pkg.ErrSyntax;
- /* goto Error */ $s = 6; continue;
- /* } */ case 12:
- $s = 10; continue;
- /* } else if (s.charCodeAt(0) === 48) { */ case 8:
- base = 8;
- $s = 10; continue;
- /* } else { */ case 9:
- base = 10;
- /* } */ case 10:
- $s = 5; continue;
- /* } else { */ case 4:
- err = errors.New("invalid base " + Itoa(base));
- /* goto Error */ $s = 6; continue;
- /* } */ case 5:
- n = new $Uint64(0, 0);
- cutoff = cutoff64(base);
- maxVal = (x = $shiftLeft64(new $Uint64(0, 1), (bitSize >>> 0)), new $Uint64(x.$high - 0, x.$low - 1));
- i = 0;
- /* while (true) { */ case 13:
- /* if (!(i < s.length)) { break; } */ if(!(i < s.length)) { $s = 14; continue; }
- v = 0;
- d = s.charCodeAt(i);
- /* */ if (48 <= d && d <= 57) { $s = 15; continue; }
- /* */ if (97 <= d && d <= 122) { $s = 16; continue; }
- /* */ if (65 <= d && d <= 90) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (48 <= d && d <= 57) { */ case 15:
- v = d - 48 << 24 >>> 24;
- $s = 19; continue;
- /* } else if (97 <= d && d <= 122) { */ case 16:
- v = (d - 97 << 24 >>> 24) + 10 << 24 >>> 24;
- $s = 19; continue;
- /* } else if (65 <= d && d <= 90) { */ case 17:
- v = (d - 65 << 24 >>> 24) + 10 << 24 >>> 24;
- $s = 19; continue;
- /* } else { */ case 18:
- n = new $Uint64(0, 0);
- err = $pkg.ErrSyntax;
- /* goto Error */ $s = 6; continue;
- /* } */ case 19:
- /* */ if ((v >> 0) >= base) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if ((v >> 0) >= base) { */ case 20:
- n = new $Uint64(0, 0);
- err = $pkg.ErrSyntax;
- /* goto Error */ $s = 6; continue;
- /* } */ case 21:
- /* */ if ((n.$high > cutoff.$high || (n.$high === cutoff.$high && n.$low >= cutoff.$low))) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if ((n.$high > cutoff.$high || (n.$high === cutoff.$high && n.$low >= cutoff.$low))) { */ case 22:
- n = new $Uint64(4294967295, 4294967295);
- err = $pkg.ErrRange;
- /* goto Error */ $s = 6; continue;
- /* } */ case 23:
- n = $mul64(n, (new $Uint64(0, base)));
- n1 = (x$1 = new $Uint64(0, v), new $Uint64(n.$high + x$1.$high, n.$low + x$1.$low));
- /* */ if ((n1.$high < n.$high || (n1.$high === n.$high && n1.$low < n.$low)) || (n1.$high > maxVal.$high || (n1.$high === maxVal.$high && n1.$low > maxVal.$low))) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if ((n1.$high < n.$high || (n1.$high === n.$high && n1.$low < n.$low)) || (n1.$high > maxVal.$high || (n1.$high === maxVal.$high && n1.$low > maxVal.$low))) { */ case 24:
- n = new $Uint64(4294967295, 4294967295);
- err = $pkg.ErrRange;
- /* goto Error */ $s = 6; continue;
- /* } */ case 25:
- n = n1;
- i = i + (1) >> 0;
- /* } */ $s = 13; continue; case 14:
- _tmp$2 = n; _tmp$3 = $ifaceNil; n = _tmp$2; err = _tmp$3;
- return [n, err];
- /* Error: */ case 6:
- _tmp$4 = n; _tmp$5 = new NumError.ptr("ParseUint", s0, err); n = _tmp$4; err = _tmp$5;
- return [n, err];
- /* */ $s = -1; case -1: } return; }
- };
- $pkg.ParseUint = ParseUint;
- ParseInt = function(s, base, bitSize) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, base, bitSize, cutoff, err, i, n, neg, s, s0, un, x, x$1;
- i = new $Int64(0, 0);
- err = $ifaceNil;
- if (bitSize === 0) {
- bitSize = 32;
- }
- if (s.length === 0) {
- _tmp = new $Int64(0, 0); _tmp$1 = syntaxError("ParseInt", s); i = _tmp; err = _tmp$1;
- return [i, err];
- }
- s0 = s;
- neg = false;
- if (s.charCodeAt(0) === 43) {
- s = s.substring(1);
- } else if (s.charCodeAt(0) === 45) {
- neg = true;
- s = s.substring(1);
- }
- un = new $Uint64(0, 0);
- _tuple = ParseUint(s, base, bitSize); un = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil)) && !($interfaceIsEqual($assertType(err, ptrType).Err, $pkg.ErrRange))) {
- $assertType(err, ptrType).Func = "ParseInt";
- $assertType(err, ptrType).Num = s0;
- _tmp$2 = new $Int64(0, 0); _tmp$3 = err; i = _tmp$2; err = _tmp$3;
- return [i, err];
- }
- cutoff = $shiftLeft64(new $Uint64(0, 1), ((bitSize - 1 >> 0) >>> 0));
- if (!neg && (un.$high > cutoff.$high || (un.$high === cutoff.$high && un.$low >= cutoff.$low))) {
- _tmp$4 = (x = new $Uint64(cutoff.$high - 0, cutoff.$low - 1), new $Int64(x.$high, x.$low)); _tmp$5 = rangeError("ParseInt", s0); i = _tmp$4; err = _tmp$5;
- return [i, err];
- }
- if (neg && (un.$high > cutoff.$high || (un.$high === cutoff.$high && un.$low > cutoff.$low))) {
- _tmp$6 = (x$1 = new $Int64(cutoff.$high, cutoff.$low), new $Int64(-x$1.$high, -x$1.$low)); _tmp$7 = rangeError("ParseInt", s0); i = _tmp$6; err = _tmp$7;
- return [i, err];
- }
- n = new $Int64(un.$high, un.$low);
- if (neg) {
- n = new $Int64(-n.$high, -n.$low);
- }
- _tmp$8 = n; _tmp$9 = $ifaceNil; i = _tmp$8; err = _tmp$9;
- return [i, err];
- };
- $pkg.ParseInt = ParseInt;
- Atoi = function(s) {
- var $ptr, _tmp, _tmp$1, _tuple, err, i, i64, s;
- i = 0;
- err = $ifaceNil;
- _tuple = ParseInt(s, 10, 0); i64 = _tuple[0]; err = _tuple[1];
- _tmp = ((i64.$low + ((i64.$high >> 31) * 4294967296)) >> 0); _tmp$1 = err; i = _tmp; err = _tmp$1;
- return [i, err];
- };
- $pkg.Atoi = Atoi;
- decimal.ptr.prototype.String = function() {
- var $ptr, a, buf, n, w;
- a = this;
- n = 10 + a.nd >> 0;
- if (a.dp > 0) {
- n = n + (a.dp) >> 0;
- }
- if (a.dp < 0) {
- n = n + (-a.dp) >> 0;
- }
- buf = $makeSlice(sliceType$6, n);
- w = 0;
- if (a.nd === 0) {
- return "0";
- } else if (a.dp <= 0) {
- ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + w] = 48);
- w = w + (1) >> 0;
- ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + w] = 46);
- w = w + (1) >> 0;
- w = w + (digitZero($subslice(buf, w, (w + -a.dp >> 0)))) >> 0;
- w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0;
- } else if (a.dp < a.nd) {
- w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.dp))) >> 0;
- ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + w] = 46);
- w = w + (1) >> 0;
- w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), a.dp, a.nd))) >> 0;
- } else {
- w = w + ($copySlice($subslice(buf, w), $subslice(new sliceType$6(a.d), 0, a.nd))) >> 0;
- w = w + (digitZero($subslice(buf, w, ((w + a.dp >> 0) - a.nd >> 0)))) >> 0;
- }
- return $bytesToString($subslice(buf, 0, w));
- };
- decimal.prototype.String = function() { return this.$val.String(); };
- digitZero = function(dst) {
- var $ptr, _i, _ref, dst, i;
- _ref = dst;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- ((i < 0 || i >= dst.$length) ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + i] = 48);
- _i++;
- }
- return dst.$length;
- };
- trim = function(a) {
- var $ptr, a, x, x$1;
- while (true) {
- if (!(a.nd > 0 && ((x = a.d, x$1 = a.nd - 1 >> 0, ((x$1 < 0 || x$1 >= x.length) ? $throwRuntimeError("index out of range") : x[x$1])) === 48))) { break; }
- a.nd = a.nd - (1) >> 0;
- }
- if (a.nd === 0) {
- a.dp = 0;
- }
- };
- decimal.ptr.prototype.Assign = function(v) {
- var $ptr, a, buf, n, v, v1, x, x$1, x$2;
- a = this;
- buf = $clone(arrayType.zero(), arrayType);
- n = 0;
- while (true) {
- if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; }
- v1 = $div64(v, new $Uint64(0, 10), false);
- v = (x = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x.$high, v.$low - x.$low));
- ((n < 0 || n >= buf.length) ? $throwRuntimeError("index out of range") : buf[n] = (new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24));
- n = n + (1) >> 0;
- v = v1;
- }
- a.nd = 0;
- n = n - (1) >> 0;
- while (true) {
- if (!(n >= 0)) { break; }
- (x$1 = a.d, x$2 = a.nd, ((x$2 < 0 || x$2 >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[x$2] = ((n < 0 || n >= buf.length) ? $throwRuntimeError("index out of range") : buf[n])));
- a.nd = a.nd + (1) >> 0;
- n = n - (1) >> 0;
- }
- a.dp = a.nd;
- trim(a);
- };
- decimal.prototype.Assign = function(v) { return this.$val.Assign(v); };
- rightShift = function(a, k) {
- var $ptr, a, c, c$1, dig, dig$1, k, n, r, w, x, x$1, x$2, x$3, y, y$1;
- r = 0;
- w = 0;
- n = 0;
- while (true) {
- if (!(((n >> $min(k, 31)) >> 0) === 0)) { break; }
- if (r >= a.nd) {
- if (n === 0) {
- a.nd = 0;
- return;
- }
- while (true) {
- if (!(((n >> $min(k, 31)) >> 0) === 0)) { break; }
- n = n * 10 >> 0;
- r = r + (1) >> 0;
- }
- break;
- }
- c = ((x = a.d, ((r < 0 || r >= x.length) ? $throwRuntimeError("index out of range") : x[r])) >> 0);
- n = ((n * 10 >> 0) + c >> 0) - 48 >> 0;
- r = r + (1) >> 0;
- }
- a.dp = a.dp - ((r - 1 >> 0)) >> 0;
- while (true) {
- if (!(r < a.nd)) { break; }
- c$1 = ((x$1 = a.d, ((r < 0 || r >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[r])) >> 0);
- dig = (n >> $min(k, 31)) >> 0;
- n = n - (((y = k, y < 32 ? (dig << y) : 0) >> 0)) >> 0;
- (x$2 = a.d, ((w < 0 || w >= x$2.length) ? $throwRuntimeError("index out of range") : x$2[w] = ((dig + 48 >> 0) << 24 >>> 24)));
- w = w + (1) >> 0;
- n = ((n * 10 >> 0) + c$1 >> 0) - 48 >> 0;
- r = r + (1) >> 0;
- }
- while (true) {
- if (!(n > 0)) { break; }
- dig$1 = (n >> $min(k, 31)) >> 0;
- n = n - (((y$1 = k, y$1 < 32 ? (dig$1 << y$1) : 0) >> 0)) >> 0;
- if (w < 800) {
- (x$3 = a.d, ((w < 0 || w >= x$3.length) ? $throwRuntimeError("index out of range") : x$3[w] = ((dig$1 + 48 >> 0) << 24 >>> 24)));
- w = w + (1) >> 0;
- } else if (dig$1 > 0) {
- a.trunc = true;
- }
- n = n * 10 >> 0;
- }
- a.nd = w;
- trim(a);
- };
- prefixIsLessThan = function(b, s) {
- var $ptr, b, i, s;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- if (i >= b.$length) {
- return true;
- }
- if (!((((i < 0 || i >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + i]) === s.charCodeAt(i)))) {
- return ((i < 0 || i >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + i]) < s.charCodeAt(i);
- }
- i = i + (1) >> 0;
- }
- return false;
- };
- leftShift = function(a, k) {
- var $ptr, _q, _q$1, a, delta, k, n, quo, quo$1, r, rem, rem$1, w, x, x$1, x$2, y;
- delta = ((k < 0 || k >= leftcheats.$length) ? $throwRuntimeError("index out of range") : leftcheats.$array[leftcheats.$offset + k]).delta;
- if (prefixIsLessThan($subslice(new sliceType$6(a.d), 0, a.nd), ((k < 0 || k >= leftcheats.$length) ? $throwRuntimeError("index out of range") : leftcheats.$array[leftcheats.$offset + k]).cutoff)) {
- delta = delta - (1) >> 0;
- }
- r = a.nd;
- w = a.nd + delta >> 0;
- n = 0;
- r = r - (1) >> 0;
- while (true) {
- if (!(r >= 0)) { break; }
- n = n + (((y = k, y < 32 ? (((((x = a.d, ((r < 0 || r >= x.length) ? $throwRuntimeError("index out of range") : x[r])) >> 0) - 48 >> 0)) << y) : 0) >> 0)) >> 0;
- quo = (_q = n / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- rem = n - (10 * quo >> 0) >> 0;
- w = w - (1) >> 0;
- if (w < 800) {
- (x$1 = a.d, ((w < 0 || w >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[w] = ((rem + 48 >> 0) << 24 >>> 24)));
- } else if (!((rem === 0))) {
- a.trunc = true;
- }
- n = quo;
- r = r - (1) >> 0;
- }
- while (true) {
- if (!(n > 0)) { break; }
- quo$1 = (_q$1 = n / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"));
- rem$1 = n - (10 * quo$1 >> 0) >> 0;
- w = w - (1) >> 0;
- if (w < 800) {
- (x$2 = a.d, ((w < 0 || w >= x$2.length) ? $throwRuntimeError("index out of range") : x$2[w] = ((rem$1 + 48 >> 0) << 24 >>> 24)));
- } else if (!((rem$1 === 0))) {
- a.trunc = true;
- }
- n = quo$1;
- }
- a.nd = a.nd + (delta) >> 0;
- if (a.nd >= 800) {
- a.nd = 800;
- }
- a.dp = a.dp + (delta) >> 0;
- trim(a);
- };
- decimal.ptr.prototype.Shift = function(k) {
- var $ptr, a, k;
- a = this;
- if (a.nd === 0) {
- } else if (k > 0) {
- while (true) {
- if (!(k > 27)) { break; }
- leftShift(a, 27);
- k = k - (27) >> 0;
- }
- leftShift(a, (k >>> 0));
- } else if (k < 0) {
- while (true) {
- if (!(k < -27)) { break; }
- rightShift(a, 27);
- k = k + (27) >> 0;
- }
- rightShift(a, (-k >>> 0));
- }
- };
- decimal.prototype.Shift = function(k) { return this.$val.Shift(k); };
- shouldRoundUp = function(a, nd) {
- var $ptr, _r, a, nd, x, x$1, x$2, x$3;
- if (nd < 0 || nd >= a.nd) {
- return false;
- }
- if (((x = a.d, ((nd < 0 || nd >= x.length) ? $throwRuntimeError("index out of range") : x[nd])) === 53) && ((nd + 1 >> 0) === a.nd)) {
- if (a.trunc) {
- return true;
- }
- return nd > 0 && !(((_r = (((x$1 = a.d, x$2 = nd - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[x$2])) - 48 << 24 >>> 24)) % 2, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0));
- }
- return (x$3 = a.d, ((nd < 0 || nd >= x$3.length) ? $throwRuntimeError("index out of range") : x$3[nd])) >= 53;
- };
- decimal.ptr.prototype.Round = function(nd) {
- var $ptr, a, nd;
- a = this;
- if (nd < 0 || nd >= a.nd) {
- return;
- }
- if (shouldRoundUp(a, nd)) {
- a.RoundUp(nd);
- } else {
- a.RoundDown(nd);
- }
- };
- decimal.prototype.Round = function(nd) { return this.$val.Round(nd); };
- decimal.ptr.prototype.RoundDown = function(nd) {
- var $ptr, a, nd;
- a = this;
- if (nd < 0 || nd >= a.nd) {
- return;
- }
- a.nd = nd;
- trim(a);
- };
- decimal.prototype.RoundDown = function(nd) { return this.$val.RoundDown(nd); };
- decimal.ptr.prototype.RoundUp = function(nd) {
- var $ptr, a, c, i, nd, x, x$1, x$2;
- a = this;
- if (nd < 0 || nd >= a.nd) {
- return;
- }
- i = nd - 1 >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- c = (x = a.d, ((i < 0 || i >= x.length) ? $throwRuntimeError("index out of range") : x[i]));
- if (c < 57) {
- (x$2 = a.d, ((i < 0 || i >= x$2.length) ? $throwRuntimeError("index out of range") : x$2[i] = (x$1 = a.d, ((i < 0 || i >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[i])) + (1) << 24 >>> 24));
- a.nd = i + 1 >> 0;
- return;
- }
- i = i - (1) >> 0;
- }
- a.d[0] = 49;
- a.nd = 1;
- a.dp = a.dp + (1) >> 0;
- };
- decimal.prototype.RoundUp = function(nd) { return this.$val.RoundUp(nd); };
- decimal.ptr.prototype.RoundedInteger = function() {
- var $ptr, a, i, n, x, x$1, x$2, x$3;
- a = this;
- if (a.dp > 20) {
- return new $Uint64(4294967295, 4294967295);
- }
- i = 0;
- n = new $Uint64(0, 0);
- i = 0;
- while (true) {
- if (!(i < a.dp && i < a.nd)) { break; }
- n = (x = $mul64(n, new $Uint64(0, 10)), x$1 = new $Uint64(0, ((x$2 = a.d, ((i < 0 || i >= x$2.length) ? $throwRuntimeError("index out of range") : x$2[i])) - 48 << 24 >>> 24)), new $Uint64(x.$high + x$1.$high, x.$low + x$1.$low));
- i = i + (1) >> 0;
- }
- while (true) {
- if (!(i < a.dp)) { break; }
- n = $mul64(n, (new $Uint64(0, 10)));
- i = i + (1) >> 0;
- }
- if (shouldRoundUp(a, a.dp)) {
- n = (x$3 = new $Uint64(0, 1), new $Uint64(n.$high + x$3.$high, n.$low + x$3.$low));
- }
- return n;
- };
- decimal.prototype.RoundedInteger = function() { return this.$val.RoundedInteger(); };
- extFloat.ptr.prototype.floatBits = function(flt) {
- var $ptr, bits, exp, f, flt, mant, n, overflow, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, y$1, y$2;
- bits = new $Uint64(0, 0);
- overflow = false;
- f = this;
- f.Normalize();
- exp = f.exp + 63 >> 0;
- if (exp < (flt.bias + 1 >> 0)) {
- n = (flt.bias + 1 >> 0) - exp >> 0;
- f.mant = $shiftRightUint64(f.mant, ((n >>> 0)));
- exp = exp + (n) >> 0;
- }
- mant = $shiftRightUint64(f.mant, ((63 - flt.mantbits >>> 0)));
- if (!((x = (x$1 = f.mant, x$2 = $shiftLeft64(new $Uint64(0, 1), ((62 - flt.mantbits >>> 0))), new $Uint64(x$1.$high & x$2.$high, (x$1.$low & x$2.$low) >>> 0)), (x.$high === 0 && x.$low === 0)))) {
- mant = (x$3 = new $Uint64(0, 1), new $Uint64(mant.$high + x$3.$high, mant.$low + x$3.$low));
- }
- if ((x$4 = $shiftLeft64(new $Uint64(0, 2), flt.mantbits), (mant.$high === x$4.$high && mant.$low === x$4.$low))) {
- mant = $shiftRightUint64(mant, (1));
- exp = exp + (1) >> 0;
- }
- if ((exp - flt.bias >> 0) >= (((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0)) {
- mant = new $Uint64(0, 0);
- exp = (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0) + flt.bias >> 0;
- overflow = true;
- } else if ((x$5 = (x$6 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high & x$6.$high, (mant.$low & x$6.$low) >>> 0)), (x$5.$high === 0 && x$5.$low === 0))) {
- exp = flt.bias;
- }
- bits = (x$7 = (x$8 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$8.$high - 0, x$8.$low - 1)), new $Uint64(mant.$high & x$7.$high, (mant.$low & x$7.$low) >>> 0));
- bits = (x$9 = $shiftLeft64(new $Uint64(0, (((exp - flt.bias >> 0)) & ((((y$2 = flt.expbits, y$2 < 32 ? (1 << y$2) : 0) >> 0) - 1 >> 0)))), flt.mantbits), new $Uint64(bits.$high | x$9.$high, (bits.$low | x$9.$low) >>> 0));
- if (f.neg) {
- bits = (x$10 = $shiftLeft64(new $Uint64(0, 1), ((flt.mantbits + flt.expbits >>> 0))), new $Uint64(bits.$high | x$10.$high, (bits.$low | x$10.$low) >>> 0));
- }
- return [bits, overflow];
- };
- extFloat.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); };
- extFloat.ptr.prototype.AssignComputeBounds = function(mant, exp, neg, flt) {
- var $ptr, _tmp, _tmp$1, exp, expBiased, f, flt, lower, mant, neg, upper, x, x$1, x$2, x$3, x$4;
- lower = new extFloat.ptr();
- upper = new extFloat.ptr();
- f = this;
- f.mant = mant;
- f.exp = exp - (flt.mantbits >> 0) >> 0;
- f.neg = neg;
- if (f.exp <= 0 && (x = $shiftLeft64(($shiftRightUint64(mant, (-f.exp >>> 0))), (-f.exp >>> 0)), (mant.$high === x.$high && mant.$low === x.$low))) {
- f.mant = $shiftRightUint64(f.mant, ((-f.exp >>> 0)));
- f.exp = 0;
- _tmp = $clone(f, extFloat); _tmp$1 = $clone(f, extFloat); $copy(lower, _tmp, extFloat); $copy(upper, _tmp$1, extFloat);
- return [lower, upper];
- }
- expBiased = exp - flt.bias >> 0;
- $copy(upper, new extFloat.ptr((x$1 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$1.$high + 0, x$1.$low + 1)), f.exp - 1 >> 0, f.neg), extFloat);
- if (!((x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high === x$2.$high && mant.$low === x$2.$low))) || (expBiased === 1)) {
- $copy(lower, new extFloat.ptr((x$3 = $mul64(new $Uint64(0, 2), f.mant), new $Uint64(x$3.$high - 0, x$3.$low - 1)), f.exp - 1 >> 0, f.neg), extFloat);
- } else {
- $copy(lower, new extFloat.ptr((x$4 = $mul64(new $Uint64(0, 4), f.mant), new $Uint64(x$4.$high - 0, x$4.$low - 1)), f.exp - 2 >> 0, f.neg), extFloat);
- }
- return [lower, upper];
- };
- extFloat.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { return this.$val.AssignComputeBounds(mant, exp, neg, flt); };
- extFloat.ptr.prototype.Normalize = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, exp, f, mant, shift, x, x$1, x$2, x$3, x$4, x$5;
- shift = 0;
- f = this;
- _tmp = f.mant; _tmp$1 = f.exp; mant = _tmp; exp = _tmp$1;
- if ((mant.$high === 0 && mant.$low === 0)) {
- shift = 0;
- return shift;
- }
- if ((x = $shiftRightUint64(mant, 32), (x.$high === 0 && x.$low === 0))) {
- mant = $shiftLeft64(mant, (32));
- exp = exp - (32) >> 0;
- }
- if ((x$1 = $shiftRightUint64(mant, 48), (x$1.$high === 0 && x$1.$low === 0))) {
- mant = $shiftLeft64(mant, (16));
- exp = exp - (16) >> 0;
- }
- if ((x$2 = $shiftRightUint64(mant, 56), (x$2.$high === 0 && x$2.$low === 0))) {
- mant = $shiftLeft64(mant, (8));
- exp = exp - (8) >> 0;
- }
- if ((x$3 = $shiftRightUint64(mant, 60), (x$3.$high === 0 && x$3.$low === 0))) {
- mant = $shiftLeft64(mant, (4));
- exp = exp - (4) >> 0;
- }
- if ((x$4 = $shiftRightUint64(mant, 62), (x$4.$high === 0 && x$4.$low === 0))) {
- mant = $shiftLeft64(mant, (2));
- exp = exp - (2) >> 0;
- }
- if ((x$5 = $shiftRightUint64(mant, 63), (x$5.$high === 0 && x$5.$low === 0))) {
- mant = $shiftLeft64(mant, (1));
- exp = exp - (1) >> 0;
- }
- shift = ((f.exp - exp >> 0) >>> 0);
- _tmp$2 = mant; _tmp$3 = exp; f.mant = _tmp$2; f.exp = _tmp$3;
- return shift;
- };
- extFloat.prototype.Normalize = function() { return this.$val.Normalize(); };
- extFloat.ptr.prototype.Multiply = function(g) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, cross1, cross2, f, fhi, flo, g, ghi, glo, rem, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- f = this;
- g = $clone(g, extFloat);
- _tmp = $shiftRightUint64(f.mant, 32); _tmp$1 = new $Uint64(0, (f.mant.$low >>> 0)); fhi = _tmp; flo = _tmp$1;
- _tmp$2 = $shiftRightUint64(g.mant, 32); _tmp$3 = new $Uint64(0, (g.mant.$low >>> 0)); ghi = _tmp$2; glo = _tmp$3;
- cross1 = $mul64(fhi, glo);
- cross2 = $mul64(flo, ghi);
- f.mant = (x = (x$1 = $mul64(fhi, ghi), x$2 = $shiftRightUint64(cross1, 32), new $Uint64(x$1.$high + x$2.$high, x$1.$low + x$2.$low)), x$3 = $shiftRightUint64(cross2, 32), new $Uint64(x.$high + x$3.$high, x.$low + x$3.$low));
- rem = (x$4 = (x$5 = new $Uint64(0, (cross1.$low >>> 0)), x$6 = new $Uint64(0, (cross2.$low >>> 0)), new $Uint64(x$5.$high + x$6.$high, x$5.$low + x$6.$low)), x$7 = $shiftRightUint64(($mul64(flo, glo)), 32), new $Uint64(x$4.$high + x$7.$high, x$4.$low + x$7.$low));
- rem = (x$8 = new $Uint64(0, 2147483648), new $Uint64(rem.$high + x$8.$high, rem.$low + x$8.$low));
- f.mant = (x$9 = f.mant, x$10 = ($shiftRightUint64(rem, 32)), new $Uint64(x$9.$high + x$10.$high, x$9.$low + x$10.$low));
- f.exp = (f.exp + g.exp >> 0) + 64 >> 0;
- };
- extFloat.prototype.Multiply = function(g) { return this.$val.Multiply(g); };
- extFloat.ptr.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) {
- var $ptr, _q, _r, adjExp, denormalExp, errors$1, exp10, extrabits, f, flt, halfway, i, mant_extra, mantissa, neg, ok, shift, trunc, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y;
- ok = false;
- f = this;
- errors$1 = 0;
- if (trunc) {
- errors$1 = errors$1 + (4) >> 0;
- }
- f.mant = mantissa;
- f.exp = 0;
- f.neg = neg;
- i = (_q = ((exp10 - -348 >> 0)) / 8, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- if (exp10 < -348 || i >= 87) {
- ok = false;
- return ok;
- }
- adjExp = (_r = ((exp10 - -348 >> 0)) % 8, _r === _r ? _r : $throwRuntimeError("integer divide by zero"));
- if (adjExp < 19 && (x = (x$1 = 19 - adjExp >> 0, ((x$1 < 0 || x$1 >= uint64pow10.length) ? $throwRuntimeError("index out of range") : uint64pow10[x$1])), (mantissa.$high < x.$high || (mantissa.$high === x.$high && mantissa.$low < x.$low)))) {
- f.mant = $mul64(f.mant, (((adjExp < 0 || adjExp >= uint64pow10.length) ? $throwRuntimeError("index out of range") : uint64pow10[adjExp])));
- f.Normalize();
- } else {
- f.Normalize();
- f.Multiply(((adjExp < 0 || adjExp >= smallPowersOfTen.length) ? $throwRuntimeError("index out of range") : smallPowersOfTen[adjExp]));
- errors$1 = errors$1 + (4) >> 0;
- }
- f.Multiply(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i]));
- if (errors$1 > 0) {
- errors$1 = errors$1 + (1) >> 0;
- }
- errors$1 = errors$1 + (4) >> 0;
- shift = f.Normalize();
- errors$1 = (y = (shift), y < 32 ? (errors$1 << y) : 0) >> 0;
- denormalExp = flt.bias - 63 >> 0;
- extrabits = 0;
- if (f.exp <= denormalExp) {
- extrabits = (((63 - flt.mantbits >>> 0) + 1 >>> 0) + ((denormalExp - f.exp >> 0) >>> 0) >>> 0);
- } else {
- extrabits = (63 - flt.mantbits >>> 0);
- }
- halfway = $shiftLeft64(new $Uint64(0, 1), ((extrabits - 1 >>> 0)));
- mant_extra = (x$2 = f.mant, x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), extrabits), new $Uint64(x$4.$high - 0, x$4.$low - 1)), new $Uint64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0));
- if ((x$5 = (x$6 = new $Int64(halfway.$high, halfway.$low), x$7 = new $Int64(0, errors$1), new $Int64(x$6.$high - x$7.$high, x$6.$low - x$7.$low)), x$8 = new $Int64(mant_extra.$high, mant_extra.$low), (x$5.$high < x$8.$high || (x$5.$high === x$8.$high && x$5.$low < x$8.$low))) && (x$9 = new $Int64(mant_extra.$high, mant_extra.$low), x$10 = (x$11 = new $Int64(halfway.$high, halfway.$low), x$12 = new $Int64(0, errors$1), new $Int64(x$11.$high + x$12.$high, x$11.$low + x$12.$low)), (x$9.$high < x$10.$high || (x$9.$high === x$10.$high && x$9.$low < x$10.$low)))) {
- ok = false;
- return ok;
- }
- ok = true;
- return ok;
- };
- extFloat.prototype.AssignDecimal = function(mantissa, exp10, neg, trunc, flt) { return this.$val.AssignDecimal(mantissa, exp10, neg, trunc, flt); };
- extFloat.ptr.prototype.frexp10 = function() {
- var $ptr, _q, _q$1, _tmp, _tmp$1, approxExp10, exp, exp10, f, i, index;
- exp10 = 0;
- index = 0;
- f = this;
- approxExp10 = (_q = (((-46 - f.exp >> 0)) * 28 >> 0) / 93, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- i = (_q$1 = ((approxExp10 - -348 >> 0)) / 8, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"));
- Loop:
- while (true) {
- exp = (f.exp + ((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i]).exp >> 0) + 64 >> 0;
- if (exp < -60) {
- i = i + (1) >> 0;
- } else if (exp > -32) {
- i = i - (1) >> 0;
- } else {
- break Loop;
- }
- }
- f.Multiply(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i]));
- _tmp = -((-348 + (i * 8 >> 0) >> 0)); _tmp$1 = i; exp10 = _tmp; index = _tmp$1;
- return [exp10, index];
- };
- extFloat.prototype.frexp10 = function() { return this.$val.frexp10(); };
- frexp10Many = function(a, b, c) {
- var $ptr, _tuple, a, b, c, exp10, i;
- exp10 = 0;
- _tuple = c.frexp10(); exp10 = _tuple[0]; i = _tuple[1];
- a.Multiply(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i]));
- b.Multiply(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i]));
- return exp10;
- };
- extFloat.ptr.prototype.FixedDecimal = function(d, n) {
- var $ptr, _q, _q$1, _tmp, _tmp$1, _tuple, buf, d, digit, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, n, nd, needed, nonAsciiName$2, ok, pos, pow, pow10, rest, shift, v, v1, x, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- f = this;
- if ((x = f.mant, (x.$high === 0 && x.$low === 0))) {
- d.nd = 0;
- d.dp = 0;
- d.neg = f.neg;
- return true;
- }
- if (n === 0) {
- $panic(new $String("strconv: internal error: extFloat.FixedDecimal called with n == 0"));
- }
- f.Normalize();
- _tuple = f.frexp10(); exp10 = _tuple[0];
- shift = (-f.exp >>> 0);
- integer = ($shiftRightUint64(f.mant, shift).$low >>> 0);
- fraction = (x$1 = f.mant, x$2 = $shiftLeft64(new $Uint64(0, integer), shift), new $Uint64(x$1.$high - x$2.$high, x$1.$low - x$2.$low));
- nonAsciiName$2 = new $Uint64(0, 1);
- needed = n;
- integerDigits = 0;
- pow10 = new $Uint64(0, 1);
- _tmp = 0; _tmp$1 = new $Uint64(0, 1); i = _tmp; pow = _tmp$1;
- while (true) {
- if (!(i < 20)) { break; }
- if ((x$3 = new $Uint64(0, integer), (pow.$high > x$3.$high || (pow.$high === x$3.$high && pow.$low > x$3.$low)))) {
- integerDigits = i;
- break;
- }
- pow = $mul64(pow, (new $Uint64(0, 10)));
- i = i + (1) >> 0;
- }
- rest = integer;
- if (integerDigits > needed) {
- pow10 = (x$4 = integerDigits - needed >> 0, ((x$4 < 0 || x$4 >= uint64pow10.length) ? $throwRuntimeError("index out of range") : uint64pow10[x$4]));
- integer = (_q = integer / ((pow10.$low >>> 0)), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- rest = rest - ((x$5 = (pow10.$low >>> 0), (((integer >>> 16 << 16) * x$5 >>> 0) + (integer << 16 >>> 16) * x$5) >>> 0)) >>> 0;
- } else {
- rest = 0;
- }
- buf = $clone(arrayType$1.zero(), arrayType$1);
- pos = 32;
- v = integer;
- while (true) {
- if (!(v > 0)) { break; }
- v1 = (_q$1 = v / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero"));
- v = v - (((((10 >>> 16 << 16) * v1 >>> 0) + (10 << 16 >>> 16) * v1) >>> 0)) >>> 0;
- pos = pos - (1) >> 0;
- ((pos < 0 || pos >= buf.length) ? $throwRuntimeError("index out of range") : buf[pos] = ((v + 48 >>> 0) << 24 >>> 24));
- v = v1;
- }
- i$1 = pos;
- while (true) {
- if (!(i$1 < 32)) { break; }
- (x$6 = d.d, x$7 = i$1 - pos >> 0, ((x$7 < 0 || x$7 >= x$6.$length) ? $throwRuntimeError("index out of range") : x$6.$array[x$6.$offset + x$7] = ((i$1 < 0 || i$1 >= buf.length) ? $throwRuntimeError("index out of range") : buf[i$1])));
- i$1 = i$1 + (1) >> 0;
- }
- nd = 32 - pos >> 0;
- d.nd = nd;
- d.dp = integerDigits + exp10 >> 0;
- needed = needed - (nd) >> 0;
- if (needed > 0) {
- if (!((rest === 0)) || !((pow10.$high === 0 && pow10.$low === 1))) {
- $panic(new $String("strconv: internal error, rest != 0 but needed > 0"));
- }
- while (true) {
- if (!(needed > 0)) { break; }
- fraction = $mul64(fraction, (new $Uint64(0, 10)));
- nonAsciiName$2 = $mul64(nonAsciiName$2, (new $Uint64(0, 10)));
- if ((x$8 = $mul64(new $Uint64(0, 2), nonAsciiName$2), x$9 = $shiftLeft64(new $Uint64(0, 1), shift), (x$8.$high > x$9.$high || (x$8.$high === x$9.$high && x$8.$low > x$9.$low)))) {
- return false;
- }
- digit = $shiftRightUint64(fraction, shift);
- (x$10 = d.d, ((nd < 0 || nd >= x$10.$length) ? $throwRuntimeError("index out of range") : x$10.$array[x$10.$offset + nd] = (new $Uint64(digit.$high + 0, digit.$low + 48).$low << 24 >>> 24)));
- fraction = (x$11 = $shiftLeft64(digit, shift), new $Uint64(fraction.$high - x$11.$high, fraction.$low - x$11.$low));
- nd = nd + (1) >> 0;
- needed = needed - (1) >> 0;
- }
- d.nd = nd;
- }
- ok = adjustLastDigitFixed(d, (x$12 = $shiftLeft64(new $Uint64(0, rest), shift), new $Uint64(x$12.$high | fraction.$high, (x$12.$low | fraction.$low) >>> 0)), pow10, shift, nonAsciiName$2);
- if (!ok) {
- return false;
- }
- i$2 = d.nd - 1 >> 0;
- while (true) {
- if (!(i$2 >= 0)) { break; }
- if (!(((x$13 = d.d, ((i$2 < 0 || i$2 >= x$13.$length) ? $throwRuntimeError("index out of range") : x$13.$array[x$13.$offset + i$2])) === 48))) {
- d.nd = i$2 + 1 >> 0;
- break;
- }
- i$2 = i$2 - (1) >> 0;
- }
- return true;
- };
- extFloat.prototype.FixedDecimal = function(d, n) { return this.$val.FixedDecimal(d, n); };
- adjustLastDigitFixed = function(d, num, den, shift, nonAsciiName$2) {
- var $ptr, d, den, i, nonAsciiName$2, num, shift, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- if ((x = $shiftLeft64(den, shift), (num.$high > x.$high || (num.$high === x.$high && num.$low > x.$low)))) {
- $panic(new $String("strconv: num > den< x$2.$high || (x$1.$high === x$2.$high && x$1.$low > x$2.$low)))) {
- $panic(new $String("strconv: \xCE\xB5 > (den< x$6.$high || (x$5.$high === x$6.$high && x$5.$low > x$6.$low)))) {
- i = d.nd - 1 >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- if ((x$7 = d.d, ((i < 0 || i >= x$7.$length) ? $throwRuntimeError("index out of range") : x$7.$array[x$7.$offset + i])) === 57) {
- d.nd = d.nd - (1) >> 0;
- } else {
- break;
- }
- i = i - (1) >> 0;
- }
- if (i < 0) {
- (x$8 = d.d, (0 >= x$8.$length ? $throwRuntimeError("index out of range") : x$8.$array[x$8.$offset + 0] = 49));
- d.nd = 1;
- d.dp = d.dp + (1) >> 0;
- } else {
- (x$10 = d.d, ((i < 0 || i >= x$10.$length) ? $throwRuntimeError("index out of range") : x$10.$array[x$10.$offset + i] = (x$9 = d.d, ((i < 0 || i >= x$9.$length) ? $throwRuntimeError("index out of range") : x$9.$array[x$9.$offset + i])) + (1) << 24 >>> 24));
- }
- return true;
- }
- return false;
- };
- extFloat.ptr.prototype.ShortestDecimal = function(d, lower, upper) {
- var $ptr, _q, _tmp, _tmp$1, _tmp$2, _tmp$3, allowance, buf, currentDiff, d, digit, digit$1, exp10, f, fraction, i, i$1, i$2, integer, integerDigits, lower, multiplier, n, nd, pow, pow$1, shift, targetDiff, upper, v, v1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$24, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- f = this;
- if ((x = f.mant, (x.$high === 0 && x.$low === 0))) {
- d.nd = 0;
- d.dp = 0;
- d.neg = f.neg;
- return true;
- }
- if ((f.exp === 0) && $equal(lower, f, extFloat) && $equal(lower, upper, extFloat)) {
- buf = $clone(arrayType.zero(), arrayType);
- n = 23;
- v = f.mant;
- while (true) {
- if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; }
- v1 = $div64(v, new $Uint64(0, 10), false);
- v = (x$1 = $mul64(new $Uint64(0, 10), v1), new $Uint64(v.$high - x$1.$high, v.$low - x$1.$low));
- ((n < 0 || n >= buf.length) ? $throwRuntimeError("index out of range") : buf[n] = (new $Uint64(v.$high + 0, v.$low + 48).$low << 24 >>> 24));
- n = n - (1) >> 0;
- v = v1;
- }
- nd = (24 - n >> 0) - 1 >> 0;
- i = 0;
- while (true) {
- if (!(i < nd)) { break; }
- (x$3 = d.d, ((i < 0 || i >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + i] = (x$2 = (n + 1 >> 0) + i >> 0, ((x$2 < 0 || x$2 >= buf.length) ? $throwRuntimeError("index out of range") : buf[x$2]))));
- i = i + (1) >> 0;
- }
- _tmp = nd; _tmp$1 = nd; d.nd = _tmp; d.dp = _tmp$1;
- while (true) {
- if (!(d.nd > 0 && ((x$4 = d.d, x$5 = d.nd - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + x$5])) === 48))) { break; }
- d.nd = d.nd - (1) >> 0;
- }
- if (d.nd === 0) {
- d.dp = 0;
- }
- d.neg = f.neg;
- return true;
- }
- upper.Normalize();
- if (f.exp > upper.exp) {
- f.mant = $shiftLeft64(f.mant, (((f.exp - upper.exp >> 0) >>> 0)));
- f.exp = upper.exp;
- }
- if (lower.exp > upper.exp) {
- lower.mant = $shiftLeft64(lower.mant, (((lower.exp - upper.exp >> 0) >>> 0)));
- lower.exp = upper.exp;
- }
- exp10 = frexp10Many(lower, f, upper);
- upper.mant = (x$6 = upper.mant, x$7 = new $Uint64(0, 1), new $Uint64(x$6.$high + x$7.$high, x$6.$low + x$7.$low));
- lower.mant = (x$8 = lower.mant, x$9 = new $Uint64(0, 1), new $Uint64(x$8.$high - x$9.$high, x$8.$low - x$9.$low));
- shift = (-upper.exp >>> 0);
- integer = ($shiftRightUint64(upper.mant, shift).$low >>> 0);
- fraction = (x$10 = upper.mant, x$11 = $shiftLeft64(new $Uint64(0, integer), shift), new $Uint64(x$10.$high - x$11.$high, x$10.$low - x$11.$low));
- allowance = (x$12 = upper.mant, x$13 = lower.mant, new $Uint64(x$12.$high - x$13.$high, x$12.$low - x$13.$low));
- targetDiff = (x$14 = upper.mant, x$15 = f.mant, new $Uint64(x$14.$high - x$15.$high, x$14.$low - x$15.$low));
- integerDigits = 0;
- _tmp$2 = 0; _tmp$3 = new $Uint64(0, 1); i$1 = _tmp$2; pow = _tmp$3;
- while (true) {
- if (!(i$1 < 20)) { break; }
- if ((x$16 = new $Uint64(0, integer), (pow.$high > x$16.$high || (pow.$high === x$16.$high && pow.$low > x$16.$low)))) {
- integerDigits = i$1;
- break;
- }
- pow = $mul64(pow, (new $Uint64(0, 10)));
- i$1 = i$1 + (1) >> 0;
- }
- i$2 = 0;
- while (true) {
- if (!(i$2 < integerDigits)) { break; }
- pow$1 = (x$17 = (integerDigits - i$2 >> 0) - 1 >> 0, ((x$17 < 0 || x$17 >= uint64pow10.length) ? $throwRuntimeError("index out of range") : uint64pow10[x$17]));
- digit = (_q = integer / (pow$1.$low >>> 0), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- (x$18 = d.d, ((i$2 < 0 || i$2 >= x$18.$length) ? $throwRuntimeError("index out of range") : x$18.$array[x$18.$offset + i$2] = ((digit + 48 >>> 0) << 24 >>> 24)));
- integer = integer - ((x$19 = (pow$1.$low >>> 0), (((digit >>> 16 << 16) * x$19 >>> 0) + (digit << 16 >>> 16) * x$19) >>> 0)) >>> 0;
- currentDiff = (x$20 = $shiftLeft64(new $Uint64(0, integer), shift), new $Uint64(x$20.$high + fraction.$high, x$20.$low + fraction.$low));
- if ((currentDiff.$high < allowance.$high || (currentDiff.$high === allowance.$high && currentDiff.$low < allowance.$low))) {
- d.nd = i$2 + 1 >> 0;
- d.dp = integerDigits + exp10 >> 0;
- d.neg = f.neg;
- return adjustLastDigit(d, currentDiff, targetDiff, allowance, $shiftLeft64(pow$1, shift), new $Uint64(0, 2));
- }
- i$2 = i$2 + (1) >> 0;
- }
- d.nd = integerDigits;
- d.dp = d.nd + exp10 >> 0;
- d.neg = f.neg;
- digit$1 = 0;
- multiplier = new $Uint64(0, 1);
- while (true) {
- fraction = $mul64(fraction, (new $Uint64(0, 10)));
- multiplier = $mul64(multiplier, (new $Uint64(0, 10)));
- digit$1 = ($shiftRightUint64(fraction, shift).$low >> 0);
- (x$21 = d.d, x$22 = d.nd, ((x$22 < 0 || x$22 >= x$21.$length) ? $throwRuntimeError("index out of range") : x$21.$array[x$21.$offset + x$22] = ((digit$1 + 48 >> 0) << 24 >>> 24)));
- d.nd = d.nd + (1) >> 0;
- fraction = (x$23 = $shiftLeft64(new $Uint64(0, digit$1), shift), new $Uint64(fraction.$high - x$23.$high, fraction.$low - x$23.$low));
- if ((x$24 = $mul64(allowance, multiplier), (fraction.$high < x$24.$high || (fraction.$high === x$24.$high && fraction.$low < x$24.$low)))) {
- return adjustLastDigit(d, fraction, $mul64(targetDiff, multiplier), $mul64(allowance, multiplier), $shiftLeft64(new $Uint64(0, 1), shift), $mul64(multiplier, new $Uint64(0, 2)));
- }
- }
- };
- extFloat.prototype.ShortestDecimal = function(d, lower, upper) { return this.$val.ShortestDecimal(d, lower, upper); };
- adjustLastDigit = function(d, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary) {
- var $ptr, _index, currentDiff, d, maxDiff, targetDiff, ulpBinary, ulpDecimal, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- if ((x = $mul64(new $Uint64(0, 2), ulpBinary), (ulpDecimal.$high < x.$high || (ulpDecimal.$high === x.$high && ulpDecimal.$low < x.$low)))) {
- return false;
- }
- while (true) {
- if (!((x$1 = (x$2 = (x$3 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(currentDiff.$high + x$3.$high, currentDiff.$low + x$3.$low)), new $Uint64(x$2.$high + ulpBinary.$high, x$2.$low + ulpBinary.$low)), (x$1.$high < targetDiff.$high || (x$1.$high === targetDiff.$high && x$1.$low < targetDiff.$low))))) { break; }
- _index = d.nd - 1 >> 0;
- (x$5 = d.d, ((_index < 0 || _index >= x$5.$length) ? $throwRuntimeError("index out of range") : x$5.$array[x$5.$offset + _index] = (x$4 = d.d, ((_index < 0 || _index >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + _index])) - (1) << 24 >>> 24));
- currentDiff = (x$6 = ulpDecimal, new $Uint64(currentDiff.$high + x$6.$high, currentDiff.$low + x$6.$low));
- }
- if ((x$7 = new $Uint64(currentDiff.$high + ulpDecimal.$high, currentDiff.$low + ulpDecimal.$low), x$8 = (x$9 = (x$10 = $div64(ulpDecimal, new $Uint64(0, 2), false), new $Uint64(targetDiff.$high + x$10.$high, targetDiff.$low + x$10.$low)), new $Uint64(x$9.$high + ulpBinary.$high, x$9.$low + ulpBinary.$low)), (x$7.$high < x$8.$high || (x$7.$high === x$8.$high && x$7.$low <= x$8.$low)))) {
- return false;
- }
- if ((currentDiff.$high < ulpBinary.$high || (currentDiff.$high === ulpBinary.$high && currentDiff.$low < ulpBinary.$low)) || (x$11 = new $Uint64(maxDiff.$high - ulpBinary.$high, maxDiff.$low - ulpBinary.$low), (currentDiff.$high > x$11.$high || (currentDiff.$high === x$11.$high && currentDiff.$low > x$11.$low)))) {
- return false;
- }
- if ((d.nd === 1) && ((x$12 = d.d, (0 >= x$12.$length ? $throwRuntimeError("index out of range") : x$12.$array[x$12.$offset + 0])) === 48)) {
- d.nd = 0;
- d.dp = 0;
- }
- return true;
- };
- FormatFloat = function(f, fmt, prec, bitSize) {
- var $ptr, bitSize, f, fmt, prec;
- return $bytesToString(genericFtoa($makeSlice(sliceType$6, 0, max(prec + 4 >> 0, 24)), f, fmt, prec, bitSize));
- };
- $pkg.FormatFloat = FormatFloat;
- AppendFloat = function(dst, f, fmt, prec, bitSize) {
- var $ptr, bitSize, dst, f, fmt, prec;
- return genericFtoa(dst, f, fmt, prec, bitSize);
- };
- $pkg.AppendFloat = AppendFloat;
- genericFtoa = function(dst, val, fmt, prec, bitSize) {
- var $ptr, _ref, _ref$1, _ref$2, _ref$3, _tuple, bitSize, bits, buf, buf$1, digits, digs, dst, exp, f, f$1, flt, fmt, lower, mant, neg, ok, prec, s, shortest, upper, val, x, x$1, x$2, x$3, y, y$1;
- bits = new $Uint64(0, 0);
- flt = ptrType$1.nil;
- _ref = bitSize;
- if (_ref === 32) {
- bits = new $Uint64(0, math.Float32bits($fround(val)));
- flt = float32info;
- } else if (_ref === 64) {
- bits = math.Float64bits(val);
- flt = float64info;
- } else {
- $panic(new $String("strconv: illegal AppendFloat/FormatFloat bitSize"));
- }
- neg = !((x = $shiftRightUint64(bits, ((flt.expbits + flt.mantbits >>> 0))), (x.$high === 0 && x.$low === 0)));
- exp = ($shiftRightUint64(bits, flt.mantbits).$low >> 0) & ((((y = flt.expbits, y < 32 ? (1 << y) : 0) >> 0) - 1 >> 0));
- mant = (x$1 = (x$2 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(x$2.$high - 0, x$2.$low - 1)), new $Uint64(bits.$high & x$1.$high, (bits.$low & x$1.$low) >>> 0));
- _ref$1 = exp;
- if (_ref$1 === (((y$1 = flt.expbits, y$1 < 32 ? (1 << y$1) : 0) >> 0) - 1 >> 0)) {
- s = "";
- if (!((mant.$high === 0 && mant.$low === 0))) {
- s = "NaN";
- } else if (neg) {
- s = "-Inf";
- } else {
- s = "+Inf";
- }
- return $appendSlice(dst, new sliceType$6($stringToBytes(s)));
- } else if (_ref$1 === 0) {
- exp = exp + (1) >> 0;
- } else {
- mant = (x$3 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), new $Uint64(mant.$high | x$3.$high, (mant.$low | x$3.$low) >>> 0));
- }
- exp = exp + (flt.bias) >> 0;
- if (fmt === 98) {
- return fmtB(dst, neg, mant, exp, flt);
- }
- if (!optimize) {
- return bigFtoa(dst, prec, fmt, neg, mant, exp, flt);
- }
- digs = $clone(new decimalSlice.ptr(), decimalSlice);
- ok = false;
- shortest = prec < 0;
- if (shortest) {
- f = new extFloat.ptr();
- _tuple = f.AssignComputeBounds(mant, exp, neg, flt); lower = $clone(_tuple[0], extFloat); upper = $clone(_tuple[1], extFloat);
- buf = $clone(arrayType$1.zero(), arrayType$1);
- digs.d = new sliceType$6(buf);
- ok = f.ShortestDecimal(digs, lower, upper);
- if (!ok) {
- return bigFtoa(dst, prec, fmt, neg, mant, exp, flt);
- }
- _ref$2 = fmt;
- if (_ref$2 === 101 || _ref$2 === 69) {
- prec = digs.nd - 1 >> 0;
- } else if (_ref$2 === 102) {
- prec = max(digs.nd - digs.dp >> 0, 0);
- } else if (_ref$2 === 103 || _ref$2 === 71) {
- prec = digs.nd;
- }
- } else if (!((fmt === 102))) {
- digits = prec;
- _ref$3 = fmt;
- if (_ref$3 === 101 || _ref$3 === 69) {
- digits = digits + (1) >> 0;
- } else if (_ref$3 === 103 || _ref$3 === 71) {
- if (prec === 0) {
- prec = 1;
- }
- digits = prec;
- }
- if (digits <= 15) {
- buf$1 = $clone(arrayType.zero(), arrayType);
- digs.d = new sliceType$6(buf$1);
- f$1 = new extFloat.ptr(mant, exp - (flt.mantbits >> 0) >> 0, neg);
- ok = f$1.FixedDecimal(digs, digits);
- }
- }
- if (!ok) {
- return bigFtoa(dst, prec, fmt, neg, mant, exp, flt);
- }
- return formatDigits(dst, shortest, neg, digs, prec, fmt);
- };
- bigFtoa = function(dst, prec, fmt, neg, mant, exp, flt) {
- var $ptr, _ref, _ref$1, d, digs, dst, exp, flt, fmt, mant, neg, prec, shortest;
- d = new decimal.ptr();
- d.Assign(mant);
- d.Shift(exp - (flt.mantbits >> 0) >> 0);
- digs = $clone(new decimalSlice.ptr(), decimalSlice);
- shortest = prec < 0;
- if (shortest) {
- roundShortest(d, mant, exp, flt);
- $copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false), decimalSlice);
- _ref = fmt;
- if (_ref === 101 || _ref === 69) {
- prec = digs.nd - 1 >> 0;
- } else if (_ref === 102) {
- prec = max(digs.nd - digs.dp >> 0, 0);
- } else if (_ref === 103 || _ref === 71) {
- prec = digs.nd;
- }
- } else {
- _ref$1 = fmt;
- if (_ref$1 === 101 || _ref$1 === 69) {
- d.Round(prec + 1 >> 0);
- } else if (_ref$1 === 102) {
- d.Round(d.dp + prec >> 0);
- } else if (_ref$1 === 103 || _ref$1 === 71) {
- if (prec === 0) {
- prec = 1;
- }
- d.Round(prec);
- }
- $copy(digs, new decimalSlice.ptr(new sliceType$6(d.d), d.nd, d.dp, false), decimalSlice);
- }
- return formatDigits(dst, shortest, neg, digs, prec, fmt);
- };
- formatDigits = function(dst, shortest, neg, digs, prec, fmt) {
- var $ptr, _ref, digs, dst, eprec, exp, fmt, neg, prec, shortest;
- digs = $clone(digs, decimalSlice);
- _ref = fmt;
- if (_ref === 101 || _ref === 69) {
- return fmtE(dst, neg, digs, prec, fmt);
- } else if (_ref === 102) {
- return fmtF(dst, neg, digs, prec);
- } else if (_ref === 103 || _ref === 71) {
- eprec = prec;
- if (eprec > digs.nd && digs.nd >= digs.dp) {
- eprec = digs.nd;
- }
- if (shortest) {
- eprec = 6;
- }
- exp = digs.dp - 1 >> 0;
- if (exp < -4 || exp >= eprec) {
- if (prec > digs.nd) {
- prec = digs.nd;
- }
- return fmtE(dst, neg, digs, prec - 1 >> 0, (fmt + 101 << 24 >>> 24) - 103 << 24 >>> 24);
- }
- if (prec > digs.dp) {
- prec = digs.nd;
- }
- return fmtF(dst, neg, digs, max(prec - digs.dp >> 0, 0));
- }
- return $append(dst, 37, fmt);
- };
- roundShortest = function(d, mant, exp, flt) {
- var $ptr, _tmp, _tmp$1, _tmp$2, d, exp, explo, flt, i, inclusive, l, lower, m, mant, mantlo, minexp, okdown, okup, u, upper, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7;
- if ((mant.$high === 0 && mant.$low === 0)) {
- d.nd = 0;
- return;
- }
- minexp = flt.bias + 1 >> 0;
- if (exp > minexp && (332 * ((d.dp - d.nd >> 0)) >> 0) >= (100 * ((exp - (flt.mantbits >> 0) >> 0)) >> 0)) {
- return;
- }
- upper = new decimal.ptr();
- upper.Assign((x = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x.$high + 0, x.$low + 1)));
- upper.Shift((exp - (flt.mantbits >> 0) >> 0) - 1 >> 0);
- mantlo = new $Uint64(0, 0);
- explo = 0;
- if ((x$1 = $shiftLeft64(new $Uint64(0, 1), flt.mantbits), (mant.$high > x$1.$high || (mant.$high === x$1.$high && mant.$low > x$1.$low))) || (exp === minexp)) {
- mantlo = new $Uint64(mant.$high - 0, mant.$low - 1);
- explo = exp;
- } else {
- mantlo = (x$2 = $mul64(mant, new $Uint64(0, 2)), new $Uint64(x$2.$high - 0, x$2.$low - 1));
- explo = exp - 1 >> 0;
- }
- lower = new decimal.ptr();
- lower.Assign((x$3 = $mul64(mantlo, new $Uint64(0, 2)), new $Uint64(x$3.$high + 0, x$3.$low + 1)));
- lower.Shift((explo - (flt.mantbits >> 0) >> 0) - 1 >> 0);
- inclusive = (x$4 = $div64(mant, new $Uint64(0, 2), true), (x$4.$high === 0 && x$4.$low === 0));
- i = 0;
- while (true) {
- if (!(i < d.nd)) { break; }
- _tmp = 0; _tmp$1 = 0; _tmp$2 = 0; l = _tmp; m = _tmp$1; u = _tmp$2;
- if (i < lower.nd) {
- l = (x$5 = lower.d, ((i < 0 || i >= x$5.length) ? $throwRuntimeError("index out of range") : x$5[i]));
- } else {
- l = 48;
- }
- m = (x$6 = d.d, ((i < 0 || i >= x$6.length) ? $throwRuntimeError("index out of range") : x$6[i]));
- if (i < upper.nd) {
- u = (x$7 = upper.d, ((i < 0 || i >= x$7.length) ? $throwRuntimeError("index out of range") : x$7[i]));
- } else {
- u = 48;
- }
- okdown = !((l === m)) || (inclusive && (l === m) && ((i + 1 >> 0) === lower.nd));
- okup = !((m === u)) && (inclusive || (m + 1 << 24 >>> 24) < u || (i + 1 >> 0) < upper.nd);
- if (okdown && okup) {
- d.Round(i + 1 >> 0);
- return;
- } else if (okdown) {
- d.RoundDown(i + 1 >> 0);
- return;
- } else if (okup) {
- d.RoundUp(i + 1 >> 0);
- return;
- }
- i = i + (1) >> 0;
- }
- };
- fmtE = function(dst, neg, d, prec, fmt) {
- var $ptr, _q, _r, _ref, buf, ch, d, dst, exp, fmt, i, i$1, m, neg, prec, x, x$1;
- d = $clone(d, decimalSlice);
- if (neg) {
- dst = $append(dst, 45);
- }
- ch = 48;
- if (!((d.nd === 0))) {
- ch = (x = d.d, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]));
- }
- dst = $append(dst, ch);
- if (prec > 0) {
- dst = $append(dst, 46);
- i = 1;
- m = ((d.nd + prec >> 0) + 1 >> 0) - max(d.nd, prec + 1 >> 0) >> 0;
- while (true) {
- if (!(i < m)) { break; }
- dst = $append(dst, (x$1 = d.d, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])));
- i = i + (1) >> 0;
- }
- while (true) {
- if (!(i <= prec)) { break; }
- dst = $append(dst, 48);
- i = i + (1) >> 0;
- }
- }
- dst = $append(dst, fmt);
- exp = d.dp - 1 >> 0;
- if (d.nd === 0) {
- exp = 0;
- }
- if (exp < 0) {
- ch = 45;
- exp = -exp;
- } else {
- ch = 43;
- }
- dst = $append(dst, ch);
- buf = $clone(arrayType$2.zero(), arrayType$2);
- i$1 = 3;
- while (true) {
- if (!(exp >= 10)) { break; }
- i$1 = i$1 - (1) >> 0;
- ((i$1 < 0 || i$1 >= buf.length) ? $throwRuntimeError("index out of range") : buf[i$1] = (((_r = exp % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >> 0) << 24 >>> 24));
- exp = (_q = exp / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- }
- i$1 = i$1 - (1) >> 0;
- ((i$1 < 0 || i$1 >= buf.length) ? $throwRuntimeError("index out of range") : buf[i$1] = ((exp + 48 >> 0) << 24 >>> 24));
- _ref = i$1;
- if (_ref === 0) {
- dst = $append(dst, buf[0], buf[1], buf[2]);
- } else if (_ref === 1) {
- dst = $append(dst, buf[1], buf[2]);
- } else if (_ref === 2) {
- dst = $append(dst, 48, buf[2]);
- }
- return dst;
- };
- fmtF = function(dst, neg, d, prec) {
- var $ptr, ch, d, dst, i, i$1, j, neg, prec, x, x$1;
- d = $clone(d, decimalSlice);
- if (neg) {
- dst = $append(dst, 45);
- }
- if (d.dp > 0) {
- i = 0;
- i = 0;
- while (true) {
- if (!(i < d.dp && i < d.nd)) { break; }
- dst = $append(dst, (x = d.d, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])));
- i = i + (1) >> 0;
- }
- while (true) {
- if (!(i < d.dp)) { break; }
- dst = $append(dst, 48);
- i = i + (1) >> 0;
- }
- } else {
- dst = $append(dst, 48);
- }
- if (prec > 0) {
- dst = $append(dst, 46);
- i$1 = 0;
- while (true) {
- if (!(i$1 < prec)) { break; }
- ch = 48;
- j = d.dp + i$1 >> 0;
- if (0 <= j && j < d.nd) {
- ch = (x$1 = d.d, ((j < 0 || j >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + j]));
- }
- dst = $append(dst, ch);
- i$1 = i$1 + (1) >> 0;
- }
- }
- return dst;
- };
- fmtB = function(dst, neg, mant, exp, flt) {
- var $ptr, _q, _r, buf, dst, esign, exp, flt, mant, n, neg, w, x;
- buf = $clone(arrayType$3.zero(), arrayType$3);
- w = 50;
- exp = exp - ((flt.mantbits >> 0)) >> 0;
- esign = 43;
- if (exp < 0) {
- esign = 45;
- exp = -exp;
- }
- n = 0;
- while (true) {
- if (!(exp > 0 || n < 1)) { break; }
- n = n + (1) >> 0;
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = (((_r = exp % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >> 0) << 24 >>> 24));
- exp = (_q = exp / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- }
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = esign);
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 112);
- n = 0;
- while (true) {
- if (!((mant.$high > 0 || (mant.$high === 0 && mant.$low > 0)) || n < 1)) { break; }
- n = n + (1) >> 0;
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = ((x = $div64(mant, new $Uint64(0, 10), true), new $Uint64(x.$high + 0, x.$low + 48)).$low << 24 >>> 24));
- mant = $div64(mant, (new $Uint64(0, 10)), false);
- }
- if (neg) {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 45);
- }
- return $appendSlice(dst, $subslice(new sliceType$6(buf), w));
- };
- max = function(a, b) {
- var $ptr, a, b;
- if (a > b) {
- return a;
- }
- return b;
- };
- FormatUint = function(i, base) {
- var $ptr, _tuple, base, i, s;
- _tuple = formatBits(sliceType$6.nil, i, base, false, false); s = _tuple[1];
- return s;
- };
- $pkg.FormatUint = FormatUint;
- FormatInt = function(i, base) {
- var $ptr, _tuple, base, i, s;
- _tuple = formatBits(sliceType$6.nil, new $Uint64(i.$high, i.$low), base, (i.$high < 0 || (i.$high === 0 && i.$low < 0)), false); s = _tuple[1];
- return s;
- };
- $pkg.FormatInt = FormatInt;
- Itoa = function(i) {
- var $ptr, i;
- return FormatInt(new $Int64(0, i), 10);
- };
- $pkg.Itoa = Itoa;
- AppendInt = function(dst, i, base) {
- var $ptr, _tuple, base, dst, i;
- _tuple = formatBits(dst, new $Uint64(i.$high, i.$low), base, (i.$high < 0 || (i.$high === 0 && i.$low < 0)), true); dst = _tuple[0];
- return dst;
- };
- $pkg.AppendInt = AppendInt;
- AppendUint = function(dst, i, base) {
- var $ptr, _tuple, base, dst, i;
- _tuple = formatBits(dst, i, base, false, true); dst = _tuple[0];
- return dst;
- };
- $pkg.AppendUint = AppendUint;
- formatBits = function(dst, u, base, neg, append_) {
- var $ptr, a, append_, b, b$1, base, d, dst, i, j, m, neg, q, q$1, s, s$1, u, x, x$1, x$2, x$3;
- d = sliceType$6.nil;
- s = "";
- if (base < 2 || base > 36) {
- $panic(new $String("strconv: illegal AppendInt/FormatInt base"));
- }
- a = $clone(arrayType$4.zero(), arrayType$4);
- i = 65;
- if (neg) {
- u = new $Uint64(-u.$high, -u.$low);
- }
- if (base === 10) {
- while (true) {
- if (!((u.$high > 0 || (u.$high === 0 && u.$low >= 100)))) { break; }
- i = i - (2) >> 0;
- q = $div64(u, new $Uint64(0, 100), false);
- j = ((x = $mul64(q, new $Uint64(0, 100)), new $Uint64(u.$high - x.$high, u.$low - x.$low)).$low >>> 0);
- (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= a.length) ? $throwRuntimeError("index out of range") : a[x$1] = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789".charCodeAt(j)));
- (x$2 = i + 0 >> 0, ((x$2 < 0 || x$2 >= a.length) ? $throwRuntimeError("index out of range") : a[x$2] = "0000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999".charCodeAt(j)));
- u = q;
- }
- if ((u.$high > 0 || (u.$high === 0 && u.$low >= 10))) {
- i = i - (1) >> 0;
- q$1 = $div64(u, new $Uint64(0, 10), false);
- ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((x$3 = $mul64(q$1, new $Uint64(0, 10)), new $Uint64(u.$high - x$3.$high, u.$low - x$3.$low)).$low >>> 0)));
- u = q$1;
- }
- } else {
- s$1 = ((base < 0 || base >= shifts.length) ? $throwRuntimeError("index out of range") : shifts[base]);
- if (s$1 > 0) {
- b = new $Uint64(0, base);
- m = (b.$low >>> 0) - 1 >>> 0;
- while (true) {
- if (!((u.$high > b.$high || (u.$high === b.$high && u.$low >= b.$low)))) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((((u.$low >>> 0) & m) >>> 0)));
- u = $shiftRightUint64(u, (s$1));
- }
- } else {
- b$1 = new $Uint64(0, base);
- while (true) {
- if (!((u.$high > b$1.$high || (u.$high === b$1.$high && u.$low >= b$1.$low)))) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(($div64(u, b$1, true).$low >>> 0)));
- u = $div64(u, (b$1), false);
- }
- }
- }
- i = i - (1) >> 0;
- ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((u.$low >>> 0)));
- if (neg) {
- i = i - (1) >> 0;
- ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = 45);
- }
- if (append_) {
- d = $appendSlice(dst, $subslice(new sliceType$6(a), i));
- return [d, s];
- }
- s = $bytesToString($subslice(new sliceType$6(a), i));
- return [d, s];
- };
- quoteWith = function(s, quote, ASCIIonly) {
- var $ptr, ASCIIonly, _q, _ref, _tuple, buf, n, quote, r, runeTmp, s, s$1, s$2, width;
- runeTmp = $clone(arrayType$5.zero(), arrayType$5);
- buf = $makeSlice(sliceType$6, 0, (_q = (3 * s.length >> 0) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")));
- buf = $append(buf, quote);
- width = 0;
- while (true) {
- if (!(s.length > 0)) { break; }
- r = (s.charCodeAt(0) >> 0);
- width = 1;
- if (r >= 128) {
- _tuple = utf8.DecodeRuneInString(s); r = _tuple[0]; width = _tuple[1];
- }
- if ((width === 1) && (r === 65533)) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\x")));
- buf = $append(buf, "0123456789abcdef".charCodeAt((s.charCodeAt(0) >>> 4 << 24 >>> 24)));
- buf = $append(buf, "0123456789abcdef".charCodeAt(((s.charCodeAt(0) & 15) >>> 0)));
- s = s.substring(width);
- continue;
- }
- if ((r === (quote >> 0)) || (r === 92)) {
- buf = $append(buf, 92);
- buf = $append(buf, (r << 24 >>> 24));
- s = s.substring(width);
- continue;
- }
- if (ASCIIonly) {
- if (r < 128 && IsPrint(r)) {
- buf = $append(buf, (r << 24 >>> 24));
- s = s.substring(width);
- continue;
- }
- } else if (IsPrint(r)) {
- n = utf8.EncodeRune(new sliceType$6(runeTmp), r);
- buf = $appendSlice(buf, $subslice(new sliceType$6(runeTmp), 0, n));
- s = s.substring(width);
- continue;
- }
- _ref = r;
- if (_ref === 7) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\a")));
- } else if (_ref === 8) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\b")));
- } else if (_ref === 12) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\f")));
- } else if (_ref === 10) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\n")));
- } else if (_ref === 13) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\r")));
- } else if (_ref === 9) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\t")));
- } else if (_ref === 11) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\v")));
- } else {
- if (r < 32) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\x")));
- buf = $append(buf, "0123456789abcdef".charCodeAt((s.charCodeAt(0) >>> 4 << 24 >>> 24)));
- buf = $append(buf, "0123456789abcdef".charCodeAt(((s.charCodeAt(0) & 15) >>> 0)));
- } else if (r > 1114111) {
- r = 65533;
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\u")));
- s$1 = 12;
- while (true) {
- if (!(s$1 >= 0)) { break; }
- buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min((s$1 >>> 0), 31)) >> 0) & 15)));
- s$1 = s$1 - (4) >> 0;
- }
- } else if (r < 65536) {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\u")));
- s$1 = 12;
- while (true) {
- if (!(s$1 >= 0)) { break; }
- buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min((s$1 >>> 0), 31)) >> 0) & 15)));
- s$1 = s$1 - (4) >> 0;
- }
- } else {
- buf = $appendSlice(buf, new sliceType$6($stringToBytes("\\U")));
- s$2 = 28;
- while (true) {
- if (!(s$2 >= 0)) { break; }
- buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min((s$2 >>> 0), 31)) >> 0) & 15)));
- s$2 = s$2 - (4) >> 0;
- }
- }
- }
- s = s.substring(width);
- }
- buf = $append(buf, quote);
- return $bytesToString(buf);
- };
- Quote = function(s) {
- var $ptr, s;
- return quoteWith(s, 34, false);
- };
- $pkg.Quote = Quote;
- QuoteToASCII = function(s) {
- var $ptr, s;
- return quoteWith(s, 34, true);
- };
- $pkg.QuoteToASCII = QuoteToASCII;
- QuoteRune = function(r) {
- var $ptr, r;
- return quoteWith($encodeRune(r), 39, false);
- };
- $pkg.QuoteRune = QuoteRune;
- AppendQuoteRune = function(dst, r) {
- var $ptr, dst, r;
- return $appendSlice(dst, new sliceType$6($stringToBytes(QuoteRune(r))));
- };
- $pkg.AppendQuoteRune = AppendQuoteRune;
- QuoteRuneToASCII = function(r) {
- var $ptr, r;
- return quoteWith($encodeRune(r), 39, true);
- };
- $pkg.QuoteRuneToASCII = QuoteRuneToASCII;
- AppendQuoteRuneToASCII = function(dst, r) {
- var $ptr, dst, r;
- return $appendSlice(dst, new sliceType$6($stringToBytes(QuoteRuneToASCII(r))));
- };
- $pkg.AppendQuoteRuneToASCII = AppendQuoteRuneToASCII;
- CanBackquote = function(s) {
- var $ptr, _tuple, r, s, wid;
- while (true) {
- if (!(s.length > 0)) { break; }
- _tuple = utf8.DecodeRuneInString(s); r = _tuple[0]; wid = _tuple[1];
- s = s.substring(wid);
- if (wid > 1) {
- if (r === 65279) {
- return false;
- }
- continue;
- }
- if (r === 65533) {
- return false;
- }
- if ((r < 32 && !((r === 9))) || (r === 96) || (r === 127)) {
- return false;
- }
- }
- return true;
- };
- $pkg.CanBackquote = CanBackquote;
- unhex = function(b) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, b, c, ok, v;
- v = 0;
- ok = false;
- c = (b >> 0);
- if (48 <= c && c <= 57) {
- _tmp = c - 48 >> 0; _tmp$1 = true; v = _tmp; ok = _tmp$1;
- return [v, ok];
- } else if (97 <= c && c <= 102) {
- _tmp$2 = (c - 97 >> 0) + 10 >> 0; _tmp$3 = true; v = _tmp$2; ok = _tmp$3;
- return [v, ok];
- } else if (65 <= c && c <= 70) {
- _tmp$4 = (c - 65 >> 0) + 10 >> 0; _tmp$5 = true; v = _tmp$4; ok = _tmp$5;
- return [v, ok];
- }
- return [v, ok];
- };
- UnquoteChar = function(s, quote) {
- var $ptr, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, c, c$1, err, j, j$1, multibyte, n, ok, quote, r, s, size, tail, v, v$1, value, x, x$1;
- value = 0;
- multibyte = false;
- tail = "";
- err = $ifaceNil;
- c = s.charCodeAt(0);
- if ((c === quote) && ((quote === 39) || (quote === 34))) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- } else if (c >= 128) {
- _tuple = utf8.DecodeRuneInString(s); r = _tuple[0]; size = _tuple[1];
- _tmp = r; _tmp$1 = true; _tmp$2 = s.substring(size); _tmp$3 = $ifaceNil; value = _tmp; multibyte = _tmp$1; tail = _tmp$2; err = _tmp$3;
- return [value, multibyte, tail, err];
- } else if (!((c === 92))) {
- _tmp$4 = (s.charCodeAt(0) >> 0); _tmp$5 = false; _tmp$6 = s.substring(1); _tmp$7 = $ifaceNil; value = _tmp$4; multibyte = _tmp$5; tail = _tmp$6; err = _tmp$7;
- return [value, multibyte, tail, err];
- }
- if (s.length <= 1) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- c$1 = s.charCodeAt(1);
- s = s.substring(2);
- _ref = c$1;
- switch (0) { default: if (_ref === 97) {
- value = 7;
- } else if (_ref === 98) {
- value = 8;
- } else if (_ref === 102) {
- value = 12;
- } else if (_ref === 110) {
- value = 10;
- } else if (_ref === 114) {
- value = 13;
- } else if (_ref === 116) {
- value = 9;
- } else if (_ref === 118) {
- value = 11;
- } else if (_ref === 120 || _ref === 117 || _ref === 85) {
- n = 0;
- _ref$1 = c$1;
- if (_ref$1 === 120) {
- n = 2;
- } else if (_ref$1 === 117) {
- n = 4;
- } else if (_ref$1 === 85) {
- n = 8;
- }
- v = 0;
- if (s.length < n) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- j = 0;
- while (true) {
- if (!(j < n)) { break; }
- _tuple$1 = unhex(s.charCodeAt(j)); x = _tuple$1[0]; ok = _tuple$1[1];
- if (!ok) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- v = (v << 4 >> 0) | x;
- j = j + (1) >> 0;
- }
- s = s.substring(n);
- if (c$1 === 120) {
- value = v;
- break;
- }
- if (v > 1114111) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- value = v;
- multibyte = true;
- } else if (_ref === 48 || _ref === 49 || _ref === 50 || _ref === 51 || _ref === 52 || _ref === 53 || _ref === 54 || _ref === 55) {
- v$1 = (c$1 >> 0) - 48 >> 0;
- if (s.length < 2) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- j$1 = 0;
- while (true) {
- if (!(j$1 < 2)) { break; }
- x$1 = (s.charCodeAt(j$1) >> 0) - 48 >> 0;
- if (x$1 < 0 || x$1 > 7) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- v$1 = ((v$1 << 3 >> 0)) | x$1;
- j$1 = j$1 + (1) >> 0;
- }
- s = s.substring(2);
- if (v$1 > 255) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- value = v$1;
- } else if (_ref === 92) {
- value = 92;
- } else if (_ref === 39 || _ref === 34) {
- if (!((c$1 === quote))) {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- }
- value = (c$1 >> 0);
- } else {
- err = $pkg.ErrSyntax;
- return [value, multibyte, tail, err];
- } }
- tail = s;
- return [value, multibyte, tail, err];
- };
- $pkg.UnquoteChar = UnquoteChar;
- Unquote = function(s) {
- var $ptr, _q, _ref, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, buf, c, err, err$1, multibyte, n, n$1, quote, r, runeTmp, s, size, ss, t;
- t = "";
- err = $ifaceNil;
- n = s.length;
- if (n < 2) {
- _tmp = ""; _tmp$1 = $pkg.ErrSyntax; t = _tmp; err = _tmp$1;
- return [t, err];
- }
- quote = s.charCodeAt(0);
- if (!((quote === s.charCodeAt((n - 1 >> 0))))) {
- _tmp$2 = ""; _tmp$3 = $pkg.ErrSyntax; t = _tmp$2; err = _tmp$3;
- return [t, err];
- }
- s = s.substring(1, (n - 1 >> 0));
- if (quote === 96) {
- if (contains(s, 96)) {
- _tmp$4 = ""; _tmp$5 = $pkg.ErrSyntax; t = _tmp$4; err = _tmp$5;
- return [t, err];
- }
- _tmp$6 = s; _tmp$7 = $ifaceNil; t = _tmp$6; err = _tmp$7;
- return [t, err];
- }
- if (!((quote === 34)) && !((quote === 39))) {
- _tmp$8 = ""; _tmp$9 = $pkg.ErrSyntax; t = _tmp$8; err = _tmp$9;
- return [t, err];
- }
- if (contains(s, 10)) {
- _tmp$10 = ""; _tmp$11 = $pkg.ErrSyntax; t = _tmp$10; err = _tmp$11;
- return [t, err];
- }
- if (!contains(s, 92) && !contains(s, quote)) {
- _ref = quote;
- if (_ref === 34) {
- _tmp$12 = s; _tmp$13 = $ifaceNil; t = _tmp$12; err = _tmp$13;
- return [t, err];
- } else if (_ref === 39) {
- _tuple = utf8.DecodeRuneInString(s); r = _tuple[0]; size = _tuple[1];
- if ((size === s.length) && (!((r === 65533)) || !((size === 1)))) {
- _tmp$14 = s; _tmp$15 = $ifaceNil; t = _tmp$14; err = _tmp$15;
- return [t, err];
- }
- }
- }
- runeTmp = $clone(arrayType$5.zero(), arrayType$5);
- buf = $makeSlice(sliceType$6, 0, (_q = (3 * s.length >> 0) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")));
- while (true) {
- if (!(s.length > 0)) { break; }
- _tuple$1 = UnquoteChar(s, quote); c = _tuple$1[0]; multibyte = _tuple$1[1]; ss = _tuple$1[2]; err$1 = _tuple$1[3];
- if (!($interfaceIsEqual(err$1, $ifaceNil))) {
- _tmp$16 = ""; _tmp$17 = err$1; t = _tmp$16; err = _tmp$17;
- return [t, err];
- }
- s = ss;
- if (c < 128 || !multibyte) {
- buf = $append(buf, (c << 24 >>> 24));
- } else {
- n$1 = utf8.EncodeRune(new sliceType$6(runeTmp), c);
- buf = $appendSlice(buf, $subslice(new sliceType$6(runeTmp), 0, n$1));
- }
- if ((quote === 39) && !((s.length === 0))) {
- _tmp$18 = ""; _tmp$19 = $pkg.ErrSyntax; t = _tmp$18; err = _tmp$19;
- return [t, err];
- }
- }
- _tmp$20 = $bytesToString(buf); _tmp$21 = $ifaceNil; t = _tmp$20; err = _tmp$21;
- return [t, err];
- };
- $pkg.Unquote = Unquote;
- contains = function(s, c) {
- var $ptr, c, i, s;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- if (s.charCodeAt(i) === c) {
- return true;
- }
- i = i + (1) >> 0;
- }
- return false;
- };
- bsearch16 = function(a, x) {
- var $ptr, _q, _tmp, _tmp$1, a, h, i, j, x;
- _tmp = 0; _tmp$1 = a.$length; i = _tmp; j = _tmp$1;
- while (true) {
- if (!(i < j)) { break; }
- h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- if (((h < 0 || h >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + h]) < x) {
- i = h + 1 >> 0;
- } else {
- j = h;
- }
- }
- return i;
- };
- bsearch32 = function(a, x) {
- var $ptr, _q, _tmp, _tmp$1, a, h, i, j, x;
- _tmp = 0; _tmp$1 = a.$length; i = _tmp; j = _tmp$1;
- while (true) {
- if (!(i < j)) { break; }
- h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- if (((h < 0 || h >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + h]) < x) {
- i = h + 1 >> 0;
- } else {
- j = h;
- }
- }
- return i;
- };
- IsPrint = function(r) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, i, i$1, isNotPrint, isNotPrint$1, isPrint, isPrint$1, j, j$1, r, rr, rr$1, x, x$1, x$2, x$3;
- if (r <= 255) {
- if (32 <= r && r <= 126) {
- return true;
- }
- if (161 <= r && r <= 255) {
- return !((r === 173));
- }
- return false;
- }
- if (0 <= r && r < 65536) {
- _tmp = (r << 16 >>> 16); _tmp$1 = isPrint16; _tmp$2 = isNotPrint16; rr = _tmp; isPrint = _tmp$1; isNotPrint = _tmp$2;
- i = bsearch16(isPrint, rr);
- if (i >= isPrint.$length || rr < (x = (i & ~1) >> 0, ((x < 0 || x >= isPrint.$length) ? $throwRuntimeError("index out of range") : isPrint.$array[isPrint.$offset + x])) || (x$1 = i | 1, ((x$1 < 0 || x$1 >= isPrint.$length) ? $throwRuntimeError("index out of range") : isPrint.$array[isPrint.$offset + x$1])) < rr) {
- return false;
- }
- j = bsearch16(isNotPrint, rr);
- return j >= isNotPrint.$length || !((((j < 0 || j >= isNotPrint.$length) ? $throwRuntimeError("index out of range") : isNotPrint.$array[isNotPrint.$offset + j]) === rr));
- }
- _tmp$3 = (r >>> 0); _tmp$4 = isPrint32; _tmp$5 = isNotPrint32; rr$1 = _tmp$3; isPrint$1 = _tmp$4; isNotPrint$1 = _tmp$5;
- i$1 = bsearch32(isPrint$1, rr$1);
- if (i$1 >= isPrint$1.$length || rr$1 < (x$2 = (i$1 & ~1) >> 0, ((x$2 < 0 || x$2 >= isPrint$1.$length) ? $throwRuntimeError("index out of range") : isPrint$1.$array[isPrint$1.$offset + x$2])) || (x$3 = i$1 | 1, ((x$3 < 0 || x$3 >= isPrint$1.$length) ? $throwRuntimeError("index out of range") : isPrint$1.$array[isPrint$1.$offset + x$3])) < rr$1) {
- return false;
- }
- if (r >= 131072) {
- return true;
- }
- r = r - (65536) >> 0;
- j$1 = bsearch16(isNotPrint$1, (r << 16 >>> 16));
- return j$1 >= isNotPrint$1.$length || !((((j$1 < 0 || j$1 >= isNotPrint$1.$length) ? $throwRuntimeError("index out of range") : isNotPrint$1.$array[isNotPrint$1.$offset + j$1]) === (r << 16 >>> 16)));
- };
- $pkg.IsPrint = IsPrint;
- ptrType.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$2.methods = [{prop: "set", name: "set", pkg: "strconv", typ: $funcType([$String], [$Bool], false)}, {prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Assign", name: "Assign", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "Shift", name: "Shift", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundDown", name: "RoundDown", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundUp", name: "RoundUp", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "RoundedInteger", name: "RoundedInteger", pkg: "", typ: $funcType([], [$Uint64], false)}];
- ptrType$4.methods = [{prop: "floatBits", name: "floatBits", pkg: "strconv", typ: $funcType([ptrType$1], [$Uint64, $Bool], false)}, {prop: "AssignComputeBounds", name: "AssignComputeBounds", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, ptrType$1], [extFloat, extFloat], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [$Uint], false)}, {prop: "Multiply", name: "Multiply", pkg: "", typ: $funcType([extFloat], [], false)}, {prop: "AssignDecimal", name: "AssignDecimal", pkg: "", typ: $funcType([$Uint64, $Int, $Bool, $Bool, ptrType$1], [$Bool], false)}, {prop: "frexp10", name: "frexp10", pkg: "strconv", typ: $funcType([], [$Int, $Int], false)}, {prop: "FixedDecimal", name: "FixedDecimal", pkg: "", typ: $funcType([ptrType$3, $Int], [$Bool], false)}, {prop: "ShortestDecimal", name: "ShortestDecimal", pkg: "", typ: $funcType([ptrType$3, ptrType$4, ptrType$4], [$Bool], false)}];
- NumError.init([{prop: "Func", name: "Func", pkg: "", typ: $String, tag: ""}, {prop: "Num", name: "Num", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]);
- decimal.init([{prop: "d", name: "d", pkg: "strconv", typ: arrayType$6, tag: ""}, {prop: "nd", name: "nd", pkg: "strconv", typ: $Int, tag: ""}, {prop: "dp", name: "dp", pkg: "strconv", typ: $Int, tag: ""}, {prop: "neg", name: "neg", pkg: "strconv", typ: $Bool, tag: ""}, {prop: "trunc", name: "trunc", pkg: "strconv", typ: $Bool, tag: ""}]);
- leftCheat.init([{prop: "delta", name: "delta", pkg: "strconv", typ: $Int, tag: ""}, {prop: "cutoff", name: "cutoff", pkg: "strconv", typ: $String, tag: ""}]);
- extFloat.init([{prop: "mant", name: "mant", pkg: "strconv", typ: $Uint64, tag: ""}, {prop: "exp", name: "exp", pkg: "strconv", typ: $Int, tag: ""}, {prop: "neg", name: "neg", pkg: "strconv", typ: $Bool, tag: ""}]);
- floatInfo.init([{prop: "mantbits", name: "mantbits", pkg: "strconv", typ: $Uint, tag: ""}, {prop: "expbits", name: "expbits", pkg: "strconv", typ: $Uint, tag: ""}, {prop: "bias", name: "bias", pkg: "strconv", typ: $Int, tag: ""}]);
- decimalSlice.init([{prop: "d", name: "d", pkg: "strconv", typ: sliceType$6, tag: ""}, {prop: "nd", name: "nd", pkg: "strconv", typ: $Int, tag: ""}, {prop: "dp", name: "dp", pkg: "strconv", typ: $Int, tag: ""}, {prop: "neg", name: "neg", pkg: "strconv", typ: $Bool, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- optimize = true;
- powtab = new sliceType([1, 3, 6, 9, 13, 16, 19, 23, 26]);
- float64pow10 = new sliceType$1([1, 10, 100, 1000, 10000, 100000, 1e+06, 1e+07, 1e+08, 1e+09, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 1e+21, 1e+22]);
- float32pow10 = new sliceType$2([1, 10, 100, 1000, 10000, 100000, 1e+06, 1e+07, 1e+08, 1e+09, 1e+10]);
- $pkg.ErrRange = errors.New("value out of range");
- $pkg.ErrSyntax = errors.New("invalid syntax");
- leftcheats = new sliceType$3([new leftCheat.ptr(0, ""), new leftCheat.ptr(1, "5"), new leftCheat.ptr(1, "25"), new leftCheat.ptr(1, "125"), new leftCheat.ptr(2, "625"), new leftCheat.ptr(2, "3125"), new leftCheat.ptr(2, "15625"), new leftCheat.ptr(3, "78125"), new leftCheat.ptr(3, "390625"), new leftCheat.ptr(3, "1953125"), new leftCheat.ptr(4, "9765625"), new leftCheat.ptr(4, "48828125"), new leftCheat.ptr(4, "244140625"), new leftCheat.ptr(4, "1220703125"), new leftCheat.ptr(5, "6103515625"), new leftCheat.ptr(5, "30517578125"), new leftCheat.ptr(5, "152587890625"), new leftCheat.ptr(6, "762939453125"), new leftCheat.ptr(6, "3814697265625"), new leftCheat.ptr(6, "19073486328125"), new leftCheat.ptr(7, "95367431640625"), new leftCheat.ptr(7, "476837158203125"), new leftCheat.ptr(7, "2384185791015625"), new leftCheat.ptr(7, "11920928955078125"), new leftCheat.ptr(8, "59604644775390625"), new leftCheat.ptr(8, "298023223876953125"), new leftCheat.ptr(8, "1490116119384765625"), new leftCheat.ptr(9, "7450580596923828125")]);
- smallPowersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(2147483648, 0), -63, false), new extFloat.ptr(new $Uint64(2684354560, 0), -60, false), new extFloat.ptr(new $Uint64(3355443200, 0), -57, false), new extFloat.ptr(new $Uint64(4194304000, 0), -54, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3276800000, 0), -47, false), new extFloat.ptr(new $Uint64(4096000000, 0), -44, false), new extFloat.ptr(new $Uint64(2560000000, 0), -40, false)]);
- powersOfTen = $toNativeArray($kindStruct, [new extFloat.ptr(new $Uint64(4203730336, 136053384), -1220, false), new extFloat.ptr(new $Uint64(3132023167, 2722021238), -1193, false), new extFloat.ptr(new $Uint64(2333539104, 810921078), -1166, false), new extFloat.ptr(new $Uint64(3477244234, 1573795306), -1140, false), new extFloat.ptr(new $Uint64(2590748842, 1432697645), -1113, false), new extFloat.ptr(new $Uint64(3860516611, 1025131999), -1087, false), new extFloat.ptr(new $Uint64(2876309015, 3348809418), -1060, false), new extFloat.ptr(new $Uint64(4286034428, 3200048207), -1034, false), new extFloat.ptr(new $Uint64(3193344495, 1097586188), -1007, false), new extFloat.ptr(new $Uint64(2379227053, 2424306748), -980, false), new extFloat.ptr(new $Uint64(3545324584, 827693699), -954, false), new extFloat.ptr(new $Uint64(2641472655, 2913388981), -927, false), new extFloat.ptr(new $Uint64(3936100983, 602835915), -901, false), new extFloat.ptr(new $Uint64(2932623761, 1081627501), -874, false), new extFloat.ptr(new $Uint64(2184974969, 1572261463), -847, false), new extFloat.ptr(new $Uint64(3255866422, 1308317239), -821, false), new extFloat.ptr(new $Uint64(2425809519, 944281679), -794, false), new extFloat.ptr(new $Uint64(3614737867, 629291719), -768, false), new extFloat.ptr(new $Uint64(2693189581, 2545915892), -741, false), new extFloat.ptr(new $Uint64(4013165208, 388672741), -715, false), new extFloat.ptr(new $Uint64(2990041083, 708162190), -688, false), new extFloat.ptr(new $Uint64(2227754207, 3536207675), -661, false), new extFloat.ptr(new $Uint64(3319612455, 450088378), -635, false), new extFloat.ptr(new $Uint64(2473304014, 3139815830), -608, false), new extFloat.ptr(new $Uint64(3685510180, 2103616900), -582, false), new extFloat.ptr(new $Uint64(2745919064, 224385782), -555, false), new extFloat.ptr(new $Uint64(4091738259, 3737383206), -529, false), new extFloat.ptr(new $Uint64(3048582568, 2868871352), -502, false), new extFloat.ptr(new $Uint64(2271371013, 1820084875), -475, false), new extFloat.ptr(new $Uint64(3384606560, 885076051), -449, false), new extFloat.ptr(new $Uint64(2521728396, 2444895829), -422, false), new extFloat.ptr(new $Uint64(3757668132, 1881767613), -396, false), new extFloat.ptr(new $Uint64(2799680927, 3102062735), -369, false), new extFloat.ptr(new $Uint64(4171849679, 2289335700), -343, false), new extFloat.ptr(new $Uint64(3108270227, 2410191823), -316, false), new extFloat.ptr(new $Uint64(2315841784, 3205436779), -289, false), new extFloat.ptr(new $Uint64(3450873173, 1697722806), -263, false), new extFloat.ptr(new $Uint64(2571100870, 3497754540), -236, false), new extFloat.ptr(new $Uint64(3831238852, 707476230), -210, false), new extFloat.ptr(new $Uint64(2854495385, 1769181907), -183, false), new extFloat.ptr(new $Uint64(4253529586, 2197867022), -157, false), new extFloat.ptr(new $Uint64(3169126500, 2450594539), -130, false), new extFloat.ptr(new $Uint64(2361183241, 1867548876), -103, false), new extFloat.ptr(new $Uint64(3518437208, 3793315116), -77, false), new extFloat.ptr(new $Uint64(2621440000, 0), -50, false), new extFloat.ptr(new $Uint64(3906250000, 0), -24, false), new extFloat.ptr(new $Uint64(2910383045, 2892103680), 3, false), new extFloat.ptr(new $Uint64(2168404344, 4170451332), 30, false), new extFloat.ptr(new $Uint64(3231174267, 3372684723), 56, false), new extFloat.ptr(new $Uint64(2407412430, 2078956656), 83, false), new extFloat.ptr(new $Uint64(3587324068, 2884206696), 109, false), new extFloat.ptr(new $Uint64(2672764710, 395977285), 136, false), new extFloat.ptr(new $Uint64(3982729777, 3569679143), 162, false), new extFloat.ptr(new $Uint64(2967364920, 2361961896), 189, false), new extFloat.ptr(new $Uint64(2210859150, 447440347), 216, false), new extFloat.ptr(new $Uint64(3294436857, 1114709402), 242, false), new extFloat.ptr(new $Uint64(2454546732, 2786846552), 269, false), new extFloat.ptr(new $Uint64(3657559652, 443583978), 295, false), new extFloat.ptr(new $Uint64(2725094297, 2599384906), 322, false), new extFloat.ptr(new $Uint64(4060706939, 3028118405), 348, false), new extFloat.ptr(new $Uint64(3025462433, 2044532855), 375, false), new extFloat.ptr(new $Uint64(2254145170, 1536935362), 402, false), new extFloat.ptr(new $Uint64(3358938053, 3365297469), 428, false), new extFloat.ptr(new $Uint64(2502603868, 4204241075), 455, false), new extFloat.ptr(new $Uint64(3729170365, 2577424355), 481, false), new extFloat.ptr(new $Uint64(2778448436, 3677981733), 508, false), new extFloat.ptr(new $Uint64(4140210802, 2744688476), 534, false), new extFloat.ptr(new $Uint64(3084697427, 1424604878), 561, false), new extFloat.ptr(new $Uint64(2298278679, 4062331362), 588, false), new extFloat.ptr(new $Uint64(3424702107, 3546052773), 614, false), new extFloat.ptr(new $Uint64(2551601907, 2065781727), 641, false), new extFloat.ptr(new $Uint64(3802183132, 2535403578), 667, false), new extFloat.ptr(new $Uint64(2832847187, 1558426518), 694, false), new extFloat.ptr(new $Uint64(4221271257, 2762425404), 720, false), new extFloat.ptr(new $Uint64(3145092172, 2812560400), 747, false), new extFloat.ptr(new $Uint64(2343276271, 3057687578), 774, false), new extFloat.ptr(new $Uint64(3491753744, 2790753324), 800, false), new extFloat.ptr(new $Uint64(2601559269, 3918606633), 827, false), new extFloat.ptr(new $Uint64(3876625403, 2711358621), 853, false), new extFloat.ptr(new $Uint64(2888311001, 1648096297), 880, false), new extFloat.ptr(new $Uint64(2151959390, 2057817989), 907, false), new extFloat.ptr(new $Uint64(3206669376, 61660461), 933, false), new extFloat.ptr(new $Uint64(2389154863, 1581580175), 960, false), new extFloat.ptr(new $Uint64(3560118173, 2626467905), 986, false), new extFloat.ptr(new $Uint64(2652494738, 3034782633), 1013, false), new extFloat.ptr(new $Uint64(3952525166, 3135207385), 1039, false), new extFloat.ptr(new $Uint64(2944860731, 2616258155), 1066, false)]);
- uint64pow10 = $toNativeArray($kindUint64, [new $Uint64(0, 1), new $Uint64(0, 10), new $Uint64(0, 100), new $Uint64(0, 1000), new $Uint64(0, 10000), new $Uint64(0, 100000), new $Uint64(0, 1000000), new $Uint64(0, 10000000), new $Uint64(0, 100000000), new $Uint64(0, 1000000000), new $Uint64(2, 1410065408), new $Uint64(23, 1215752192), new $Uint64(232, 3567587328), new $Uint64(2328, 1316134912), new $Uint64(23283, 276447232), new $Uint64(232830, 2764472320), new $Uint64(2328306, 1874919424), new $Uint64(23283064, 1569325056), new $Uint64(232830643, 2808348672), new $Uint64(2328306436, 2313682944)]);
- float32info = new floatInfo.ptr(23, 8, -127);
- float64info = new floatInfo.ptr(52, 11, -1023);
- isPrint16 = new sliceType$4([32, 126, 161, 887, 890, 895, 900, 1366, 1369, 1418, 1421, 1479, 1488, 1514, 1520, 1524, 1542, 1563, 1566, 1805, 1808, 1866, 1869, 1969, 1984, 2042, 2048, 2093, 2096, 2139, 2142, 2142, 2208, 2226, 2276, 2444, 2447, 2448, 2451, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2531, 2534, 2555, 2561, 2570, 2575, 2576, 2579, 2617, 2620, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2654, 2662, 2677, 2689, 2745, 2748, 2765, 2768, 2768, 2784, 2787, 2790, 2801, 2817, 2828, 2831, 2832, 2835, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2915, 2918, 2935, 2946, 2954, 2958, 2965, 2969, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3021, 3024, 3024, 3031, 3031, 3046, 3066, 3072, 3129, 3133, 3149, 3157, 3161, 3168, 3171, 3174, 3183, 3192, 3257, 3260, 3277, 3285, 3286, 3294, 3299, 3302, 3314, 3329, 3386, 3389, 3406, 3415, 3415, 3424, 3427, 3430, 3445, 3449, 3455, 3458, 3478, 3482, 3517, 3520, 3526, 3530, 3530, 3535, 3551, 3558, 3567, 3570, 3572, 3585, 3642, 3647, 3675, 3713, 3716, 3719, 3722, 3725, 3725, 3732, 3751, 3754, 3773, 3776, 3789, 3792, 3801, 3804, 3807, 3840, 3948, 3953, 4058, 4096, 4295, 4301, 4301, 4304, 4685, 4688, 4701, 4704, 4749, 4752, 4789, 4792, 4805, 4808, 4885, 4888, 4954, 4957, 4988, 4992, 5017, 5024, 5108, 5120, 5788, 5792, 5880, 5888, 5908, 5920, 5942, 5952, 5971, 5984, 6003, 6016, 6109, 6112, 6121, 6128, 6137, 6144, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6443, 6448, 6459, 6464, 6464, 6468, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6622, 6683, 6686, 6780, 6783, 6793, 6800, 6809, 6816, 6829, 6832, 6846, 6912, 6987, 6992, 7036, 7040, 7155, 7164, 7223, 7227, 7241, 7245, 7295, 7360, 7367, 7376, 7417, 7424, 7669, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8061, 8064, 8147, 8150, 8175, 8178, 8190, 8208, 8231, 8240, 8286, 8304, 8305, 8308, 8348, 8352, 8381, 8400, 8432, 8448, 8585, 8592, 9210, 9216, 9254, 9280, 9290, 9312, 11123, 11126, 11157, 11160, 11193, 11197, 11217, 11264, 11507, 11513, 11559, 11565, 11565, 11568, 11623, 11631, 11632, 11647, 11670, 11680, 11842, 11904, 12019, 12032, 12245, 12272, 12283, 12289, 12438, 12441, 12543, 12549, 12589, 12593, 12730, 12736, 12771, 12784, 19893, 19904, 40908, 40960, 42124, 42128, 42182, 42192, 42539, 42560, 42743, 42752, 42925, 42928, 42929, 42999, 43051, 43056, 43065, 43072, 43127, 43136, 43204, 43214, 43225, 43232, 43259, 43264, 43347, 43359, 43388, 43392, 43481, 43486, 43574, 43584, 43597, 43600, 43609, 43612, 43714, 43739, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43871, 43876, 43877, 43968, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64449, 64467, 64831, 64848, 64911, 64914, 64967, 65008, 65021, 65024, 65049, 65056, 65069, 65072, 65131, 65136, 65276, 65281, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65504, 65518, 65532, 65533]);
- isNotPrint16 = new sliceType$4([173, 907, 909, 930, 1328, 1376, 1416, 1424, 1757, 2111, 2436, 2473, 2481, 2526, 2564, 2601, 2609, 2612, 2615, 2621, 2653, 2692, 2702, 2706, 2729, 2737, 2740, 2758, 2762, 2820, 2857, 2865, 2868, 2910, 2948, 2961, 2971, 2973, 3017, 3076, 3085, 3089, 3113, 3141, 3145, 3159, 3200, 3204, 3213, 3217, 3241, 3252, 3269, 3273, 3295, 3312, 3332, 3341, 3345, 3397, 3401, 3460, 3506, 3516, 3541, 3543, 3715, 3721, 3736, 3744, 3748, 3750, 3756, 3770, 3781, 3783, 3912, 3992, 4029, 4045, 4294, 4681, 4695, 4697, 4745, 4785, 4799, 4801, 4823, 4881, 5760, 5901, 5997, 6001, 6431, 6751, 7415, 8024, 8026, 8028, 8030, 8117, 8133, 8156, 8181, 8335, 11209, 11311, 11359, 11558, 11687, 11695, 11703, 11711, 11719, 11727, 11735, 11743, 11930, 12352, 12687, 12831, 13055, 42654, 42895, 43470, 43519, 43815, 43823, 64311, 64317, 64319, 64322, 64325, 65107, 65127, 65141, 65511]);
- isPrint32 = new sliceType$5([65536, 65613, 65616, 65629, 65664, 65786, 65792, 65794, 65799, 65843, 65847, 65932, 65936, 65947, 65952, 65952, 66000, 66045, 66176, 66204, 66208, 66256, 66272, 66299, 66304, 66339, 66352, 66378, 66384, 66426, 66432, 66499, 66504, 66517, 66560, 66717, 66720, 66729, 66816, 66855, 66864, 66915, 66927, 66927, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67640, 67644, 67644, 67647, 67742, 67751, 67759, 67840, 67867, 67871, 67897, 67903, 67903, 67968, 68023, 68030, 68031, 68096, 68102, 68108, 68147, 68152, 68154, 68159, 68167, 68176, 68184, 68192, 68255, 68288, 68326, 68331, 68342, 68352, 68405, 68409, 68437, 68440, 68466, 68472, 68497, 68505, 68508, 68521, 68527, 68608, 68680, 69216, 69246, 69632, 69709, 69714, 69743, 69759, 69825, 69840, 69864, 69872, 69881, 69888, 69955, 69968, 70006, 70016, 70088, 70093, 70093, 70096, 70106, 70113, 70132, 70144, 70205, 70320, 70378, 70384, 70393, 70401, 70412, 70415, 70416, 70419, 70457, 70460, 70468, 70471, 70472, 70475, 70477, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70784, 70855, 70864, 70873, 71040, 71093, 71096, 71113, 71168, 71236, 71248, 71257, 71296, 71351, 71360, 71369, 71840, 71922, 71935, 71935, 72384, 72440, 73728, 74648, 74752, 74868, 77824, 78894, 92160, 92728, 92736, 92777, 92782, 92783, 92880, 92909, 92912, 92917, 92928, 92997, 93008, 93047, 93053, 93071, 93952, 94020, 94032, 94078, 94095, 94111, 110592, 110593, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113820, 113823, 118784, 119029, 119040, 119078, 119081, 119154, 119163, 119261, 119296, 119365, 119552, 119638, 119648, 119665, 119808, 119967, 119970, 119970, 119973, 119974, 119977, 120074, 120077, 120134, 120138, 120485, 120488, 120779, 120782, 120831, 124928, 125124, 125127, 125142, 126464, 126500, 126503, 126523, 126530, 126530, 126535, 126548, 126551, 126564, 126567, 126619, 126625, 126651, 126704, 126705, 126976, 127019, 127024, 127123, 127136, 127150, 127153, 127221, 127232, 127244, 127248, 127339, 127344, 127386, 127462, 127490, 127504, 127546, 127552, 127560, 127568, 127569, 127744, 127788, 127792, 127869, 127872, 127950, 127956, 127991, 128000, 128330, 128336, 128578, 128581, 128719, 128736, 128748, 128752, 128755, 128768, 128883, 128896, 128980, 129024, 129035, 129040, 129095, 129104, 129113, 129120, 129159, 129168, 129197, 131072, 173782, 173824, 177972, 177984, 178205, 194560, 195101, 917760, 917999]);
- isNotPrint32 = new sliceType$4([12, 39, 59, 62, 926, 2057, 2102, 2134, 2564, 2580, 2584, 4285, 4405, 4626, 4868, 4905, 4913, 4916, 9327, 27231, 27482, 27490, 54357, 54429, 54445, 54458, 54460, 54468, 54534, 54549, 54557, 54586, 54591, 54597, 54609, 60932, 60960, 60963, 60968, 60979, 60984, 60986, 61000, 61002, 61004, 61008, 61011, 61016, 61018, 61020, 61022, 61024, 61027, 61035, 61043, 61048, 61053, 61055, 61066, 61092, 61098, 61632, 61648, 61743, 62719, 62842, 62884]);
- shifts = $toNativeArray($kindUint, [0, 0, 1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0]);
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["reflect"] = (function() {
- var $pkg = {}, $init, js, math, runtime, strconv, sync, mapIter, Type, Kind, rtype, typeAlg, method, uncommonType, ChanDir, arrayType, chanType, funcType, imethod, interfaceType, mapType, ptrType, sliceType, structField, structType, Method, StructField, StructTag, fieldScan, Value, flag, ValueError, nonEmptyInterface, ptrType$1, sliceType$1, ptrType$3, funcType$1, sliceType$2, ptrType$4, arrayType$1, ptrType$5, ptrType$6, sliceType$3, sliceType$4, sliceType$5, sliceType$6, structType$5, sliceType$7, ptrType$7, arrayType$2, structType$6, ptrType$8, sliceType$8, ptrType$9, sliceType$9, ptrType$10, ptrType$11, ptrType$12, sliceType$11, sliceType$12, ptrType$13, ptrType$18, sliceType$14, sliceType$15, funcType$3, funcType$4, funcType$5, arrayType$3, ptrType$21, initialized, stringPtrMap, callHelper, jsObjectPtr, selectHelper, kindNames, uint8Type, init, jsType, reflectType, setKindType, newStringPtr, isWrapped, copyStruct, makeValue, MakeSlice, TypeOf, ValueOf, SliceOf, Zero, unsafe_New, makeInt, memmove, makemap, mapaccess, mapassign, mapdelete, mapiterinit, mapiterkey, mapiternext, maplen, cvtDirect, Copy, methodReceiver, valueInterface, ifaceE2I, methodName, makeMethodValue, wrapJsObject, unwrapJsObject, getJsTag, chanrecv, chansend, PtrTo, implements$1, directlyAssignable, haveIdenticalUnderlyingType, toType, ifaceIndir, overflowFloat32, typesMustMatch, MakeMap, Indirect, New, convertOp, makeFloat, makeComplex, makeString, makeBytes, makeRunes, cvtInt, cvtUint, cvtFloatInt, cvtFloatUint, cvtIntFloat, cvtUintFloat, cvtFloat, cvtComplex, cvtIntString, cvtUintString, cvtBytesString, cvtStringBytes, cvtRunesString, cvtStringRunes, cvtT2I, cvtI2I;
- js = $packages["github.com/gopherjs/gopherjs/js"];
- math = $packages["math"];
- runtime = $packages["runtime"];
- strconv = $packages["strconv"];
- sync = $packages["sync"];
- mapIter = $pkg.mapIter = $newType(0, $kindStruct, "reflect.mapIter", "mapIter", "reflect", function(t_, m_, keys_, i_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.t = $ifaceNil;
- this.m = null;
- this.keys = null;
- this.i = 0;
- return;
- }
- this.t = t_;
- this.m = m_;
- this.keys = keys_;
- this.i = i_;
- });
- Type = $pkg.Type = $newType(8, $kindInterface, "reflect.Type", "Type", "reflect", null);
- Kind = $pkg.Kind = $newType(4, $kindUint, "reflect.Kind", "Kind", "reflect", null);
- rtype = $pkg.rtype = $newType(0, $kindStruct, "reflect.rtype", "rtype", "reflect", function(size_, hash_, _$2_, align_, fieldAlign_, kind_, alg_, gc_, string_, uncommonType_, ptrToThis_, zero_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.size = 0;
- this.hash = 0;
- this._$2 = 0;
- this.align = 0;
- this.fieldAlign = 0;
- this.kind = 0;
- this.alg = ptrType$4.nil;
- this.gc = arrayType$1.zero();
- this.string = ptrType$5.nil;
- this.uncommonType = ptrType$6.nil;
- this.ptrToThis = ptrType$1.nil;
- this.zero = 0;
- return;
- }
- this.size = size_;
- this.hash = hash_;
- this._$2 = _$2_;
- this.align = align_;
- this.fieldAlign = fieldAlign_;
- this.kind = kind_;
- this.alg = alg_;
- this.gc = gc_;
- this.string = string_;
- this.uncommonType = uncommonType_;
- this.ptrToThis = ptrToThis_;
- this.zero = zero_;
- });
- typeAlg = $pkg.typeAlg = $newType(0, $kindStruct, "reflect.typeAlg", "typeAlg", "reflect", function(hash_, equal_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.hash = $throwNilPointerError;
- this.equal = $throwNilPointerError;
- return;
- }
- this.hash = hash_;
- this.equal = equal_;
- });
- method = $pkg.method = $newType(0, $kindStruct, "reflect.method", "method", "reflect", function(name_, pkgPath_, mtyp_, typ_, ifn_, tfn_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = ptrType$5.nil;
- this.pkgPath = ptrType$5.nil;
- this.mtyp = ptrType$1.nil;
- this.typ = ptrType$1.nil;
- this.ifn = 0;
- this.tfn = 0;
- return;
- }
- this.name = name_;
- this.pkgPath = pkgPath_;
- this.mtyp = mtyp_;
- this.typ = typ_;
- this.ifn = ifn_;
- this.tfn = tfn_;
- });
- uncommonType = $pkg.uncommonType = $newType(0, $kindStruct, "reflect.uncommonType", "uncommonType", "reflect", function(name_, pkgPath_, methods_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = ptrType$5.nil;
- this.pkgPath = ptrType$5.nil;
- this.methods = sliceType$3.nil;
- return;
- }
- this.name = name_;
- this.pkgPath = pkgPath_;
- this.methods = methods_;
- });
- ChanDir = $pkg.ChanDir = $newType(4, $kindInt, "reflect.ChanDir", "ChanDir", "reflect", null);
- arrayType = $pkg.arrayType = $newType(0, $kindStruct, "reflect.arrayType", "arrayType", "reflect", function(rtype_, elem_, slice_, len_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.elem = ptrType$1.nil;
- this.slice = ptrType$1.nil;
- this.len = 0;
- return;
- }
- this.rtype = rtype_;
- this.elem = elem_;
- this.slice = slice_;
- this.len = len_;
- });
- chanType = $pkg.chanType = $newType(0, $kindStruct, "reflect.chanType", "chanType", "reflect", function(rtype_, elem_, dir_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.elem = ptrType$1.nil;
- this.dir = 0;
- return;
- }
- this.rtype = rtype_;
- this.elem = elem_;
- this.dir = dir_;
- });
- funcType = $pkg.funcType = $newType(0, $kindStruct, "reflect.funcType", "funcType", "reflect", function(rtype_, dotdotdot_, in$2_, out_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.dotdotdot = false;
- this.in$2 = sliceType$4.nil;
- this.out = sliceType$4.nil;
- return;
- }
- this.rtype = rtype_;
- this.dotdotdot = dotdotdot_;
- this.in$2 = in$2_;
- this.out = out_;
- });
- imethod = $pkg.imethod = $newType(0, $kindStruct, "reflect.imethod", "imethod", "reflect", function(name_, pkgPath_, typ_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = ptrType$5.nil;
- this.pkgPath = ptrType$5.nil;
- this.typ = ptrType$1.nil;
- return;
- }
- this.name = name_;
- this.pkgPath = pkgPath_;
- this.typ = typ_;
- });
- interfaceType = $pkg.interfaceType = $newType(0, $kindStruct, "reflect.interfaceType", "interfaceType", "reflect", function(rtype_, methods_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.methods = sliceType$5.nil;
- return;
- }
- this.rtype = rtype_;
- this.methods = methods_;
- });
- mapType = $pkg.mapType = $newType(0, $kindStruct, "reflect.mapType", "mapType", "reflect", function(rtype_, key_, elem_, bucket_, hmap_, keysize_, indirectkey_, valuesize_, indirectvalue_, bucketsize_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.key = ptrType$1.nil;
- this.elem = ptrType$1.nil;
- this.bucket = ptrType$1.nil;
- this.hmap = ptrType$1.nil;
- this.keysize = 0;
- this.indirectkey = 0;
- this.valuesize = 0;
- this.indirectvalue = 0;
- this.bucketsize = 0;
- return;
- }
- this.rtype = rtype_;
- this.key = key_;
- this.elem = elem_;
- this.bucket = bucket_;
- this.hmap = hmap_;
- this.keysize = keysize_;
- this.indirectkey = indirectkey_;
- this.valuesize = valuesize_;
- this.indirectvalue = indirectvalue_;
- this.bucketsize = bucketsize_;
- });
- ptrType = $pkg.ptrType = $newType(0, $kindStruct, "reflect.ptrType", "ptrType", "reflect", function(rtype_, elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.elem = ptrType$1.nil;
- return;
- }
- this.rtype = rtype_;
- this.elem = elem_;
- });
- sliceType = $pkg.sliceType = $newType(0, $kindStruct, "reflect.sliceType", "sliceType", "reflect", function(rtype_, elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.elem = ptrType$1.nil;
- return;
- }
- this.rtype = rtype_;
- this.elem = elem_;
- });
- structField = $pkg.structField = $newType(0, $kindStruct, "reflect.structField", "structField", "reflect", function(name_, pkgPath_, typ_, tag_, offset_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = ptrType$5.nil;
- this.pkgPath = ptrType$5.nil;
- this.typ = ptrType$1.nil;
- this.tag = ptrType$5.nil;
- this.offset = 0;
- return;
- }
- this.name = name_;
- this.pkgPath = pkgPath_;
- this.typ = typ_;
- this.tag = tag_;
- this.offset = offset_;
- });
- structType = $pkg.structType = $newType(0, $kindStruct, "reflect.structType", "structType", "reflect", function(rtype_, fields_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rtype = new rtype.ptr();
- this.fields = sliceType$6.nil;
- return;
- }
- this.rtype = rtype_;
- this.fields = fields_;
- });
- Method = $pkg.Method = $newType(0, $kindStruct, "reflect.Method", "Method", "reflect", function(Name_, PkgPath_, Type_, Func_, Index_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Name = "";
- this.PkgPath = "";
- this.Type = $ifaceNil;
- this.Func = new Value.ptr();
- this.Index = 0;
- return;
- }
- this.Name = Name_;
- this.PkgPath = PkgPath_;
- this.Type = Type_;
- this.Func = Func_;
- this.Index = Index_;
- });
- StructField = $pkg.StructField = $newType(0, $kindStruct, "reflect.StructField", "StructField", "reflect", function(Name_, PkgPath_, Type_, Tag_, Offset_, Index_, Anonymous_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Name = "";
- this.PkgPath = "";
- this.Type = $ifaceNil;
- this.Tag = "";
- this.Offset = 0;
- this.Index = sliceType$11.nil;
- this.Anonymous = false;
- return;
- }
- this.Name = Name_;
- this.PkgPath = PkgPath_;
- this.Type = Type_;
- this.Tag = Tag_;
- this.Offset = Offset_;
- this.Index = Index_;
- this.Anonymous = Anonymous_;
- });
- StructTag = $pkg.StructTag = $newType(8, $kindString, "reflect.StructTag", "StructTag", "reflect", null);
- fieldScan = $pkg.fieldScan = $newType(0, $kindStruct, "reflect.fieldScan", "fieldScan", "reflect", function(typ_, index_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.typ = ptrType$13.nil;
- this.index = sliceType$11.nil;
- return;
- }
- this.typ = typ_;
- this.index = index_;
- });
- Value = $pkg.Value = $newType(0, $kindStruct, "reflect.Value", "Value", "reflect", function(typ_, ptr_, flag_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.typ = ptrType$1.nil;
- this.ptr = 0;
- this.flag = 0;
- return;
- }
- this.typ = typ_;
- this.ptr = ptr_;
- this.flag = flag_;
- });
- flag = $pkg.flag = $newType(4, $kindUintptr, "reflect.flag", "flag", "reflect", null);
- ValueError = $pkg.ValueError = $newType(0, $kindStruct, "reflect.ValueError", "ValueError", "reflect", function(Method_, Kind_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Method = "";
- this.Kind = 0;
- return;
- }
- this.Method = Method_;
- this.Kind = Kind_;
- });
- nonEmptyInterface = $pkg.nonEmptyInterface = $newType(0, $kindStruct, "reflect.nonEmptyInterface", "nonEmptyInterface", "reflect", function(itab_, word_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.itab = ptrType$8.nil;
- this.word = 0;
- return;
- }
- this.itab = itab_;
- this.word = word_;
- });
- ptrType$1 = $ptrType(rtype);
- sliceType$1 = $sliceType($emptyInterface);
- ptrType$3 = $ptrType(js.Object);
- funcType$1 = $funcType([sliceType$1], [ptrType$3], true);
- sliceType$2 = $sliceType($String);
- ptrType$4 = $ptrType(typeAlg);
- arrayType$1 = $arrayType($UnsafePointer, 2);
- ptrType$5 = $ptrType($String);
- ptrType$6 = $ptrType(uncommonType);
- sliceType$3 = $sliceType(method);
- sliceType$4 = $sliceType(ptrType$1);
- sliceType$5 = $sliceType(imethod);
- sliceType$6 = $sliceType(structField);
- structType$5 = $structType([{prop: "str", name: "str", pkg: "reflect", typ: $String, tag: ""}]);
- sliceType$7 = $sliceType(Value);
- ptrType$7 = $ptrType(nonEmptyInterface);
- arrayType$2 = $arrayType($UnsafePointer, 100000);
- structType$6 = $structType([{prop: "ityp", name: "ityp", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "link", name: "link", pkg: "reflect", typ: $UnsafePointer, tag: ""}, {prop: "bad", name: "bad", pkg: "reflect", typ: $Int32, tag: ""}, {prop: "unused", name: "unused", pkg: "reflect", typ: $Int32, tag: ""}, {prop: "fun", name: "fun", pkg: "reflect", typ: arrayType$2, tag: ""}]);
- ptrType$8 = $ptrType(structType$6);
- sliceType$8 = $sliceType(ptrType$3);
- ptrType$9 = $ptrType($Uint8);
- sliceType$9 = $sliceType(sliceType$1);
- ptrType$10 = $ptrType(method);
- ptrType$11 = $ptrType(interfaceType);
- ptrType$12 = $ptrType(imethod);
- sliceType$11 = $sliceType($Int);
- sliceType$12 = $sliceType(fieldScan);
- ptrType$13 = $ptrType(structType);
- ptrType$18 = $ptrType($UnsafePointer);
- sliceType$14 = $sliceType($Uint8);
- sliceType$15 = $sliceType($Int32);
- funcType$3 = $funcType([$String], [$Bool], false);
- funcType$4 = $funcType([$UnsafePointer, $Uintptr, $Uintptr], [$Uintptr], false);
- funcType$5 = $funcType([$UnsafePointer, $UnsafePointer, $Uintptr], [$Bool], false);
- arrayType$3 = $arrayType($Uintptr, 2);
- ptrType$21 = $ptrType(ValueError);
- init = function() {
- var $ptr, used, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; used = $f.used; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- used = (function(i) {
- var $ptr, i;
- });
- $r = used((x = new rtype.ptr(0, 0, 0, 0, 0, 0, ptrType$4.nil, arrayType$1.zero(), ptrType$5.nil, ptrType$6.nil, ptrType$1.nil, 0), new x.constructor.elem(x))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$1 = new uncommonType.ptr(ptrType$5.nil, ptrType$5.nil, sliceType$3.nil), new x$1.constructor.elem(x$1))); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$2 = new method.ptr(ptrType$5.nil, ptrType$5.nil, ptrType$1.nil, ptrType$1.nil, 0, 0), new x$2.constructor.elem(x$2))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$3 = new arrayType.ptr(new rtype.ptr(), ptrType$1.nil, ptrType$1.nil, 0), new x$3.constructor.elem(x$3))); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$4 = new chanType.ptr(new rtype.ptr(), ptrType$1.nil, 0), new x$4.constructor.elem(x$4))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$5 = new funcType.ptr(new rtype.ptr(), false, sliceType$4.nil, sliceType$4.nil), new x$5.constructor.elem(x$5))); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$6 = new interfaceType.ptr(new rtype.ptr(), sliceType$5.nil), new x$6.constructor.elem(x$6))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$7 = new mapType.ptr(new rtype.ptr(), ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0, 0), new x$7.constructor.elem(x$7))); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$8 = new ptrType.ptr(new rtype.ptr(), ptrType$1.nil), new x$8.constructor.elem(x$8))); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$9 = new sliceType.ptr(new rtype.ptr(), ptrType$1.nil), new x$9.constructor.elem(x$9))); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$10 = new structType.ptr(new rtype.ptr(), sliceType$6.nil), new x$10.constructor.elem(x$10))); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$11 = new imethod.ptr(ptrType$5.nil, ptrType$5.nil, ptrType$1.nil), new x$11.constructor.elem(x$11))); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = used((x$12 = new structField.ptr(ptrType$5.nil, ptrType$5.nil, ptrType$1.nil, ptrType$5.nil, 0), new x$12.constructor.elem(x$12))); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- initialized = true;
- uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: init }; } $f.$ptr = $ptr; $f.used = used; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f;
- };
- jsType = function(typ) {
- var $ptr, typ;
- return typ.jsType;
- };
- reflectType = function(typ) {
- var $ptr, _i, _i$1, _i$2, _i$3, _i$4, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, dir, f, fields, i, i$1, i$2, i$3, i$4, imethods, in$1, m, m$1, methodSet, methods, out, params, reflectFields, reflectMethods, results, rt, t, typ;
- if (typ.reflectType === undefined) {
- rt = new rtype.ptr((($parseInt(typ.size) >> 0) >>> 0), 0, 0, 0, 0, (($parseInt(typ.kind) >> 0) << 24 >>> 24), ptrType$4.nil, arrayType$1.zero(), newStringPtr(typ.string), ptrType$6.nil, ptrType$1.nil, 0);
- rt.jsType = typ;
- typ.reflectType = rt;
- methodSet = $methodSet(typ);
- if (!($internalize(typ.typeName, $String) === "") || !(($parseInt(methodSet.length) === 0))) {
- reflectMethods = $makeSlice(sliceType$3, $parseInt(methodSet.length));
- _ref = reflectMethods;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- m = methodSet[i];
- t = m.typ;
- $copy(((i < 0 || i >= reflectMethods.$length) ? $throwRuntimeError("index out of range") : reflectMethods.$array[reflectMethods.$offset + i]), new method.ptr(newStringPtr(m.name), newStringPtr(m.pkg), reflectType(t), reflectType($funcType(new ($global.Array)(typ).concat(t.params), t.results, t.variadic)), 0, 0), method);
- _i++;
- }
- rt.uncommonType = new uncommonType.ptr(newStringPtr(typ.typeName), newStringPtr(typ.pkg), reflectMethods);
- rt.uncommonType.jsType = typ;
- }
- _ref$1 = rt.Kind();
- if (_ref$1 === 17) {
- setKindType(rt, new arrayType.ptr(new rtype.ptr(), reflectType(typ.elem), ptrType$1.nil, (($parseInt(typ.len) >> 0) >>> 0)));
- } else if (_ref$1 === 18) {
- dir = 3;
- if (!!(typ.sendOnly)) {
- dir = 2;
- }
- if (!!(typ.recvOnly)) {
- dir = 1;
- }
- setKindType(rt, new chanType.ptr(new rtype.ptr(), reflectType(typ.elem), (dir >>> 0)));
- } else if (_ref$1 === 19) {
- params = typ.params;
- in$1 = $makeSlice(sliceType$4, $parseInt(params.length));
- _ref$2 = in$1;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$2.$length)) { break; }
- i$1 = _i$1;
- ((i$1 < 0 || i$1 >= in$1.$length) ? $throwRuntimeError("index out of range") : in$1.$array[in$1.$offset + i$1] = reflectType(params[i$1]));
- _i$1++;
- }
- results = typ.results;
- out = $makeSlice(sliceType$4, $parseInt(results.length));
- _ref$3 = out;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$3.$length)) { break; }
- i$2 = _i$2;
- ((i$2 < 0 || i$2 >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i$2] = reflectType(results[i$2]));
- _i$2++;
- }
- setKindType(rt, new funcType.ptr($clone(rt, rtype), !!(typ.variadic), in$1, out));
- } else if (_ref$1 === 20) {
- methods = typ.methods;
- imethods = $makeSlice(sliceType$5, $parseInt(methods.length));
- _ref$4 = imethods;
- _i$3 = 0;
- while (true) {
- if (!(_i$3 < _ref$4.$length)) { break; }
- i$3 = _i$3;
- m$1 = methods[i$3];
- $copy(((i$3 < 0 || i$3 >= imethods.$length) ? $throwRuntimeError("index out of range") : imethods.$array[imethods.$offset + i$3]), new imethod.ptr(newStringPtr(m$1.name), newStringPtr(m$1.pkg), reflectType(m$1.typ)), imethod);
- _i$3++;
- }
- setKindType(rt, new interfaceType.ptr($clone(rt, rtype), imethods));
- } else if (_ref$1 === 21) {
- setKindType(rt, new mapType.ptr(new rtype.ptr(), reflectType(typ.key), reflectType(typ.elem), ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0, 0));
- } else if (_ref$1 === 22) {
- setKindType(rt, new ptrType.ptr(new rtype.ptr(), reflectType(typ.elem)));
- } else if (_ref$1 === 23) {
- setKindType(rt, new sliceType.ptr(new rtype.ptr(), reflectType(typ.elem)));
- } else if (_ref$1 === 25) {
- fields = typ.fields;
- reflectFields = $makeSlice(sliceType$6, $parseInt(fields.length));
- _ref$5 = reflectFields;
- _i$4 = 0;
- while (true) {
- if (!(_i$4 < _ref$5.$length)) { break; }
- i$4 = _i$4;
- f = fields[i$4];
- $copy(((i$4 < 0 || i$4 >= reflectFields.$length) ? $throwRuntimeError("index out of range") : reflectFields.$array[reflectFields.$offset + i$4]), new structField.ptr(newStringPtr(f.name), newStringPtr(f.pkg), reflectType(f.typ), newStringPtr(f.tag), (i$4 >>> 0)), structField);
- _i$4++;
- }
- setKindType(rt, new structType.ptr($clone(rt, rtype), reflectFields));
- }
- }
- return typ.reflectType;
- };
- setKindType = function(rt, kindType) {
- var $ptr, kindType, rt;
- rt.kindType = kindType;
- kindType.rtype = rt;
- };
- newStringPtr = function(strObj) {
- var $ptr, _entry, _key, _tuple, c, nonAsciiName, ok, ptr, str, strObj;
- c = $clone(new structType$5.ptr(), structType$5);
- c.str = strObj;
- str = c.str;
- if (str === "") {
- return ptrType$5.nil;
- }
- _tuple = (_entry = stringPtrMap[$String.keyFor(str)], _entry !== undefined ? [_entry.v, true] : [ptrType$5.nil, false]); ptr = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- ptr = (nonAsciiName || (nonAsciiName = new ptrType$5(function() { return str; }, function($v) { str = $v; })));
- _key = str; (stringPtrMap || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: ptr };
- }
- return ptr;
- };
- isWrapped = function(typ) {
- var $ptr, _r, _r$1, _r$2, _ref, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Kind(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if (_ref === 1 || _ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 12 || _ref === 13 || _ref === 14 || _ref === 17 || _ref === 21 || _ref === 19 || _ref === 24 || _ref === 25) { $s = 2; continue; }
- /* */ if (_ref === 22) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_ref === 1 || _ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 12 || _ref === 13 || _ref === 14 || _ref === 17 || _ref === 21 || _ref === 19 || _ref === 24 || _ref === 25) { */ case 2:
- return true;
- $s = 4; continue;
- /* } else if (_ref === 22) { */ case 3:
- _r$1 = typ.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = _r$1.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2 === 17;
- /* } */ case 4:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isWrapped }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- copyStruct = function(dst, src, typ) {
- var $ptr, dst, fields, i, prop, src, typ;
- fields = jsType(typ).fields;
- i = 0;
- while (true) {
- if (!(i < $parseInt(fields.length))) { break; }
- prop = $internalize(fields[i].prop, $String);
- dst[$externalize(prop, $String)] = src[$externalize(prop, $String)];
- i = i + (1) >> 0;
- }
- };
- makeValue = function(t, v, fl) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _v, _v$1, fl, rt, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _v = $f._v; _v$1 = $f._v$1; fl = $f.fl; rt = $f.rt; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- rt = _r;
- _r$1 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- if (_r$1 === 17) { _v$1 = true; $s = 5; continue s; }
- _r$2 = t.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v$1 = _r$2 === 25; case 5:
- if (_v$1) { _v = true; $s = 4; continue s; }
- _r$3 = t.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v = _r$3 === 22; case 4:
- /* */ if (_v) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_v) { */ case 2:
- _r$4 = t.Kind(); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return new Value.ptr(rt, v, (fl | (_r$4 >>> 0)) >>> 0);
- /* } */ case 3:
- _r$5 = t.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return new Value.ptr(rt, $newDataPointer(v, jsType(rt.ptrTo())), (((fl | (_r$5 >>> 0)) >>> 0) | 64) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeValue }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._v = _v; $f._v$1 = _v$1; $f.fl = fl; $f.rt = rt; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- MakeSlice = function(typ, len, cap) {
- var $ptr, _r, _r$1, cap, len, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; cap = $f.cap; len = $f.len; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- typ = [typ];
- _r = typ[0].Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!((_r === 23))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r === 23))) { */ case 1:
- $panic(new $String("reflect.MakeSlice of non-slice type"));
- /* } */ case 2:
- if (len < 0) {
- $panic(new $String("reflect.MakeSlice: negative len"));
- }
- if (cap < 0) {
- $panic(new $String("reflect.MakeSlice: negative cap"));
- }
- if (len > cap) {
- $panic(new $String("reflect.MakeSlice: len > cap"));
- }
- _r$1 = makeValue(typ[0], $makeSlice(jsType(typ[0]), len, cap, (function(typ) { return function $b() {
- var $ptr, _r$1, _r$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$1 = typ[0].Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = jsType(_r$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2.zero();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.$s = $s; $f.$r = $r; return $f;
- }; })(typ)), 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: MakeSlice }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.cap = cap; $f.len = len; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.MakeSlice = MakeSlice;
- TypeOf = function(i) {
- var $ptr, i;
- if (!initialized) {
- return new rtype.ptr(0, 0, 0, 0, 0, 0, ptrType$4.nil, arrayType$1.zero(), ptrType$5.nil, ptrType$6.nil, ptrType$1.nil, 0);
- }
- if ($interfaceIsEqual(i, $ifaceNil)) {
- return $ifaceNil;
- }
- return reflectType(i.constructor);
- };
- $pkg.TypeOf = TypeOf;
- ValueOf = function(i) {
- var $ptr, _r, i, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if ($interfaceIsEqual(i, $ifaceNil)) {
- return new Value.ptr(ptrType$1.nil, 0, 0);
- }
- _r = makeValue(reflectType(i.constructor), i.$val, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ValueOf }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ValueOf = ValueOf;
- rtype.ptr.prototype.ptrTo = function() {
- var $ptr, t;
- t = this;
- return reflectType($ptrType(jsType(t)));
- };
- rtype.prototype.ptrTo = function() { return this.$val.ptrTo(); };
- SliceOf = function(t) {
- var $ptr, t;
- return reflectType($sliceType(jsType(t)));
- };
- $pkg.SliceOf = SliceOf;
- Zero = function(typ) {
- var $ptr, _r, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = makeValue(typ, jsType(typ).zero(), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Zero }; } $f.$ptr = $ptr; $f._r = _r; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Zero = Zero;
- unsafe_New = function(typ) {
- var $ptr, _ref, typ;
- _ref = typ.Kind();
- if (_ref === 25) {
- return new (jsType(typ).ptr)();
- } else if (_ref === 17) {
- return jsType(typ).zero();
- } else {
- return $newDataPointer(jsType(typ).zero(), jsType(typ.ptrTo()));
- }
- };
- makeInt = function(f, bits, t) {
- var $ptr, _r, _ref, bits, f, ptr, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; bits = $f.bits; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ = _r;
- ptr = unsafe_New(typ);
- _ref = typ.Kind();
- if (_ref === 3) {
- ptr.$set((bits.$low << 24 >> 24));
- } else if (_ref === 4) {
- ptr.$set((bits.$low << 16 >> 16));
- } else if (_ref === 2 || _ref === 5) {
- ptr.$set((bits.$low >> 0));
- } else if (_ref === 6) {
- ptr.$set(new $Int64(bits.$high, bits.$low));
- } else if (_ref === 8) {
- ptr.$set((bits.$low << 24 >>> 24));
- } else if (_ref === 9) {
- ptr.$set((bits.$low << 16 >>> 16));
- } else if (_ref === 7 || _ref === 10 || _ref === 12) {
- ptr.$set((bits.$low >>> 0));
- } else if (_ref === 11) {
- ptr.$set(bits);
- }
- return new Value.ptr(typ, ptr, (((f | 64) >>> 0) | (typ.Kind() >>> 0)) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeInt }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.bits = bits; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- memmove = function(adst, asrc, n) {
- var $ptr, adst, asrc, n;
- adst.$set(asrc.$get());
- };
- makemap = function(t) {
- var $ptr, m, t;
- m = 0;
- m = new ($Map)();
- return m;
- };
- mapaccess = function(t, m, key) {
- var $ptr, entry, k, key, m, t;
- k = $internalize(jsType(t.Key()).keyFor(key.$get()), $String);
- entry = m[$externalize(k, $String)];
- if (entry === undefined) {
- return 0;
- }
- return $newDataPointer(entry.v, jsType(PtrTo(t.Elem())));
- };
- mapassign = function(t, m, key, val) {
- var $ptr, _r, entry, et, jsVal, k, key, kv, m, newVal, t, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; entry = $f.entry; et = $f.et; jsVal = $f.jsVal; k = $f.k; key = $f.key; kv = $f.kv; m = $f.m; newVal = $f.newVal; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- kv = key.$get();
- k = $internalize(jsType(t.Key()).keyFor(kv), $String);
- jsVal = val.$get();
- et = t.Elem();
- _r = et.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r === 25) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r === 25) { */ case 1:
- newVal = jsType(et).zero();
- copyStruct(newVal, jsVal, et);
- jsVal = newVal;
- /* } */ case 2:
- entry = new ($global.Object)();
- entry.k = kv;
- entry.v = jsVal;
- m[$externalize(k, $String)] = entry;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mapassign }; } $f.$ptr = $ptr; $f._r = _r; $f.entry = entry; $f.et = et; $f.jsVal = jsVal; $f.k = k; $f.key = key; $f.kv = kv; $f.m = m; $f.newVal = newVal; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- mapdelete = function(t, m, key) {
- var $ptr, k, key, m, t;
- k = $internalize(jsType(t.Key()).keyFor(key.$get()), $String);
- delete m[$externalize(k, $String)];
- };
- mapiterinit = function(t, m) {
- var $ptr, m, t;
- return new mapIter.ptr(t, m, $keys(m), 0);
- };
- mapiterkey = function(it) {
- var $ptr, _r, _r$1, _r$2, it, iter, k, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; iter = $f.iter; k = $f.k; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- iter = it;
- k = iter.keys[iter.i];
- _r = iter.t.Key(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = PtrTo(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = jsType(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return $newDataPointer(iter.m[$externalize($internalize(k, $String), $String)].k, _r$2);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mapiterkey }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.iter = iter; $f.k = k; $f.$s = $s; $f.$r = $r; return $f;
- };
- mapiternext = function(it) {
- var $ptr, it, iter;
- iter = it;
- iter.i = iter.i + (1) >> 0;
- };
- maplen = function(m) {
- var $ptr, m;
- return $parseInt($keys(m).length);
- };
- cvtDirect = function(v, typ) {
- var $ptr, _arg, _arg$1, _arg$2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, k, slice, srcVal, typ, v, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; k = $f.k; slice = $f.slice; srcVal = $f.srcVal; typ = $f.typ; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- srcVal = v.object();
- /* */ if (srcVal === jsType(v.typ).nil) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (srcVal === jsType(v.typ).nil) { */ case 1:
- _r = makeValue(typ, jsType(typ).nil, v.flag); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- val = null;
- _r$1 = typ.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- k = _r$1;
- _ref = k;
- /* */ if (_ref === 18) { $s = 5; continue; }
- /* */ if (_ref === 23) { $s = 6; continue; }
- /* */ if (_ref === 22) { $s = 7; continue; }
- /* */ if (_ref === 25) { $s = 8; continue; }
- /* */ if (_ref === 17 || _ref === 19 || _ref === 20 || _ref === 21 || _ref === 24) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* switch (0) { default: if (_ref === 18) { */ case 5:
- val = new (jsType(typ))();
- $s = 11; continue;
- /* } else if (_ref === 23) { */ case 6:
- slice = new (jsType(typ))(srcVal.$array);
- slice.$offset = srcVal.$offset;
- slice.$length = srcVal.$length;
- slice.$capacity = srcVal.$capacity;
- val = $newDataPointer(slice, jsType(PtrTo(typ)));
- $s = 11; continue;
- /* } else if (_ref === 22) { */ case 7:
- _r$2 = typ.Elem(); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = _r$2.Kind(); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3 === 25) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (_r$3 === 25) { */ case 12:
- _r$4 = typ.Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if ($interfaceIsEqual(_r$4, v.typ.Elem())) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if ($interfaceIsEqual(_r$4, v.typ.Elem())) { */ case 16:
- val = srcVal;
- /* break; */ $s = 11; continue;
- /* } */ case 17:
- val = new (jsType(typ))();
- _arg = val;
- _arg$1 = srcVal;
- _r$5 = typ.Elem(); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$2 = _r$5;
- $r = copyStruct(_arg, _arg$1, _arg$2); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* break; */ $s = 11; continue;
- /* } */ case 13:
- val = new (jsType(typ))(srcVal.$get, srcVal.$set);
- $s = 11; continue;
- /* } else if (_ref === 25) { */ case 8:
- val = new (jsType(typ).ptr)();
- copyStruct(val, srcVal, typ);
- $s = 11; continue;
- /* } else if (_ref === 17 || _ref === 19 || _ref === 20 || _ref === 21 || _ref === 24) { */ case 9:
- val = v.ptr;
- $s = 11; continue;
- /* } else { */ case 10:
- $panic(new ValueError.ptr("reflect.Convert", k));
- /* } } */ case 11:
- _r$6 = typ.common(); /* */ $s = 21; case 21: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = typ.Kind(); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return new Value.ptr(_r$6, val, (((v.flag & 96) >>> 0) | (_r$7 >>> 0)) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtDirect }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f.k = k; $f.slice = slice; $f.srcVal = srcVal; $f.typ = typ; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- Copy = function(dst, src) {
- var $ptr, dk, dst, dstVal, sk, src, srcVal, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dk = $f.dk; dst = $f.dst; dstVal = $f.dstVal; sk = $f.sk; src = $f.src; srcVal = $f.srcVal; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- src = src;
- dst = dst;
- dk = new flag(dst.flag).kind();
- if (!((dk === 17)) && !((dk === 23))) {
- $panic(new ValueError.ptr("reflect.Copy", dk));
- }
- if (dk === 17) {
- new flag(dst.flag).mustBeAssignable();
- }
- new flag(dst.flag).mustBeExported();
- sk = new flag(src.flag).kind();
- if (!((sk === 17)) && !((sk === 23))) {
- $panic(new ValueError.ptr("reflect.Copy", sk));
- }
- new flag(src.flag).mustBeExported();
- $r = typesMustMatch("reflect.Copy", dst.typ.Elem(), src.typ.Elem()); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- dstVal = dst.object();
- if (dk === 17) {
- dstVal = new (jsType(SliceOf(dst.typ.Elem())))(dstVal);
- }
- srcVal = src.object();
- if (sk === 17) {
- srcVal = new (jsType(SliceOf(src.typ.Elem())))(srcVal);
- }
- return $parseInt($copySlice(dstVal, srcVal)) >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Copy }; } $f.$ptr = $ptr; $f.dk = dk; $f.dst = dst; $f.dstVal = dstVal; $f.sk = sk; $f.src = src; $f.srcVal = srcVal; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Copy = Copy;
- methodReceiver = function(op, v, i) {
- var $ptr, _r, fn, i, iface, m, m$1, op, prop, rcvr, rcvrtype, t, tt, ut, v, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; fn = $f.fn; i = $f.i; iface = $f.iface; m = $f.m; m$1 = $f.m$1; op = $f.op; prop = $f.prop; rcvr = $f.rcvr; rcvrtype = $f.rcvrtype; t = $f.t; tt = $f.tt; ut = $f.ut; v = $f.v; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- rcvrtype = ptrType$1.nil;
- t = ptrType$1.nil;
- fn = 0;
- v = v;
- prop = "";
- if (v.typ.Kind() === 20) {
- tt = v.typ.kindType;
- if (i < 0 || i >= tt.methods.$length) {
- $panic(new $String("reflect: internal error: invalid method index"));
- }
- m = (x = tt.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- if (!(m.pkgPath === ptrType$5.nil)) {
- $panic(new $String("reflect: " + op + " of unexported method"));
- }
- iface = $pointerOfStructConversion(v.ptr, ptrType$7);
- if (iface.itab === ptrType$8.nil) {
- $panic(new $String("reflect: " + op + " of method on nil interface value"));
- }
- t = m.typ;
- prop = m.name.$get();
- } else {
- ut = v.typ.uncommonType.uncommon();
- if (ut === ptrType$6.nil || i < 0 || i >= ut.methods.$length) {
- $panic(new $String("reflect: internal error: invalid method index"));
- }
- m$1 = (x$1 = ut.methods, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i]));
- if (!(m$1.pkgPath === ptrType$5.nil)) {
- $panic(new $String("reflect: " + op + " of unexported method"));
- }
- t = m$1.mtyp;
- prop = $internalize($methodSet(jsType(v.typ))[i].prop, $String);
- }
- rcvr = v.object();
- _r = isWrapped(v.typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r) { */ case 1:
- rcvr = new (jsType(v.typ))(rcvr);
- /* } */ case 2:
- fn = rcvr[$externalize(prop, $String)];
- return [rcvrtype, t, fn];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: methodReceiver }; } $f.$ptr = $ptr; $f._r = _r; $f.fn = fn; $f.i = i; $f.iface = iface; $f.m = m; $f.m$1 = m$1; $f.op = op; $f.prop = prop; $f.rcvr = rcvr; $f.rcvrtype = rcvrtype; $f.t = t; $f.tt = tt; $f.ut = ut; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- valueInterface = function(v, safe) {
- var $ptr, _r, _r$1, safe, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; safe = $f.safe; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (v.flag === 0) {
- $panic(new ValueError.ptr("reflect.Value.Interface", 0));
- }
- if (safe && !((((v.flag & 32) >>> 0) === 0))) {
- $panic(new $String("reflect.Value.Interface: cannot return value obtained from unexported field or method"));
- }
- /* */ if (!((((v.flag & 256) >>> 0) === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((((v.flag & 256) >>> 0) === 0))) { */ case 1:
- _r = makeMethodValue("Interface", v); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- v = _r;
- /* } */ case 2:
- _r$1 = isWrapped(v.typ); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_r$1) { */ case 4:
- return new (jsType(v.typ))(v.object());
- /* } */ case 5:
- return v.object();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: valueInterface }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.safe = safe; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- ifaceE2I = function(t, src, dst) {
- var $ptr, dst, src, t;
- dst.$set(src);
- };
- methodName = function() {
- var $ptr;
- return "?FIXME?";
- };
- makeMethodValue = function(op, v) {
- var $ptr, _r, _r$1, _r$2, _tuple, fn, fv, op, rcvr, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; fn = $f.fn; fv = $f.fv; op = $f.op; rcvr = $f.rcvr; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- fn = [fn];
- rcvr = [rcvr];
- v = v;
- if (((v.flag & 256) >>> 0) === 0) {
- $panic(new $String("reflect: internal error: invalid use of makePartialFunc"));
- }
- _r = methodReceiver(op, v, (v.flag >> 0) >> 9 >> 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; fn[0] = _tuple[2];
- rcvr[0] = v.object();
- _r$1 = isWrapped(v.typ); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_r$1) { */ case 2:
- rcvr[0] = new (jsType(v.typ))(rcvr[0]);
- /* } */ case 3:
- fv = $makeFunc((function(fn, rcvr) { return function(arguments$1) {
- var $ptr, arguments$1;
- return fn[0].apply(rcvr[0], $externalize(arguments$1, sliceType$8));
- }; })(fn, rcvr));
- _r$2 = v.Type().common(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return new Value.ptr(_r$2, fv, (((v.flag & 32) >>> 0) | 19) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeMethodValue }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.fn = fn; $f.fv = fv; $f.op = op; $f.rcvr = rcvr; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.ptr.prototype.pointers = function() {
- var $ptr, _ref, t;
- t = this;
- _ref = t.Kind();
- if (_ref === 22 || _ref === 21 || _ref === 18 || _ref === 19 || _ref === 25 || _ref === 17) {
- return true;
- } else {
- return false;
- }
- };
- rtype.prototype.pointers = function() { return this.$val.pointers(); };
- rtype.ptr.prototype.Comparable = function() {
- var $ptr, _r, _r$1, _r$2, _ref, i, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; i = $f.i; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _ref = t.Kind();
- /* */ if (_ref === 19 || _ref === 23 || _ref === 21) { $s = 1; continue; }
- /* */ if (_ref === 17) { $s = 2; continue; }
- /* */ if (_ref === 25) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_ref === 19 || _ref === 23 || _ref === 21) { */ case 1:
- return false;
- $s = 4; continue;
- /* } else if (_ref === 17) { */ case 2:
- _r = t.Elem().Comparable(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 4; continue;
- /* } else if (_ref === 25) { */ case 3:
- i = 0;
- /* while (true) { */ case 6:
- /* if (!(i < t.NumField())) { break; } */ if(!(i < t.NumField())) { $s = 7; continue; }
- _r$1 = t.Field(i); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = _r$1.Type.Comparable(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!_r$2) { */ case 8:
- return false;
- /* } */ case 9:
- i = i + (1) >> 0;
- /* } */ $s = 6; continue; case 7:
- /* } */ case 4:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Comparable }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.i = i; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.prototype.Comparable = function() { return this.$val.Comparable(); };
- uncommonType.ptr.prototype.Method = function(i) {
- var $ptr, fl, fn, i, m, mt, p, prop, t, x;
- m = new Method.ptr();
- t = this;
- if (t === ptrType$6.nil || i < 0 || i >= t.methods.$length) {
- $panic(new $String("reflect: Method index out of range"));
- }
- p = (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- if (!(p.name === ptrType$5.nil)) {
- m.Name = p.name.$get();
- }
- fl = 19;
- if (!(p.pkgPath === ptrType$5.nil)) {
- m.PkgPath = p.pkgPath.$get();
- fl = (fl | (32)) >>> 0;
- }
- mt = p.typ;
- m.Type = mt;
- prop = $internalize($methodSet(t.jsType)[i].prop, $String);
- fn = $makeFunc((function(arguments$1) {
- var $ptr, arguments$1, rcvr;
- rcvr = (0 >= arguments$1.$length ? $throwRuntimeError("index out of range") : arguments$1.$array[arguments$1.$offset + 0]);
- return rcvr[$externalize(prop, $String)].apply(rcvr, $externalize($subslice(arguments$1, 1), sliceType$8));
- }));
- m.Func = new Value.ptr(mt, fn, fl);
- m.Index = i;
- return m;
- };
- uncommonType.prototype.Method = function(i) { return this.$val.Method(i); };
- Value.ptr.prototype.object = function() {
- var $ptr, _ref, newVal, v, val;
- v = this;
- if ((v.typ.Kind() === 17) || (v.typ.Kind() === 25)) {
- return v.ptr;
- }
- if (!((((v.flag & 64) >>> 0) === 0))) {
- val = v.ptr.$get();
- if (!(val === $ifaceNil) && !(val.constructor === jsType(v.typ))) {
- _ref = v.typ.Kind();
- switch (0) { default: if (_ref === 11 || _ref === 6) {
- val = new (jsType(v.typ))(val.$high, val.$low);
- } else if (_ref === 15 || _ref === 16) {
- val = new (jsType(v.typ))(val.$real, val.$imag);
- } else if (_ref === 23) {
- if (val === val.constructor.nil) {
- val = jsType(v.typ).nil;
- break;
- }
- newVal = new (jsType(v.typ))(val.$array);
- newVal.$offset = val.$offset;
- newVal.$length = val.$length;
- newVal.$capacity = val.$capacity;
- val = newVal;
- } }
- }
- return val;
- }
- return v.ptr;
- };
- Value.prototype.object = function() { return this.$val.object(); };
- Value.ptr.prototype.call = function(op, in$1) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _i, _i$1, _i$2, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _tmp, _tmp$1, _tuple, arg, argsArray, elem, fn, i, i$1, i$2, i$3, in$1, isSlice, m, n, nin, nout, op, origIn, rcvr, results, ret, slice, t, targ, v, x, x$1, x$2, xt, xt$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; arg = $f.arg; argsArray = $f.argsArray; elem = $f.elem; fn = $f.fn; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; in$1 = $f.in$1; isSlice = $f.isSlice; m = $f.m; n = $f.n; nin = $f.nin; nout = $f.nout; op = $f.op; origIn = $f.origIn; rcvr = $f.rcvr; results = $f.results; ret = $f.ret; slice = $f.slice; t = $f.t; targ = $f.targ; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; xt = $f.xt; xt$1 = $f.xt$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- t = v.typ;
- fn = 0;
- rcvr = null;
- /* */ if (!((((v.flag & 256) >>> 0) === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((((v.flag & 256) >>> 0) === 0))) { */ case 1:
- _r = methodReceiver(op, v, (v.flag >> 0) >> 9 >> 0); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; t = _tuple[1]; fn = _tuple[2];
- rcvr = v.object();
- _r$1 = isWrapped(v.typ); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_r$1) { */ case 5:
- rcvr = new (jsType(v.typ))(rcvr);
- /* } */ case 6:
- $s = 3; continue;
- /* } else { */ case 2:
- fn = v.object();
- rcvr = undefined;
- /* } */ case 3:
- if (fn === 0) {
- $panic(new $String("reflect.Value.Call: call of nil function"));
- }
- isSlice = op === "CallSlice";
- n = t.NumIn();
- if (isSlice) {
- if (!t.IsVariadic()) {
- $panic(new $String("reflect: CallSlice of non-variadic function"));
- }
- if (in$1.$length < n) {
- $panic(new $String("reflect: CallSlice with too few input arguments"));
- }
- if (in$1.$length > n) {
- $panic(new $String("reflect: CallSlice with too many input arguments"));
- }
- } else {
- if (t.IsVariadic()) {
- n = n - (1) >> 0;
- }
- if (in$1.$length < n) {
- $panic(new $String("reflect: Call with too few input arguments"));
- }
- if (!t.IsVariadic() && in$1.$length > n) {
- $panic(new $String("reflect: Call with too many input arguments"));
- }
- }
- _ref = in$1;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (x.Kind() === 0) {
- $panic(new $String("reflect: " + op + " using zero Value argument"));
- }
- _i++;
- }
- i = 0;
- /* while (true) { */ case 8:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 9; continue; }
- _tmp = ((i < 0 || i >= in$1.$length) ? $throwRuntimeError("index out of range") : in$1.$array[in$1.$offset + i]).Type(); _tmp$1 = t.In(i); xt = _tmp; targ = _tmp$1;
- _r$2 = xt.AssignableTo(targ); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!_r$2) { */ case 10:
- _r$3 = xt.String(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = targ.String(); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $panic(new $String("reflect: " + op + " using " + _r$3 + " as type " + _r$4));
- /* } */ case 11:
- i = i + (1) >> 0;
- /* } */ $s = 8; continue; case 9:
- /* */ if (!isSlice && t.IsVariadic()) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!isSlice && t.IsVariadic()) { */ case 15:
- m = in$1.$length - n >> 0;
- _r$5 = MakeSlice(t.In(n), m, m); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- slice = _r$5;
- _r$6 = t.In(n).Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- elem = _r$6;
- i$1 = 0;
- /* while (true) { */ case 19:
- /* if (!(i$1 < m)) { break; } */ if(!(i$1 < m)) { $s = 20; continue; }
- x$2 = (x$1 = n + i$1 >> 0, ((x$1 < 0 || x$1 >= in$1.$length) ? $throwRuntimeError("index out of range") : in$1.$array[in$1.$offset + x$1]));
- xt$1 = x$2.Type();
- _r$7 = xt$1.AssignableTo(elem); /* */ $s = 23; case 23: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (!_r$7) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (!_r$7) { */ case 21:
- _r$8 = xt$1.String(); /* */ $s = 24; case 24: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = elem.String(); /* */ $s = 25; case 25: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- $panic(new $String("reflect: cannot use " + _r$8 + " as type " + _r$9 + " in " + op));
- /* } */ case 22:
- _r$10 = slice.Index(i$1); /* */ $s = 26; case 26: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- $r = _r$10.Set(x$2); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$1 = i$1 + (1) >> 0;
- /* } */ $s = 19; continue; case 20:
- origIn = in$1;
- in$1 = $makeSlice(sliceType$7, (n + 1 >> 0));
- $copySlice($subslice(in$1, 0, n), origIn);
- ((n < 0 || n >= in$1.$length) ? $throwRuntimeError("index out of range") : in$1.$array[in$1.$offset + n] = slice);
- /* } */ case 16:
- nin = in$1.$length;
- if (!((nin === t.NumIn()))) {
- $panic(new $String("reflect.Value.Call: wrong argument count"));
- }
- nout = t.NumOut();
- argsArray = new ($global.Array)(t.NumIn());
- _ref$1 = in$1;
- _i$1 = 0;
- /* while (true) { */ case 28:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 29; continue; }
- i$2 = _i$1;
- arg = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _arg = t.In(i$2);
- _r$11 = t.In(i$2).common(); /* */ $s = 30; case 30: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _arg$1 = _r$11;
- _arg$2 = 0;
- _r$12 = arg.assignTo("reflect.Value.Call", _arg$1, _arg$2); /* */ $s = 31; case 31: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _r$13 = _r$12.object(); /* */ $s = 32; case 32: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _arg$3 = _r$13;
- _r$14 = unwrapJsObject(_arg, _arg$3); /* */ $s = 33; case 33: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- argsArray[i$2] = _r$14;
- _i$1++;
- /* } */ $s = 28; continue; case 29:
- _r$15 = callHelper(new sliceType$1([new $jsObjectPtr(fn), new $jsObjectPtr(rcvr), new $jsObjectPtr(argsArray)])); /* */ $s = 34; case 34: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- results = _r$15;
- _ref$2 = nout;
- /* */ if (_ref$2 === 0) { $s = 35; continue; }
- /* */ if (_ref$2 === 1) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (_ref$2 === 0) { */ case 35:
- return sliceType$7.nil;
- $s = 38; continue;
- /* } else if (_ref$2 === 1) { */ case 36:
- _r$16 = makeValue(t.Out(0), wrapJsObject(t.Out(0), results), 0); /* */ $s = 39; case 39: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- return new sliceType$7([$clone(_r$16, Value)]);
- $s = 38; continue;
- /* } else { */ case 37:
- ret = $makeSlice(sliceType$7, nout);
- _ref$3 = ret;
- _i$2 = 0;
- /* while (true) { */ case 40:
- /* if (!(_i$2 < _ref$3.$length)) { break; } */ if(!(_i$2 < _ref$3.$length)) { $s = 41; continue; }
- i$3 = _i$2;
- _r$17 = makeValue(t.Out(i$3), wrapJsObject(t.Out(i$3), results[i$3]), 0); /* */ $s = 42; case 42: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- ((i$3 < 0 || i$3 >= ret.$length) ? $throwRuntimeError("index out of range") : ret.$array[ret.$offset + i$3] = _r$17);
- _i$2++;
- /* } */ $s = 40; continue; case 41:
- return ret;
- /* } */ case 38:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.call }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.arg = arg; $f.argsArray = argsArray; $f.elem = elem; $f.fn = fn; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.in$1 = in$1; $f.isSlice = isSlice; $f.m = m; $f.n = n; $f.nin = nin; $f.nout = nout; $f.op = op; $f.origIn = origIn; $f.rcvr = rcvr; $f.results = results; $f.ret = ret; $f.slice = slice; $f.t = t; $f.targ = targ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.xt = xt; $f.xt$1 = xt$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.call = function(op, in$1) { return this.$val.call(op, in$1); };
- Value.ptr.prototype.Cap = function() {
- var $ptr, _ref, k, v;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 17) {
- return v.typ.Len();
- } else if (_ref === 18 || _ref === 23) {
- return $parseInt(v.object().$capacity) >> 0;
- }
- $panic(new ValueError.ptr("reflect.Value.Cap", k));
- };
- Value.prototype.Cap = function() { return this.$val.Cap(); };
- wrapJsObject = function(typ, val) {
- var $ptr, typ, val;
- if ($interfaceIsEqual(typ, jsObjectPtr)) {
- return new (jsType(jsObjectPtr))(val);
- }
- return val;
- };
- unwrapJsObject = function(typ, val) {
- var $ptr, typ, val;
- if ($interfaceIsEqual(typ, jsObjectPtr)) {
- return val.object;
- }
- return val;
- };
- Value.ptr.prototype.Elem = function() {
- var $ptr, _r, _ref, fl, k, tt, typ, v, val, val$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; fl = $f.fl; k = $f.k; tt = $f.tt; typ = $f.typ; v = $f.v; val = $f.val; val$1 = $f.val$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- /* */ if (_ref === 20) { $s = 1; continue; }
- /* */ if (_ref === 22) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_ref === 20) { */ case 1:
- val = v.object();
- if (val === $ifaceNil) {
- return new Value.ptr(ptrType$1.nil, 0, 0);
- }
- typ = reflectType(val.constructor);
- _r = makeValue(typ, val.$val, (v.flag & 32) >>> 0); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 4; continue;
- /* } else if (_ref === 22) { */ case 2:
- if (v.IsNil()) {
- return new Value.ptr(ptrType$1.nil, 0, 0);
- }
- val$1 = v.object();
- tt = v.typ.kindType;
- fl = (((((v.flag & 32) >>> 0) | 64) >>> 0) | 128) >>> 0;
- fl = (fl | ((tt.elem.Kind() >>> 0))) >>> 0;
- return new Value.ptr(tt.elem, wrapJsObject(tt.elem, val$1), fl);
- $s = 4; continue;
- /* } else { */ case 3:
- $panic(new ValueError.ptr("reflect.Value.Elem", k));
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Elem }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.fl = fl; $f.k = k; $f.tt = tt; $f.typ = typ; $f.v = v; $f.val = val; $f.val$1 = val$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Elem = function() { return this.$val.Elem(); };
- Value.ptr.prototype.Field = function(i) {
- var $ptr, _r, _r$1, _r$2, field, fl, i, jsTag, o, prop, s, tag, tt, typ, v, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; field = $f.field; fl = $f.fl; i = $f.i; jsTag = $f.jsTag; o = $f.o; prop = $f.prop; s = $f.s; tag = $f.tag; tt = $f.tt; typ = $f.typ; v = $f.v; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- jsTag = [jsTag];
- prop = [prop];
- s = [s];
- typ = [typ];
- v = this;
- new flag(v.flag).mustBe(25);
- tt = v.typ.kindType;
- if (i < 0 || i >= tt.fields.$length) {
- $panic(new $String("reflect: Field index out of range"));
- }
- prop[0] = $internalize(jsType(v.typ).fields[i].prop, $String);
- field = (x = tt.fields, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- typ[0] = field.typ;
- fl = (v.flag & 224) >>> 0;
- if (!(field.pkgPath === ptrType$5.nil)) {
- fl = (fl | (32)) >>> 0;
- }
- fl = (fl | ((typ[0].Kind() >>> 0))) >>> 0;
- tag = (x$1 = tt.fields, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])).tag;
- /* */ if (!(tag === ptrType$5.nil) && !((i === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(tag === ptrType$5.nil) && !((i === 0))) { */ case 1:
- jsTag[0] = getJsTag(tag.$get());
- /* */ if (!(jsTag[0] === "")) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(jsTag[0] === "")) { */ case 3:
- /* while (true) { */ case 5:
- o = [o];
- _r = v.Field(0); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- v = _r;
- /* */ if (v.typ === jsObjectPtr) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (v.typ === jsObjectPtr) { */ case 8:
- o[0] = v.object().object;
- return new Value.ptr(typ[0], new (jsType(PtrTo(typ[0])))((function(jsTag, o, prop, s, typ) { return function() {
- var $ptr;
- return $internalize(o[0][$externalize(jsTag[0], $String)], jsType(typ[0]));
- }; })(jsTag, o, prop, s, typ), (function(jsTag, o, prop, s, typ) { return function(x$2) {
- var $ptr, x$2;
- o[0][$externalize(jsTag[0], $String)] = $externalize(x$2, jsType(typ[0]));
- }; })(jsTag, o, prop, s, typ)), fl);
- /* } */ case 9:
- /* */ if (v.typ.Kind() === 22) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (v.typ.Kind() === 22) { */ case 10:
- _r$1 = v.Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- v = _r$1;
- /* } */ case 11:
- /* } */ $s = 5; continue; case 6:
- /* } */ case 4:
- /* } */ case 2:
- s[0] = v.ptr;
- /* */ if (!((((fl & 64) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!((((fl & 64) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 13:
- return new Value.ptr(typ[0], new (jsType(PtrTo(typ[0])))((function(jsTag, prop, s, typ) { return function() {
- var $ptr;
- return wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]);
- }; })(jsTag, prop, s, typ), (function(jsTag, prop, s, typ) { return function(x$2) {
- var $ptr, x$2;
- s[0][$externalize(prop[0], $String)] = unwrapJsObject(typ[0], x$2);
- }; })(jsTag, prop, s, typ)), fl);
- /* } */ case 14:
- _r$2 = makeValue(typ[0], wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]), fl); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Field }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.field = field; $f.fl = fl; $f.i = i; $f.jsTag = jsTag; $f.o = o; $f.prop = prop; $f.s = s; $f.tag = tag; $f.tt = tt; $f.typ = typ; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Field = function(i) { return this.$val.Field(i); };
- getJsTag = function(tag) {
- var $ptr, _tuple, i, name, qvalue, tag, value;
- while (true) {
- if (!(!(tag === ""))) { break; }
- i = 0;
- while (true) {
- if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; }
- i = i + (1) >> 0;
- }
- tag = tag.substring(i);
- if (tag === "") {
- break;
- }
- i = 0;
- while (true) {
- if (!(i < tag.length && !((tag.charCodeAt(i) === 32)) && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)))) { break; }
- i = i + (1) >> 0;
- }
- if ((i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) {
- break;
- }
- name = tag.substring(0, i);
- tag = tag.substring((i + 1 >> 0));
- i = 1;
- while (true) {
- if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; }
- if (tag.charCodeAt(i) === 92) {
- i = i + (1) >> 0;
- }
- i = i + (1) >> 0;
- }
- if (i >= tag.length) {
- break;
- }
- qvalue = tag.substring(0, (i + 1 >> 0));
- tag = tag.substring((i + 1 >> 0));
- if (name === "js") {
- _tuple = strconv.Unquote(qvalue); value = _tuple[0];
- return value;
- }
- }
- return "";
- };
- Value.ptr.prototype.Index = function(i) {
- var $ptr, _r, _r$1, _ref, a, a$1, c, fl, fl$1, fl$2, i, k, s, str, tt, tt$1, typ, typ$1, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; a = $f.a; a$1 = $f.a$1; c = $f.c; fl = $f.fl; fl$1 = $f.fl$1; fl$2 = $f.fl$2; i = $f.i; k = $f.k; s = $f.s; str = $f.str; tt = $f.tt; tt$1 = $f.tt$1; typ = $f.typ; typ$1 = $f.typ$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = [a];
- a$1 = [a$1];
- c = [c];
- i = [i];
- typ = [typ];
- typ$1 = [typ$1];
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- /* */ if (_ref === 17) { $s = 1; continue; }
- /* */ if (_ref === 23) { $s = 2; continue; }
- /* */ if (_ref === 24) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_ref === 17) { */ case 1:
- tt = v.typ.kindType;
- if (i[0] < 0 || i[0] > (tt.len >> 0)) {
- $panic(new $String("reflect: array index out of range"));
- }
- typ$1[0] = tt.elem;
- fl = (v.flag & 224) >>> 0;
- fl = (fl | ((typ$1[0].Kind() >>> 0))) >>> 0;
- a[0] = v.ptr;
- /* */ if (!((((fl & 64) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!((((fl & 64) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { */ case 6:
- return new Value.ptr(typ$1[0], new (jsType(PtrTo(typ$1[0])))((function(a, a$1, c, i, typ, typ$1) { return function() {
- var $ptr;
- return wrapJsObject(typ$1[0], a[0][i[0]]);
- }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) {
- var $ptr, x;
- a[0][i[0]] = unwrapJsObject(typ$1[0], x);
- }; })(a, a$1, c, i, typ, typ$1)), fl);
- /* } */ case 7:
- _r = makeValue(typ$1[0], wrapJsObject(typ$1[0], a[0][i[0]]), fl); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 5; continue;
- /* } else if (_ref === 23) { */ case 2:
- s = v.object();
- if (i[0] < 0 || i[0] >= ($parseInt(s.$length) >> 0)) {
- $panic(new $String("reflect: slice index out of range"));
- }
- tt$1 = v.typ.kindType;
- typ[0] = tt$1.elem;
- fl$1 = (192 | ((v.flag & 32) >>> 0)) >>> 0;
- fl$1 = (fl$1 | ((typ[0].Kind() >>> 0))) >>> 0;
- i[0] = i[0] + (($parseInt(s.$offset) >> 0)) >> 0;
- a$1[0] = s.$array;
- /* */ if (!((((fl$1 & 64) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!((((fl$1 & 64) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 9:
- return new Value.ptr(typ[0], new (jsType(PtrTo(typ[0])))((function(a, a$1, c, i, typ, typ$1) { return function() {
- var $ptr;
- return wrapJsObject(typ[0], a$1[0][i[0]]);
- }; })(a, a$1, c, i, typ, typ$1), (function(a, a$1, c, i, typ, typ$1) { return function(x) {
- var $ptr, x;
- a$1[0][i[0]] = unwrapJsObject(typ[0], x);
- }; })(a, a$1, c, i, typ, typ$1)), fl$1);
- /* } */ case 10:
- _r$1 = makeValue(typ[0], wrapJsObject(typ[0], a$1[0][i[0]]), fl$1); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 5; continue;
- /* } else if (_ref === 24) { */ case 3:
- str = v.ptr.$get();
- if (i[0] < 0 || i[0] >= str.length) {
- $panic(new $String("reflect: string index out of range"));
- }
- fl$2 = (((v.flag & 32) >>> 0) | 8) >>> 0;
- c[0] = str.charCodeAt(i[0]);
- return new Value.ptr(uint8Type, (c.$ptr || (c.$ptr = new ptrType$9(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, c))), (fl$2 | 64) >>> 0);
- $s = 5; continue;
- /* } else { */ case 4:
- $panic(new ValueError.ptr("reflect.Value.Index", k));
- /* } */ case 5:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Index }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.a = a; $f.a$1 = a$1; $f.c = c; $f.fl = fl; $f.fl$1 = fl$1; $f.fl$2 = fl$2; $f.i = i; $f.k = k; $f.s = s; $f.str = str; $f.tt = tt; $f.tt$1 = tt$1; $f.typ = typ; $f.typ$1 = typ$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Index = function(i) { return this.$val.Index(i); };
- Value.ptr.prototype.IsNil = function() {
- var $ptr, _ref, k, v;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 18 || _ref === 22 || _ref === 23) {
- return v.object() === jsType(v.typ).nil;
- } else if (_ref === 19) {
- return v.object() === $throwNilPointerError;
- } else if (_ref === 21) {
- return v.object() === false;
- } else if (_ref === 20) {
- return v.object() === $ifaceNil;
- } else {
- $panic(new ValueError.ptr("reflect.Value.IsNil", k));
- }
- };
- Value.prototype.IsNil = function() { return this.$val.IsNil(); };
- Value.ptr.prototype.Len = function() {
- var $ptr, _ref, k, v;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 17 || _ref === 24) {
- return $parseInt(v.object().length);
- } else if (_ref === 23) {
- return $parseInt(v.object().$length) >> 0;
- } else if (_ref === 18) {
- return $parseInt(v.object().$buffer.length) >> 0;
- } else if (_ref === 21) {
- return $parseInt($keys(v.object()).length);
- } else {
- $panic(new ValueError.ptr("reflect.Value.Len", k));
- }
- };
- Value.prototype.Len = function() { return this.$val.Len(); };
- Value.ptr.prototype.Pointer = function() {
- var $ptr, _ref, k, v;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 18 || _ref === 21 || _ref === 22 || _ref === 26) {
- if (v.IsNil()) {
- return 0;
- }
- return v.object();
- } else if (_ref === 19) {
- if (v.IsNil()) {
- return 0;
- }
- return 1;
- } else if (_ref === 23) {
- if (v.IsNil()) {
- return 0;
- }
- return v.object().$array;
- } else {
- $panic(new ValueError.ptr("reflect.Value.Pointer", k));
- }
- };
- Value.prototype.Pointer = function() { return this.$val.Pointer(); };
- Value.ptr.prototype.Set = function(x) {
- var $ptr, _r, _r$1, _ref, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- x = x;
- new flag(v.flag).mustBeAssignable();
- new flag(x.flag).mustBeExported();
- _r = x.assignTo("reflect.Set", v.typ, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- x = _r;
- /* */ if (!((((v.flag & 64) >>> 0) === 0))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((((v.flag & 64) >>> 0) === 0))) { */ case 2:
- _ref = v.typ.Kind();
- /* */ if (_ref === 17) { $s = 4; continue; }
- /* */ if (_ref === 20) { $s = 5; continue; }
- /* */ if (_ref === 25) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 17) { */ case 4:
- $copy(v.ptr, x.ptr, jsType(v.typ));
- $s = 8; continue;
- /* } else if (_ref === 20) { */ case 5:
- _r$1 = valueInterface(x, false); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- v.ptr.$set(_r$1);
- $s = 8; continue;
- /* } else if (_ref === 25) { */ case 6:
- copyStruct(v.ptr, x.ptr, v.typ);
- $s = 8; continue;
- /* } else { */ case 7:
- v.ptr.$set(x.object());
- /* } */ case 8:
- return;
- /* } */ case 3:
- v.ptr = x.ptr;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Set }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Set = function(x) { return this.$val.Set(x); };
- Value.ptr.prototype.SetCap = function(n) {
- var $ptr, n, newSlice, s, v;
- v = this;
- new flag(v.flag).mustBeAssignable();
- new flag(v.flag).mustBe(23);
- s = v.ptr.$get();
- if (n < ($parseInt(s.$length) >> 0) || n > ($parseInt(s.$capacity) >> 0)) {
- $panic(new $String("reflect: slice capacity out of range in SetCap"));
- }
- newSlice = new (jsType(v.typ))(s.$array);
- newSlice.$offset = s.$offset;
- newSlice.$length = s.$length;
- newSlice.$capacity = n;
- v.ptr.$set(newSlice);
- };
- Value.prototype.SetCap = function(n) { return this.$val.SetCap(n); };
- Value.ptr.prototype.SetLen = function(n) {
- var $ptr, n, newSlice, s, v;
- v = this;
- new flag(v.flag).mustBeAssignable();
- new flag(v.flag).mustBe(23);
- s = v.ptr.$get();
- if (n < 0 || n > ($parseInt(s.$capacity) >> 0)) {
- $panic(new $String("reflect: slice length out of range in SetLen"));
- }
- newSlice = new (jsType(v.typ))(s.$array);
- newSlice.$offset = s.$offset;
- newSlice.$length = n;
- newSlice.$capacity = s.$capacity;
- v.ptr.$set(newSlice);
- };
- Value.prototype.SetLen = function(n) { return this.$val.SetLen(n); };
- Value.ptr.prototype.Slice = function(i, j) {
- var $ptr, _r, _r$1, _ref, cap, i, j, kind, s, str, tt, typ, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; cap = $f.cap; i = $f.i; j = $f.j; kind = $f.kind; s = $f.s; str = $f.str; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- cap = 0;
- typ = $ifaceNil;
- s = null;
- kind = new flag(v.flag).kind();
- _ref = kind;
- /* */ if (_ref === 17) { $s = 1; continue; }
- /* */ if (_ref === 23) { $s = 2; continue; }
- /* */ if (_ref === 24) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_ref === 17) { */ case 1:
- if (((v.flag & 128) >>> 0) === 0) {
- $panic(new $String("reflect.Value.Slice: slice of unaddressable array"));
- }
- tt = v.typ.kindType;
- cap = (tt.len >> 0);
- typ = SliceOf(tt.elem);
- s = new (jsType(typ))(v.object());
- $s = 5; continue;
- /* } else if (_ref === 23) { */ case 2:
- typ = v.typ;
- s = v.object();
- cap = $parseInt(s.$capacity) >> 0;
- $s = 5; continue;
- /* } else if (_ref === 24) { */ case 3:
- str = v.ptr.$get();
- if (i < 0 || j < i || j > str.length) {
- $panic(new $String("reflect.Value.Slice: string slice index out of bounds"));
- }
- _r = ValueOf(new $String(str.substring(i, j))); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 5; continue;
- /* } else { */ case 4:
- $panic(new ValueError.ptr("reflect.Value.Slice", kind));
- /* } */ case 5:
- if (i < 0 || j < i || j > cap) {
- $panic(new $String("reflect.Value.Slice: slice index out of bounds"));
- }
- _r$1 = makeValue(typ, $subslice(s, i, j), (v.flag & 32) >>> 0); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.cap = cap; $f.i = i; $f.j = j; $f.kind = kind; $f.s = s; $f.str = str; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Slice = function(i, j) { return this.$val.Slice(i, j); };
- Value.ptr.prototype.Slice3 = function(i, j, k) {
- var $ptr, _r, _ref, cap, i, j, k, kind, s, tt, typ, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; cap = $f.cap; i = $f.i; j = $f.j; k = $f.k; kind = $f.kind; s = $f.s; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- cap = 0;
- typ = $ifaceNil;
- s = null;
- kind = new flag(v.flag).kind();
- _ref = kind;
- if (_ref === 17) {
- if (((v.flag & 128) >>> 0) === 0) {
- $panic(new $String("reflect.Value.Slice: slice of unaddressable array"));
- }
- tt = v.typ.kindType;
- cap = (tt.len >> 0);
- typ = SliceOf(tt.elem);
- s = new (jsType(typ))(v.object());
- } else if (_ref === 23) {
- typ = v.typ;
- s = v.object();
- cap = $parseInt(s.$capacity) >> 0;
- } else {
- $panic(new ValueError.ptr("reflect.Value.Slice3", kind));
- }
- if (i < 0 || j < i || k < j || k > cap) {
- $panic(new $String("reflect.Value.Slice3: slice index out of bounds"));
- }
- _r = makeValue(typ, $subslice(s, i, j, k), (v.flag & 32) >>> 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice3 }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.cap = cap; $f.i = i; $f.j = j; $f.k = k; $f.kind = kind; $f.s = s; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Slice3 = function(i, j, k) { return this.$val.Slice3(i, j, k); };
- Value.ptr.prototype.Close = function() {
- var $ptr, v;
- v = this;
- new flag(v.flag).mustBe(18);
- new flag(v.flag).mustBeExported();
- $close(v.object());
- };
- Value.prototype.Close = function() { return this.$val.Close(); };
- chanrecv = function(t, ch, nb, val) {
- var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, ch, comms, nb, received, recvRes, selectRes, selected, t, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; ch = $f.ch; comms = $f.comms; nb = $f.nb; received = $f.received; recvRes = $f.recvRes; selectRes = $f.selectRes; selected = $f.selected; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- selected = false;
- received = false;
- comms = new sliceType$9([new sliceType$1([new $jsObjectPtr(ch)])]);
- if (nb) {
- comms = $append(comms, new sliceType$1([]));
- }
- _r = selectHelper(new sliceType$1([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- selectRes = _r;
- if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) {
- _tmp = false; _tmp$1 = false; selected = _tmp; received = _tmp$1;
- return [selected, received];
- }
- recvRes = selectRes[1];
- val.$set(recvRes[0]);
- _tmp$2 = true; _tmp$3 = !!(recvRes[1]); selected = _tmp$2; received = _tmp$3;
- return [selected, received];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: chanrecv }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.received = received; $f.recvRes = recvRes; $f.selectRes = selectRes; $f.selected = selected; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- chansend = function(t, ch, val, nb) {
- var $ptr, _r, ch, comms, nb, selectRes, t, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; ch = $f.ch; comms = $f.comms; nb = $f.nb; selectRes = $f.selectRes; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- comms = new sliceType$9([new sliceType$1([new $jsObjectPtr(ch), new $jsObjectPtr(val.$get())])]);
- if (nb) {
- comms = $append(comms, new sliceType$1([]));
- }
- _r = selectHelper(new sliceType$1([comms])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- selectRes = _r;
- if (nb && (($parseInt(selectRes[0]) >> 0) === 1)) {
- return false;
- }
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: chansend }; } $f.$ptr = $ptr; $f._r = _r; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.selectRes = selectRes; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- Kind.prototype.String = function() {
- var $ptr, k;
- k = this.$val;
- if ((k >> 0) < kindNames.$length) {
- return ((k < 0 || k >= kindNames.$length) ? $throwRuntimeError("index out of range") : kindNames.$array[kindNames.$offset + k]);
- }
- return "kind" + strconv.Itoa((k >> 0));
- };
- $ptrType(Kind).prototype.String = function() { return new Kind(this.$get()).String(); };
- uncommonType.ptr.prototype.uncommon = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- uncommonType.prototype.uncommon = function() { return this.$val.uncommon(); };
- uncommonType.ptr.prototype.PkgPath = function() {
- var $ptr, t;
- t = this;
- if (t === ptrType$6.nil || t.pkgPath === ptrType$5.nil) {
- return "";
- }
- return t.pkgPath.$get();
- };
- uncommonType.prototype.PkgPath = function() { return this.$val.PkgPath(); };
- uncommonType.ptr.prototype.Name = function() {
- var $ptr, t;
- t = this;
- if (t === ptrType$6.nil || t.name === ptrType$5.nil) {
- return "";
- }
- return t.name.$get();
- };
- uncommonType.prototype.Name = function() { return this.$val.Name(); };
- rtype.ptr.prototype.String = function() {
- var $ptr, t;
- t = this;
- return t.string.$get();
- };
- rtype.prototype.String = function() { return this.$val.String(); };
- rtype.ptr.prototype.Size = function() {
- var $ptr, t;
- t = this;
- return t.size;
- };
- rtype.prototype.Size = function() { return this.$val.Size(); };
- rtype.ptr.prototype.Bits = function() {
- var $ptr, k, t;
- t = this;
- if (t === ptrType$1.nil) {
- $panic(new $String("reflect: Bits of nil Type"));
- }
- k = t.Kind();
- if (k < 2 || k > 16) {
- $panic(new $String("reflect: Bits of non-arithmetic Type " + t.String()));
- }
- return (t.size >> 0) * 8 >> 0;
- };
- rtype.prototype.Bits = function() { return this.$val.Bits(); };
- rtype.ptr.prototype.Align = function() {
- var $ptr, t;
- t = this;
- return (t.align >> 0);
- };
- rtype.prototype.Align = function() { return this.$val.Align(); };
- rtype.ptr.prototype.FieldAlign = function() {
- var $ptr, t;
- t = this;
- return (t.fieldAlign >> 0);
- };
- rtype.prototype.FieldAlign = function() { return this.$val.FieldAlign(); };
- rtype.ptr.prototype.Kind = function() {
- var $ptr, t;
- t = this;
- return (((t.kind & 31) >>> 0) >>> 0);
- };
- rtype.prototype.Kind = function() { return this.$val.Kind(); };
- rtype.ptr.prototype.common = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- rtype.prototype.common = function() { return this.$val.common(); };
- uncommonType.ptr.prototype.NumMethod = function() {
- var $ptr, t;
- t = this;
- if (t === ptrType$6.nil) {
- return 0;
- }
- return t.methods.$length;
- };
- uncommonType.prototype.NumMethod = function() { return this.$val.NumMethod(); };
- uncommonType.ptr.prototype.MethodByName = function(name) {
- var $ptr, _i, _ref, _tmp, _tmp$1, i, m, name, ok, p, t, x;
- m = new Method.ptr();
- ok = false;
- t = this;
- if (t === ptrType$6.nil) {
- return [m, ok];
- }
- p = ptrType$10.nil;
- _ref = t.methods;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- p = (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- if (!(p.name === ptrType$5.nil) && p.name.$get() === name) {
- _tmp = $clone(t.Method(i), Method); _tmp$1 = true; $copy(m, _tmp, Method); ok = _tmp$1;
- return [m, ok];
- }
- _i++;
- }
- return [m, ok];
- };
- uncommonType.prototype.MethodByName = function(name) { return this.$val.MethodByName(name); };
- rtype.ptr.prototype.NumMethod = function() {
- var $ptr, t, tt;
- t = this;
- if (t.Kind() === 20) {
- tt = t.kindType;
- return tt.NumMethod();
- }
- return t.uncommonType.NumMethod();
- };
- rtype.prototype.NumMethod = function() { return this.$val.NumMethod(); };
- rtype.ptr.prototype.Method = function(i) {
- var $ptr, i, m, t, tt;
- m = new Method.ptr();
- t = this;
- if (t.Kind() === 20) {
- tt = t.kindType;
- $copy(m, tt.Method(i), Method);
- return m;
- }
- $copy(m, t.uncommonType.Method(i), Method);
- return m;
- };
- rtype.prototype.Method = function(i) { return this.$val.Method(i); };
- rtype.ptr.prototype.MethodByName = function(name) {
- var $ptr, _tuple, _tuple$1, m, name, ok, t, tt;
- m = new Method.ptr();
- ok = false;
- t = this;
- if (t.Kind() === 20) {
- tt = t.kindType;
- _tuple = tt.MethodByName(name); $copy(m, _tuple[0], Method); ok = _tuple[1];
- return [m, ok];
- }
- _tuple$1 = t.uncommonType.MethodByName(name); $copy(m, _tuple$1[0], Method); ok = _tuple$1[1];
- return [m, ok];
- };
- rtype.prototype.MethodByName = function(name) { return this.$val.MethodByName(name); };
- rtype.ptr.prototype.PkgPath = function() {
- var $ptr, t;
- t = this;
- return t.uncommonType.PkgPath();
- };
- rtype.prototype.PkgPath = function() { return this.$val.PkgPath(); };
- rtype.ptr.prototype.Name = function() {
- var $ptr, t;
- t = this;
- return t.uncommonType.Name();
- };
- rtype.prototype.Name = function() { return this.$val.Name(); };
- rtype.ptr.prototype.ChanDir = function() {
- var $ptr, t, tt;
- t = this;
- if (!((t.Kind() === 18))) {
- $panic(new $String("reflect: ChanDir of non-chan type"));
- }
- tt = t.kindType;
- return (tt.dir >> 0);
- };
- rtype.prototype.ChanDir = function() { return this.$val.ChanDir(); };
- rtype.ptr.prototype.IsVariadic = function() {
- var $ptr, t, tt;
- t = this;
- if (!((t.Kind() === 19))) {
- $panic(new $String("reflect: IsVariadic of non-func type"));
- }
- tt = t.kindType;
- return tt.dotdotdot;
- };
- rtype.prototype.IsVariadic = function() { return this.$val.IsVariadic(); };
- rtype.ptr.prototype.Elem = function() {
- var $ptr, _ref, t, tt, tt$1, tt$2, tt$3, tt$4;
- t = this;
- _ref = t.Kind();
- if (_ref === 17) {
- tt = t.kindType;
- return toType(tt.elem);
- } else if (_ref === 18) {
- tt$1 = t.kindType;
- return toType(tt$1.elem);
- } else if (_ref === 21) {
- tt$2 = t.kindType;
- return toType(tt$2.elem);
- } else if (_ref === 22) {
- tt$3 = t.kindType;
- return toType(tt$3.elem);
- } else if (_ref === 23) {
- tt$4 = t.kindType;
- return toType(tt$4.elem);
- }
- $panic(new $String("reflect: Elem of invalid type"));
- };
- rtype.prototype.Elem = function() { return this.$val.Elem(); };
- rtype.ptr.prototype.Field = function(i) {
- var $ptr, _r, i, t, tt, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- if (!((t.Kind() === 25))) {
- $panic(new $String("reflect: Field of non-struct type"));
- }
- tt = t.kindType;
- _r = tt.Field(i); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Field }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.prototype.Field = function(i) { return this.$val.Field(i); };
- rtype.ptr.prototype.FieldByIndex = function(index) {
- var $ptr, _r, index, t, tt, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; index = $f.index; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- if (!((t.Kind() === 25))) {
- $panic(new $String("reflect: FieldByIndex of non-struct type"));
- }
- tt = t.kindType;
- _r = tt.FieldByIndex(index); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByIndex }; } $f.$ptr = $ptr; $f._r = _r; $f.index = index; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); };
- rtype.ptr.prototype.FieldByName = function(name) {
- var $ptr, _r, name, t, tt, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- if (!((t.Kind() === 25))) {
- $panic(new $String("reflect: FieldByName of non-struct type"));
- }
- tt = t.kindType;
- _r = tt.FieldByName(name); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByName }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.prototype.FieldByName = function(name) { return this.$val.FieldByName(name); };
- rtype.ptr.prototype.FieldByNameFunc = function(match) {
- var $ptr, _r, match, t, tt, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; match = $f.match; t = $f.t; tt = $f.tt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- if (!((t.Kind() === 25))) {
- $panic(new $String("reflect: FieldByNameFunc of non-struct type"));
- }
- tt = t.kindType;
- _r = tt.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByNameFunc }; } $f.$ptr = $ptr; $f._r = _r; $f.match = match; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); };
- rtype.ptr.prototype.In = function(i) {
- var $ptr, i, t, tt, x;
- t = this;
- if (!((t.Kind() === 19))) {
- $panic(new $String("reflect: In of non-func type"));
- }
- tt = t.kindType;
- return toType((x = tt.in$2, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])));
- };
- rtype.prototype.In = function(i) { return this.$val.In(i); };
- rtype.ptr.prototype.Key = function() {
- var $ptr, t, tt;
- t = this;
- if (!((t.Kind() === 21))) {
- $panic(new $String("reflect: Key of non-map type"));
- }
- tt = t.kindType;
- return toType(tt.key);
- };
- rtype.prototype.Key = function() { return this.$val.Key(); };
- rtype.ptr.prototype.Len = function() {
- var $ptr, t, tt;
- t = this;
- if (!((t.Kind() === 17))) {
- $panic(new $String("reflect: Len of non-array type"));
- }
- tt = t.kindType;
- return (tt.len >> 0);
- };
- rtype.prototype.Len = function() { return this.$val.Len(); };
- rtype.ptr.prototype.NumField = function() {
- var $ptr, t, tt;
- t = this;
- if (!((t.Kind() === 25))) {
- $panic(new $String("reflect: NumField of non-struct type"));
- }
- tt = t.kindType;
- return tt.fields.$length;
- };
- rtype.prototype.NumField = function() { return this.$val.NumField(); };
- rtype.ptr.prototype.NumIn = function() {
- var $ptr, t, tt;
- t = this;
- if (!((t.Kind() === 19))) {
- $panic(new $String("reflect: NumIn of non-func type"));
- }
- tt = t.kindType;
- return tt.in$2.$length;
- };
- rtype.prototype.NumIn = function() { return this.$val.NumIn(); };
- rtype.ptr.prototype.NumOut = function() {
- var $ptr, t, tt;
- t = this;
- if (!((t.Kind() === 19))) {
- $panic(new $String("reflect: NumOut of non-func type"));
- }
- tt = t.kindType;
- return tt.out.$length;
- };
- rtype.prototype.NumOut = function() { return this.$val.NumOut(); };
- rtype.ptr.prototype.Out = function(i) {
- var $ptr, i, t, tt, x;
- t = this;
- if (!((t.Kind() === 19))) {
- $panic(new $String("reflect: Out of non-func type"));
- }
- tt = t.kindType;
- return toType((x = tt.out, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])));
- };
- rtype.prototype.Out = function(i) { return this.$val.Out(i); };
- ChanDir.prototype.String = function() {
- var $ptr, _ref, d;
- d = this.$val;
- _ref = d;
- if (_ref === 2) {
- return "chan<-";
- } else if (_ref === 1) {
- return "<-chan";
- } else if (_ref === 3) {
- return "chan";
- }
- return "ChanDir" + strconv.Itoa((d >> 0));
- };
- $ptrType(ChanDir).prototype.String = function() { return new ChanDir(this.$get()).String(); };
- interfaceType.ptr.prototype.Method = function(i) {
- var $ptr, i, m, p, t, x;
- m = new Method.ptr();
- t = this;
- if (i < 0 || i >= t.methods.$length) {
- return m;
- }
- p = (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- m.Name = p.name.$get();
- if (!(p.pkgPath === ptrType$5.nil)) {
- m.PkgPath = p.pkgPath.$get();
- }
- m.Type = toType(p.typ);
- m.Index = i;
- return m;
- };
- interfaceType.prototype.Method = function(i) { return this.$val.Method(i); };
- interfaceType.ptr.prototype.NumMethod = function() {
- var $ptr, t;
- t = this;
- return t.methods.$length;
- };
- interfaceType.prototype.NumMethod = function() { return this.$val.NumMethod(); };
- interfaceType.ptr.prototype.MethodByName = function(name) {
- var $ptr, _i, _ref, _tmp, _tmp$1, i, m, name, ok, p, t, x;
- m = new Method.ptr();
- ok = false;
- t = this;
- if (t === ptrType$11.nil) {
- return [m, ok];
- }
- p = ptrType$12.nil;
- _ref = t.methods;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- p = (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- if (p.name.$get() === name) {
- _tmp = $clone(t.Method(i), Method); _tmp$1 = true; $copy(m, _tmp, Method); ok = _tmp$1;
- return [m, ok];
- }
- _i++;
- }
- return [m, ok];
- };
- interfaceType.prototype.MethodByName = function(name) { return this.$val.MethodByName(name); };
- StructTag.prototype.Get = function(key) {
- var $ptr, _tuple, i, key, name, qvalue, tag, value;
- tag = this.$val;
- while (true) {
- if (!(!(tag === ""))) { break; }
- i = 0;
- while (true) {
- if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; }
- i = i + (1) >> 0;
- }
- tag = tag.substring(i);
- if (tag === "") {
- break;
- }
- i = 0;
- while (true) {
- if (!(i < tag.length && !((tag.charCodeAt(i) === 32)) && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)))) { break; }
- i = i + (1) >> 0;
- }
- if ((i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) {
- break;
- }
- name = tag.substring(0, i);
- tag = tag.substring((i + 1 >> 0));
- i = 1;
- while (true) {
- if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; }
- if (tag.charCodeAt(i) === 92) {
- i = i + (1) >> 0;
- }
- i = i + (1) >> 0;
- }
- if (i >= tag.length) {
- break;
- }
- qvalue = tag.substring(0, (i + 1 >> 0));
- tag = tag.substring((i + 1 >> 0));
- if (key === name) {
- _tuple = strconv.Unquote(qvalue); value = _tuple[0];
- return value;
- }
- }
- return "";
- };
- $ptrType(StructTag).prototype.Get = function(key) { return new StructTag(this.$get()).Get(key); };
- structType.ptr.prototype.Field = function(i) {
- var $ptr, _r, _r$1, _r$2, f, i, p, t, t$1, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; f = $f.f; i = $f.i; p = $f.p; t = $f.t; t$1 = $f.t$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = new StructField.ptr();
- t = this;
- if (i < 0 || i >= t.fields.$length) {
- return f;
- }
- p = (x = t.fields, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- f.Type = toType(p.typ);
- /* */ if (!(p.name === ptrType$5.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(p.name === ptrType$5.nil)) { */ case 1:
- f.Name = p.name.$get();
- $s = 3; continue;
- /* } else { */ case 2:
- t$1 = f.Type;
- _r = t$1.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r === 22) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_r === 22) { */ case 4:
- _r$1 = t$1.Elem(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- t$1 = _r$1;
- /* } */ case 5:
- _r$2 = t$1.Name(); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- f.Name = _r$2;
- f.Anonymous = true;
- /* } */ case 3:
- if (!(p.pkgPath === ptrType$5.nil)) {
- f.PkgPath = p.pkgPath.$get();
- }
- if (!(p.tag === ptrType$5.nil)) {
- f.Tag = p.tag.$get();
- }
- f.Offset = p.offset;
- f.Index = new sliceType$11([i]);
- return f;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.Field }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.f = f; $f.i = i; $f.p = p; $f.t = t; $f.t$1 = t$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- structType.prototype.Field = function(i) { return this.$val.Field(i); };
- structType.ptr.prototype.FieldByIndex = function(index) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _ref, _v, f, ft, i, index, t, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _v = $f._v; f = $f.f; ft = $f.ft; i = $f.i; index = $f.index; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = new StructField.ptr();
- t = this;
- f.Type = toType(t.rtype);
- _ref = index;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (i > 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (i > 0) { */ case 3:
- ft = f.Type;
- _r = ft.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- if (!(_r === 22)) { _v = false; $s = 7; continue s; }
- _r$1 = ft.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = _r$1.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2 === 25; case 7:
- /* */ if (_v) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_v) { */ case 5:
- _r$3 = ft.Elem(); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- ft = _r$3;
- /* } */ case 6:
- f.Type = ft;
- /* } */ case 4:
- _r$4 = f.Type.Field(x); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $copy(f, _r$4, StructField);
- _i++;
- /* } */ $s = 1; continue; case 2:
- return f;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByIndex }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._v = _v; $f.f = f; $f.ft = ft; $f.i = i; $f.index = index; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- structType.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); };
- structType.ptr.prototype.FieldByNameFunc = function(match) {
- var $ptr, _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _key, _key$1, _key$2, _key$3, _key$4, _key$5, _map, _map$1, _r, _r$1, _r$2, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, count, current, f, fname, i, index, match, next, nextCount, ntyp, ok, result, scan, styp, t, t$1, visited, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _i$1 = $f._i$1; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _key$4 = $f._key$4; _key$5 = $f._key$5; _map = $f._map; _map$1 = $f._map$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; count = $f.count; current = $f.current; f = $f.f; fname = $f.fname; i = $f.i; index = $f.index; match = $f.match; next = $f.next; nextCount = $f.nextCount; ntyp = $f.ntyp; ok = $f.ok; result = $f.result; scan = $f.scan; styp = $f.styp; t = $f.t; t$1 = $f.t$1; visited = $f.visited; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- result = new StructField.ptr();
- ok = false;
- t = this;
- current = new sliceType$12([]);
- next = new sliceType$12([new fieldScan.ptr(t, sliceType$11.nil)]);
- nextCount = false;
- visited = (_map = new $Map(), _map);
- /* while (true) { */ case 1:
- /* if (!(next.$length > 0)) { break; } */ if(!(next.$length > 0)) { $s = 2; continue; }
- _tmp = next; _tmp$1 = $subslice(current, 0, 0); current = _tmp; next = _tmp$1;
- count = nextCount;
- nextCount = false;
- _ref = current;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- scan = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), fieldScan);
- t$1 = scan.typ;
- /* */ if ((_entry = visited[ptrType$13.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ((_entry = visited[ptrType$13.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { */ case 5:
- _i++;
- /* continue; */ $s = 3; continue;
- /* } */ case 6:
- _key$1 = t$1; (visited || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$1)] = { k: _key$1, v: true };
- _ref$1 = t$1.fields;
- _i$1 = 0;
- /* while (true) { */ case 7:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 8; continue; }
- i = _i$1;
- f = (x = t$1.fields, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- fname = "";
- ntyp = ptrType$1.nil;
- /* */ if (!(f.name === ptrType$5.nil)) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!(f.name === ptrType$5.nil)) { */ case 9:
- fname = f.name.$get();
- $s = 11; continue;
- /* } else { */ case 10:
- ntyp = f.typ;
- /* */ if (ntyp.Kind() === 22) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (ntyp.Kind() === 22) { */ case 12:
- _r = ntyp.Elem().common(); /* */ $s = 14; case 14: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- ntyp = _r;
- /* } */ case 13:
- fname = ntyp.Name();
- /* } */ case 11:
- _r$1 = match(fname); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_r$1) { */ case 15:
- if ((_entry$1 = count[ptrType$13.keyFor(t$1)], _entry$1 !== undefined ? _entry$1.v : 0) > 1 || ok) {
- _tmp$2 = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$11.nil, false); _tmp$3 = false; $copy(result, _tmp$2, StructField); ok = _tmp$3;
- return [result, ok];
- }
- _r$2 = t$1.Field(i); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $copy(result, _r$2, StructField);
- result.Index = sliceType$11.nil;
- result.Index = $appendSlice(result.Index, scan.index);
- result.Index = $append(result.Index, i);
- ok = true;
- _i$1++;
- /* continue; */ $s = 7; continue;
- /* } */ case 16:
- if (ok || ntyp === ptrType$1.nil || !((ntyp.Kind() === 25))) {
- _i$1++;
- /* continue; */ $s = 7; continue;
- }
- styp = ntyp.kindType;
- if ((_entry$2 = nextCount[ptrType$13.keyFor(styp)], _entry$2 !== undefined ? _entry$2.v : 0) > 0) {
- _key$2 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$2)] = { k: _key$2, v: 2 };
- _i$1++;
- /* continue; */ $s = 7; continue;
- }
- if (nextCount === false) {
- nextCount = (_map$1 = new $Map(), _map$1);
- }
- _key$4 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$4)] = { k: _key$4, v: 1 };
- if ((_entry$3 = count[ptrType$13.keyFor(t$1)], _entry$3 !== undefined ? _entry$3.v : 0) > 1) {
- _key$5 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$5)] = { k: _key$5, v: 2 };
- }
- index = sliceType$11.nil;
- index = $appendSlice(index, scan.index);
- index = $append(index, i);
- next = $append(next, new fieldScan.ptr(styp, index));
- _i$1++;
- /* } */ $s = 7; continue; case 8:
- _i++;
- /* } */ $s = 3; continue; case 4:
- if (ok) {
- /* break; */ $s = 2; continue;
- }
- /* } */ $s = 1; continue; case 2:
- return [result, ok];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByNameFunc }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._i$1 = _i$1; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._key$4 = _key$4; $f._key$5 = _key$5; $f._map = _map; $f._map$1 = _map$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.count = count; $f.current = current; $f.f = f; $f.fname = fname; $f.i = i; $f.index = index; $f.match = match; $f.next = next; $f.nextCount = nextCount; $f.ntyp = ntyp; $f.ok = ok; $f.result = result; $f.scan = scan; $f.styp = styp; $f.t = t; $f.t$1 = t$1; $f.visited = visited; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- structType.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); };
- structType.ptr.prototype.FieldByName = function(name) {
- var $ptr, _i, _r, _r$1, _ref, _tmp, _tmp$1, _tuple, f, hasAnon, i, name, present, t, tf, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; f = $f.f; hasAnon = $f.hasAnon; i = $f.i; name = $f.name; present = $f.present; t = $f.t; tf = $f.tf; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- name = [name];
- f = new StructField.ptr();
- present = false;
- t = this;
- hasAnon = false;
- /* */ if (!(name[0] === "")) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(name[0] === "")) { */ case 1:
- _ref = t.fields;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- i = _i;
- tf = (x = t.fields, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- /* */ if (tf.name === ptrType$5.nil) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (tf.name === ptrType$5.nil) { */ case 5:
- hasAnon = true;
- _i++;
- /* continue; */ $s = 3; continue;
- /* } */ case 6:
- /* */ if (tf.name.$get() === name[0]) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (tf.name.$get() === name[0]) { */ case 7:
- _r = t.Field(i); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tmp = $clone(_r, StructField); _tmp$1 = true; $copy(f, _tmp, StructField); present = _tmp$1;
- return [f, present];
- /* } */ case 8:
- _i++;
- /* } */ $s = 3; continue; case 4:
- /* } */ case 2:
- if (!hasAnon) {
- return [f, present];
- }
- _r$1 = t.FieldByNameFunc((function(name) { return function(s) {
- var $ptr, s;
- return s === name[0];
- }; })(name)); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; $copy(f, _tuple[0], StructField); present = _tuple[1];
- return [f, present];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByName }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.f = f; $f.hasAnon = hasAnon; $f.i = i; $f.name = name; $f.present = present; $f.t = t; $f.tf = tf; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- structType.prototype.FieldByName = function(name) { return this.$val.FieldByName(name); };
- PtrTo = function(t) {
- var $ptr, t;
- return $assertType(t, ptrType$1).ptrTo();
- };
- $pkg.PtrTo = PtrTo;
- rtype.ptr.prototype.Implements = function(u) {
- var $ptr, _r, t, u, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- if ($interfaceIsEqual(u, $ifaceNil)) {
- $panic(new $String("reflect: nil type passed to Type.Implements"));
- }
- _r = u.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!((_r === 20))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r === 20))) { */ case 1:
- $panic(new $String("reflect: non-interface type passed to Type.Implements"));
- /* } */ case 2:
- return implements$1($assertType(u, ptrType$1), t);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Implements }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.u = u; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.prototype.Implements = function(u) { return this.$val.Implements(u); };
- rtype.ptr.prototype.AssignableTo = function(u) {
- var $ptr, t, u, uu;
- t = this;
- if ($interfaceIsEqual(u, $ifaceNil)) {
- $panic(new $String("reflect: nil type passed to Type.AssignableTo"));
- }
- uu = $assertType(u, ptrType$1);
- return directlyAssignable(uu, t) || implements$1(uu, t);
- };
- rtype.prototype.AssignableTo = function(u) { return this.$val.AssignableTo(u); };
- rtype.ptr.prototype.ConvertibleTo = function(u) {
- var $ptr, _r, t, u, uu, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; u = $f.u; uu = $f.uu; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- if ($interfaceIsEqual(u, $ifaceNil)) {
- $panic(new $String("reflect: nil type passed to Type.ConvertibleTo"));
- }
- uu = $assertType(u, ptrType$1);
- _r = convertOp(uu, t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return !(_r === $throwNilPointerError);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.ConvertibleTo }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.u = u; $f.uu = uu; $f.$s = $s; $f.$r = $r; return $f;
- };
- rtype.prototype.ConvertibleTo = function(u) { return this.$val.ConvertibleTo(u); };
- implements$1 = function(T, V) {
- var $ptr, T, V, i, i$1, j, j$1, t, tm, tm$1, v, v$1, vm, vm$1, x, x$1, x$2, x$3;
- if (!((T.Kind() === 20))) {
- return false;
- }
- t = T.kindType;
- if (t.methods.$length === 0) {
- return true;
- }
- if (V.Kind() === 20) {
- v = V.kindType;
- i = 0;
- j = 0;
- while (true) {
- if (!(j < v.methods.$length)) { break; }
- tm = (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- vm = (x$1 = v.methods, ((j < 0 || j >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + j]));
- if (vm.name === tm.name && vm.pkgPath === tm.pkgPath && vm.typ === tm.typ) {
- i = i + (1) >> 0;
- if (i >= t.methods.$length) {
- return true;
- }
- }
- j = j + (1) >> 0;
- }
- return false;
- }
- v$1 = V.uncommonType.uncommon();
- if (v$1 === ptrType$6.nil) {
- return false;
- }
- i$1 = 0;
- j$1 = 0;
- while (true) {
- if (!(j$1 < v$1.methods.$length)) { break; }
- tm$1 = (x$2 = t.methods, ((i$1 < 0 || i$1 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$1]));
- vm$1 = (x$3 = v$1.methods, ((j$1 < 0 || j$1 >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + j$1]));
- if (vm$1.name === tm$1.name && vm$1.pkgPath === tm$1.pkgPath && vm$1.mtyp === tm$1.typ) {
- i$1 = i$1 + (1) >> 0;
- if (i$1 >= t.methods.$length) {
- return true;
- }
- }
- j$1 = j$1 + (1) >> 0;
- }
- return false;
- };
- directlyAssignable = function(T, V) {
- var $ptr, T, V;
- if (T === V) {
- return true;
- }
- if (!(T.Name() === "") && !(V.Name() === "") || !((T.Kind() === V.Kind()))) {
- return false;
- }
- return haveIdenticalUnderlyingType(T, V);
- };
- haveIdenticalUnderlyingType = function(T, V) {
- var $ptr, T, V, _i, _i$1, _i$2, _ref, _ref$1, _ref$2, _ref$3, i, i$1, i$2, kind, t, t$1, t$2, tf, typ, typ$1, v, v$1, v$2, vf, x, x$1, x$2, x$3;
- if (T === V) {
- return true;
- }
- kind = T.Kind();
- if (!((kind === V.Kind()))) {
- return false;
- }
- if (1 <= kind && kind <= 16 || (kind === 24) || (kind === 26)) {
- return true;
- }
- _ref = kind;
- if (_ref === 17) {
- return $interfaceIsEqual(T.Elem(), V.Elem()) && (T.Len() === V.Len());
- } else if (_ref === 18) {
- if ((V.ChanDir() === 3) && $interfaceIsEqual(T.Elem(), V.Elem())) {
- return true;
- }
- return (V.ChanDir() === T.ChanDir()) && $interfaceIsEqual(T.Elem(), V.Elem());
- } else if (_ref === 19) {
- t = T.kindType;
- v = V.kindType;
- if (!(t.dotdotdot === v.dotdotdot) || !((t.in$2.$length === v.in$2.$length)) || !((t.out.$length === v.out.$length))) {
- return false;
- }
- _ref$1 = t.in$2;
- _i = 0;
- while (true) {
- if (!(_i < _ref$1.$length)) { break; }
- i = _i;
- typ = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- if (!(typ === (x = v.in$2, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])))) {
- return false;
- }
- _i++;
- }
- _ref$2 = t.out;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$2.$length)) { break; }
- i$1 = _i$1;
- typ$1 = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- if (!(typ$1 === (x$1 = v.out, ((i$1 < 0 || i$1 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i$1])))) {
- return false;
- }
- _i$1++;
- }
- return true;
- } else if (_ref === 20) {
- t$1 = T.kindType;
- v$1 = V.kindType;
- if ((t$1.methods.$length === 0) && (v$1.methods.$length === 0)) {
- return true;
- }
- return false;
- } else if (_ref === 21) {
- return $interfaceIsEqual(T.Key(), V.Key()) && $interfaceIsEqual(T.Elem(), V.Elem());
- } else if (_ref === 22 || _ref === 23) {
- return $interfaceIsEqual(T.Elem(), V.Elem());
- } else if (_ref === 25) {
- t$2 = T.kindType;
- v$2 = V.kindType;
- if (!((t$2.fields.$length === v$2.fields.$length))) {
- return false;
- }
- _ref$3 = t$2.fields;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$3.$length)) { break; }
- i$2 = _i$2;
- tf = (x$2 = t$2.fields, ((i$2 < 0 || i$2 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$2]));
- vf = (x$3 = v$2.fields, ((i$2 < 0 || i$2 >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + i$2]));
- if (!(tf.name === vf.name) && (tf.name === ptrType$5.nil || vf.name === ptrType$5.nil || !(tf.name.$get() === vf.name.$get()))) {
- return false;
- }
- if (!(tf.pkgPath === vf.pkgPath) && (tf.pkgPath === ptrType$5.nil || vf.pkgPath === ptrType$5.nil || !(tf.pkgPath.$get() === vf.pkgPath.$get()))) {
- return false;
- }
- if (!(tf.typ === vf.typ)) {
- return false;
- }
- if (!(tf.tag === vf.tag) && (tf.tag === ptrType$5.nil || vf.tag === ptrType$5.nil || !(tf.tag.$get() === vf.tag.$get()))) {
- return false;
- }
- if (!((tf.offset === vf.offset))) {
- return false;
- }
- _i$2++;
- }
- return true;
- }
- return false;
- };
- toType = function(t) {
- var $ptr, t;
- if (t === ptrType$1.nil) {
- return $ifaceNil;
- }
- return t;
- };
- ifaceIndir = function(t) {
- var $ptr, t;
- return ((t.kind & 32) >>> 0) === 0;
- };
- flag.prototype.kind = function() {
- var $ptr, f;
- f = this.$val;
- return (((f & 31) >>> 0) >>> 0);
- };
- $ptrType(flag).prototype.kind = function() { return new flag(this.$get()).kind(); };
- Value.ptr.prototype.pointer = function() {
- var $ptr, v;
- v = this;
- if (!((v.typ.size === 4)) || !v.typ.pointers()) {
- $panic(new $String("can't call pointer on a non-pointer Value"));
- }
- if (!((((v.flag & 64) >>> 0) === 0))) {
- return v.ptr.$get();
- }
- return v.ptr;
- };
- Value.prototype.pointer = function() { return this.$val.pointer(); };
- ValueError.ptr.prototype.Error = function() {
- var $ptr, e;
- e = this;
- if (e.Kind === 0) {
- return "reflect: call of " + e.Method + " on zero Value";
- }
- return "reflect: call of " + e.Method + " on " + new Kind(e.Kind).String() + " Value";
- };
- ValueError.prototype.Error = function() { return this.$val.Error(); };
- flag.prototype.mustBe = function(expected) {
- var $ptr, expected, f;
- f = this.$val;
- if (!((new flag(f).kind() === expected))) {
- $panic(new ValueError.ptr(methodName(), new flag(f).kind()));
- }
- };
- $ptrType(flag).prototype.mustBe = function(expected) { return new flag(this.$get()).mustBe(expected); };
- flag.prototype.mustBeExported = function() {
- var $ptr, f;
- f = this.$val;
- if (f === 0) {
- $panic(new ValueError.ptr(methodName(), 0));
- }
- if (!((((f & 32) >>> 0) === 0))) {
- $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field"));
- }
- };
- $ptrType(flag).prototype.mustBeExported = function() { return new flag(this.$get()).mustBeExported(); };
- flag.prototype.mustBeAssignable = function() {
- var $ptr, f;
- f = this.$val;
- if (f === 0) {
- $panic(new ValueError.ptr(methodName(), 0));
- }
- if (!((((f & 32) >>> 0) === 0))) {
- $panic(new $String("reflect: " + methodName() + " using value obtained using unexported field"));
- }
- if (((f & 128) >>> 0) === 0) {
- $panic(new $String("reflect: " + methodName() + " using unaddressable value"));
- }
- };
- $ptrType(flag).prototype.mustBeAssignable = function() { return new flag(this.$get()).mustBeAssignable(); };
- Value.ptr.prototype.Addr = function() {
- var $ptr, v;
- v = this;
- if (((v.flag & 128) >>> 0) === 0) {
- $panic(new $String("reflect.Value.Addr of unaddressable value"));
- }
- return new Value.ptr(v.typ.ptrTo(), v.ptr, ((((v.flag & 32) >>> 0)) | 22) >>> 0);
- };
- Value.prototype.Addr = function() { return this.$val.Addr(); };
- Value.ptr.prototype.Bool = function() {
- var $ptr, v;
- v = this;
- new flag(v.flag).mustBe(1);
- return v.ptr.$get();
- };
- Value.prototype.Bool = function() { return this.$val.Bool(); };
- Value.ptr.prototype.Bytes = function() {
- var $ptr, _r, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBe(23);
- _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!((_r === 8))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r === 8))) { */ case 1:
- $panic(new $String("reflect.Value.Bytes of non-byte slice"));
- /* } */ case 2:
- return v.ptr.$get();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Bytes }; } $f.$ptr = $ptr; $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Bytes = function() { return this.$val.Bytes(); };
- Value.ptr.prototype.runes = function() {
- var $ptr, _r, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBe(23);
- _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!((_r === 5))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r === 5))) { */ case 1:
- $panic(new $String("reflect.Value.Bytes of non-rune slice"));
- /* } */ case 2:
- return v.ptr.$get();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.runes }; } $f.$ptr = $ptr; $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.runes = function() { return this.$val.runes(); };
- Value.ptr.prototype.CanAddr = function() {
- var $ptr, v;
- v = this;
- return !((((v.flag & 128) >>> 0) === 0));
- };
- Value.prototype.CanAddr = function() { return this.$val.CanAddr(); };
- Value.ptr.prototype.CanSet = function() {
- var $ptr, v;
- v = this;
- return ((v.flag & 160) >>> 0) === 128;
- };
- Value.prototype.CanSet = function() { return this.$val.CanSet(); };
- Value.ptr.prototype.Call = function(in$1) {
- var $ptr, _r, in$1, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBe(19);
- new flag(v.flag).mustBeExported();
- _r = v.call("Call", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Call }; } $f.$ptr = $ptr; $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Call = function(in$1) { return this.$val.Call(in$1); };
- Value.ptr.prototype.CallSlice = function(in$1) {
- var $ptr, _r, in$1, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; in$1 = $f.in$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBe(19);
- new flag(v.flag).mustBeExported();
- _r = v.call("CallSlice", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.CallSlice }; } $f.$ptr = $ptr; $f._r = _r; $f.in$1 = in$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.CallSlice = function(in$1) { return this.$val.CallSlice(in$1); };
- Value.ptr.prototype.Complex = function() {
- var $ptr, _ref, k, v, x;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 15) {
- return (x = v.ptr.$get(), new $Complex128(x.$real, x.$imag));
- } else if (_ref === 16) {
- return v.ptr.$get();
- }
- $panic(new ValueError.ptr("reflect.Value.Complex", new flag(v.flag).kind()));
- };
- Value.prototype.Complex = function() { return this.$val.Complex(); };
- Value.ptr.prototype.FieldByIndex = function(index) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _ref, _v, i, index, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _v = $f._v; i = $f.i; index = $f.index; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- /* */ if (index.$length === 1) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (index.$length === 1) { */ case 1:
- _r = v.Field((0 >= index.$length ? $throwRuntimeError("index out of range") : index.$array[index.$offset + 0])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- new flag(v.flag).mustBe(25);
- _ref = index;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- i = _i;
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (i > 0) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (i > 0) { */ case 6:
- if (!(v.Kind() === 22)) { _v = false; $s = 10; continue s; }
- _r$1 = v.typ.Elem().Kind(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1 === 25; case 10:
- /* */ if (_v) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_v) { */ case 8:
- if (v.IsNil()) {
- $panic(new $String("reflect: indirection through nil pointer to embedded struct"));
- }
- _r$2 = v.Elem(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- /* } */ case 9:
- /* } */ case 7:
- _r$3 = v.Field(x); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- v = _r$3;
- _i++;
- /* } */ $s = 4; continue; case 5:
- return v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByIndex }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._v = _v; $f.i = i; $f.index = index; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.FieldByIndex = function(index) { return this.$val.FieldByIndex(index); };
- Value.ptr.prototype.FieldByName = function(name) {
- var $ptr, _r, _r$1, _tuple, f, name, ok, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; name = $f.name; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBe(25);
- _r = v.typ.FieldByName(name); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f = $clone(_tuple[0], StructField); ok = _tuple[1];
- /* */ if (ok) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (ok) { */ case 2:
- _r$1 = v.FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 3:
- return new Value.ptr(ptrType$1.nil, 0, 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByName }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.name = name; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.FieldByName = function(name) { return this.$val.FieldByName(name); };
- Value.ptr.prototype.FieldByNameFunc = function(match) {
- var $ptr, _r, _r$1, _tuple, f, match, ok, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; match = $f.match; ok = $f.ok; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- _r = v.typ.FieldByNameFunc(match); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f = $clone(_tuple[0], StructField); ok = _tuple[1];
- /* */ if (ok) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (ok) { */ case 2:
- _r$1 = v.FieldByIndex(f.Index); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 3:
- return new Value.ptr(ptrType$1.nil, 0, 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByNameFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.match = match; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.FieldByNameFunc = function(match) { return this.$val.FieldByNameFunc(match); };
- Value.ptr.prototype.Float = function() {
- var $ptr, _ref, k, v;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 13) {
- return v.ptr.$get();
- } else if (_ref === 14) {
- return v.ptr.$get();
- }
- $panic(new ValueError.ptr("reflect.Value.Float", new flag(v.flag).kind()));
- };
- Value.prototype.Float = function() { return this.$val.Float(); };
- Value.ptr.prototype.Int = function() {
- var $ptr, _ref, k, p, v;
- v = this;
- k = new flag(v.flag).kind();
- p = v.ptr;
- _ref = k;
- if (_ref === 2) {
- return new $Int64(0, p.$get());
- } else if (_ref === 3) {
- return new $Int64(0, p.$get());
- } else if (_ref === 4) {
- return new $Int64(0, p.$get());
- } else if (_ref === 5) {
- return new $Int64(0, p.$get());
- } else if (_ref === 6) {
- return p.$get();
- }
- $panic(new ValueError.ptr("reflect.Value.Int", new flag(v.flag).kind()));
- };
- Value.prototype.Int = function() { return this.$val.Int(); };
- Value.ptr.prototype.CanInterface = function() {
- var $ptr, v;
- v = this;
- if (v.flag === 0) {
- $panic(new ValueError.ptr("reflect.Value.CanInterface", 0));
- }
- return ((v.flag & 32) >>> 0) === 0;
- };
- Value.prototype.CanInterface = function() { return this.$val.CanInterface(); };
- Value.ptr.prototype.Interface = function() {
- var $ptr, _r, i, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = $ifaceNil;
- v = this;
- _r = valueInterface(v, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- i = _r;
- return i;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Interface }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Interface = function() { return this.$val.Interface(); };
- Value.ptr.prototype.InterfaceData = function() {
- var $ptr, v;
- v = this;
- new flag(v.flag).mustBe(20);
- return v.ptr;
- };
- Value.prototype.InterfaceData = function() { return this.$val.InterfaceData(); };
- Value.ptr.prototype.IsValid = function() {
- var $ptr, v;
- v = this;
- return !((v.flag === 0));
- };
- Value.prototype.IsValid = function() { return this.$val.IsValid(); };
- Value.ptr.prototype.Kind = function() {
- var $ptr, v;
- v = this;
- return new flag(v.flag).kind();
- };
- Value.prototype.Kind = function() { return this.$val.Kind(); };
- Value.ptr.prototype.MapIndex = function(key) {
- var $ptr, _r, c, e, fl, k, key, tt, typ, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; c = $f.c; e = $f.e; fl = $f.fl; k = $f.k; key = $f.key; tt = $f.tt; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- key = key;
- new flag(v.flag).mustBe(21);
- tt = v.typ.kindType;
- _r = key.assignTo("reflect.Value.MapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- key = _r;
- k = 0;
- if (!((((key.flag & 64) >>> 0) === 0))) {
- k = key.ptr;
- } else {
- k = (key.$ptr_ptr || (key.$ptr_ptr = new ptrType$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)));
- }
- e = mapaccess(v.typ, v.pointer(), k);
- if (e === 0) {
- return new Value.ptr(ptrType$1.nil, 0, 0);
- }
- typ = tt.elem;
- fl = ((((v.flag | key.flag) >>> 0)) & 32) >>> 0;
- fl = (fl | ((typ.Kind() >>> 0))) >>> 0;
- if (ifaceIndir(typ)) {
- c = unsafe_New(typ);
- memmove(c, e, typ.size);
- return new Value.ptr(typ, c, (fl | 64) >>> 0);
- } else {
- return new Value.ptr(typ, e.$get(), fl);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapIndex }; } $f.$ptr = $ptr; $f._r = _r; $f.c = c; $f.e = e; $f.fl = fl; $f.k = k; $f.key = key; $f.tt = tt; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.MapIndex = function(key) { return this.$val.MapIndex(key); };
- Value.ptr.prototype.MapKeys = function() {
- var $ptr, _r, a, c, fl, i, it, key, keyType, m, mlen, tt, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; a = $f.a; c = $f.c; fl = $f.fl; i = $f.i; it = $f.it; key = $f.key; keyType = $f.keyType; m = $f.m; mlen = $f.mlen; tt = $f.tt; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBe(21);
- tt = v.typ.kindType;
- keyType = tt.key;
- fl = (((v.flag & 32) >>> 0) | (keyType.Kind() >>> 0)) >>> 0;
- m = v.pointer();
- mlen = 0;
- if (!(m === 0)) {
- mlen = maplen(m);
- }
- it = mapiterinit(v.typ, m);
- a = $makeSlice(sliceType$7, mlen);
- i = 0;
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < a.$length)) { break; } */ if(!(i < a.$length)) { $s = 2; continue; }
- _r = mapiterkey(it); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- key = _r;
- if (key === 0) {
- /* break; */ $s = 2; continue;
- }
- if (ifaceIndir(keyType)) {
- c = unsafe_New(keyType);
- memmove(c, key, keyType.size);
- ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = new Value.ptr(keyType, c, (fl | 64) >>> 0));
- } else {
- ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = new Value.ptr(keyType, key.$get(), fl));
- }
- mapiternext(it);
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- return $subslice(a, 0, i);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapKeys }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.c = c; $f.fl = fl; $f.i = i; $f.it = it; $f.key = key; $f.keyType = keyType; $f.m = m; $f.mlen = mlen; $f.tt = tt; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.MapKeys = function() { return this.$val.MapKeys(); };
- Value.ptr.prototype.Method = function(i) {
- var $ptr, fl, i, v;
- v = this;
- if (v.typ === ptrType$1.nil) {
- $panic(new ValueError.ptr("reflect.Value.Method", 0));
- }
- if (!((((v.flag & 256) >>> 0) === 0)) || (i >>> 0) >= (v.typ.NumMethod() >>> 0)) {
- $panic(new $String("reflect: Method index out of range"));
- }
- if ((v.typ.Kind() === 20) && v.IsNil()) {
- $panic(new $String("reflect: Method on nil interface value"));
- }
- fl = (v.flag & 96) >>> 0;
- fl = (fl | (19)) >>> 0;
- fl = (fl | (((((i >>> 0) << 9 >>> 0) | 256) >>> 0))) >>> 0;
- return new Value.ptr(v.typ, v.ptr, fl);
- };
- Value.prototype.Method = function(i) { return this.$val.Method(i); };
- Value.ptr.prototype.NumMethod = function() {
- var $ptr, v;
- v = this;
- if (v.typ === ptrType$1.nil) {
- $panic(new ValueError.ptr("reflect.Value.NumMethod", 0));
- }
- if (!((((v.flag & 256) >>> 0) === 0))) {
- return 0;
- }
- return v.typ.NumMethod();
- };
- Value.prototype.NumMethod = function() { return this.$val.NumMethod(); };
- Value.ptr.prototype.MethodByName = function(name) {
- var $ptr, _tuple, m, name, ok, v;
- v = this;
- if (v.typ === ptrType$1.nil) {
- $panic(new ValueError.ptr("reflect.Value.MethodByName", 0));
- }
- if (!((((v.flag & 256) >>> 0) === 0))) {
- return new Value.ptr(ptrType$1.nil, 0, 0);
- }
- _tuple = v.typ.MethodByName(name); m = $clone(_tuple[0], Method); ok = _tuple[1];
- if (!ok) {
- return new Value.ptr(ptrType$1.nil, 0, 0);
- }
- return v.Method(m.Index);
- };
- Value.prototype.MethodByName = function(name) { return this.$val.MethodByName(name); };
- Value.ptr.prototype.NumField = function() {
- var $ptr, tt, v;
- v = this;
- new flag(v.flag).mustBe(25);
- tt = v.typ.kindType;
- return tt.fields.$length;
- };
- Value.prototype.NumField = function() { return this.$val.NumField(); };
- Value.ptr.prototype.OverflowComplex = function(x) {
- var $ptr, _ref, k, v, x;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 15) {
- return overflowFloat32(x.$real) || overflowFloat32(x.$imag);
- } else if (_ref === 16) {
- return false;
- }
- $panic(new ValueError.ptr("reflect.Value.OverflowComplex", new flag(v.flag).kind()));
- };
- Value.prototype.OverflowComplex = function(x) { return this.$val.OverflowComplex(x); };
- Value.ptr.prototype.OverflowFloat = function(x) {
- var $ptr, _ref, k, v, x;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 13) {
- return overflowFloat32(x);
- } else if (_ref === 14) {
- return false;
- }
- $panic(new ValueError.ptr("reflect.Value.OverflowFloat", new flag(v.flag).kind()));
- };
- Value.prototype.OverflowFloat = function(x) { return this.$val.OverflowFloat(x); };
- overflowFloat32 = function(x) {
- var $ptr, x;
- if (x < 0) {
- x = -x;
- }
- return 3.4028234663852886e+38 < x && x <= 1.7976931348623157e+308;
- };
- Value.ptr.prototype.OverflowInt = function(x) {
- var $ptr, _ref, bitSize, k, trunc, v, x, x$1;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) {
- bitSize = (x$1 = v.typ.size, (((x$1 >>> 16 << 16) * 8 >>> 0) + (x$1 << 16 >>> 16) * 8) >>> 0);
- trunc = $shiftRightInt64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0)));
- return !((x.$high === trunc.$high && x.$low === trunc.$low));
- }
- $panic(new ValueError.ptr("reflect.Value.OverflowInt", new flag(v.flag).kind()));
- };
- Value.prototype.OverflowInt = function(x) { return this.$val.OverflowInt(x); };
- Value.ptr.prototype.OverflowUint = function(x) {
- var $ptr, _ref, bitSize, k, trunc, v, x, x$1;
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 7 || _ref === 12 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11) {
- bitSize = (x$1 = v.typ.size, (((x$1 >>> 16 << 16) * 8 >>> 0) + (x$1 << 16 >>> 16) * 8) >>> 0);
- trunc = $shiftRightUint64(($shiftLeft64(x, ((64 - bitSize >>> 0)))), ((64 - bitSize >>> 0)));
- return !((x.$high === trunc.$high && x.$low === trunc.$low));
- }
- $panic(new ValueError.ptr("reflect.Value.OverflowUint", new flag(v.flag).kind()));
- };
- Value.prototype.OverflowUint = function(x) { return this.$val.OverflowUint(x); };
- Value.ptr.prototype.Recv = function() {
- var $ptr, _r, _tuple, ok, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = new Value.ptr();
- ok = false;
- v = this;
- new flag(v.flag).mustBe(18);
- new flag(v.flag).mustBeExported();
- _r = v.recv(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; x = _tuple[0]; ok = _tuple[1];
- return [x, ok];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Recv }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Recv = function() { return this.$val.Recv(); };
- Value.ptr.prototype.recv = function(nb) {
- var $ptr, _r, _tuple, nb, ok, p, selected, t, tt, v, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; nb = $f.nb; ok = $f.ok; p = $f.p; selected = $f.selected; t = $f.t; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- val = new Value.ptr();
- ok = false;
- v = this;
- tt = v.typ.kindType;
- if (((tt.dir >> 0) & 1) === 0) {
- $panic(new $String("reflect: recv on send-only channel"));
- }
- t = tt.elem;
- val = new Value.ptr(t, 0, (t.Kind() >>> 0));
- p = 0;
- if (ifaceIndir(t)) {
- p = unsafe_New(t);
- val.ptr = p;
- val.flag = (val.flag | (64)) >>> 0;
- } else {
- p = (val.$ptr_ptr || (val.$ptr_ptr = new ptrType$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)));
- }
- _r = chanrecv(v.typ, v.pointer(), nb, p); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; selected = _tuple[0]; ok = _tuple[1];
- if (!selected) {
- val = new Value.ptr(ptrType$1.nil, 0, 0);
- }
- return [val, ok];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.recv }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.nb = nb; $f.ok = ok; $f.p = p; $f.selected = selected; $f.t = t; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.recv = function(nb) { return this.$val.recv(nb); };
- Value.ptr.prototype.Send = function(x) {
- var $ptr, _r, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- x = x;
- new flag(v.flag).mustBe(18);
- new flag(v.flag).mustBeExported();
- _r = v.send(x, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Send }; } $f.$ptr = $ptr; $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Send = function(x) { return this.$val.Send(x); };
- Value.ptr.prototype.send = function(x, nb) {
- var $ptr, _r, _r$1, nb, p, selected, tt, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; nb = $f.nb; p = $f.p; selected = $f.selected; tt = $f.tt; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- selected = false;
- v = this;
- x = x;
- tt = v.typ.kindType;
- if (((tt.dir >> 0) & 2) === 0) {
- $panic(new $String("reflect: send on recv-only channel"));
- }
- new flag(x.flag).mustBeExported();
- _r = x.assignTo("reflect.Value.Send", tt.elem, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- x = _r;
- p = 0;
- if (!((((x.flag & 64) >>> 0) === 0))) {
- p = x.ptr;
- } else {
- p = (x.$ptr_ptr || (x.$ptr_ptr = new ptrType$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, x)));
- }
- _r$1 = chansend(v.typ, v.pointer(), p, nb); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- selected = _r$1;
- return selected;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.send }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.nb = nb; $f.p = p; $f.selected = selected; $f.tt = tt; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.send = function(x, nb) { return this.$val.send(x, nb); };
- Value.ptr.prototype.SetBool = function(x) {
- var $ptr, v, x;
- v = this;
- new flag(v.flag).mustBeAssignable();
- new flag(v.flag).mustBe(1);
- v.ptr.$set(x);
- };
- Value.prototype.SetBool = function(x) { return this.$val.SetBool(x); };
- Value.ptr.prototype.SetBytes = function(x) {
- var $ptr, _r, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBeAssignable();
- new flag(v.flag).mustBe(23);
- _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!((_r === 8))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r === 8))) { */ case 1:
- $panic(new $String("reflect.Value.SetBytes of non-byte slice"));
- /* } */ case 2:
- v.ptr.$set(x);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetBytes }; } $f.$ptr = $ptr; $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.SetBytes = function(x) { return this.$val.SetBytes(x); };
- Value.ptr.prototype.setRunes = function(x) {
- var $ptr, _r, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- new flag(v.flag).mustBeAssignable();
- new flag(v.flag).mustBe(23);
- _r = v.typ.Elem().Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!((_r === 5))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r === 5))) { */ case 1:
- $panic(new $String("reflect.Value.setRunes of non-rune slice"));
- /* } */ case 2:
- v.ptr.$set(x);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.setRunes }; } $f.$ptr = $ptr; $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.setRunes = function(x) { return this.$val.setRunes(x); };
- Value.ptr.prototype.SetComplex = function(x) {
- var $ptr, _ref, k, v, x;
- v = this;
- new flag(v.flag).mustBeAssignable();
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 15) {
- v.ptr.$set(new $Complex64(x.$real, x.$imag));
- } else if (_ref === 16) {
- v.ptr.$set(x);
- } else {
- $panic(new ValueError.ptr("reflect.Value.SetComplex", new flag(v.flag).kind()));
- }
- };
- Value.prototype.SetComplex = function(x) { return this.$val.SetComplex(x); };
- Value.ptr.prototype.SetFloat = function(x) {
- var $ptr, _ref, k, v, x;
- v = this;
- new flag(v.flag).mustBeAssignable();
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 13) {
- v.ptr.$set($fround(x));
- } else if (_ref === 14) {
- v.ptr.$set(x);
- } else {
- $panic(new ValueError.ptr("reflect.Value.SetFloat", new flag(v.flag).kind()));
- }
- };
- Value.prototype.SetFloat = function(x) { return this.$val.SetFloat(x); };
- Value.ptr.prototype.SetInt = function(x) {
- var $ptr, _ref, k, v, x;
- v = this;
- new flag(v.flag).mustBeAssignable();
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 2) {
- v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) >> 0));
- } else if (_ref === 3) {
- v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) << 24 >> 24));
- } else if (_ref === 4) {
- v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) << 16 >> 16));
- } else if (_ref === 5) {
- v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) >> 0));
- } else if (_ref === 6) {
- v.ptr.$set(x);
- } else {
- $panic(new ValueError.ptr("reflect.Value.SetInt", new flag(v.flag).kind()));
- }
- };
- Value.prototype.SetInt = function(x) { return this.$val.SetInt(x); };
- Value.ptr.prototype.SetMapIndex = function(key, val) {
- var $ptr, _r, _r$1, e, k, key, tt, v, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; e = $f.e; k = $f.k; key = $f.key; tt = $f.tt; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- val = val;
- key = key;
- new flag(v.flag).mustBe(21);
- new flag(v.flag).mustBeExported();
- new flag(key.flag).mustBeExported();
- tt = v.typ.kindType;
- _r = key.assignTo("reflect.Value.SetMapIndex", tt.key, 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- key = _r;
- k = 0;
- if (!((((key.flag & 64) >>> 0) === 0))) {
- k = key.ptr;
- } else {
- k = (key.$ptr_ptr || (key.$ptr_ptr = new ptrType$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key)));
- }
- if (val.typ === ptrType$1.nil) {
- mapdelete(v.typ, v.pointer(), k);
- return;
- }
- new flag(val.flag).mustBeExported();
- _r$1 = val.assignTo("reflect.Value.SetMapIndex", tt.elem, 0); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- val = _r$1;
- e = 0;
- if (!((((val.flag & 64) >>> 0) === 0))) {
- e = val.ptr;
- } else {
- e = (val.$ptr_ptr || (val.$ptr_ptr = new ptrType$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val)));
- }
- $r = mapassign(v.typ, v.pointer(), k, e); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetMapIndex }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.e = e; $f.k = k; $f.key = key; $f.tt = tt; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.SetMapIndex = function(key, val) { return this.$val.SetMapIndex(key, val); };
- Value.ptr.prototype.SetUint = function(x) {
- var $ptr, _ref, k, v, x;
- v = this;
- new flag(v.flag).mustBeAssignable();
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 7) {
- v.ptr.$set((x.$low >>> 0));
- } else if (_ref === 8) {
- v.ptr.$set((x.$low << 24 >>> 24));
- } else if (_ref === 9) {
- v.ptr.$set((x.$low << 16 >>> 16));
- } else if (_ref === 10) {
- v.ptr.$set((x.$low >>> 0));
- } else if (_ref === 11) {
- v.ptr.$set(x);
- } else if (_ref === 12) {
- v.ptr.$set((x.$low >>> 0));
- } else {
- $panic(new ValueError.ptr("reflect.Value.SetUint", new flag(v.flag).kind()));
- }
- };
- Value.prototype.SetUint = function(x) { return this.$val.SetUint(x); };
- Value.ptr.prototype.SetPointer = function(x) {
- var $ptr, v, x;
- v = this;
- new flag(v.flag).mustBeAssignable();
- new flag(v.flag).mustBe(26);
- v.ptr.$set(x);
- };
- Value.prototype.SetPointer = function(x) { return this.$val.SetPointer(x); };
- Value.ptr.prototype.SetString = function(x) {
- var $ptr, v, x;
- v = this;
- new flag(v.flag).mustBeAssignable();
- new flag(v.flag).mustBe(24);
- v.ptr.$set(x);
- };
- Value.prototype.SetString = function(x) { return this.$val.SetString(x); };
- Value.ptr.prototype.String = function() {
- var $ptr, _r, _ref, k, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; k = $f.k; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- k = new flag(v.flag).kind();
- _ref = k;
- if (_ref === 0) {
- return "";
- } else if (_ref === 24) {
- return v.ptr.$get();
- }
- _r = v.Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return "<" + _r + " Value>";
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.k = k; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.String = function() { return this.$val.String(); };
- Value.ptr.prototype.TryRecv = function() {
- var $ptr, _r, _tuple, ok, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = new Value.ptr();
- ok = false;
- v = this;
- new flag(v.flag).mustBe(18);
- new flag(v.flag).mustBeExported();
- _r = v.recv(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; x = _tuple[0]; ok = _tuple[1];
- return [x, ok];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TryRecv }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.TryRecv = function() { return this.$val.TryRecv(); };
- Value.ptr.prototype.TrySend = function(x) {
- var $ptr, _r, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- x = x;
- new flag(v.flag).mustBe(18);
- new flag(v.flag).mustBeExported();
- _r = v.send(x, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TrySend }; } $f.$ptr = $ptr; $f._r = _r; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.TrySend = function(x) { return this.$val.TrySend(x); };
- Value.ptr.prototype.Type = function() {
- var $ptr, f, i, m, m$1, tt, ut, v, x, x$1;
- v = this;
- f = v.flag;
- if (f === 0) {
- $panic(new ValueError.ptr("reflect.Value.Type", 0));
- }
- if (((f & 256) >>> 0) === 0) {
- return v.typ;
- }
- i = (v.flag >> 0) >> 9 >> 0;
- if (v.typ.Kind() === 20) {
- tt = v.typ.kindType;
- if ((i >>> 0) >= (tt.methods.$length >>> 0)) {
- $panic(new $String("reflect: internal error: invalid method index"));
- }
- m = (x = tt.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- return m.typ;
- }
- ut = v.typ.uncommonType.uncommon();
- if (ut === ptrType$6.nil || (i >>> 0) >= (ut.methods.$length >>> 0)) {
- $panic(new $String("reflect: internal error: invalid method index"));
- }
- m$1 = (x$1 = ut.methods, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i]));
- return m$1.mtyp;
- };
- Value.prototype.Type = function() { return this.$val.Type(); };
- Value.ptr.prototype.Uint = function() {
- var $ptr, _ref, k, p, v, x;
- v = this;
- k = new flag(v.flag).kind();
- p = v.ptr;
- _ref = k;
- if (_ref === 7) {
- return new $Uint64(0, p.$get());
- } else if (_ref === 8) {
- return new $Uint64(0, p.$get());
- } else if (_ref === 9) {
- return new $Uint64(0, p.$get());
- } else if (_ref === 10) {
- return new $Uint64(0, p.$get());
- } else if (_ref === 11) {
- return p.$get();
- } else if (_ref === 12) {
- return (x = p.$get(), new $Uint64(0, x.constructor === Number ? x : 1));
- }
- $panic(new ValueError.ptr("reflect.Value.Uint", new flag(v.flag).kind()));
- };
- Value.prototype.Uint = function() { return this.$val.Uint(); };
- Value.ptr.prototype.UnsafeAddr = function() {
- var $ptr, v;
- v = this;
- if (v.typ === ptrType$1.nil) {
- $panic(new ValueError.ptr("reflect.Value.UnsafeAddr", 0));
- }
- if (((v.flag & 128) >>> 0) === 0) {
- $panic(new $String("reflect.Value.UnsafeAddr of unaddressable value"));
- }
- return v.ptr;
- };
- Value.prototype.UnsafeAddr = function() { return this.$val.UnsafeAddr(); };
- typesMustMatch = function(what, t1, t2) {
- var $ptr, _r, _r$1, t1, t2, what, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; t1 = $f.t1; t2 = $f.t2; what = $f.what; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!($interfaceIsEqual(t1, t2))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(t1, t2))) { */ case 1:
- _r = t1.String(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = t2.String(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $panic(new $String(what + ": " + _r + " != " + _r$1));
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: typesMustMatch }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.t1 = t1; $f.t2 = t2; $f.what = what; $f.$s = $s; $f.$r = $r; return $f;
- };
- MakeMap = function(typ) {
- var $ptr, _r, _r$1, m, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; m = $f.m; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!((_r === 21))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r === 21))) { */ case 1:
- $panic(new $String("reflect.MakeMap of non-map type"));
- /* } */ case 2:
- m = makemap($assertType(typ, ptrType$1));
- _r$1 = typ.common(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return new Value.ptr(_r$1, m, 21);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: MakeMap }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.m = m; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.MakeMap = MakeMap;
- Indirect = function(v) {
- var $ptr, _r, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!((v.Kind() === 22))) {
- return v;
- }
- _r = v.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Indirect }; } $f.$ptr = $ptr; $f._r = _r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Indirect = Indirect;
- New = function(typ) {
- var $ptr, _r, _r$1, fl, ptr, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; fl = $f.fl; ptr = $f.ptr; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if ($interfaceIsEqual(typ, $ifaceNil)) {
- $panic(new $String("reflect: New(nil)"));
- }
- ptr = unsafe_New($assertType(typ, ptrType$1));
- fl = 22;
- _r = typ.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.ptrTo(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return new Value.ptr(_r$1, ptr, fl);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: New }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.fl = fl; $f.ptr = ptr; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.New = New;
- Value.ptr.prototype.assignTo = function(context, dst, target) {
- var $ptr, _r, _r$1, context, dst, fl, target, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; context = $f.context; dst = $f.dst; fl = $f.fl; target = $f.target; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- /* */ if (!((((v.flag & 256) >>> 0) === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((((v.flag & 256) >>> 0) === 0))) { */ case 1:
- _r = makeMethodValue(context, v); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- v = _r;
- /* } */ case 2:
- /* */ if (directlyAssignable(dst, v.typ)) { $s = 4; continue; }
- /* */ if (implements$1(dst, v.typ)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (directlyAssignable(dst, v.typ)) { */ case 4:
- v.typ = dst;
- fl = (v.flag & 224) >>> 0;
- fl = (fl | ((dst.Kind() >>> 0))) >>> 0;
- return new Value.ptr(dst, v.ptr, fl);
- $s = 6; continue;
- /* } else if (implements$1(dst, v.typ)) { */ case 5:
- if (target === 0) {
- target = unsafe_New(dst);
- }
- _r$1 = valueInterface(v, false); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- if (dst.NumMethod() === 0) {
- target.$set(x);
- } else {
- ifaceE2I(dst, x, target);
- }
- return new Value.ptr(dst, target, 84);
- /* } */ case 6:
- $panic(new $String(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String()));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.assignTo }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.context = context; $f.dst = dst; $f.fl = fl; $f.target = target; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.assignTo = function(context, dst, target) { return this.$val.assignTo(context, dst, target); };
- Value.ptr.prototype.Convert = function(t) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, op, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; op = $f.op; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = this;
- /* */ if (!((((v.flag & 256) >>> 0) === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((((v.flag & 256) >>> 0) === 0))) { */ case 1:
- _r = makeMethodValue("Convert", v); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- v = _r;
- /* } */ case 2:
- _r$1 = t.common(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = convertOp(_r$1, v.typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- op = _r$2;
- /* */ if (op === $throwNilPointerError) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (op === $throwNilPointerError) { */ case 6:
- _r$3 = t.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $panic(new $String("reflect.Value.Convert: value of type " + v.typ.String() + " cannot be converted to type " + _r$3));
- /* } */ case 7:
- _r$4 = op(v, t); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Convert }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.op = op; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Value.prototype.Convert = function(t) { return this.$val.Convert(t); };
- convertOp = function(dst, src) {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _v, _v$1, _v$2, dst, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; dst = $f.dst; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = src.Kind();
- /* */ if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { $s = 1; continue; }
- /* */ if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { $s = 2; continue; }
- /* */ if (_ref === 13 || _ref === 14) { $s = 3; continue; }
- /* */ if (_ref === 15 || _ref === 16) { $s = 4; continue; }
- /* */ if (_ref === 24) { $s = 5; continue; }
- /* */ if (_ref === 23) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { */ case 1:
- _ref$1 = dst.Kind();
- if (_ref$1 === 2 || _ref$1 === 3 || _ref$1 === 4 || _ref$1 === 5 || _ref$1 === 6 || _ref$1 === 7 || _ref$1 === 8 || _ref$1 === 9 || _ref$1 === 10 || _ref$1 === 11 || _ref$1 === 12) {
- return cvtInt;
- } else if (_ref$1 === 13 || _ref$1 === 14) {
- return cvtIntFloat;
- } else if (_ref$1 === 24) {
- return cvtIntString;
- }
- $s = 7; continue;
- /* } else if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { */ case 2:
- _ref$2 = dst.Kind();
- if (_ref$2 === 2 || _ref$2 === 3 || _ref$2 === 4 || _ref$2 === 5 || _ref$2 === 6 || _ref$2 === 7 || _ref$2 === 8 || _ref$2 === 9 || _ref$2 === 10 || _ref$2 === 11 || _ref$2 === 12) {
- return cvtUint;
- } else if (_ref$2 === 13 || _ref$2 === 14) {
- return cvtUintFloat;
- } else if (_ref$2 === 24) {
- return cvtUintString;
- }
- $s = 7; continue;
- /* } else if (_ref === 13 || _ref === 14) { */ case 3:
- _ref$3 = dst.Kind();
- if (_ref$3 === 2 || _ref$3 === 3 || _ref$3 === 4 || _ref$3 === 5 || _ref$3 === 6) {
- return cvtFloatInt;
- } else if (_ref$3 === 7 || _ref$3 === 8 || _ref$3 === 9 || _ref$3 === 10 || _ref$3 === 11 || _ref$3 === 12) {
- return cvtFloatUint;
- } else if (_ref$3 === 13 || _ref$3 === 14) {
- return cvtFloat;
- }
- $s = 7; continue;
- /* } else if (_ref === 15 || _ref === 16) { */ case 4:
- _ref$4 = dst.Kind();
- if (_ref$4 === 15 || _ref$4 === 16) {
- return cvtComplex;
- }
- $s = 7; continue;
- /* } else if (_ref === 24) { */ case 5:
- if (!(dst.Kind() === 23)) { _v = false; $s = 10; continue s; }
- _r = dst.Elem().PkgPath(); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r === ""; case 10:
- /* */ if (_v) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_v) { */ case 8:
- _r$1 = dst.Elem().Kind(); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _ref$5 = _r$1;
- /* */ if (_ref$5 === 8) { $s = 13; continue; }
- /* */ if (_ref$5 === 5) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (_ref$5 === 8) { */ case 13:
- return cvtStringBytes;
- $s = 15; continue;
- /* } else if (_ref$5 === 5) { */ case 14:
- return cvtStringRunes;
- /* } */ case 15:
- /* } */ case 9:
- $s = 7; continue;
- /* } else if (_ref === 23) { */ case 6:
- if (!(dst.Kind() === 24)) { _v$1 = false; $s = 18; continue s; }
- _r$2 = src.Elem().PkgPath(); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v$1 = _r$2 === ""; case 18:
- /* */ if (_v$1) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (_v$1) { */ case 16:
- _r$3 = src.Elem().Kind(); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _ref$6 = _r$3;
- /* */ if (_ref$6 === 8) { $s = 21; continue; }
- /* */ if (_ref$6 === 5) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (_ref$6 === 8) { */ case 21:
- return cvtBytesString;
- $s = 23; continue;
- /* } else if (_ref$6 === 5) { */ case 22:
- return cvtRunesString;
- /* } */ case 23:
- /* } */ case 17:
- /* } */ case 7:
- if (haveIdenticalUnderlyingType(dst, src)) {
- return cvtDirect;
- }
- if (!((dst.Kind() === 22) && dst.Name() === "" && (src.Kind() === 22) && src.Name() === "")) { _v$2 = false; $s = 26; continue s; }
- _r$4 = dst.Elem().common(); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg = _r$4;
- _r$5 = src.Elem().common(); /* */ $s = 28; case 28: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$1 = _r$5;
- _r$6 = haveIdenticalUnderlyingType(_arg, _arg$1); /* */ $s = 29; case 29: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _v$2 = _r$6; case 26:
- /* */ if (_v$2) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (_v$2) { */ case 24:
- return cvtDirect;
- /* } */ case 25:
- if (implements$1(dst, src)) {
- if (src.Kind() === 20) {
- return cvtI2I;
- }
- return cvtT2I;
- }
- return $throwNilPointerError;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: convertOp }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.dst = dst; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- makeFloat = function(f, v, t) {
- var $ptr, _r, _ref, f, ptr, t, typ, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ = _r;
- ptr = unsafe_New(typ);
- _ref = typ.size;
- if (_ref === 4) {
- ptr.$set($fround(v));
- } else if (_ref === 8) {
- ptr.$set(v);
- }
- return new Value.ptr(typ, ptr, (((f | 64) >>> 0) | (typ.Kind() >>> 0)) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeFloat }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- makeComplex = function(f, v, t) {
- var $ptr, _r, _ref, f, ptr, t, typ, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; f = $f.f; ptr = $f.ptr; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = t.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ = _r;
- ptr = unsafe_New(typ);
- _ref = typ.size;
- if (_ref === 8) {
- ptr.$set(new $Complex64(v.$real, v.$imag));
- } else if (_ref === 16) {
- ptr.$set(v);
- }
- return new Value.ptr(typ, ptr, (((f | 64) >>> 0) | (typ.Kind() >>> 0)) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeComplex }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.f = f; $f.ptr = ptr; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- makeString = function(f, v, t) {
- var $ptr, _r, _r$1, f, ret, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ret = _r$1;
- ret.SetString(v);
- ret.flag = (((ret.flag & ~128) >>> 0) | f) >>> 0;
- return ret;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeString }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- makeBytes = function(f, v, t) {
- var $ptr, _r, _r$1, f, ret, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ret = _r$1;
- $r = ret.SetBytes(v); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- ret.flag = (((ret.flag & ~128) >>> 0) | f) >>> 0;
- return ret;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeBytes }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- makeRunes = function(f, v, t) {
- var $ptr, _r, _r$1, f, ret, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; f = $f.f; ret = $f.ret; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ret = _r$1;
- $r = ret.setRunes(v); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- ret.flag = (((ret.flag & ~128) >>> 0) | f) >>> 0;
- return ret;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeRunes }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.ret = ret; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtInt = function(v, t) {
- var $ptr, _r, t, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeInt((v.flag & 32) >>> 0, (x = v.Int(), new $Uint64(x.$high, x.$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtInt }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtUint = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeInt((v.flag & 32) >>> 0, v.Uint(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtUint }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtFloatInt = function(v, t) {
- var $ptr, _r, t, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeInt((v.flag & 32) >>> 0, (x = new $Int64(0, v.Float()), new $Uint64(x.$high, x.$low)), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtFloatInt }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtFloatUint = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeInt((v.flag & 32) >>> 0, new $Uint64(0, v.Float()), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtFloatUint }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtIntFloat = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeFloat((v.flag & 32) >>> 0, $flatten64(v.Int()), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtIntFloat }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtUintFloat = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeFloat((v.flag & 32) >>> 0, $flatten64(v.Uint()), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtUintFloat }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtFloat = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeFloat((v.flag & 32) >>> 0, v.Float(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtFloat }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtComplex = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeComplex((v.flag & 32) >>> 0, v.Complex(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtComplex }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtIntString = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeString((v.flag & 32) >>> 0, $encodeRune(v.Int().$low), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtIntString }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtUintString = function(v, t) {
- var $ptr, _r, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = makeString((v.flag & 32) >>> 0, $encodeRune(v.Uint().$low), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtUintString }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtBytesString = function(v, t) {
- var $ptr, _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _arg = (v.flag & 32) >>> 0;
- _r = v.Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = $bytesToString(_r);
- _arg$2 = t;
- _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtBytesString }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtStringBytes = function(v, t) {
- var $ptr, _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _arg = (v.flag & 32) >>> 0;
- _r = v.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = new sliceType$14($stringToBytes(_r));
- _arg$2 = t;
- _r$1 = makeBytes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtStringBytes }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtRunesString = function(v, t) {
- var $ptr, _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _arg = (v.flag & 32) >>> 0;
- _r = v.runes(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = $runesToString(_r);
- _arg$2 = t;
- _r$1 = makeString(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtRunesString }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtStringRunes = function(v, t) {
- var $ptr, _arg, _arg$1, _arg$2, _r, _r$1, t, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _arg = (v.flag & 32) >>> 0;
- _r = v.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = new sliceType$15($stringToRunes(_r));
- _arg$2 = t;
- _r$1 = makeRunes(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtStringRunes }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtT2I = function(v, typ) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, target, typ, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; target = $f.target; typ = $f.typ; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r = typ.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = unsafe_New(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- target = _r$1;
- _r$2 = valueInterface(v, false); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- x = _r$2;
- _r$3 = typ.NumMethod(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3 === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_r$3 === 0) { */ case 4:
- target.$set(x);
- $s = 6; continue;
- /* } else { */ case 5:
- ifaceE2I($assertType(typ, ptrType$1), x, target);
- /* } */ case 6:
- _r$4 = typ.common(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return new Value.ptr(_r$4, target, (((((v.flag & 32) >>> 0) | 64) >>> 0) | 20) >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtT2I }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.target = target; $f.typ = typ; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- cvtI2I = function(v, typ) {
- var $ptr, _r, _r$1, _r$2, ret, typ, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; ret = $f.ret; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- /* */ if (v.IsNil()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (v.IsNil()) { */ case 1:
- _r = Zero(typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- ret = _r;
- ret.flag = (ret.flag | (((v.flag & 32) >>> 0))) >>> 0;
- return ret;
- /* } */ case 2:
- _r$1 = v.Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = cvtT2I(_r$1, typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cvtI2I }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.ret = ret; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Kind.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$1.methods = [{prop: "ptrTo", name: "ptrTo", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "pointers", name: "pointers", pkg: "reflect", typ: $funcType([], [$Bool], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$11], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}];
- ptrType$6.methods = [{prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$6], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}];
- ChanDir.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$11.methods = [{prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}];
- ptrType$13.methods = [{prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$11], [StructField], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}];
- StructTag.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String], [$String], false)}];
- Value.methods = [{prop: "object", name: "object", pkg: "reflect", typ: $funcType([], [ptrType$3], false)}, {prop: "call", name: "call", pkg: "reflect", typ: $funcType([$String, sliceType$7], [sliceType$7], false)}, {prop: "Cap", name: "Cap", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "IsNil", name: "IsNil", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Pointer", name: "Pointer", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([Value], [], false)}, {prop: "SetCap", name: "SetCap", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "SetLen", name: "SetLen", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Slice", name: "Slice", pkg: "", typ: $funcType([$Int, $Int], [Value], false)}, {prop: "Slice3", name: "Slice3", pkg: "", typ: $funcType([$Int, $Int, $Int], [Value], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [], false)}, {prop: "pointer", name: "pointer", pkg: "reflect", typ: $funcType([], [$UnsafePointer], false)}, {prop: "Addr", name: "Addr", pkg: "", typ: $funcType([], [Value], false)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$14], false)}, {prop: "runes", name: "runes", pkg: "reflect", typ: $funcType([], [sliceType$15], false)}, {prop: "CanAddr", name: "CanAddr", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "CanSet", name: "CanSet", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Call", name: "Call", pkg: "", typ: $funcType([sliceType$7], [sliceType$7], false)}, {prop: "CallSlice", name: "CallSlice", pkg: "", typ: $funcType([sliceType$7], [sliceType$7], false)}, {prop: "Complex", name: "Complex", pkg: "", typ: $funcType([], [$Complex128], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$11], [Value], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [Value], false)}, {prop: "Float", name: "Float", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "CanInterface", name: "CanInterface", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Interface", name: "Interface", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "InterfaceData", name: "InterfaceData", pkg: "", typ: $funcType([], [arrayType$3], false)}, {prop: "IsValid", name: "IsValid", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "MapIndex", name: "MapIndex", pkg: "", typ: $funcType([Value], [Value], false)}, {prop: "MapKeys", name: "MapKeys", pkg: "", typ: $funcType([], [sliceType$7], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Value], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Value], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "OverflowComplex", name: "OverflowComplex", pkg: "", typ: $funcType([$Complex128], [$Bool], false)}, {prop: "OverflowFloat", name: "OverflowFloat", pkg: "", typ: $funcType([$Float64], [$Bool], false)}, {prop: "OverflowInt", name: "OverflowInt", pkg: "", typ: $funcType([$Int64], [$Bool], false)}, {prop: "OverflowUint", name: "OverflowUint", pkg: "", typ: $funcType([$Uint64], [$Bool], false)}, {prop: "Recv", name: "Recv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "recv", name: "recv", pkg: "reflect", typ: $funcType([$Bool], [Value, $Bool], false)}, {prop: "Send", name: "Send", pkg: "", typ: $funcType([Value], [], false)}, {prop: "send", name: "send", pkg: "reflect", typ: $funcType([Value, $Bool], [$Bool], false)}, {prop: "SetBool", name: "SetBool", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "SetBytes", name: "SetBytes", pkg: "", typ: $funcType([sliceType$14], [], false)}, {prop: "setRunes", name: "setRunes", pkg: "reflect", typ: $funcType([sliceType$15], [], false)}, {prop: "SetComplex", name: "SetComplex", pkg: "", typ: $funcType([$Complex128], [], false)}, {prop: "SetFloat", name: "SetFloat", pkg: "", typ: $funcType([$Float64], [], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "SetMapIndex", name: "SetMapIndex", pkg: "", typ: $funcType([Value, Value], [], false)}, {prop: "SetUint", name: "SetUint", pkg: "", typ: $funcType([$Uint64], [], false)}, {prop: "SetPointer", name: "SetPointer", pkg: "", typ: $funcType([$UnsafePointer], [], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "TryRecv", name: "TryRecv", pkg: "", typ: $funcType([], [Value, $Bool], false)}, {prop: "TrySend", name: "TrySend", pkg: "", typ: $funcType([Value], [$Bool], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Uint", name: "Uint", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "UnsafeAddr", name: "UnsafeAddr", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "assignTo", name: "assignTo", pkg: "reflect", typ: $funcType([$String, ptrType$1, $UnsafePointer], [Value], false)}, {prop: "Convert", name: "Convert", pkg: "", typ: $funcType([Type], [Value], false)}];
- flag.methods = [{prop: "kind", name: "kind", pkg: "reflect", typ: $funcType([], [Kind], false)}, {prop: "mustBe", name: "mustBe", pkg: "reflect", typ: $funcType([Kind], [], false)}, {prop: "mustBeExported", name: "mustBeExported", pkg: "reflect", typ: $funcType([], [], false)}, {prop: "mustBeAssignable", name: "mustBeAssignable", pkg: "reflect", typ: $funcType([], [], false)}];
- ptrType$21.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- mapIter.init([{prop: "t", name: "t", pkg: "reflect", typ: Type, tag: ""}, {prop: "m", name: "m", pkg: "reflect", typ: ptrType$3, tag: ""}, {prop: "keys", name: "keys", pkg: "reflect", typ: ptrType$3, tag: ""}, {prop: "i", name: "i", pkg: "reflect", typ: $Int, tag: ""}]);
- Type.init([{prop: "Align", name: "Align", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "AssignableTo", name: "AssignableTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ChanDir", name: "ChanDir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "Comparable", name: "Comparable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ConvertibleTo", name: "ConvertibleTo", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldAlign", name: "FieldAlign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$11], [StructField], false)}, {prop: "FieldByName", name: "FieldByName", pkg: "", typ: $funcType([$String], [StructField, $Bool], false)}, {prop: "FieldByNameFunc", name: "FieldByNameFunc", pkg: "", typ: $funcType([funcType$3], [StructField, $Bool], false)}, {prop: "Implements", name: "Implements", pkg: "", typ: $funcType([Type], [$Bool], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "IsVariadic", name: "IsVariadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NumField", name: "NumField", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumIn", name: "NumIn", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NumOut", name: "NumOut", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Out", name: "Out", pkg: "", typ: $funcType([$Int], [Type], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "common", name: "common", pkg: "reflect", typ: $funcType([], [ptrType$1], false)}, {prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$6], false)}]);
- rtype.init([{prop: "size", name: "size", pkg: "reflect", typ: $Uintptr, tag: ""}, {prop: "hash", name: "hash", pkg: "reflect", typ: $Uint32, tag: ""}, {prop: "_$2", name: "_", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "align", name: "align", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "fieldAlign", name: "fieldAlign", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "kind", name: "kind", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "alg", name: "alg", pkg: "reflect", typ: ptrType$4, tag: ""}, {prop: "gc", name: "gc", pkg: "reflect", typ: arrayType$1, tag: ""}, {prop: "string", name: "string", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "uncommonType", name: "", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "ptrToThis", name: "ptrToThis", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "zero", name: "zero", pkg: "reflect", typ: $UnsafePointer, tag: ""}]);
- typeAlg.init([{prop: "hash", name: "hash", pkg: "reflect", typ: funcType$4, tag: ""}, {prop: "equal", name: "equal", pkg: "reflect", typ: funcType$5, tag: ""}]);
- method.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "mtyp", name: "mtyp", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "ifn", name: "ifn", pkg: "reflect", typ: $UnsafePointer, tag: ""}, {prop: "tfn", name: "tfn", pkg: "reflect", typ: $UnsafePointer, tag: ""}]);
- uncommonType.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "methods", name: "methods", pkg: "reflect", typ: sliceType$3, tag: ""}]);
- arrayType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"array\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "slice", name: "slice", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "len", name: "len", pkg: "reflect", typ: $Uintptr, tag: ""}]);
- chanType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"chan\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "dir", name: "dir", pkg: "reflect", typ: $Uintptr, tag: ""}]);
- funcType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"func\""}, {prop: "dotdotdot", name: "dotdotdot", pkg: "reflect", typ: $Bool, tag: ""}, {prop: "in$2", name: "in", pkg: "reflect", typ: sliceType$4, tag: ""}, {prop: "out", name: "out", pkg: "reflect", typ: sliceType$4, tag: ""}]);
- imethod.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}]);
- interfaceType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"interface\""}, {prop: "methods", name: "methods", pkg: "reflect", typ: sliceType$5, tag: ""}]);
- mapType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"map\""}, {prop: "key", name: "key", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "bucket", name: "bucket", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "hmap", name: "hmap", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "keysize", name: "keysize", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "indirectkey", name: "indirectkey", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "valuesize", name: "valuesize", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "indirectvalue", name: "indirectvalue", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "bucketsize", name: "bucketsize", pkg: "reflect", typ: $Uint16, tag: ""}]);
- ptrType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"ptr\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}]);
- sliceType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"slice\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}]);
- structField.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "tag", name: "tag", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "offset", name: "offset", pkg: "reflect", typ: $Uintptr, tag: ""}]);
- structType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"struct\""}, {prop: "fields", name: "fields", pkg: "reflect", typ: sliceType$6, tag: ""}]);
- Method.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $String, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Type, tag: ""}, {prop: "Func", name: "Func", pkg: "", typ: Value, tag: ""}, {prop: "Index", name: "Index", pkg: "", typ: $Int, tag: ""}]);
- StructField.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $String, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Type, tag: ""}, {prop: "Tag", name: "Tag", pkg: "", typ: StructTag, tag: ""}, {prop: "Offset", name: "Offset", pkg: "", typ: $Uintptr, tag: ""}, {prop: "Index", name: "Index", pkg: "", typ: sliceType$11, tag: ""}, {prop: "Anonymous", name: "Anonymous", pkg: "", typ: $Bool, tag: ""}]);
- fieldScan.init([{prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$13, tag: ""}, {prop: "index", name: "index", pkg: "reflect", typ: sliceType$11, tag: ""}]);
- Value.init([{prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "ptr", name: "ptr", pkg: "reflect", typ: $UnsafePointer, tag: ""}, {prop: "flag", name: "", pkg: "reflect", typ: flag, tag: ""}]);
- ValueError.init([{prop: "Method", name: "Method", pkg: "", typ: $String, tag: ""}, {prop: "Kind", name: "Kind", pkg: "", typ: Kind, tag: ""}]);
- nonEmptyInterface.init([{prop: "itab", name: "itab", pkg: "reflect", typ: ptrType$8, tag: ""}, {prop: "word", name: "word", pkg: "reflect", typ: $UnsafePointer, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = runtime.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- initialized = false;
- stringPtrMap = new $Map();
- callHelper = $assertType($internalize($call, $emptyInterface), funcType$1);
- selectHelper = $assertType($internalize($select, $emptyInterface), funcType$1);
- kindNames = new sliceType$2(["invalid", "bool", "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", "complex64", "complex128", "array", "chan", "func", "interface", "map", "ptr", "slice", "string", "struct", "unsafe.Pointer"]);
- jsObjectPtr = reflectType($jsObjectPtr);
- uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1);
- $r = init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["encoding/binary"] = (function() {
- var $pkg = {}, $init, errors, io, math, reflect, ByteOrder, bigEndian, encoder, arrayType, sliceType, ptrType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, sliceType$1, sliceType$2, sliceType$3, sliceType$4, sliceType$5, sliceType$6, sliceType$7, ptrType$9, overflow, Write, dataSize, sizeof, intDataSize, PutUvarint, Uvarint, PutVarint, Varint;
- errors = $packages["errors"];
- io = $packages["io"];
- math = $packages["math"];
- reflect = $packages["reflect"];
- ByteOrder = $pkg.ByteOrder = $newType(8, $kindInterface, "binary.ByteOrder", "ByteOrder", "encoding/binary", null);
- bigEndian = $pkg.bigEndian = $newType(0, $kindStruct, "binary.bigEndian", "bigEndian", "encoding/binary", function() {
- this.$val = this;
- if (arguments.length === 0) {
- return;
- }
- });
- encoder = $pkg.encoder = $newType(0, $kindStruct, "binary.encoder", "encoder", "encoding/binary", function(order_, buf_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.order = $ifaceNil;
- this.buf = sliceType.nil;
- return;
- }
- this.order = order_;
- this.buf = buf_;
- });
- arrayType = $arrayType($Uint8, 8);
- sliceType = $sliceType($Uint8);
- ptrType = $ptrType($Int8);
- ptrType$1 = $ptrType($Uint8);
- ptrType$2 = $ptrType($Int16);
- ptrType$3 = $ptrType($Uint16);
- ptrType$4 = $ptrType($Int32);
- ptrType$5 = $ptrType($Uint32);
- ptrType$6 = $ptrType($Int64);
- ptrType$7 = $ptrType($Uint64);
- sliceType$1 = $sliceType($Int8);
- sliceType$2 = $sliceType($Int16);
- sliceType$3 = $sliceType($Uint16);
- sliceType$4 = $sliceType($Int32);
- sliceType$5 = $sliceType($Uint32);
- sliceType$6 = $sliceType($Int64);
- sliceType$7 = $sliceType($Uint64);
- ptrType$9 = $ptrType(encoder);
- bigEndian.ptr.prototype.Uint16 = function(b) {
- var $ptr, b;
- return (((1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1]) << 16 >>> 16) | (((0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0]) << 16 >>> 16) << 8 << 16 >>> 16)) >>> 0;
- };
- bigEndian.prototype.Uint16 = function(b) { return this.$val.Uint16(b); };
- bigEndian.ptr.prototype.PutUint16 = function(b, v) {
- var $ptr, b, v;
- (0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0] = ((v >>> 8 << 16 >>> 16) << 24 >>> 24));
- (1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1] = (v << 24 >>> 24));
- };
- bigEndian.prototype.PutUint16 = function(b, v) { return this.$val.PutUint16(b, v); };
- bigEndian.ptr.prototype.Uint32 = function(b) {
- var $ptr, b;
- return (((((((3 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 3]) >>> 0) | (((2 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 2]) >>> 0) << 8 >>> 0)) >>> 0) | (((1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1]) >>> 0) << 16 >>> 0)) >>> 0) | (((0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0]) >>> 0) << 24 >>> 0)) >>> 0;
- };
- bigEndian.prototype.Uint32 = function(b) { return this.$val.Uint32(b); };
- bigEndian.ptr.prototype.PutUint32 = function(b, v) {
- var $ptr, b, v;
- (0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0] = ((v >>> 24 >>> 0) << 24 >>> 24));
- (1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1] = ((v >>> 16 >>> 0) << 24 >>> 24));
- (2 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 2] = ((v >>> 8 >>> 0) << 24 >>> 24));
- (3 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 3] = (v << 24 >>> 24));
- };
- bigEndian.prototype.PutUint32 = function(b, v) { return this.$val.PutUint32(b, v); };
- bigEndian.ptr.prototype.Uint64 = function(b) {
- var $ptr, b, x, x$1, x$10, x$11, x$12, x$13, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- return (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = new $Uint64(0, (7 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 7])), x$7 = $shiftLeft64(new $Uint64(0, (6 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 6])), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64(new $Uint64(0, (5 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 5])), 16), new $Uint64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64(new $Uint64(0, (4 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 4])), 24), new $Uint64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64(new $Uint64(0, (3 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 3])), 32), new $Uint64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64(new $Uint64(0, (2 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 2])), 40), new $Uint64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64(new $Uint64(0, (1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1])), 48), new $Uint64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64(new $Uint64(0, (0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0])), 56), new $Uint64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0));
- };
- bigEndian.prototype.Uint64 = function(b) { return this.$val.Uint64(b); };
- bigEndian.ptr.prototype.PutUint64 = function(b, v) {
- var $ptr, b, v;
- (0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0] = ($shiftRightUint64(v, 56).$low << 24 >>> 24));
- (1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1] = ($shiftRightUint64(v, 48).$low << 24 >>> 24));
- (2 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 2] = ($shiftRightUint64(v, 40).$low << 24 >>> 24));
- (3 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 3] = ($shiftRightUint64(v, 32).$low << 24 >>> 24));
- (4 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 4] = ($shiftRightUint64(v, 24).$low << 24 >>> 24));
- (5 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 5] = ($shiftRightUint64(v, 16).$low << 24 >>> 24));
- (6 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 6] = ($shiftRightUint64(v, 8).$low << 24 >>> 24));
- (7 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 7] = (v.$low << 24 >>> 24));
- };
- bigEndian.prototype.PutUint64 = function(b, v) { return this.$val.PutUint64(b, v); };
- bigEndian.ptr.prototype.String = function() {
- var $ptr;
- return "BigEndian";
- };
- bigEndian.prototype.String = function() { return this.$val.String(); };
- bigEndian.ptr.prototype.GoString = function() {
- var $ptr;
- return "binary.BigEndian";
- };
- bigEndian.prototype.GoString = function() { return this.$val.GoString(); };
- Write = function(w, order, data) {
- var $ptr, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _tuple, _tuple$1, b, bs, buf, data, e, err, err$1, i, i$1, i$2, i$3, i$4, i$5, i$6, n, order, size, v, v$1, v$10, v$11, v$12, v$13, v$14, v$15, v$16, v$17, v$18, v$19, v$2, v$20, v$21, v$22, v$23, v$24, v$3, v$4, v$5, v$6, v$7, v$8, v$9, w, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; bs = $f.bs; buf = $f.buf; data = $f.data; e = $f.e; err = $f.err; err$1 = $f.err$1; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; i$5 = $f.i$5; i$6 = $f.i$6; n = $f.n; order = $f.order; size = $f.size; v = $f.v; v$1 = $f.v$1; v$10 = $f.v$10; v$11 = $f.v$11; v$12 = $f.v$12; v$13 = $f.v$13; v$14 = $f.v$14; v$15 = $f.v$15; v$16 = $f.v$16; v$17 = $f.v$17; v$18 = $f.v$18; v$19 = $f.v$19; v$2 = $f.v$2; v$20 = $f.v$20; v$21 = $f.v$21; v$22 = $f.v$22; v$23 = $f.v$23; v$24 = $f.v$24; v$3 = $f.v$3; v$4 = $f.v$4; v$5 = $f.v$5; v$6 = $f.v$6; v$7 = $f.v$7; v$8 = $f.v$8; v$9 = $f.v$9; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = intDataSize(data);
- /* */ if (!((n === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((n === 0))) { */ case 1:
- b = $clone(arrayType.zero(), arrayType);
- bs = sliceType.nil;
- if (n > 8) {
- bs = $makeSlice(sliceType, n);
- } else {
- bs = $subslice(new sliceType(b), 0, n);
- }
- _ref = data;
- /* */ if ($assertType(_ref, ptrType, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, $Int8, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, sliceType$1, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$1, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, $Uint8, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, sliceType, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$2, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, $Int16, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, sliceType$2, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, $Uint16, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, sliceType$3, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$4, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, $Int32, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, sliceType$4, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref, $Uint32, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref, sliceType$5, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref, ptrType$6, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref, $Int64, true)[1]) { $s = 22; continue; }
- /* */ if ($assertType(_ref, sliceType$6, true)[1]) { $s = 23; continue; }
- /* */ if ($assertType(_ref, ptrType$7, true)[1]) { $s = 24; continue; }
- /* */ if ($assertType(_ref, $Uint64, true)[1]) { $s = 25; continue; }
- /* */ if ($assertType(_ref, sliceType$7, true)[1]) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if ($assertType(_ref, ptrType, true)[1]) { */ case 3:
- v = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 1);
- b[0] = (v.$get() << 24 >>> 24);
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Int8, true)[1]) { */ case 4:
- v$1 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 1);
- b[0] = (v$1 << 24 >>> 24);
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType$1, true)[1]) { */ case 5:
- v$2 = _ref.$val;
- _ref$1 = v$2;
- _i = 0;
- while (true) {
- if (!(_i < _ref$1.$length)) { break; }
- i = _i;
- x = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- ((i < 0 || i >= bs.$length) ? $throwRuntimeError("index out of range") : bs.$array[bs.$offset + i] = (x << 24 >>> 24));
- _i++;
- }
- $s = 27; continue;
- /* } else if ($assertType(_ref, ptrType$1, true)[1]) { */ case 6:
- v$3 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 1);
- b[0] = v$3.$get();
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Uint8, true)[1]) { */ case 7:
- v$4 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 1);
- b[0] = v$4;
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType, true)[1]) { */ case 8:
- v$5 = _ref.$val;
- bs = v$5;
- $s = 27; continue;
- /* } else if ($assertType(_ref, ptrType$2, true)[1]) { */ case 9:
- v$6 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 2);
- $r = order.PutUint16(bs, (v$6.$get() << 16 >>> 16)); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Int16, true)[1]) { */ case 10:
- v$7 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 2);
- $r = order.PutUint16(bs, (v$7 << 16 >>> 16)); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType$2, true)[1]) { */ case 11:
- v$8 = _ref.$val;
- _ref$2 = v$8;
- _i$1 = 0;
- /* while (true) { */ case 30:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 31; continue; }
- i$1 = _i$1;
- x$1 = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- $r = order.PutUint16($subslice(bs, (2 * i$1 >> 0)), (x$1 << 16 >>> 16)); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 30; continue; case 31:
- $s = 27; continue;
- /* } else if ($assertType(_ref, ptrType$3, true)[1]) { */ case 12:
- v$9 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 2);
- $r = order.PutUint16(bs, v$9.$get()); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Uint16, true)[1]) { */ case 13:
- v$10 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 2);
- $r = order.PutUint16(bs, v$10); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType$3, true)[1]) { */ case 14:
- v$11 = _ref.$val;
- _ref$3 = v$11;
- _i$2 = 0;
- /* while (true) { */ case 35:
- /* if (!(_i$2 < _ref$3.$length)) { break; } */ if(!(_i$2 < _ref$3.$length)) { $s = 36; continue; }
- i$2 = _i$2;
- x$2 = ((_i$2 < 0 || _i$2 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$2]);
- $r = order.PutUint16($subslice(bs, (2 * i$2 >> 0)), x$2); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 35; continue; case 36:
- $s = 27; continue;
- /* } else if ($assertType(_ref, ptrType$4, true)[1]) { */ case 15:
- v$12 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 4);
- $r = order.PutUint32(bs, (v$12.$get() >>> 0)); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Int32, true)[1]) { */ case 16:
- v$13 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 4);
- $r = order.PutUint32(bs, (v$13 >>> 0)); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType$4, true)[1]) { */ case 17:
- v$14 = _ref.$val;
- _ref$4 = v$14;
- _i$3 = 0;
- /* while (true) { */ case 40:
- /* if (!(_i$3 < _ref$4.$length)) { break; } */ if(!(_i$3 < _ref$4.$length)) { $s = 41; continue; }
- i$3 = _i$3;
- x$3 = ((_i$3 < 0 || _i$3 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$3]);
- $r = order.PutUint32($subslice(bs, (4 * i$3 >> 0)), (x$3 >>> 0)); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* } */ $s = 40; continue; case 41:
- $s = 27; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1]) { */ case 18:
- v$15 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 4);
- $r = order.PutUint32(bs, v$15.$get()); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Uint32, true)[1]) { */ case 19:
- v$16 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 4);
- $r = order.PutUint32(bs, v$16); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType$5, true)[1]) { */ case 20:
- v$17 = _ref.$val;
- _ref$5 = v$17;
- _i$4 = 0;
- /* while (true) { */ case 45:
- /* if (!(_i$4 < _ref$5.$length)) { break; } */ if(!(_i$4 < _ref$5.$length)) { $s = 46; continue; }
- i$4 = _i$4;
- x$4 = ((_i$4 < 0 || _i$4 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$4]);
- $r = order.PutUint32($subslice(bs, (4 * i$4 >> 0)), x$4); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$4++;
- /* } */ $s = 45; continue; case 46:
- $s = 27; continue;
- /* } else if ($assertType(_ref, ptrType$6, true)[1]) { */ case 21:
- v$18 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 8);
- $r = order.PutUint64(bs, (x$5 = v$18.$get(), new $Uint64(x$5.$high, x$5.$low))); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Int64, true)[1]) { */ case 22:
- v$19 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 8);
- $r = order.PutUint64(bs, new $Uint64(v$19.$high, v$19.$low)); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType$6, true)[1]) { */ case 23:
- v$20 = _ref.$val;
- _ref$6 = v$20;
- _i$5 = 0;
- /* while (true) { */ case 50:
- /* if (!(_i$5 < _ref$6.$length)) { break; } */ if(!(_i$5 < _ref$6.$length)) { $s = 51; continue; }
- i$5 = _i$5;
- x$6 = ((_i$5 < 0 || _i$5 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$5]);
- $r = order.PutUint64($subslice(bs, (8 * i$5 >> 0)), new $Uint64(x$6.$high, x$6.$low)); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$5++;
- /* } */ $s = 50; continue; case 51:
- $s = 27; continue;
- /* } else if ($assertType(_ref, ptrType$7, true)[1]) { */ case 24:
- v$21 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 8);
- $r = order.PutUint64(bs, v$21.$get()); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, $Uint64, true)[1]) { */ case 25:
- v$22 = _ref.$val;
- bs = $subslice(new sliceType(b), 0, 8);
- $r = order.PutUint64(bs, v$22); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 27; continue;
- /* } else if ($assertType(_ref, sliceType$7, true)[1]) { */ case 26:
- v$23 = _ref.$val;
- _ref$7 = v$23;
- _i$6 = 0;
- /* while (true) { */ case 55:
- /* if (!(_i$6 < _ref$7.$length)) { break; } */ if(!(_i$6 < _ref$7.$length)) { $s = 56; continue; }
- i$6 = _i$6;
- x$7 = ((_i$6 < 0 || _i$6 >= _ref$7.$length) ? $throwRuntimeError("index out of range") : _ref$7.$array[_ref$7.$offset + _i$6]);
- $r = order.PutUint64($subslice(bs, (8 * i$6 >> 0)), x$7); /* */ $s = 57; case 57: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$6++;
- /* } */ $s = 55; continue; case 56:
- /* } */ case 27:
- _r = w.Write(bs); /* */ $s = 58; case 58: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; err = _tuple[1];
- return err;
- /* } */ case 2:
- _r$1 = reflect.ValueOf(data); /* */ $s = 59; case 59: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = reflect.Indirect(_r$1); /* */ $s = 60; case 60: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v$24 = _r$2;
- _r$3 = dataSize(v$24); /* */ $s = 61; case 61: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- size = _r$3;
- /* */ if (size < 0) { $s = 62; continue; }
- /* */ $s = 63; continue;
- /* if (size < 0) { */ case 62:
- _r$4 = reflect.TypeOf(data).String(); /* */ $s = 64; case 64: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = errors.New("binary.Write: invalid type " + _r$4); /* */ $s = 65; case 65: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- /* } */ case 63:
- buf = $makeSlice(sliceType, size);
- e = new encoder.ptr(order, buf);
- $r = e.value(v$24); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$6 = w.Write(buf); /* */ $s = 67; case 67: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$1 = _r$6; err$1 = _tuple$1[1];
- return err$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Write }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.bs = bs; $f.buf = buf; $f.data = data; $f.e = e; $f.err = err; $f.err$1 = err$1; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.i$5 = i$5; $f.i$6 = i$6; $f.n = n; $f.order = order; $f.size = size; $f.v = v; $f.v$1 = v$1; $f.v$10 = v$10; $f.v$11 = v$11; $f.v$12 = v$12; $f.v$13 = v$13; $f.v$14 = v$14; $f.v$15 = v$15; $f.v$16 = v$16; $f.v$17 = v$17; $f.v$18 = v$18; $f.v$19 = v$19; $f.v$2 = v$2; $f.v$20 = v$20; $f.v$21 = v$21; $f.v$22 = v$22; $f.v$23 = v$23; $f.v$24 = v$24; $f.v$3 = v$3; $f.v$4 = v$4; $f.v$5 = v$5; $f.v$6 = v$6; $f.v$7 = v$7; $f.v$8 = v$8; $f.v$9 = v$9; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Write = Write;
- dataSize = function(v) {
- var $ptr, _r, _r$1, _r$2, s, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- /* */ if (v.Kind() === 23) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (v.Kind() === 23) { */ case 1:
- _r = v.Type().Elem(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = sizeof(_r); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- s = _r$1;
- /* */ if (s >= 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (s >= 0) { */ case 5:
- return s * v.Len() >> 0;
- /* } */ case 6:
- return -1;
- /* } */ case 2:
- _r$2 = sizeof(v.Type()); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: dataSize }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- sizeof = function(t) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _tmp, _tmp$1, i, n, s, s$1, sum, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; i = $f.i; n = $f.n; s = $f.s; s$1 = $f.s$1; sum = $f.sum; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = t.Kind(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if (_ref === 17) { $s = 2; continue; }
- /* */ if (_ref === 25) { $s = 3; continue; }
- /* */ if (_ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6 || _ref === 13 || _ref === 14 || _ref === 15 || _ref === 16) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref === 17) { */ case 2:
- _r$1 = t.Elem(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = sizeof(_r$1); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- s = _r$2;
- /* */ if (s >= 0) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (s >= 0) { */ case 8:
- _r$3 = t.Len(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return s * _r$3 >> 0;
- /* } */ case 9:
- $s = 5; continue;
- /* } else if (_ref === 25) { */ case 3:
- sum = 0;
- _r$4 = t.NumField(); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tmp = 0; _tmp$1 = _r$4; i = _tmp; n = _tmp$1;
- /* while (true) { */ case 12:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 13; continue; }
- _r$5 = t.Field(i); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = sizeof(_r$5.Type); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- s$1 = _r$6;
- if (s$1 < 0) {
- return -1;
- }
- sum = sum + (s$1) >> 0;
- i = i + (1) >> 0;
- /* } */ $s = 12; continue; case 13:
- return sum;
- $s = 5; continue;
- /* } else if (_ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6 || _ref === 13 || _ref === 14 || _ref === 15 || _ref === 16) { */ case 4:
- _r$7 = t.Size(); /* */ $s = 16; case 16: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return (_r$7 >> 0);
- /* } */ case 5:
- return -1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sizeof }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.i = i; $f.n = n; $f.s = s; $f.s$1 = s$1; $f.sum = sum; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.ptr.prototype.uint8 = function(x) {
- var $ptr, e, x, x$1;
- e = this;
- (x$1 = e.buf, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0] = x));
- e.buf = $subslice(e.buf, 1);
- };
- encoder.prototype.uint8 = function(x) { return this.$val.uint8(x); };
- encoder.ptr.prototype.uint16 = function(x) {
- var $ptr, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- $r = e.order.PutUint16($subslice(e.buf, 0, 2), x); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- e.buf = $subslice(e.buf, 2);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.uint16 }; } $f.$ptr = $ptr; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.uint16 = function(x) { return this.$val.uint16(x); };
- encoder.ptr.prototype.uint32 = function(x) {
- var $ptr, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- $r = e.order.PutUint32($subslice(e.buf, 0, 4), x); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- e.buf = $subslice(e.buf, 4);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.uint32 }; } $f.$ptr = $ptr; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.uint32 = function(x) { return this.$val.uint32(x); };
- encoder.ptr.prototype.uint64 = function(x) {
- var $ptr, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- $r = e.order.PutUint64($subslice(e.buf, 0, 8), x); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- e.buf = $subslice(e.buf, 8);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.uint64 }; } $f.$ptr = $ptr; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.uint64 = function(x) { return this.$val.uint64(x); };
- encoder.ptr.prototype.int8 = function(x) {
- var $ptr, e, x;
- e = this;
- e.uint8((x << 24 >>> 24));
- };
- encoder.prototype.int8 = function(x) { return this.$val.int8(x); };
- encoder.ptr.prototype.int16 = function(x) {
- var $ptr, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- $r = e.uint16((x << 16 >>> 16)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.int16 }; } $f.$ptr = $ptr; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.int16 = function(x) { return this.$val.int16(x); };
- encoder.ptr.prototype.int32 = function(x) {
- var $ptr, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- $r = e.uint32((x >>> 0)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.int32 }; } $f.$ptr = $ptr; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.int32 = function(x) { return this.$val.int32(x); };
- encoder.ptr.prototype.int64 = function(x) {
- var $ptr, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- $r = e.uint64(new $Uint64(x.$high, x.$low)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.int64 }; } $f.$ptr = $ptr; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.int64 = function(x) { return this.$val.int64(x); };
- encoder.ptr.prototype.value = function(v) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _v, e, i, i$1, i$2, l, l$1, l$2, t, v, v$1, x, x$1, x$2, x$3, x$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _v = $f._v; e = $f.e; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; l = $f.l; l$1 = $f.l$1; l$2 = $f.l$2; t = $f.t; v = $f.v; v$1 = $f.v$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- v = v;
- _ref = v.Kind();
- /* */ if (_ref === 17) { $s = 1; continue; }
- /* */ if (_ref === 25) { $s = 2; continue; }
- /* */ if (_ref === 23) { $s = 3; continue; }
- /* */ if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { $s = 4; continue; }
- /* */ if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { $s = 5; continue; }
- /* */ if (_ref === 13 || _ref === 14) { $s = 6; continue; }
- /* */ if (_ref === 15 || _ref === 16) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_ref === 17) { */ case 1:
- l = v.Len();
- i = 0;
- /* while (true) { */ case 9:
- /* if (!(i < l)) { break; } */ if(!(i < l)) { $s = 10; continue; }
- _r = v.Index(i); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = e.value(_r); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 9; continue; case 10:
- $s = 8; continue;
- /* } else if (_ref === 25) { */ case 2:
- t = v.Type();
- l$1 = v.NumField();
- i$1 = 0;
- /* while (true) { */ case 13:
- /* if (!(i$1 < l$1)) { break; } */ if(!(i$1 < l$1)) { $s = 14; continue; }
- _r$1 = v.Field(i$1); /* */ $s = 15; case 15: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- v$1 = _r$1;
- if (v$1.CanSet()) { _v = true; $s = 19; continue s; }
- _r$2 = t.Field(i$1); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = !(_r$2.Name === "_"); case 19:
- /* */ if (_v) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (_v) { */ case 16:
- $r = e.value(v$1); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else { */ case 17:
- $r = e.skip(v$1); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- i$1 = i$1 + (1) >> 0;
- /* } */ $s = 13; continue; case 14:
- $s = 8; continue;
- /* } else if (_ref === 23) { */ case 3:
- l$2 = v.Len();
- i$2 = 0;
- /* while (true) { */ case 23:
- /* if (!(i$2 < l$2)) { break; } */ if(!(i$2 < l$2)) { $s = 24; continue; }
- _r$3 = v.Index(i$2); /* */ $s = 25; case 25: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = e.value(_r$3); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$2 = i$2 + (1) >> 0;
- /* } */ $s = 23; continue; case 24:
- $s = 8; continue;
- /* } else if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { */ case 4:
- _r$4 = v.Type().Kind(); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _ref$1 = _r$4;
- /* */ if (_ref$1 === 3) { $s = 28; continue; }
- /* */ if (_ref$1 === 4) { $s = 29; continue; }
- /* */ if (_ref$1 === 5) { $s = 30; continue; }
- /* */ if (_ref$1 === 6) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (_ref$1 === 3) { */ case 28:
- e.int8(((x = v.Int(), x.$low + ((x.$high >> 31) * 4294967296)) << 24 >> 24));
- $s = 32; continue;
- /* } else if (_ref$1 === 4) { */ case 29:
- $r = e.int16(((x$1 = v.Int(), x$1.$low + ((x$1.$high >> 31) * 4294967296)) << 16 >> 16)); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 32; continue;
- /* } else if (_ref$1 === 5) { */ case 30:
- $r = e.int32(((x$2 = v.Int(), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0)); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 32; continue;
- /* } else if (_ref$1 === 6) { */ case 31:
- $r = e.int64(v.Int()); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 32:
- $s = 8; continue;
- /* } else if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { */ case 5:
- _r$5 = v.Type().Kind(); /* */ $s = 36; case 36: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _ref$2 = _r$5;
- /* */ if (_ref$2 === 8) { $s = 37; continue; }
- /* */ if (_ref$2 === 9) { $s = 38; continue; }
- /* */ if (_ref$2 === 10) { $s = 39; continue; }
- /* */ if (_ref$2 === 11) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if (_ref$2 === 8) { */ case 37:
- e.uint8((v.Uint().$low << 24 >>> 24));
- $s = 41; continue;
- /* } else if (_ref$2 === 9) { */ case 38:
- $r = e.uint16((v.Uint().$low << 16 >>> 16)); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 41; continue;
- /* } else if (_ref$2 === 10) { */ case 39:
- $r = e.uint32((v.Uint().$low >>> 0)); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 41; continue;
- /* } else if (_ref$2 === 11) { */ case 40:
- $r = e.uint64(v.Uint()); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 41:
- $s = 8; continue;
- /* } else if (_ref === 13 || _ref === 14) { */ case 6:
- _r$6 = v.Type().Kind(); /* */ $s = 45; case 45: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _ref$3 = _r$6;
- /* */ if (_ref$3 === 13) { $s = 46; continue; }
- /* */ if (_ref$3 === 14) { $s = 47; continue; }
- /* */ $s = 48; continue;
- /* if (_ref$3 === 13) { */ case 46:
- $r = e.uint32(math.Float32bits($fround(v.Float()))); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 48; continue;
- /* } else if (_ref$3 === 14) { */ case 47:
- $r = e.uint64(math.Float64bits(v.Float())); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 48:
- $s = 8; continue;
- /* } else if (_ref === 15 || _ref === 16) { */ case 7:
- _r$7 = v.Type().Kind(); /* */ $s = 51; case 51: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _ref$4 = _r$7;
- /* */ if (_ref$4 === 15) { $s = 52; continue; }
- /* */ if (_ref$4 === 16) { $s = 53; continue; }
- /* */ $s = 54; continue;
- /* if (_ref$4 === 15) { */ case 52:
- x$3 = v.Complex();
- $r = e.uint32(math.Float32bits($fround(x$3.$real))); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = e.uint32(math.Float32bits($fround(x$3.$imag))); /* */ $s = 56; case 56: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 54; continue;
- /* } else if (_ref$4 === 16) { */ case 53:
- x$4 = v.Complex();
- $r = e.uint64(math.Float64bits(x$4.$real)); /* */ $s = 57; case 57: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = e.uint64(math.Float64bits(x$4.$imag)); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 54:
- /* } */ case 8:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.value }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._v = _v; $f.e = e; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.l = l; $f.l$1 = l$1; $f.l$2 = l$2; $f.t = t; $f.v = v; $f.v$1 = v$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.value = function(v) { return this.$val.value(v); };
- encoder.ptr.prototype.skip = function(v) {
- var $ptr, _i, _r, _ref, e, i, n, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; e = $f.e; i = $f.i; n = $f.n; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- v = v;
- _r = dataSize(v); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n = _r;
- _ref = $subslice(e.buf, 0, n);
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- (x = e.buf, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = 0));
- _i++;
- }
- e.buf = $subslice(e.buf, n);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.skip }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.e = e; $f.i = i; $f.n = n; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.skip = function(v) { return this.$val.skip(v); };
- intDataSize = function(data) {
- var $ptr, _ref, data, data$1, data$10, data$11, data$12, data$2, data$3, data$4, data$5, data$6, data$7, data$8, data$9;
- _ref = data;
- if ($assertType(_ref, $Int8, true)[1] || $assertType(_ref, ptrType, true)[1] || $assertType(_ref, ptrType$1, true)[1]) {
- data$1 = _ref;
- return 1;
- } else if ($assertType(_ref, sliceType$1, true)[1]) {
- data$2 = _ref.$val;
- return data$2.$length;
- } else if ($assertType(_ref, sliceType, true)[1]) {
- data$3 = _ref.$val;
- return data$3.$length;
- } else if ($assertType(_ref, $Int16, true)[1] || $assertType(_ref, ptrType$2, true)[1] || $assertType(_ref, ptrType$3, true)[1]) {
- data$4 = _ref;
- return 2;
- } else if ($assertType(_ref, sliceType$2, true)[1]) {
- data$5 = _ref.$val;
- return 2 * data$5.$length >> 0;
- } else if ($assertType(_ref, sliceType$3, true)[1]) {
- data$6 = _ref.$val;
- return 2 * data$6.$length >> 0;
- } else if ($assertType(_ref, $Int32, true)[1] || $assertType(_ref, ptrType$4, true)[1] || $assertType(_ref, ptrType$5, true)[1]) {
- data$7 = _ref;
- return 4;
- } else if ($assertType(_ref, sliceType$4, true)[1]) {
- data$8 = _ref.$val;
- return 4 * data$8.$length >> 0;
- } else if ($assertType(_ref, sliceType$5, true)[1]) {
- data$9 = _ref.$val;
- return 4 * data$9.$length >> 0;
- } else if ($assertType(_ref, $Int64, true)[1] || $assertType(_ref, ptrType$6, true)[1] || $assertType(_ref, ptrType$7, true)[1]) {
- data$10 = _ref;
- return 8;
- } else if ($assertType(_ref, sliceType$6, true)[1]) {
- data$11 = _ref.$val;
- return 8 * data$11.$length >> 0;
- } else if ($assertType(_ref, sliceType$7, true)[1]) {
- data$12 = _ref.$val;
- return 8 * data$12.$length >> 0;
- }
- return 0;
- };
- PutUvarint = function(buf, x) {
- var $ptr, buf, i, x;
- i = 0;
- while (true) {
- if (!((x.$high > 0 || (x.$high === 0 && x.$low >= 128)))) { break; }
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((x.$low << 24 >>> 24) | 128) >>> 0);
- x = $shiftRightUint64(x, (7));
- i = i + (1) >> 0;
- }
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = (x.$low << 24 >>> 24));
- return i + 1 >> 0;
- };
- $pkg.PutUvarint = PutUvarint;
- Uvarint = function(buf) {
- var $ptr, _i, _ref, b, buf, i, s, x, x$1, x$2;
- x = new $Uint64(0, 0);
- s = 0;
- _ref = buf;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (b < 128) {
- if (i > 9 || (i === 9) && b > 1) {
- return [new $Uint64(0, 0), -((i + 1 >> 0))];
- }
- return [(x$1 = $shiftLeft64(new $Uint64(0, b), s), new $Uint64(x.$high | x$1.$high, (x.$low | x$1.$low) >>> 0)), i + 1 >> 0];
- }
- x = (x$2 = $shiftLeft64(new $Uint64(0, ((b & 127) >>> 0)), s), new $Uint64(x.$high | x$2.$high, (x.$low | x$2.$low) >>> 0));
- s = s + (7) >>> 0;
- _i++;
- }
- return [new $Uint64(0, 0), 0];
- };
- $pkg.Uvarint = Uvarint;
- PutVarint = function(buf, x) {
- var $ptr, buf, ux, x;
- ux = $shiftLeft64(new $Uint64(x.$high, x.$low), 1);
- if ((x.$high < 0 || (x.$high === 0 && x.$low < 0))) {
- ux = new $Uint64(~ux.$high, ~ux.$low >>> 0);
- }
- return PutUvarint(buf, ux);
- };
- $pkg.PutVarint = PutVarint;
- Varint = function(buf) {
- var $ptr, _tuple, buf, n, ux, x, x$1, x$2;
- _tuple = Uvarint(buf); ux = _tuple[0]; n = _tuple[1];
- x$1 = (x = $shiftRightUint64(ux, 1), new $Int64(x.$high, x.$low));
- if (!((x$2 = new $Uint64(ux.$high & 0, (ux.$low & 1) >>> 0), (x$2.$high === 0 && x$2.$low === 0)))) {
- x$1 = new $Int64(~x$1.$high, ~x$1.$low >>> 0);
- }
- return [x$1, n];
- };
- $pkg.Varint = Varint;
- bigEndian.methods = [{prop: "Uint16", name: "Uint16", pkg: "", typ: $funcType([sliceType], [$Uint16], false)}, {prop: "PutUint16", name: "PutUint16", pkg: "", typ: $funcType([sliceType, $Uint16], [], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([sliceType], [$Uint32], false)}, {prop: "PutUint32", name: "PutUint32", pkg: "", typ: $funcType([sliceType, $Uint32], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([sliceType], [$Uint64], false)}, {prop: "PutUint64", name: "PutUint64", pkg: "", typ: $funcType([sliceType, $Uint64], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$9.methods = [{prop: "uint8", name: "uint8", pkg: "encoding/binary", typ: $funcType([$Uint8], [], false)}, {prop: "uint16", name: "uint16", pkg: "encoding/binary", typ: $funcType([$Uint16], [], false)}, {prop: "uint32", name: "uint32", pkg: "encoding/binary", typ: $funcType([$Uint32], [], false)}, {prop: "uint64", name: "uint64", pkg: "encoding/binary", typ: $funcType([$Uint64], [], false)}, {prop: "int8", name: "int8", pkg: "encoding/binary", typ: $funcType([$Int8], [], false)}, {prop: "int16", name: "int16", pkg: "encoding/binary", typ: $funcType([$Int16], [], false)}, {prop: "int32", name: "int32", pkg: "encoding/binary", typ: $funcType([$Int32], [], false)}, {prop: "int64", name: "int64", pkg: "encoding/binary", typ: $funcType([$Int64], [], false)}, {prop: "value", name: "value", pkg: "encoding/binary", typ: $funcType([reflect.Value], [], false)}, {prop: "skip", name: "skip", pkg: "encoding/binary", typ: $funcType([reflect.Value], [], false)}];
- ByteOrder.init([{prop: "PutUint16", name: "PutUint16", pkg: "", typ: $funcType([sliceType, $Uint16], [], false)}, {prop: "PutUint32", name: "PutUint32", pkg: "", typ: $funcType([sliceType, $Uint32], [], false)}, {prop: "PutUint64", name: "PutUint64", pkg: "", typ: $funcType([sliceType, $Uint64], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Uint16", name: "Uint16", pkg: "", typ: $funcType([sliceType], [$Uint16], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([sliceType], [$Uint32], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([sliceType], [$Uint64], false)}]);
- bigEndian.init([]);
- encoder.init([{prop: "order", name: "order", pkg: "encoding/binary", typ: ByteOrder, tag: ""}, {prop: "buf", name: "buf", pkg: "encoding/binary", typ: sliceType, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = reflect.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.BigEndian = new bigEndian.ptr();
- overflow = errors.New("binary: varint overflows a 64-bit integer");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["bufio"] = (function() {
- var $pkg = {}, $init, bytes, errors, io, utf8, Reader, sliceType, ptrType, sliceType$1, errNegativeRead, errNegativeWrite, NewReaderSize, NewReader;
- bytes = $packages["bytes"];
- errors = $packages["errors"];
- io = $packages["io"];
- utf8 = $packages["unicode/utf8"];
- Reader = $pkg.Reader = $newType(0, $kindStruct, "bufio.Reader", "Reader", "bufio", function(buf_, rd_, r_, w_, err_, lastByte_, lastRuneSize_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.buf = sliceType.nil;
- this.rd = $ifaceNil;
- this.r = 0;
- this.w = 0;
- this.err = $ifaceNil;
- this.lastByte = 0;
- this.lastRuneSize = 0;
- return;
- }
- this.buf = buf_;
- this.rd = rd_;
- this.r = r_;
- this.w = w_;
- this.err = err_;
- this.lastByte = lastByte_;
- this.lastRuneSize = lastRuneSize_;
- });
- sliceType = $sliceType($Uint8);
- ptrType = $ptrType(Reader);
- sliceType$1 = $sliceType(sliceType);
- NewReaderSize = function(rd, size) {
- var $ptr, _tuple, b, ok, r, rd, size;
- _tuple = $assertType(rd, ptrType, true); b = _tuple[0]; ok = _tuple[1];
- if (ok && b.buf.$length >= size) {
- return b;
- }
- if (size < 16) {
- size = 16;
- }
- r = new Reader.ptr();
- r.reset($makeSlice(sliceType, size), rd);
- return r;
- };
- $pkg.NewReaderSize = NewReaderSize;
- NewReader = function(rd) {
- var $ptr, rd;
- return NewReaderSize(rd, 4096);
- };
- $pkg.NewReader = NewReader;
- Reader.ptr.prototype.Reset = function(r) {
- var $ptr, b, r;
- b = this;
- b.reset(b.buf, r);
- };
- Reader.prototype.Reset = function(r) { return this.$val.Reset(r); };
- Reader.ptr.prototype.reset = function(buf, r) {
- var $ptr, b, buf, r;
- b = this;
- $copy(b, new Reader.ptr(buf, r, 0, 0, $ifaceNil, -1, -1), Reader);
- };
- Reader.prototype.reset = function(buf, r) { return this.$val.reset(buf, r); };
- Reader.ptr.prototype.fill = function() {
- var $ptr, _r, _tuple, b, err, i, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; b = $f.b; err = $f.err; i = $f.i; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- b = this;
- if (b.r > 0) {
- $copySlice(b.buf, $subslice(b.buf, b.r, b.w));
- b.w = b.w - (b.r) >> 0;
- b.r = 0;
- }
- if (b.w >= b.buf.$length) {
- $panic(new $String("bufio: tried to fill full buffer"));
- }
- i = 100;
- /* while (true) { */ case 1:
- /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 2; continue; }
- _r = b.rd.Read($subslice(b.buf, b.w)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; n = _tuple[0]; err = _tuple[1];
- if (n < 0) {
- $panic(errNegativeRead);
- }
- b.w = b.w + (n) >> 0;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- b.err = err;
- return;
- }
- if (n > 0) {
- return;
- }
- i = i - (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- b.err = io.ErrNoProgress;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.fill }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.i = i; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.fill = function() { return this.$val.fill(); };
- Reader.ptr.prototype.readErr = function() {
- var $ptr, b, err;
- b = this;
- err = b.err;
- b.err = $ifaceNil;
- return err;
- };
- Reader.prototype.readErr = function() { return this.$val.readErr(); };
- Reader.ptr.prototype.Peek = function(n) {
- var $ptr, avail, b, err, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; avail = $f.avail; b = $f.b; err = $f.err; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- b = this;
- if (n < 0) {
- return [sliceType.nil, $pkg.ErrNegativeCount];
- }
- if (n > b.buf.$length) {
- return [sliceType.nil, $pkg.ErrBufferFull];
- }
- /* while (true) { */ case 1:
- /* if (!((b.w - b.r >> 0) < n && $interfaceIsEqual(b.err, $ifaceNil))) { break; } */ if(!((b.w - b.r >> 0) < n && $interfaceIsEqual(b.err, $ifaceNil))) { $s = 2; continue; }
- $r = b.fill(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- err = $ifaceNil;
- avail = b.w - b.r >> 0;
- if (avail < n) {
- n = avail;
- err = b.readErr();
- if ($interfaceIsEqual(err, $ifaceNil)) {
- err = $pkg.ErrBufferFull;
- }
- }
- return [$subslice(b.buf, b.r, (b.r + n >> 0)), err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.Peek }; } $f.$ptr = $ptr; $f.avail = avail; $f.b = b; $f.err = err; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.Peek = function(n) { return this.$val.Peek(n); };
- Reader.ptr.prototype.Read = function(p) {
- var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, b, err, n, p, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; b = $f.b; err = $f.err; n = $f.n; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- b = this;
- n = p.$length;
- if (n === 0) {
- _tmp = 0; _tmp$1 = b.readErr(); n = _tmp; err = _tmp$1;
- return [n, err];
- }
- /* */ if (b.r === b.w) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (b.r === b.w) { */ case 1:
- if (!($interfaceIsEqual(b.err, $ifaceNil))) {
- _tmp$2 = 0; _tmp$3 = b.readErr(); n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- /* */ if (p.$length >= b.buf.$length) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (p.$length >= b.buf.$length) { */ case 3:
- _r = b.rd.Read(p); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; n = _tuple[0]; b.err = _tuple[1];
- if (n < 0) {
- $panic(errNegativeRead);
- }
- if (n > 0) {
- b.lastByte = ((x = n - 1 >> 0, ((x < 0 || x >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + x])) >> 0);
- b.lastRuneSize = -1;
- }
- _tmp$4 = n; _tmp$5 = b.readErr(); n = _tmp$4; err = _tmp$5;
- return [n, err];
- /* } */ case 4:
- $r = b.fill(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (b.r === b.w) {
- _tmp$6 = 0; _tmp$7 = b.readErr(); n = _tmp$6; err = _tmp$7;
- return [n, err];
- }
- /* } */ case 2:
- n = $copySlice(p, $subslice(b.buf, b.r, b.w));
- b.r = b.r + (n) >> 0;
- b.lastByte = ((x$1 = b.buf, x$2 = b.r - 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + x$2])) >> 0);
- b.lastRuneSize = -1;
- _tmp$8 = n; _tmp$9 = $ifaceNil; n = _tmp$8; err = _tmp$9;
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.Read }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.n = n; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.Read = function(p) { return this.$val.Read(p); };
- Reader.ptr.prototype.ReadByte = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, c, err, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; b = $f.b; c = $f.c; err = $f.err; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = 0;
- err = $ifaceNil;
- b = this;
- b.lastRuneSize = -1;
- /* while (true) { */ case 1:
- /* if (!(b.r === b.w)) { break; } */ if(!(b.r === b.w)) { $s = 2; continue; }
- if (!($interfaceIsEqual(b.err, $ifaceNil))) {
- _tmp = 0; _tmp$1 = b.readErr(); c = _tmp; err = _tmp$1;
- return [c, err];
- }
- $r = b.fill(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- c = (x = b.buf, x$1 = b.r, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- b.r = b.r + (1) >> 0;
- b.lastByte = (c >> 0);
- _tmp$2 = c; _tmp$3 = $ifaceNil; c = _tmp$2; err = _tmp$3;
- return [c, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.ReadByte }; } $f.$ptr = $ptr; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.b = b; $f.c = c; $f.err = err; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.ReadByte = function() { return this.$val.ReadByte(); };
- Reader.ptr.prototype.UnreadByte = function() {
- var $ptr, b, x, x$1;
- b = this;
- if (b.lastByte < 0 || (b.r === 0) && b.w > 0) {
- return $pkg.ErrInvalidUnreadByte;
- }
- if (b.r > 0) {
- b.r = b.r - (1) >> 0;
- } else {
- b.w = 1;
- }
- (x = b.buf, x$1 = b.r, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1] = (b.lastByte << 24 >>> 24)));
- b.lastByte = -1;
- b.lastRuneSize = -1;
- return $ifaceNil;
- };
- Reader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); };
- Reader.ptr.prototype.ReadRune = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, b, err, r, size, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; b = $f.b; err = $f.err; r = $f.r; size = $f.size; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = 0;
- size = 0;
- err = $ifaceNil;
- b = this;
- /* while (true) { */ case 1:
- /* if (!((b.r + 4 >> 0) > b.w && !utf8.FullRune($subslice(b.buf, b.r, b.w)) && $interfaceIsEqual(b.err, $ifaceNil) && (b.w - b.r >> 0) < b.buf.$length)) { break; } */ if(!((b.r + 4 >> 0) > b.w && !utf8.FullRune($subslice(b.buf, b.r, b.w)) && $interfaceIsEqual(b.err, $ifaceNil) && (b.w - b.r >> 0) < b.buf.$length)) { $s = 2; continue; }
- $r = b.fill(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- b.lastRuneSize = -1;
- if (b.r === b.w) {
- _tmp = 0; _tmp$1 = 0; _tmp$2 = b.readErr(); r = _tmp; size = _tmp$1; err = _tmp$2;
- return [r, size, err];
- }
- _tmp$3 = ((x = b.buf, x$1 = b.r, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])) >> 0); _tmp$4 = 1; r = _tmp$3; size = _tmp$4;
- if (r >= 128) {
- _tuple = utf8.DecodeRune($subslice(b.buf, b.r, b.w)); r = _tuple[0]; size = _tuple[1];
- }
- b.r = b.r + (size) >> 0;
- b.lastByte = ((x$2 = b.buf, x$3 = b.r - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3])) >> 0);
- b.lastRuneSize = size;
- _tmp$5 = r; _tmp$6 = size; _tmp$7 = $ifaceNil; r = _tmp$5; size = _tmp$6; err = _tmp$7;
- return [r, size, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.ReadRune }; } $f.$ptr = $ptr; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.r = r; $f.size = size; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.ReadRune = function() { return this.$val.ReadRune(); };
- Reader.ptr.prototype.UnreadRune = function() {
- var $ptr, b;
- b = this;
- if (b.lastRuneSize < 0 || b.r < b.lastRuneSize) {
- return $pkg.ErrInvalidUnreadRune;
- }
- b.r = b.r - (b.lastRuneSize) >> 0;
- b.lastByte = -1;
- b.lastRuneSize = -1;
- return $ifaceNil;
- };
- Reader.prototype.UnreadRune = function() { return this.$val.UnreadRune(); };
- Reader.ptr.prototype.Buffered = function() {
- var $ptr, b;
- b = this;
- return b.w - b.r >> 0;
- };
- Reader.prototype.Buffered = function() { return this.$val.Buffered(); };
- Reader.ptr.prototype.ReadSlice = function(delim) {
- var $ptr, b, delim, err, i, i$1, line, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; b = $f.b; delim = $f.delim; err = $f.err; i = $f.i; i$1 = $f.i$1; line = $f.line; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- line = sliceType.nil;
- err = $ifaceNil;
- b = this;
- /* while (true) { */ case 1:
- i = bytes.IndexByte($subslice(b.buf, b.r, b.w), delim);
- if (i >= 0) {
- line = $subslice(b.buf, b.r, ((b.r + i >> 0) + 1 >> 0));
- b.r = b.r + ((i + 1 >> 0)) >> 0;
- /* break; */ $s = 2; continue;
- }
- if (!($interfaceIsEqual(b.err, $ifaceNil))) {
- line = $subslice(b.buf, b.r, b.w);
- b.r = b.w;
- err = b.readErr();
- /* break; */ $s = 2; continue;
- }
- if (b.Buffered() >= b.buf.$length) {
- b.r = b.w;
- line = b.buf;
- err = $pkg.ErrBufferFull;
- /* break; */ $s = 2; continue;
- }
- $r = b.fill(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- i$1 = line.$length - 1 >> 0;
- if (i$1 >= 0) {
- b.lastByte = (((i$1 < 0 || i$1 >= line.$length) ? $throwRuntimeError("index out of range") : line.$array[line.$offset + i$1]) >> 0);
- b.lastRuneSize = -1;
- }
- return [line, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.ReadSlice }; } $f.$ptr = $ptr; $f.b = b; $f.delim = delim; $f.err = err; $f.i = i; $f.i$1 = i$1; $f.line = line; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.ReadSlice = function(delim) { return this.$val.ReadSlice(delim); };
- Reader.ptr.prototype.ReadLine = function() {
- var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tuple, b, drop, err, isPrefix, line, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; b = $f.b; drop = $f.drop; err = $f.err; isPrefix = $f.isPrefix; line = $f.line; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- line = sliceType.nil;
- isPrefix = false;
- err = $ifaceNil;
- b = this;
- _r = b.ReadSlice(10); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; line = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $pkg.ErrBufferFull)) {
- if (line.$length > 0 && ((x = line.$length - 1 >> 0, ((x < 0 || x >= line.$length) ? $throwRuntimeError("index out of range") : line.$array[line.$offset + x])) === 13)) {
- if (b.r === 0) {
- $panic(new $String("bufio: tried to rewind past start of buffer"));
- }
- b.r = b.r - (1) >> 0;
- line = $subslice(line, 0, (line.$length - 1 >> 0));
- }
- _tmp = line; _tmp$1 = true; _tmp$2 = $ifaceNil; line = _tmp; isPrefix = _tmp$1; err = _tmp$2;
- return [line, isPrefix, err];
- }
- if (line.$length === 0) {
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- line = sliceType.nil;
- }
- return [line, isPrefix, err];
- }
- err = $ifaceNil;
- if ((x$1 = line.$length - 1 >> 0, ((x$1 < 0 || x$1 >= line.$length) ? $throwRuntimeError("index out of range") : line.$array[line.$offset + x$1])) === 10) {
- drop = 1;
- if (line.$length > 1 && ((x$2 = line.$length - 2 >> 0, ((x$2 < 0 || x$2 >= line.$length) ? $throwRuntimeError("index out of range") : line.$array[line.$offset + x$2])) === 13)) {
- drop = 2;
- }
- line = $subslice(line, 0, (line.$length - drop >> 0));
- }
- return [line, isPrefix, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.ReadLine }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.b = b; $f.drop = drop; $f.err = err; $f.isPrefix = isPrefix; $f.line = line; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.ReadLine = function() { return this.$val.ReadLine(); };
- Reader.ptr.prototype.ReadBytes = function(delim) {
- var $ptr, _i, _i$1, _r, _ref, _ref$1, _tmp, _tmp$1, _tuple, b, buf, buf$1, delim, e, err, frag, full, i, i$1, line, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; buf = $f.buf; buf$1 = $f.buf$1; delim = $f.delim; e = $f.e; err = $f.err; frag = $f.frag; full = $f.full; i = $f.i; i$1 = $f.i$1; line = $f.line; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- line = sliceType.nil;
- err = $ifaceNil;
- b = this;
- frag = sliceType.nil;
- full = sliceType$1.nil;
- err = $ifaceNil;
- /* while (true) { */ case 1:
- e = $ifaceNil;
- _r = b.ReadSlice(delim); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; frag = _tuple[0]; e = _tuple[1];
- if ($interfaceIsEqual(e, $ifaceNil)) {
- /* break; */ $s = 2; continue;
- }
- if (!($interfaceIsEqual(e, $pkg.ErrBufferFull))) {
- err = e;
- /* break; */ $s = 2; continue;
- }
- buf = $makeSlice(sliceType, frag.$length);
- $copySlice(buf, frag);
- full = $append(full, buf);
- /* } */ $s = 1; continue; case 2:
- n = 0;
- _ref = full;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- n = n + (((i < 0 || i >= full.$length) ? $throwRuntimeError("index out of range") : full.$array[full.$offset + i]).$length) >> 0;
- _i++;
- }
- n = n + (frag.$length) >> 0;
- buf$1 = $makeSlice(sliceType, n);
- n = 0;
- _ref$1 = full;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- i$1 = _i$1;
- n = n + ($copySlice($subslice(buf$1, n), ((i$1 < 0 || i$1 >= full.$length) ? $throwRuntimeError("index out of range") : full.$array[full.$offset + i$1]))) >> 0;
- _i$1++;
- }
- $copySlice($subslice(buf$1, n), frag);
- _tmp = buf$1; _tmp$1 = err; line = _tmp; err = _tmp$1;
- return [line, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.ReadBytes }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.buf = buf; $f.buf$1 = buf$1; $f.delim = delim; $f.e = e; $f.err = err; $f.frag = frag; $f.full = full; $f.i = i; $f.i$1 = i$1; $f.line = line; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.ReadBytes = function(delim) { return this.$val.ReadBytes(delim); };
- Reader.ptr.prototype.ReadString = function(delim) {
- var $ptr, _r, _tmp, _tmp$1, _tuple, b, bytes$1, delim, err, line, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; bytes$1 = $f.bytes$1; delim = $f.delim; err = $f.err; line = $f.line; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- line = "";
- err = $ifaceNil;
- b = this;
- _r = b.ReadBytes(delim); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; bytes$1 = _tuple[0]; err = _tuple[1];
- line = $bytesToString(bytes$1);
- _tmp = line; _tmp$1 = err; line = _tmp; err = _tmp$1;
- return [line, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.ReadString }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.bytes$1 = bytes$1; $f.delim = delim; $f.err = err; $f.line = line; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.ReadString = function(delim) { return this.$val.ReadString(delim); };
- Reader.ptr.prototype.WriteTo = function(w) {
- var $ptr, _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, b, err, err$1, err$2, err$3, m, m$1, m$2, n, ok, ok$1, r, w, w$1, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; b = $f.b; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; err$3 = $f.err$3; m = $f.m; m$1 = $f.m$1; m$2 = $f.m$2; n = $f.n; ok = $f.ok; ok$1 = $f.ok$1; r = $f.r; w = $f.w; w$1 = $f.w$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = new $Int64(0, 0);
- err = $ifaceNil;
- b = this;
- _r = b.writeBuf(w); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; n = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [n, err];
- }
- _tuple$1 = $assertType(b.rd, io.WriterTo, true); r = _tuple$1[0]; ok = _tuple$1[1];
- /* */ if (ok) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (ok) { */ case 2:
- _r$1 = r.WriteTo(w); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$2 = _r$1; m = _tuple$2[0]; err$1 = _tuple$2[1];
- n = (x = m, new $Int64(n.$high + x.$high, n.$low + x.$low));
- _tmp = n; _tmp$1 = err$1; n = _tmp; err = _tmp$1;
- return [n, err];
- /* } */ case 3:
- _tuple$3 = $assertType(w, io.ReaderFrom, true); w$1 = _tuple$3[0]; ok$1 = _tuple$3[1];
- /* */ if (ok$1) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (ok$1) { */ case 5:
- _r$2 = w$1.ReadFrom(b.rd); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$4 = _r$2; m$1 = _tuple$4[0]; err$2 = _tuple$4[1];
- n = (x$1 = m$1, new $Int64(n.$high + x$1.$high, n.$low + x$1.$low));
- _tmp$2 = n; _tmp$3 = err$2; n = _tmp$2; err = _tmp$3;
- return [n, err];
- /* } */ case 6:
- /* */ if ((b.w - b.r >> 0) < b.buf.$length) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ((b.w - b.r >> 0) < b.buf.$length) { */ case 8:
- $r = b.fill(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- /* while (true) { */ case 11:
- /* if (!(b.r < b.w)) { break; } */ if(!(b.r < b.w)) { $s = 12; continue; }
- _r$3 = b.writeBuf(w); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$5 = _r$3; m$2 = _tuple$5[0]; err$3 = _tuple$5[1];
- n = (x$2 = m$2, new $Int64(n.$high + x$2.$high, n.$low + x$2.$low));
- if (!($interfaceIsEqual(err$3, $ifaceNil))) {
- _tmp$4 = n; _tmp$5 = err$3; n = _tmp$4; err = _tmp$5;
- return [n, err];
- }
- $r = b.fill(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 11; continue; case 12:
- if ($interfaceIsEqual(b.err, io.EOF)) {
- b.err = $ifaceNil;
- }
- _tmp$6 = n; _tmp$7 = b.readErr(); n = _tmp$6; err = _tmp$7;
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.WriteTo }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.b = b; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.err$3 = err$3; $f.m = m; $f.m$1 = m$1; $f.m$2 = m$2; $f.n = n; $f.ok = ok; $f.ok$1 = ok$1; $f.r = r; $f.w = w; $f.w$1 = w$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); };
- Reader.ptr.prototype.writeBuf = function(w) {
- var $ptr, _r, _tuple, b, err, n, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; b = $f.b; err = $f.err; n = $f.n; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- b = this;
- _r = w.Write($subslice(b.buf, b.r, b.w)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; n = _tuple[0]; err = _tuple[1];
- if (n < 0) {
- $panic(errNegativeWrite);
- }
- b.r = b.r + (n) >> 0;
- return [new $Int64(0, n), err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.writeBuf }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.err = err; $f.n = n; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.writeBuf = function(w) { return this.$val.writeBuf(w); };
- ptrType.methods = [{prop: "Reset", name: "Reset", pkg: "", typ: $funcType([io.Reader], [], false)}, {prop: "reset", name: "reset", pkg: "bufio", typ: $funcType([sliceType, io.Reader], [], false)}, {prop: "fill", name: "fill", pkg: "bufio", typ: $funcType([], [], false)}, {prop: "readErr", name: "readErr", pkg: "bufio", typ: $funcType([], [$error], false)}, {prop: "Peek", name: "Peek", pkg: "", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Buffered", name: "Buffered", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ReadSlice", name: "ReadSlice", pkg: "", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "ReadLine", name: "ReadLine", pkg: "", typ: $funcType([], [sliceType, $Bool, $error], false)}, {prop: "ReadBytes", name: "ReadBytes", pkg: "", typ: $funcType([$Uint8], [sliceType, $error], false)}, {prop: "ReadString", name: "ReadString", pkg: "", typ: $funcType([$Uint8], [$String, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}, {prop: "writeBuf", name: "writeBuf", pkg: "bufio", typ: $funcType([io.Writer], [$Int64, $error], false)}];
- Reader.init([{prop: "buf", name: "buf", pkg: "bufio", typ: sliceType, tag: ""}, {prop: "rd", name: "rd", pkg: "bufio", typ: io.Reader, tag: ""}, {prop: "r", name: "r", pkg: "bufio", typ: $Int, tag: ""}, {prop: "w", name: "w", pkg: "bufio", typ: $Int, tag: ""}, {prop: "err", name: "err", pkg: "bufio", typ: $error, tag: ""}, {prop: "lastByte", name: "lastByte", pkg: "bufio", typ: $Int, tag: ""}, {prop: "lastRuneSize", name: "lastRuneSize", pkg: "bufio", typ: $Int, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte");
- $pkg.ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune");
- $pkg.ErrBufferFull = errors.New("bufio: buffer full");
- $pkg.ErrNegativeCount = errors.New("bufio: negative count");
- errNegativeRead = errors.New("bufio: reader returned negative count from Read");
- errNegativeWrite = errors.New("bufio: writer returned negative count from Write");
- $pkg.ErrTooLong = errors.New("bufio.Scanner: token too long");
- $pkg.ErrNegativeAdvance = errors.New("bufio.Scanner: SplitFunc returns negative advance count");
- $pkg.ErrAdvanceTooFar = errors.New("bufio.Scanner: SplitFunc returns advance count beyond input");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["encoding"] = (function() {
- var $pkg = {}, $init, BinaryMarshaler, BinaryUnmarshaler, TextMarshaler, TextUnmarshaler, sliceType;
- BinaryMarshaler = $pkg.BinaryMarshaler = $newType(8, $kindInterface, "encoding.BinaryMarshaler", "BinaryMarshaler", "encoding", null);
- BinaryUnmarshaler = $pkg.BinaryUnmarshaler = $newType(8, $kindInterface, "encoding.BinaryUnmarshaler", "BinaryUnmarshaler", "encoding", null);
- TextMarshaler = $pkg.TextMarshaler = $newType(8, $kindInterface, "encoding.TextMarshaler", "TextMarshaler", "encoding", null);
- TextUnmarshaler = $pkg.TextUnmarshaler = $newType(8, $kindInterface, "encoding.TextUnmarshaler", "TextUnmarshaler", "encoding", null);
- sliceType = $sliceType($Uint8);
- BinaryMarshaler.init([{prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType, $error], false)}]);
- BinaryUnmarshaler.init([{prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType], [$error], false)}]);
- TextMarshaler.init([{prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType, $error], false)}]);
- TextUnmarshaler.init([{prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType], [$error], false)}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["syscall"] = (function() {
- var $pkg = {}, $init, bytes, errors, js, runtime, sync, mmapper, Errno, _C_int, Timespec, Stat_t, Dirent, sliceType, sliceType$1, ptrType, sliceType$4, ptrType$10, arrayType$2, arrayType$3, arrayType$4, structType, ptrType$24, mapType, funcType, funcType$1, ptrType$28, arrayType$8, arrayType$10, arrayType$12, warningPrinted, lineBuffer, syscallModule, alreadyTriedToLoad, minusOne, envOnce, envLock, env, envs, mapper, errors$1, init, printWarning, printToConsole, use, runtime_envs, syscall, Syscall, Syscall6, BytePtrFromString, copyenv, Getenv, CloseOnExec, itoa, uitoa, ByteSliceFromString, ReadDirent, Sysctl, nametomib, ParseDirent, Read, Write, sysctl, fcntl, Close, Exit, Fchdir, Fchmod, Fchown, Fstat, Fsync, Ftruncate, Getdirentries, Lstat, Open, Pread, Pwrite, read, Seek, write, mmap, munmap;
- bytes = $packages["bytes"];
- errors = $packages["errors"];
- js = $packages["github.com/gopherjs/gopherjs/js"];
- runtime = $packages["runtime"];
- sync = $packages["sync"];
- mmapper = $pkg.mmapper = $newType(0, $kindStruct, "syscall.mmapper", "mmapper", "syscall", function(Mutex_, active_, mmap_, munmap_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Mutex = new sync.Mutex.ptr();
- this.active = false;
- this.mmap = $throwNilPointerError;
- this.munmap = $throwNilPointerError;
- return;
- }
- this.Mutex = Mutex_;
- this.active = active_;
- this.mmap = mmap_;
- this.munmap = munmap_;
- });
- Errno = $pkg.Errno = $newType(4, $kindUintptr, "syscall.Errno", "Errno", "syscall", null);
- _C_int = $pkg._C_int = $newType(4, $kindInt32, "syscall._C_int", "_C_int", "syscall", null);
- Timespec = $pkg.Timespec = $newType(0, $kindStruct, "syscall.Timespec", "Timespec", "syscall", function(Sec_, Nsec_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Sec = new $Int64(0, 0);
- this.Nsec = new $Int64(0, 0);
- return;
- }
- this.Sec = Sec_;
- this.Nsec = Nsec_;
- });
- Stat_t = $pkg.Stat_t = $newType(0, $kindStruct, "syscall.Stat_t", "Stat_t", "syscall", function(Dev_, Mode_, Nlink_, Ino_, Uid_, Gid_, Rdev_, Pad_cgo_0_, Atimespec_, Mtimespec_, Ctimespec_, Birthtimespec_, Size_, Blocks_, Blksize_, Flags_, Gen_, Lspare_, Qspare_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Dev = 0;
- this.Mode = 0;
- this.Nlink = 0;
- this.Ino = new $Uint64(0, 0);
- this.Uid = 0;
- this.Gid = 0;
- this.Rdev = 0;
- this.Pad_cgo_0 = arrayType$3.zero();
- this.Atimespec = new Timespec.ptr();
- this.Mtimespec = new Timespec.ptr();
- this.Ctimespec = new Timespec.ptr();
- this.Birthtimespec = new Timespec.ptr();
- this.Size = new $Int64(0, 0);
- this.Blocks = new $Int64(0, 0);
- this.Blksize = 0;
- this.Flags = 0;
- this.Gen = 0;
- this.Lspare = 0;
- this.Qspare = arrayType$8.zero();
- return;
- }
- this.Dev = Dev_;
- this.Mode = Mode_;
- this.Nlink = Nlink_;
- this.Ino = Ino_;
- this.Uid = Uid_;
- this.Gid = Gid_;
- this.Rdev = Rdev_;
- this.Pad_cgo_0 = Pad_cgo_0_;
- this.Atimespec = Atimespec_;
- this.Mtimespec = Mtimespec_;
- this.Ctimespec = Ctimespec_;
- this.Birthtimespec = Birthtimespec_;
- this.Size = Size_;
- this.Blocks = Blocks_;
- this.Blksize = Blksize_;
- this.Flags = Flags_;
- this.Gen = Gen_;
- this.Lspare = Lspare_;
- this.Qspare = Qspare_;
- });
- Dirent = $pkg.Dirent = $newType(0, $kindStruct, "syscall.Dirent", "Dirent", "syscall", function(Ino_, Seekoff_, Reclen_, Namlen_, Type_, Name_, Pad_cgo_0_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Ino = new $Uint64(0, 0);
- this.Seekoff = new $Uint64(0, 0);
- this.Reclen = 0;
- this.Namlen = 0;
- this.Type = 0;
- this.Name = arrayType$10.zero();
- this.Pad_cgo_0 = arrayType$12.zero();
- return;
- }
- this.Ino = Ino_;
- this.Seekoff = Seekoff_;
- this.Reclen = Reclen_;
- this.Namlen = Namlen_;
- this.Type = Type_;
- this.Name = Name_;
- this.Pad_cgo_0 = Pad_cgo_0_;
- });
- sliceType = $sliceType($Uint8);
- sliceType$1 = $sliceType($String);
- ptrType = $ptrType($Uint8);
- sliceType$4 = $sliceType(_C_int);
- ptrType$10 = $ptrType($Uintptr);
- arrayType$2 = $arrayType($Uint8, 32);
- arrayType$3 = $arrayType($Uint8, 4);
- arrayType$4 = $arrayType(_C_int, 14);
- structType = $structType([{prop: "addr", name: "addr", pkg: "syscall", typ: $Uintptr, tag: ""}, {prop: "len", name: "len", pkg: "syscall", typ: $Int, tag: ""}, {prop: "cap", name: "cap", pkg: "syscall", typ: $Int, tag: ""}]);
- ptrType$24 = $ptrType(mmapper);
- mapType = $mapType(ptrType, sliceType);
- funcType = $funcType([$Uintptr, $Uintptr, $Int, $Int, $Int, $Int64], [$Uintptr, $error], false);
- funcType$1 = $funcType([$Uintptr, $Uintptr], [$error], false);
- ptrType$28 = $ptrType(Timespec);
- arrayType$8 = $arrayType($Int64, 2);
- arrayType$10 = $arrayType($Int8, 1024);
- arrayType$12 = $arrayType($Uint8, 3);
- init = function() {
- var $ptr;
- $flushConsole = (function() {
- var $ptr;
- if (!((lineBuffer.$length === 0))) {
- $global.console.log($externalize($bytesToString(lineBuffer), $String));
- lineBuffer = sliceType.nil;
- }
- });
- };
- printWarning = function() {
- var $ptr;
- if (!warningPrinted) {
- console.log("warning: system calls not available, see https://github.com/gopherjs/gopherjs/blob/master/doc/syscalls.md");
- }
- warningPrinted = true;
- };
- printToConsole = function(b) {
- var $ptr, b, goPrintToConsole, i;
- goPrintToConsole = $global.goPrintToConsole;
- if (!(goPrintToConsole === undefined)) {
- goPrintToConsole(b);
- return;
- }
- lineBuffer = $appendSlice(lineBuffer, b);
- while (true) {
- i = bytes.IndexByte(lineBuffer, 10);
- if (i === -1) {
- break;
- }
- $global.console.log($externalize($bytesToString($subslice(lineBuffer, 0, i)), $String));
- lineBuffer = $subslice(lineBuffer, (i + 1 >> 0));
- }
- };
- use = function(p) {
- var $ptr, p;
- };
- runtime_envs = function() {
- var $ptr, envkeys, envs$1, i, jsEnv, key, process;
- process = $global.process;
- if (process === undefined) {
- return sliceType$1.nil;
- }
- jsEnv = process.env;
- envkeys = $global.Object.keys(jsEnv);
- envs$1 = $makeSlice(sliceType$1, $parseInt(envkeys.length));
- i = 0;
- while (true) {
- if (!(i < $parseInt(envkeys.length))) { break; }
- key = $internalize(envkeys[i], $String);
- ((i < 0 || i >= envs$1.$length) ? $throwRuntimeError("index out of range") : envs$1.$array[envs$1.$offset + i] = key + "=" + $internalize(jsEnv[$externalize(key, $String)], $String));
- i = i + (1) >> 0;
- }
- return envs$1;
- };
- syscall = function(name) {
- var $ptr, name, require, $deferred;
- /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- $deferred.push([(function() {
- var $ptr;
- $recover();
- }), []]);
- if (syscallModule === null) {
- if (alreadyTriedToLoad) {
- return null;
- }
- alreadyTriedToLoad = true;
- require = $global.require;
- if (require === undefined) {
- $panic(new $String(""));
- }
- syscallModule = require($externalize("syscall", $String));
- }
- return syscallModule[$externalize(name, $String)];
- /* */ } catch(err) { $err = err; return null; } finally { $callDeferred($deferred, $err); }
- };
- Syscall = function(trap, a1, a2, a3) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, a1, a2, a3, array, err, f, r, r1, r2, slice, trap;
- r1 = 0;
- r2 = 0;
- err = 0;
- f = syscall("Syscall");
- if (!(f === null)) {
- r = f(trap, a1, a2, a3);
- _tmp = (($parseInt(r[0]) >> 0) >>> 0); _tmp$1 = (($parseInt(r[1]) >> 0) >>> 0); _tmp$2 = (($parseInt(r[2]) >> 0) >>> 0); r1 = _tmp; r2 = _tmp$1; err = _tmp$2;
- return [r1, r2, err];
- }
- if ((trap === 4) && ((a1 === 1) || (a1 === 2))) {
- array = a2;
- slice = $makeSlice(sliceType, $parseInt(array.length));
- slice.$array = array;
- printToConsole(slice);
- _tmp$3 = ($parseInt(array.length) >>> 0); _tmp$4 = 0; _tmp$5 = 0; r1 = _tmp$3; r2 = _tmp$4; err = _tmp$5;
- return [r1, r2, err];
- }
- printWarning();
- _tmp$6 = (minusOne >>> 0); _tmp$7 = 0; _tmp$8 = 13; r1 = _tmp$6; r2 = _tmp$7; err = _tmp$8;
- return [r1, r2, err];
- };
- $pkg.Syscall = Syscall;
- Syscall6 = function(trap, a1, a2, a3, a4, a5, a6) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, a1, a2, a3, a4, a5, a6, err, f, r, r1, r2, trap;
- r1 = 0;
- r2 = 0;
- err = 0;
- f = syscall("Syscall6");
- if (!(f === null)) {
- r = f(trap, a1, a2, a3, a4, a5, a6);
- _tmp = (($parseInt(r[0]) >> 0) >>> 0); _tmp$1 = (($parseInt(r[1]) >> 0) >>> 0); _tmp$2 = (($parseInt(r[2]) >> 0) >>> 0); r1 = _tmp; r2 = _tmp$1; err = _tmp$2;
- return [r1, r2, err];
- }
- if (!((trap === 202))) {
- printWarning();
- }
- _tmp$3 = (minusOne >>> 0); _tmp$4 = 0; _tmp$5 = 13; r1 = _tmp$3; r2 = _tmp$4; err = _tmp$5;
- return [r1, r2, err];
- };
- $pkg.Syscall6 = Syscall6;
- BytePtrFromString = function(s) {
- var $ptr, _i, _ref, array, b, i, s;
- array = new ($global.Uint8Array)(s.length + 1 >> 0);
- _ref = new sliceType($stringToBytes(s));
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (b === 0) {
- return [ptrType.nil, new Errno(22)];
- }
- array[i] = b;
- _i++;
- }
- array[s.length] = 0;
- return [array, $ifaceNil];
- };
- $pkg.BytePtrFromString = BytePtrFromString;
- copyenv = function() {
- var $ptr, _entry, _i, _key, _ref, _tuple, i, j, key, ok, s;
- env = new $Map();
- _ref = envs;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- j = 0;
- while (true) {
- if (!(j < s.length)) { break; }
- if (s.charCodeAt(j) === 61) {
- key = s.substring(0, j);
- _tuple = (_entry = env[$String.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [0, false]); ok = _tuple[1];
- if (!ok) {
- _key = key; (env || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: i };
- } else {
- ((i < 0 || i >= envs.$length) ? $throwRuntimeError("index out of range") : envs.$array[envs.$offset + i] = "");
- }
- break;
- }
- j = j + (1) >> 0;
- }
- _i++;
- }
- };
- Getenv = function(key) {
- var $ptr, _entry, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, found, i, i$1, key, ok, s, value, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; found = $f.found; i = $f.i; i$1 = $f.i$1; key = $f.key; ok = $f.ok; s = $f.s; value = $f.value; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- value = "";
- found = false;
- $r = envOnce.Do(copyenv); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (key.length === 0) {
- _tmp = ""; _tmp$1 = false; value = _tmp; found = _tmp$1;
- return [value, found];
- }
- $r = envLock.RLock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(envLock, "RUnlock"), []]);
- _tuple = (_entry = env[$String.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [0, false]); i = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- _tmp$2 = ""; _tmp$3 = false; value = _tmp$2; found = _tmp$3;
- return [value, found];
- }
- s = ((i < 0 || i >= envs.$length) ? $throwRuntimeError("index out of range") : envs.$array[envs.$offset + i]);
- i$1 = 0;
- while (true) {
- if (!(i$1 < s.length)) { break; }
- if (s.charCodeAt(i$1) === 61) {
- _tmp$4 = s.substring((i$1 + 1 >> 0)); _tmp$5 = true; value = _tmp$4; found = _tmp$5;
- return [value, found];
- }
- i$1 = i$1 + (1) >> 0;
- }
- _tmp$6 = ""; _tmp$7 = false; value = _tmp$6; found = _tmp$7;
- return [value, found];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [value, found]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Getenv }; } $f.$ptr = $ptr; $f._entry = _entry; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f.found = found; $f.i = i; $f.i$1 = i$1; $f.key = key; $f.ok = ok; $f.s = s; $f.value = value; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- $pkg.Getenv = Getenv;
- CloseOnExec = function(fd) {
- var $ptr, fd;
- fcntl(fd, 2, 1);
- };
- $pkg.CloseOnExec = CloseOnExec;
- itoa = function(val) {
- var $ptr, val;
- if (val < 0) {
- return "-" + uitoa((-val >>> 0));
- }
- return uitoa((val >>> 0));
- };
- uitoa = function(val) {
- var $ptr, _q, _r, buf, i, val;
- buf = $clone(arrayType$2.zero(), arrayType$2);
- i = 31;
- while (true) {
- if (!(val >= 10)) { break; }
- ((i < 0 || i >= buf.length) ? $throwRuntimeError("index out of range") : buf[i] = (((_r = val % 10, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24));
- i = i - (1) >> 0;
- val = (_q = val / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- }
- ((i < 0 || i >= buf.length) ? $throwRuntimeError("index out of range") : buf[i] = ((val + 48 >>> 0) << 24 >>> 24));
- return $bytesToString($subslice(new sliceType(buf), i));
- };
- ByteSliceFromString = function(s) {
- var $ptr, a, i, s;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- if (s.charCodeAt(i) === 0) {
- return [sliceType.nil, new Errno(22)];
- }
- i = i + (1) >> 0;
- }
- a = $makeSlice(sliceType, (s.length + 1 >> 0));
- $copyString(a, s);
- return [a, $ifaceNil];
- };
- $pkg.ByteSliceFromString = ByteSliceFromString;
- Timespec.ptr.prototype.Unix = function() {
- var $ptr, _tmp, _tmp$1, nsec, sec, ts;
- sec = new $Int64(0, 0);
- nsec = new $Int64(0, 0);
- ts = this;
- _tmp = ts.Sec; _tmp$1 = ts.Nsec; sec = _tmp; nsec = _tmp$1;
- return [sec, nsec];
- };
- Timespec.prototype.Unix = function() { return this.$val.Unix(); };
- Timespec.ptr.prototype.Nano = function() {
- var $ptr, ts, x, x$1;
- ts = this;
- return (x = $mul64(ts.Sec, new $Int64(0, 1000000000)), x$1 = ts.Nsec, new $Int64(x.$high + x$1.$high, x.$low + x$1.$low));
- };
- Timespec.prototype.Nano = function() { return this.$val.Nano(); };
- ReadDirent = function(fd, buf) {
- var $ptr, _tuple, base, buf, err, fd, n;
- n = 0;
- err = $ifaceNil;
- base = new Uint8Array(8);
- _tuple = Getdirentries(fd, buf, base); n = _tuple[0]; err = _tuple[1];
- if (true && ($interfaceIsEqual(err, new Errno(22)) || $interfaceIsEqual(err, new Errno(2)))) {
- err = $ifaceNil;
- }
- return [n, err];
- };
- $pkg.ReadDirent = ReadDirent;
- Sysctl = function(name) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, buf, err, mib, n, name, nonAsciiName$4, value, x;
- value = "";
- err = $ifaceNil;
- _tuple = nametomib(name); mib = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- _tmp = ""; _tmp$1 = err; value = _tmp; err = _tmp$1;
- return [value, err];
- }
- n = 0;
- err = sysctl(mib, ptrType.nil, (nonAsciiName$4 || (nonAsciiName$4 = new ptrType$10(function() { return n; }, function($v) { n = $v; }))), ptrType.nil, 0);
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- _tmp$2 = ""; _tmp$3 = err; value = _tmp$2; err = _tmp$3;
- return [value, err];
- }
- if (n === 0) {
- _tmp$4 = ""; _tmp$5 = $ifaceNil; value = _tmp$4; err = _tmp$5;
- return [value, err];
- }
- buf = $makeSlice(sliceType, n);
- err = sysctl(mib, $indexPtr(buf.$array, buf.$offset + 0, ptrType), (nonAsciiName$4 || (nonAsciiName$4 = new ptrType$10(function() { return n; }, function($v) { n = $v; }))), ptrType.nil, 0);
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- _tmp$6 = ""; _tmp$7 = err; value = _tmp$6; err = _tmp$7;
- return [value, err];
- }
- if (n > 0 && ((x = n - 1 >>> 0, ((x < 0 || x >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + x])) === 0)) {
- n = n - (1) >>> 0;
- }
- _tmp$8 = $bytesToString($subslice(buf, 0, n)); _tmp$9 = $ifaceNil; value = _tmp$8; err = _tmp$9;
- return [value, err];
- };
- $pkg.Sysctl = Sysctl;
- nametomib = function(name) {
- var $ptr, _q, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, buf, bytes$1, err, mib, n, name, nonAsciiName$4, p;
- mib = sliceType$4.nil;
- err = $ifaceNil;
- buf = $clone(arrayType$4.zero(), arrayType$4);
- n = 48;
- p = $sliceToArray(new sliceType(buf));
- _tuple = ByteSliceFromString(name); bytes$1 = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- _tmp = sliceType$4.nil; _tmp$1 = err; mib = _tmp; err = _tmp$1;
- return [mib, err];
- }
- err = sysctl(new sliceType$4([0, 3]), p, (nonAsciiName$4 || (nonAsciiName$4 = new ptrType$10(function() { return n; }, function($v) { n = $v; }))), $indexPtr(bytes$1.$array, bytes$1.$offset + 0, ptrType), (name.length >>> 0));
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- _tmp$2 = sliceType$4.nil; _tmp$3 = err; mib = _tmp$2; err = _tmp$3;
- return [mib, err];
- }
- _tmp$4 = $subslice(new sliceType$4(buf), 0, (_q = n / 4, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"))); _tmp$5 = $ifaceNil; mib = _tmp$4; err = _tmp$5;
- return [mib, err];
- };
- ParseDirent = function(buf, max, names) {
- var $ptr, _array, _struct, _tmp, _tmp$1, _tmp$2, _view, buf, bytes$1, consumed, count, dirent, max, name, names, newnames, origlen, x;
- consumed = 0;
- count = 0;
- newnames = sliceType$1.nil;
- origlen = buf.$length;
- while (true) {
- if (!(!((max === 0)) && buf.$length > 0)) { break; }
- dirent = (_array = $sliceToArray(buf), _struct = new Dirent.ptr(), _view = new DataView(_array.buffer, _array.byteOffset), _struct.Ino = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Seekoff = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Reclen = _view.getUint16(16, true), _struct.Namlen = _view.getUint16(18, true), _struct.Type = _view.getUint8(20, true), _struct.Name = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 21, _array.buffer.byteLength)), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 1045, _array.buffer.byteLength)), _struct);
- if (dirent.Reclen === 0) {
- buf = sliceType.nil;
- break;
- }
- buf = $subslice(buf, dirent.Reclen);
- if ((x = dirent.Ino, (x.$high === 0 && x.$low === 0))) {
- continue;
- }
- bytes$1 = $sliceToArray(new sliceType(dirent.Name));
- name = $bytesToString($subslice(new sliceType(bytes$1), 0, dirent.Namlen));
- if (name === "." || name === "..") {
- continue;
- }
- max = max - (1) >> 0;
- count = count + (1) >> 0;
- names = $append(names, name);
- }
- _tmp = origlen - buf.$length >> 0; _tmp$1 = count; _tmp$2 = names; consumed = _tmp; count = _tmp$1; newnames = _tmp$2;
- return [consumed, count, newnames];
- };
- $pkg.ParseDirent = ParseDirent;
- mmapper.ptr.prototype.Mmap = function(fd, offset, length, prot, flags) {
- var $ptr, _key, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, addr, b, data, err, errno, fd, flags, length, m, offset, p, prot, sl, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key = $f._key; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; addr = $f.addr; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; fd = $f.fd; flags = $f.flags; length = $f.length; m = $f.m; offset = $f.offset; p = $f.p; prot = $f.prot; sl = $f.sl; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- sl = [sl];
- data = sliceType.nil;
- err = $ifaceNil;
- m = this;
- if (length <= 0) {
- _tmp = sliceType.nil; _tmp$1 = new Errno(22); data = _tmp; err = _tmp$1;
- return [data, err];
- }
- _r = m.mmap(0, (length >>> 0), prot, flags, fd, offset); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; addr = _tuple[0]; errno = _tuple[1];
- if (!($interfaceIsEqual(errno, $ifaceNil))) {
- _tmp$2 = sliceType.nil; _tmp$3 = errno; data = _tmp$2; err = _tmp$3;
- return [data, err];
- }
- sl[0] = new structType.ptr(addr, length, length);
- b = sl[0];
- p = $indexPtr(b.$array, b.$offset + (b.$capacity - 1 >> 0), ptrType);
- $r = m.Mutex.Lock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(m.Mutex, "Unlock"), []]);
- _key = p; (m.active || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: b };
- _tmp$4 = b; _tmp$5 = $ifaceNil; data = _tmp$4; err = _tmp$5;
- return [data, err];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [data, err]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Mmap }; } $f.$ptr = $ptr; $f._key = _key; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.addr = addr; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.fd = fd; $f.flags = flags; $f.length = length; $f.m = m; $f.offset = offset; $f.p = p; $f.prot = prot; $f.sl = sl; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- mmapper.prototype.Mmap = function(fd, offset, length, prot, flags) { return this.$val.Mmap(fd, offset, length, prot, flags); };
- mmapper.ptr.prototype.Munmap = function(data) {
- var $ptr, _entry, _r, b, data, err, errno, m, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; b = $f.b; data = $f.data; err = $f.err; errno = $f.errno; m = $f.m; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = $ifaceNil;
- m = this;
- if ((data.$length === 0) || !((data.$length === data.$capacity))) {
- err = new Errno(22);
- return err;
- }
- p = $indexPtr(data.$array, data.$offset + (data.$capacity - 1 >> 0), ptrType);
- $r = m.Mutex.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(m.Mutex, "Unlock"), []]);
- b = (_entry = m.active[ptrType.keyFor(p)], _entry !== undefined ? _entry.v : sliceType.nil);
- if (b === sliceType.nil || !($indexPtr(b.$array, b.$offset + 0, ptrType) === $indexPtr(data.$array, data.$offset + 0, ptrType))) {
- err = new Errno(22);
- return err;
- }
- _r = m.munmap($sliceToArray(b), (b.$length >>> 0)); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- errno = _r;
- /* */ if (!($interfaceIsEqual(errno, $ifaceNil))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!($interfaceIsEqual(errno, $ifaceNil))) { */ case 3:
- err = errno;
- return err;
- /* } */ case 4:
- delete m.active[ptrType.keyFor(p)];
- err = $ifaceNil;
- return err;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: mmapper.ptr.prototype.Munmap }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f.b = b; $f.data = data; $f.err = err; $f.errno = errno; $f.m = m; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- mmapper.prototype.Munmap = function(data) { return this.$val.Munmap(data); };
- Errno.prototype.Error = function() {
- var $ptr, e, s;
- e = this.$val;
- if (0 <= (e >> 0) && (e >> 0) < 106) {
- s = ((e < 0 || e >= errors$1.length) ? $throwRuntimeError("index out of range") : errors$1[e]);
- if (!(s === "")) {
- return s;
- }
- }
- return "errno " + itoa((e >> 0));
- };
- $ptrType(Errno).prototype.Error = function() { return new Errno(this.$get()).Error(); };
- Errno.prototype.Temporary = function() {
- var $ptr, e;
- e = this.$val;
- return (e === 4) || (e === 24) || (e === 54) || (e === 53) || new Errno(e).Timeout();
- };
- $ptrType(Errno).prototype.Temporary = function() { return new Errno(this.$get()).Temporary(); };
- Errno.prototype.Timeout = function() {
- var $ptr, e;
- e = this.$val;
- return (e === 35) || (e === 35) || (e === 60);
- };
- $ptrType(Errno).prototype.Timeout = function() { return new Errno(this.$get()).Timeout(); };
- Read = function(fd, p) {
- var $ptr, _tuple, err, fd, n, p;
- n = 0;
- err = $ifaceNil;
- _tuple = read(fd, p); n = _tuple[0]; err = _tuple[1];
- return [n, err];
- };
- $pkg.Read = Read;
- Write = function(fd, p) {
- var $ptr, _tuple, err, fd, n, p;
- n = 0;
- err = $ifaceNil;
- _tuple = write(fd, p); n = _tuple[0]; err = _tuple[1];
- return [n, err];
- };
- $pkg.Write = Write;
- sysctl = function(mib, old, oldlen, new$1, newlen) {
- var $ptr, _p0, _tuple, e1, err, mib, new$1, newlen, old, oldlen;
- err = $ifaceNil;
- _p0 = 0;
- if (mib.$length > 0) {
- _p0 = $sliceToArray(mib);
- } else {
- _p0 = new Uint8Array(0);
- }
- _tuple = Syscall6(202, _p0, (mib.$length >>> 0), old, oldlen, new$1, newlen); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- fcntl = function(fd, cmd, arg) {
- var $ptr, _tuple, arg, cmd, e1, err, fd, r0, val;
- val = 0;
- err = $ifaceNil;
- _tuple = Syscall(92, (fd >>> 0), (cmd >>> 0), (arg >>> 0)); r0 = _tuple[0]; e1 = _tuple[2];
- val = (r0 >> 0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [val, err];
- };
- Close = function(fd) {
- var $ptr, _tuple, e1, err, fd;
- err = $ifaceNil;
- _tuple = Syscall(6, (fd >>> 0), 0, 0); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Close = Close;
- Exit = function(code) {
- var $ptr, code;
- Syscall(1, (code >>> 0), 0, 0);
- return;
- };
- $pkg.Exit = Exit;
- Fchdir = function(fd) {
- var $ptr, _tuple, e1, err, fd;
- err = $ifaceNil;
- _tuple = Syscall(13, (fd >>> 0), 0, 0); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Fchdir = Fchdir;
- Fchmod = function(fd, mode) {
- var $ptr, _tuple, e1, err, fd, mode;
- err = $ifaceNil;
- _tuple = Syscall(124, (fd >>> 0), (mode >>> 0), 0); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Fchmod = Fchmod;
- Fchown = function(fd, uid, gid) {
- var $ptr, _tuple, e1, err, fd, gid, uid;
- err = $ifaceNil;
- _tuple = Syscall(123, (fd >>> 0), (uid >>> 0), (gid >>> 0)); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Fchown = Fchown;
- Fstat = function(fd, stat) {
- var $ptr, _array, _struct, _tuple, _view, e1, err, fd, stat;
- err = $ifaceNil;
- _array = new Uint8Array(144);
- _tuple = Syscall(339, (fd >>> 0), _array, 0); e1 = _tuple[2];
- _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = _view.getInt32(0, true), _struct.Mode = _view.getUint16(4, true), _struct.Nlink = _view.getUint16(6, true), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Uid = _view.getUint32(16, true), _struct.Gid = _view.getUint32(20, true), _struct.Rdev = _view.getInt32(24, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 28, _array.buffer.byteLength)), _struct.Atimespec.Sec = new $Int64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Atimespec.Nsec = new $Int64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Mtimespec.Sec = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Mtimespec.Nsec = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Ctimespec.Sec = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Ctimespec.Nsec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Birthtimespec.Sec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Birthtimespec.Nsec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Size = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Blocks = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Blksize = _view.getInt32(112, true), _struct.Flags = _view.getUint32(116, true), _struct.Gen = _view.getUint32(120, true), _struct.Lspare = _view.getInt32(124, true), _struct.Qspare = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 128, _array.buffer.byteLength));
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Fstat = Fstat;
- Fsync = function(fd) {
- var $ptr, _tuple, e1, err, fd;
- err = $ifaceNil;
- _tuple = Syscall(95, (fd >>> 0), 0, 0); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Fsync = Fsync;
- Ftruncate = function(fd, length) {
- var $ptr, _tuple, e1, err, fd, length;
- err = $ifaceNil;
- _tuple = Syscall(201, (fd >>> 0), (length.$low >>> 0), 0); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Ftruncate = Ftruncate;
- Getdirentries = function(fd, buf, basep) {
- var $ptr, _p0, _tuple, basep, buf, e1, err, fd, n, r0;
- n = 0;
- err = $ifaceNil;
- _p0 = 0;
- if (buf.$length > 0) {
- _p0 = $sliceToArray(buf);
- } else {
- _p0 = new Uint8Array(0);
- }
- _tuple = Syscall6(344, (fd >>> 0), _p0, (buf.$length >>> 0), basep, 0, 0); r0 = _tuple[0]; e1 = _tuple[2];
- n = (r0 >> 0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [n, err];
- };
- $pkg.Getdirentries = Getdirentries;
- Lstat = function(path, stat) {
- var $ptr, _array, _p0, _struct, _tuple, _tuple$1, _view, e1, err, path, stat;
- err = $ifaceNil;
- _p0 = ptrType.nil;
- _tuple = BytePtrFromString(path); _p0 = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return err;
- }
- _array = new Uint8Array(144);
- _tuple$1 = Syscall(340, _p0, _array, 0); e1 = _tuple$1[2];
- _struct = stat, _view = new DataView(_array.buffer, _array.byteOffset), _struct.Dev = _view.getInt32(0, true), _struct.Mode = _view.getUint16(4, true), _struct.Nlink = _view.getUint16(6, true), _struct.Ino = new $Uint64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Uid = _view.getUint32(16, true), _struct.Gid = _view.getUint32(20, true), _struct.Rdev = _view.getInt32(24, true), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 28, _array.buffer.byteLength)), _struct.Atimespec.Sec = new $Int64(_view.getUint32(36, true), _view.getUint32(32, true)), _struct.Atimespec.Nsec = new $Int64(_view.getUint32(44, true), _view.getUint32(40, true)), _struct.Mtimespec.Sec = new $Int64(_view.getUint32(52, true), _view.getUint32(48, true)), _struct.Mtimespec.Nsec = new $Int64(_view.getUint32(60, true), _view.getUint32(56, true)), _struct.Ctimespec.Sec = new $Int64(_view.getUint32(68, true), _view.getUint32(64, true)), _struct.Ctimespec.Nsec = new $Int64(_view.getUint32(76, true), _view.getUint32(72, true)), _struct.Birthtimespec.Sec = new $Int64(_view.getUint32(84, true), _view.getUint32(80, true)), _struct.Birthtimespec.Nsec = new $Int64(_view.getUint32(92, true), _view.getUint32(88, true)), _struct.Size = new $Int64(_view.getUint32(100, true), _view.getUint32(96, true)), _struct.Blocks = new $Int64(_view.getUint32(108, true), _view.getUint32(104, true)), _struct.Blksize = _view.getInt32(112, true), _struct.Flags = _view.getUint32(116, true), _struct.Gen = _view.getUint32(120, true), _struct.Lspare = _view.getInt32(124, true), _struct.Qspare = new ($nativeArray($kindInt64))(_array.buffer, $min(_array.byteOffset + 128, _array.buffer.byteLength));
- use(_p0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- $pkg.Lstat = Lstat;
- Open = function(path, mode, perm) {
- var $ptr, _p0, _tuple, _tuple$1, e1, err, fd, mode, path, perm, r0;
- fd = 0;
- err = $ifaceNil;
- _p0 = ptrType.nil;
- _tuple = BytePtrFromString(path); _p0 = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [fd, err];
- }
- _tuple$1 = Syscall(5, _p0, (mode >>> 0), (perm >>> 0)); r0 = _tuple$1[0]; e1 = _tuple$1[2];
- use(_p0);
- fd = (r0 >> 0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [fd, err];
- };
- $pkg.Open = Open;
- Pread = function(fd, p, offset) {
- var $ptr, _p0, _tuple, e1, err, fd, n, offset, p, r0;
- n = 0;
- err = $ifaceNil;
- _p0 = 0;
- if (p.$length > 0) {
- _p0 = $sliceToArray(p);
- } else {
- _p0 = new Uint8Array(0);
- }
- _tuple = Syscall6(153, (fd >>> 0), _p0, (p.$length >>> 0), (offset.$low >>> 0), 0, 0); r0 = _tuple[0]; e1 = _tuple[2];
- n = (r0 >> 0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [n, err];
- };
- $pkg.Pread = Pread;
- Pwrite = function(fd, p, offset) {
- var $ptr, _p0, _tuple, e1, err, fd, n, offset, p, r0;
- n = 0;
- err = $ifaceNil;
- _p0 = 0;
- if (p.$length > 0) {
- _p0 = $sliceToArray(p);
- } else {
- _p0 = new Uint8Array(0);
- }
- _tuple = Syscall6(154, (fd >>> 0), _p0, (p.$length >>> 0), (offset.$low >>> 0), 0, 0); r0 = _tuple[0]; e1 = _tuple[2];
- n = (r0 >> 0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [n, err];
- };
- $pkg.Pwrite = Pwrite;
- read = function(fd, p) {
- var $ptr, _p0, _tuple, e1, err, fd, n, p, r0;
- n = 0;
- err = $ifaceNil;
- _p0 = 0;
- if (p.$length > 0) {
- _p0 = $sliceToArray(p);
- } else {
- _p0 = new Uint8Array(0);
- }
- _tuple = Syscall(3, (fd >>> 0), _p0, (p.$length >>> 0)); r0 = _tuple[0]; e1 = _tuple[2];
- n = (r0 >> 0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [n, err];
- };
- Seek = function(fd, offset, whence) {
- var $ptr, _tuple, e1, err, fd, newoffset, offset, r0, whence;
- newoffset = new $Int64(0, 0);
- err = $ifaceNil;
- _tuple = Syscall(199, (fd >>> 0), (offset.$low >>> 0), (whence >>> 0)); r0 = _tuple[0]; e1 = _tuple[2];
- newoffset = new $Int64(0, r0.constructor === Number ? r0 : 1);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [newoffset, err];
- };
- $pkg.Seek = Seek;
- write = function(fd, p) {
- var $ptr, _p0, _tuple, e1, err, fd, n, p, r0;
- n = 0;
- err = $ifaceNil;
- _p0 = 0;
- if (p.$length > 0) {
- _p0 = $sliceToArray(p);
- } else {
- _p0 = new Uint8Array(0);
- }
- _tuple = Syscall(4, (fd >>> 0), _p0, (p.$length >>> 0)); r0 = _tuple[0]; e1 = _tuple[2];
- n = (r0 >> 0);
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [n, err];
- };
- mmap = function(addr, length, prot, flag, fd, pos) {
- var $ptr, _tuple, addr, e1, err, fd, flag, length, pos, prot, r0, ret;
- ret = 0;
- err = $ifaceNil;
- _tuple = Syscall6(197, addr, length, (prot >>> 0), (flag >>> 0), (fd >>> 0), (pos.$low >>> 0)); r0 = _tuple[0]; e1 = _tuple[2];
- ret = r0;
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return [ret, err];
- };
- munmap = function(addr, length) {
- var $ptr, _tuple, addr, e1, err, length;
- err = $ifaceNil;
- _tuple = Syscall(73, addr, length, 0); e1 = _tuple[2];
- if (!((e1 === 0))) {
- err = new Errno(e1);
- }
- return err;
- };
- ptrType$24.methods = [{prop: "Mmap", name: "Mmap", pkg: "", typ: $funcType([$Int, $Int64, $Int, $Int, $Int], [sliceType, $error], false)}, {prop: "Munmap", name: "Munmap", pkg: "", typ: $funcType([sliceType], [$error], false)}];
- Errno.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Temporary", name: "Temporary", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $funcType([], [$Bool], false)}];
- ptrType$28.methods = [{prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64, $Int64], false)}, {prop: "Nano", name: "Nano", pkg: "", typ: $funcType([], [$Int64], false)}];
- mmapper.init([{prop: "Mutex", name: "", pkg: "", typ: sync.Mutex, tag: ""}, {prop: "active", name: "active", pkg: "syscall", typ: mapType, tag: ""}, {prop: "mmap", name: "mmap", pkg: "syscall", typ: funcType, tag: ""}, {prop: "munmap", name: "munmap", pkg: "syscall", typ: funcType$1, tag: ""}]);
- Timespec.init([{prop: "Sec", name: "Sec", pkg: "", typ: $Int64, tag: ""}, {prop: "Nsec", name: "Nsec", pkg: "", typ: $Int64, tag: ""}]);
- Stat_t.init([{prop: "Dev", name: "Dev", pkg: "", typ: $Int32, tag: ""}, {prop: "Mode", name: "Mode", pkg: "", typ: $Uint16, tag: ""}, {prop: "Nlink", name: "Nlink", pkg: "", typ: $Uint16, tag: ""}, {prop: "Ino", name: "Ino", pkg: "", typ: $Uint64, tag: ""}, {prop: "Uid", name: "Uid", pkg: "", typ: $Uint32, tag: ""}, {prop: "Gid", name: "Gid", pkg: "", typ: $Uint32, tag: ""}, {prop: "Rdev", name: "Rdev", pkg: "", typ: $Int32, tag: ""}, {prop: "Pad_cgo_0", name: "Pad_cgo_0", pkg: "", typ: arrayType$3, tag: ""}, {prop: "Atimespec", name: "Atimespec", pkg: "", typ: Timespec, tag: ""}, {prop: "Mtimespec", name: "Mtimespec", pkg: "", typ: Timespec, tag: ""}, {prop: "Ctimespec", name: "Ctimespec", pkg: "", typ: Timespec, tag: ""}, {prop: "Birthtimespec", name: "Birthtimespec", pkg: "", typ: Timespec, tag: ""}, {prop: "Size", name: "Size", pkg: "", typ: $Int64, tag: ""}, {prop: "Blocks", name: "Blocks", pkg: "", typ: $Int64, tag: ""}, {prop: "Blksize", name: "Blksize", pkg: "", typ: $Int32, tag: ""}, {prop: "Flags", name: "Flags", pkg: "", typ: $Uint32, tag: ""}, {prop: "Gen", name: "Gen", pkg: "", typ: $Uint32, tag: ""}, {prop: "Lspare", name: "Lspare", pkg: "", typ: $Int32, tag: ""}, {prop: "Qspare", name: "Qspare", pkg: "", typ: arrayType$8, tag: ""}]);
- Dirent.init([{prop: "Ino", name: "Ino", pkg: "", typ: $Uint64, tag: ""}, {prop: "Seekoff", name: "Seekoff", pkg: "", typ: $Uint64, tag: ""}, {prop: "Reclen", name: "Reclen", pkg: "", typ: $Uint16, tag: ""}, {prop: "Namlen", name: "Namlen", pkg: "", typ: $Uint16, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: $Uint8, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: arrayType$10, tag: ""}, {prop: "Pad_cgo_0", name: "Pad_cgo_0", pkg: "", typ: arrayType$12, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = js.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- lineBuffer = sliceType.nil;
- syscallModule = null;
- envOnce = new sync.Once.ptr();
- envLock = new sync.RWMutex.ptr();
- env = false;
- warningPrinted = false;
- alreadyTriedToLoad = false;
- minusOne = -1;
- envs = runtime_envs();
- $pkg.Stdin = 0;
- $pkg.Stdout = 1;
- $pkg.Stderr = 2;
- errors$1 = $toNativeArray($kindString, ["", "operation not permitted", "no such file or directory", "no such process", "interrupted system call", "input/output error", "device not configured", "argument list too long", "exec format error", "bad file descriptor", "no child processes", "resource deadlock avoided", "cannot allocate memory", "permission denied", "bad address", "block device required", "resource busy", "file exists", "cross-device link", "operation not supported by device", "not a directory", "is a directory", "invalid argument", "too many open files in system", "too many open files", "inappropriate ioctl for device", "text file busy", "file too large", "no space left on device", "illegal seek", "read-only file system", "too many links", "broken pipe", "numerical argument out of domain", "result too large", "resource temporarily unavailable", "operation now in progress", "operation already in progress", "socket operation on non-socket", "destination address required", "message too long", "protocol wrong type for socket", "protocol not available", "protocol not supported", "socket type not supported", "operation not supported", "protocol family not supported", "address family not supported by protocol family", "address already in use", "can't assign requested address", "network is down", "network is unreachable", "network dropped connection on reset", "software caused connection abort", "connection reset by peer", "no buffer space available", "socket is already connected", "socket is not connected", "can't send after socket shutdown", "too many references: can't splice", "operation timed out", "connection refused", "too many levels of symbolic links", "file name too long", "host is down", "no route to host", "directory not empty", "too many processes", "too many users", "disc quota exceeded", "stale NFS file handle", "too many levels of remote in path", "RPC struct is bad", "RPC version wrong", "RPC prog. not avail", "program version wrong", "bad procedure for program", "no locks available", "function not implemented", "inappropriate file type or format", "authentication error", "need authenticator", "device power is off", "device error", "value too large to be stored in data type", "bad executable (or shared library)", "bad CPU type in executable", "shared library version mismatch", "malformed Mach-o file", "operation canceled", "identifier removed", "no message of desired type", "illegal byte sequence", "attribute not found", "bad message", "EMULTIHOP (Reserved)", "no message available on STREAM", "ENOLINK (Reserved)", "no STREAM resources", "not a STREAM", "protocol error", "STREAM ioctl timeout", "operation not supported on socket", "policy not found", "state not recoverable", "previous owner died"]);
- mapper = new mmapper.ptr(new sync.Mutex.ptr(), new $Map(), mmap, munmap);
- init();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs/nosync"] = (function() {
- var $pkg = {}, $init, Mutex, RWMutex, WaitGroup, Once, Pool, ptrType, ptrType$1, ptrType$2, funcType, ptrType$3, sliceType, ptrType$4, funcType$1;
- Mutex = $pkg.Mutex = $newType(0, $kindStruct, "nosync.Mutex", "Mutex", "github.com/gopherjs/gopherjs/nosync", function(locked_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.locked = false;
- return;
- }
- this.locked = locked_;
- });
- RWMutex = $pkg.RWMutex = $newType(0, $kindStruct, "nosync.RWMutex", "RWMutex", "github.com/gopherjs/gopherjs/nosync", function(writeLocked_, readLockCounter_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.writeLocked = false;
- this.readLockCounter = 0;
- return;
- }
- this.writeLocked = writeLocked_;
- this.readLockCounter = readLockCounter_;
- });
- WaitGroup = $pkg.WaitGroup = $newType(0, $kindStruct, "nosync.WaitGroup", "WaitGroup", "github.com/gopherjs/gopherjs/nosync", function(counter_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.counter = 0;
- return;
- }
- this.counter = counter_;
- });
- Once = $pkg.Once = $newType(0, $kindStruct, "nosync.Once", "Once", "github.com/gopherjs/gopherjs/nosync", function(doing_, done_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.doing = false;
- this.done = false;
- return;
- }
- this.doing = doing_;
- this.done = done_;
- });
- Pool = $pkg.Pool = $newType(0, $kindStruct, "nosync.Pool", "Pool", "github.com/gopherjs/gopherjs/nosync", function(store_, New_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.store = sliceType.nil;
- this.New = $throwNilPointerError;
- return;
- }
- this.store = store_;
- this.New = New_;
- });
- ptrType = $ptrType(Mutex);
- ptrType$1 = $ptrType(RWMutex);
- ptrType$2 = $ptrType(WaitGroup);
- funcType = $funcType([], [], false);
- ptrType$3 = $ptrType(Once);
- sliceType = $sliceType($emptyInterface);
- ptrType$4 = $ptrType(Pool);
- funcType$1 = $funcType([], [$emptyInterface], false);
- Mutex.ptr.prototype.Lock = function() {
- var $ptr, m;
- m = this;
- if (m.locked) {
- $panic(new $String("nosync: mutex is already locked"));
- }
- m.locked = true;
- };
- Mutex.prototype.Lock = function() { return this.$val.Lock(); };
- Mutex.ptr.prototype.Unlock = function() {
- var $ptr, m;
- m = this;
- if (!m.locked) {
- $panic(new $String("nosync: unlock of unlocked mutex"));
- }
- m.locked = false;
- };
- Mutex.prototype.Unlock = function() { return this.$val.Unlock(); };
- RWMutex.ptr.prototype.Lock = function() {
- var $ptr, rw;
- rw = this;
- if (!((rw.readLockCounter === 0)) || rw.writeLocked) {
- $panic(new $String("nosync: mutex is already locked"));
- }
- rw.writeLocked = true;
- };
- RWMutex.prototype.Lock = function() { return this.$val.Lock(); };
- RWMutex.ptr.prototype.Unlock = function() {
- var $ptr, rw;
- rw = this;
- if (!rw.writeLocked) {
- $panic(new $String("nosync: unlock of unlocked mutex"));
- }
- rw.writeLocked = false;
- };
- RWMutex.prototype.Unlock = function() { return this.$val.Unlock(); };
- RWMutex.ptr.prototype.RLock = function() {
- var $ptr, rw;
- rw = this;
- if (rw.writeLocked) {
- $panic(new $String("nosync: mutex is already locked"));
- }
- rw.readLockCounter = rw.readLockCounter + (1) >> 0;
- };
- RWMutex.prototype.RLock = function() { return this.$val.RLock(); };
- RWMutex.ptr.prototype.RUnlock = function() {
- var $ptr, rw;
- rw = this;
- if (rw.readLockCounter === 0) {
- $panic(new $String("nosync: unlock of unlocked mutex"));
- }
- rw.readLockCounter = rw.readLockCounter - (1) >> 0;
- };
- RWMutex.prototype.RUnlock = function() { return this.$val.RUnlock(); };
- WaitGroup.ptr.prototype.Add = function(delta) {
- var $ptr, delta, wg;
- wg = this;
- wg.counter = wg.counter + (delta) >> 0;
- if (wg.counter < 0) {
- $panic(new $String("sync: negative WaitGroup counter"));
- }
- };
- WaitGroup.prototype.Add = function(delta) { return this.$val.Add(delta); };
- WaitGroup.ptr.prototype.Done = function() {
- var $ptr, wg;
- wg = this;
- wg.Add(-1);
- };
- WaitGroup.prototype.Done = function() { return this.$val.Done(); };
- WaitGroup.ptr.prototype.Wait = function() {
- var $ptr, wg;
- wg = this;
- if (!((wg.counter === 0))) {
- $panic(new $String("sync: WaitGroup counter not zero"));
- }
- };
- WaitGroup.prototype.Wait = function() { return this.$val.Wait(); };
- Once.ptr.prototype.Do = function(f) {
- var $ptr, f, o, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; o = $f.o; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- o = [o];
- o[0] = this;
- if (o[0].done) {
- return;
- }
- if (o[0].doing) {
- $panic(new $String("nosync: Do called within f"));
- }
- o[0].doing = true;
- $deferred.push([(function(o) { return function() {
- var $ptr;
- o[0].doing = false;
- o[0].done = true;
- }; })(o), []]);
- $r = f(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Once.ptr.prototype.Do }; } $f.$ptr = $ptr; $f.f = f; $f.o = o; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Once.prototype.Do = function(f) { return this.$val.Do(f); };
- Pool.ptr.prototype.Get = function() {
- var $ptr, _r, p, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (p.store.$length === 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.store.$length === 0) { */ case 1:
- /* */ if (!(p.New === $throwNilPointerError)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(p.New === $throwNilPointerError)) { */ case 3:
- _r = p.New(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 4:
- return $ifaceNil;
- /* } */ case 2:
- x$2 = (x = p.store, x$1 = p.store.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0));
- return x$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Pool.prototype.Get = function() { return this.$val.Get(); };
- Pool.ptr.prototype.Put = function(x) {
- var $ptr, p, x;
- p = this;
- if ($interfaceIsEqual(x, $ifaceNil)) {
- return;
- }
- p.store = $append(p.store, x);
- };
- Pool.prototype.Put = function(x) { return this.$val.Put(x); };
- ptrType.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}];
- ptrType$1.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}, {prop: "RLock", name: "RLock", pkg: "", typ: $funcType([], [], false)}, {prop: "RUnlock", name: "RUnlock", pkg: "", typ: $funcType([], [], false)}];
- ptrType$2.methods = [{prop: "Add", name: "Add", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Done", name: "Done", pkg: "", typ: $funcType([], [], false)}, {prop: "Wait", name: "Wait", pkg: "", typ: $funcType([], [], false)}];
- ptrType$3.methods = [{prop: "Do", name: "Do", pkg: "", typ: $funcType([funcType], [], false)}];
- ptrType$4.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "Put", name: "Put", pkg: "", typ: $funcType([$emptyInterface], [], false)}];
- Mutex.init([{prop: "locked", name: "locked", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Bool, tag: ""}]);
- RWMutex.init([{prop: "writeLocked", name: "writeLocked", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Bool, tag: ""}, {prop: "readLockCounter", name: "readLockCounter", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Int, tag: ""}]);
- WaitGroup.init([{prop: "counter", name: "counter", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Int, tag: ""}]);
- Once.init([{prop: "doing", name: "doing", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Bool, tag: ""}, {prop: "done", name: "done", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Bool, tag: ""}]);
- Pool.init([{prop: "store", name: "store", pkg: "github.com/gopherjs/gopherjs/nosync", typ: sliceType, tag: ""}, {prop: "New", name: "New", pkg: "", typ: funcType$1, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["strings"] = (function() {
- var $pkg = {}, $init, errors, js, io, unicode, utf8, Reader, sliceType, sliceType$3, ptrType$5, IndexByte, NewReader, explode, hashStr, hashStrRev, Count, Contains, ContainsRune, Index, LastIndex, IndexRune, IndexAny, genSplit, Split, Join, HasPrefix, HasSuffix, Map, Repeat, ToUpper, ToLower, TrimLeftFunc, TrimRightFunc, TrimFunc, indexFunc, lastIndexFunc, TrimSpace, TrimSuffix, Replace;
- errors = $packages["errors"];
- js = $packages["github.com/gopherjs/gopherjs/js"];
- io = $packages["io"];
- unicode = $packages["unicode"];
- utf8 = $packages["unicode/utf8"];
- Reader = $pkg.Reader = $newType(0, $kindStruct, "strings.Reader", "Reader", "strings", function(s_, i_, prevRune_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.s = "";
- this.i = new $Int64(0, 0);
- this.prevRune = 0;
- return;
- }
- this.s = s_;
- this.i = i_;
- this.prevRune = prevRune_;
- });
- sliceType = $sliceType($Uint8);
- sliceType$3 = $sliceType($String);
- ptrType$5 = $ptrType(Reader);
- IndexByte = function(s, c) {
- var $ptr, c, s;
- return $parseInt(s.indexOf($global.String.fromCharCode(c))) >> 0;
- };
- $pkg.IndexByte = IndexByte;
- Reader.ptr.prototype.Len = function() {
- var $ptr, r, x, x$1, x$2, x$3, x$4;
- r = this;
- if ((x = r.i, x$1 = new $Int64(0, r.s.length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- return 0;
- }
- return ((x$2 = (x$3 = new $Int64(0, r.s.length), x$4 = r.i, new $Int64(x$3.$high - x$4.$high, x$3.$low - x$4.$low)), x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0);
- };
- Reader.prototype.Len = function() { return this.$val.Len(); };
- Reader.ptr.prototype.Read = function(b) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, r, x, x$1, x$2, x$3;
- n = 0;
- err = $ifaceNil;
- r = this;
- if (b.$length === 0) {
- _tmp = 0; _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- if ((x = r.i, x$1 = new $Int64(0, r.s.length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- _tmp$2 = 0; _tmp$3 = io.EOF; n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- r.prevRune = -1;
- n = $copyString(b, r.s.substring($flatten64(r.i)));
- r.i = (x$2 = r.i, x$3 = new $Int64(0, n), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low));
- return [n, err];
- };
- Reader.prototype.Read = function(b) { return this.$val.Read(b); };
- Reader.ptr.prototype.ReadAt = function(b, off) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, off, r, x;
- n = 0;
- err = $ifaceNil;
- r = this;
- if ((off.$high < 0 || (off.$high === 0 && off.$low < 0))) {
- _tmp = 0; _tmp$1 = errors.New("strings.Reader.ReadAt: negative offset"); n = _tmp; err = _tmp$1;
- return [n, err];
- }
- if ((x = new $Int64(0, r.s.length), (off.$high > x.$high || (off.$high === x.$high && off.$low >= x.$low)))) {
- _tmp$2 = 0; _tmp$3 = io.EOF; n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- n = $copyString(b, r.s.substring($flatten64(off)));
- if (n < b.$length) {
- err = io.EOF;
- }
- return [n, err];
- };
- Reader.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); };
- Reader.ptr.prototype.ReadByte = function() {
- var $ptr, _tmp, _tmp$1, b, err, r, x, x$1, x$2, x$3;
- b = 0;
- err = $ifaceNil;
- r = this;
- r.prevRune = -1;
- if ((x = r.i, x$1 = new $Int64(0, r.s.length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- _tmp = 0; _tmp$1 = io.EOF; b = _tmp; err = _tmp$1;
- return [b, err];
- }
- b = r.s.charCodeAt($flatten64(r.i));
- r.i = (x$2 = r.i, x$3 = new $Int64(0, 1), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low));
- return [b, err];
- };
- Reader.prototype.ReadByte = function() { return this.$val.ReadByte(); };
- Reader.ptr.prototype.UnreadByte = function() {
- var $ptr, r, x, x$1, x$2;
- r = this;
- r.prevRune = -1;
- if ((x = r.i, (x.$high < 0 || (x.$high === 0 && x.$low <= 0)))) {
- return errors.New("strings.Reader.UnreadByte: at beginning of string");
- }
- r.i = (x$1 = r.i, x$2 = new $Int64(0, 1), new $Int64(x$1.$high - x$2.$high, x$1.$low - x$2.$low));
- return $ifaceNil;
- };
- Reader.prototype.UnreadByte = function() { return this.$val.UnreadByte(); };
- Reader.ptr.prototype.ReadRune = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, c, ch, err, r, size, x, x$1, x$2, x$3, x$4, x$5, x$6;
- ch = 0;
- size = 0;
- err = $ifaceNil;
- r = this;
- if ((x = r.i, x$1 = new $Int64(0, r.s.length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- r.prevRune = -1;
- _tmp = 0; _tmp$1 = 0; _tmp$2 = io.EOF; ch = _tmp; size = _tmp$1; err = _tmp$2;
- return [ch, size, err];
- }
- r.prevRune = ((x$2 = r.i, x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0);
- c = r.s.charCodeAt($flatten64(r.i));
- if (c < 128) {
- r.i = (x$3 = r.i, x$4 = new $Int64(0, 1), new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low));
- _tmp$3 = (c >> 0); _tmp$4 = 1; _tmp$5 = $ifaceNil; ch = _tmp$3; size = _tmp$4; err = _tmp$5;
- return [ch, size, err];
- }
- _tuple = utf8.DecodeRuneInString(r.s.substring($flatten64(r.i))); ch = _tuple[0]; size = _tuple[1];
- r.i = (x$5 = r.i, x$6 = new $Int64(0, size), new $Int64(x$5.$high + x$6.$high, x$5.$low + x$6.$low));
- return [ch, size, err];
- };
- Reader.prototype.ReadRune = function() { return this.$val.ReadRune(); };
- Reader.ptr.prototype.UnreadRune = function() {
- var $ptr, r;
- r = this;
- if (r.prevRune < 0) {
- return errors.New("strings.Reader.UnreadRune: previous operation was not ReadRune");
- }
- r.i = new $Int64(0, r.prevRune);
- r.prevRune = -1;
- return $ifaceNil;
- };
- Reader.prototype.UnreadRune = function() { return this.$val.UnreadRune(); };
- Reader.ptr.prototype.Seek = function(offset, whence) {
- var $ptr, _ref, abs, offset, r, whence, x, x$1;
- r = this;
- r.prevRune = -1;
- abs = new $Int64(0, 0);
- _ref = whence;
- if (_ref === 0) {
- abs = offset;
- } else if (_ref === 1) {
- abs = (x = r.i, new $Int64(x.$high + offset.$high, x.$low + offset.$low));
- } else if (_ref === 2) {
- abs = (x$1 = new $Int64(0, r.s.length), new $Int64(x$1.$high + offset.$high, x$1.$low + offset.$low));
- } else {
- return [new $Int64(0, 0), errors.New("strings.Reader.Seek: invalid whence")];
- }
- if ((abs.$high < 0 || (abs.$high === 0 && abs.$low < 0))) {
- return [new $Int64(0, 0), errors.New("strings.Reader.Seek: negative position")];
- }
- r.i = abs;
- return [abs, $ifaceNil];
- };
- Reader.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); };
- Reader.ptr.prototype.WriteTo = function(w) {
- var $ptr, _r, _tmp, _tmp$1, _tuple, err, m, n, r, s, w, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; m = $f.m; n = $f.n; r = $f.r; s = $f.s; w = $f.w; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = new $Int64(0, 0);
- err = $ifaceNil;
- r = this;
- r.prevRune = -1;
- if ((x = r.i, x$1 = new $Int64(0, r.s.length), (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low >= x$1.$low)))) {
- _tmp = new $Int64(0, 0); _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- s = r.s.substring($flatten64(r.i));
- _r = io.WriteString(w, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; m = _tuple[0]; err = _tuple[1];
- if (m > s.length) {
- $panic(new $String("strings.Reader.WriteTo: invalid WriteString count"));
- }
- r.i = (x$2 = r.i, x$3 = new $Int64(0, m), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low));
- n = new $Int64(0, m);
- if (!((m === s.length)) && $interfaceIsEqual(err, $ifaceNil)) {
- err = io.ErrShortWrite;
- }
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Reader.ptr.prototype.WriteTo }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.m = m; $f.n = n; $f.r = r; $f.s = s; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Reader.prototype.WriteTo = function(w) { return this.$val.WriteTo(w); };
- NewReader = function(s) {
- var $ptr, s;
- return new Reader.ptr(s, new $Int64(0, 0), -1);
- };
- $pkg.NewReader = NewReader;
- explode = function(s, n) {
- var $ptr, _tmp, _tmp$1, _tuple, a, ch, cur, i, l, n, s, size;
- if (n === 0) {
- return sliceType$3.nil;
- }
- l = utf8.RuneCountInString(s);
- if (n <= 0 || n > l) {
- n = l;
- }
- a = $makeSlice(sliceType$3, n);
- size = 0;
- ch = 0;
- _tmp = 0; _tmp$1 = 0; i = _tmp; cur = _tmp$1;
- while (true) {
- if (!((i + 1 >> 0) < n)) { break; }
- _tuple = utf8.DecodeRuneInString(s.substring(cur)); ch = _tuple[0]; size = _tuple[1];
- if (ch === 65533) {
- ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = "\xEF\xBF\xBD");
- } else {
- ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = s.substring(cur, (cur + size >> 0)));
- }
- cur = cur + (size) >> 0;
- i = i + (1) >> 0;
- }
- if (cur < s.length) {
- ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = s.substring(cur));
- }
- return a;
- };
- hashStr = function(sep) {
- var $ptr, _tmp, _tmp$1, hash, i, i$1, pow, sep, sq, x, x$1;
- hash = 0;
- i = 0;
- while (true) {
- if (!(i < sep.length)) { break; }
- hash = ((((hash >>> 16 << 16) * 16777619 >>> 0) + (hash << 16 >>> 16) * 16777619) >>> 0) + (sep.charCodeAt(i) >>> 0) >>> 0;
- i = i + (1) >> 0;
- }
- _tmp = 1; _tmp$1 = 16777619; pow = _tmp; sq = _tmp$1;
- i$1 = sep.length;
- while (true) {
- if (!(i$1 > 0)) { break; }
- if (!(((i$1 & 1) === 0))) {
- pow = (x = sq, (((pow >>> 16 << 16) * x >>> 0) + (pow << 16 >>> 16) * x) >>> 0);
- }
- sq = (x$1 = sq, (((sq >>> 16 << 16) * x$1 >>> 0) + (sq << 16 >>> 16) * x$1) >>> 0);
- i$1 = (i$1 >> $min((1), 31)) >> 0;
- }
- return [hash, pow];
- };
- hashStrRev = function(sep) {
- var $ptr, _tmp, _tmp$1, hash, i, i$1, pow, sep, sq, x, x$1;
- hash = 0;
- i = sep.length - 1 >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- hash = ((((hash >>> 16 << 16) * 16777619 >>> 0) + (hash << 16 >>> 16) * 16777619) >>> 0) + (sep.charCodeAt(i) >>> 0) >>> 0;
- i = i - (1) >> 0;
- }
- _tmp = 1; _tmp$1 = 16777619; pow = _tmp; sq = _tmp$1;
- i$1 = sep.length;
- while (true) {
- if (!(i$1 > 0)) { break; }
- if (!(((i$1 & 1) === 0))) {
- pow = (x = sq, (((pow >>> 16 << 16) * x >>> 0) + (pow << 16 >>> 16) * x) >>> 0);
- }
- sq = (x$1 = sq, (((sq >>> 16 << 16) * x$1 >>> 0) + (sq << 16 >>> 16) * x$1) >>> 0);
- i$1 = (i$1 >> $min((1), 31)) >> 0;
- }
- return [hash, pow];
- };
- Count = function(s, sep) {
- var $ptr, _tuple, c, h, hashsep, i, i$1, i$2, lastmatch, n, pow, s, sep, x, x$1;
- n = 0;
- if (sep.length === 0) {
- return utf8.RuneCountInString(s) + 1 >> 0;
- } else if (sep.length === 1) {
- c = sep.charCodeAt(0);
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- if (s.charCodeAt(i) === c) {
- n = n + (1) >> 0;
- }
- i = i + (1) >> 0;
- }
- return n;
- } else if (sep.length > s.length) {
- return 0;
- } else if (sep.length === s.length) {
- if (sep === s) {
- return 1;
- }
- return 0;
- }
- _tuple = hashStr(sep); hashsep = _tuple[0]; pow = _tuple[1];
- h = 0;
- i$1 = 0;
- while (true) {
- if (!(i$1 < sep.length)) { break; }
- h = ((((h >>> 16 << 16) * 16777619 >>> 0) + (h << 16 >>> 16) * 16777619) >>> 0) + (s.charCodeAt(i$1) >>> 0) >>> 0;
- i$1 = i$1 + (1) >> 0;
- }
- lastmatch = 0;
- if ((h === hashsep) && s.substring(0, sep.length) === sep) {
- n = n + (1) >> 0;
- lastmatch = sep.length;
- }
- i$2 = sep.length;
- while (true) {
- if (!(i$2 < s.length)) { break; }
- h = (x = 16777619, (((h >>> 16 << 16) * x >>> 0) + (h << 16 >>> 16) * x) >>> 0);
- h = h + ((s.charCodeAt(i$2) >>> 0)) >>> 0;
- h = h - ((x$1 = (s.charCodeAt((i$2 - sep.length >> 0)) >>> 0), (((pow >>> 16 << 16) * x$1 >>> 0) + (pow << 16 >>> 16) * x$1) >>> 0)) >>> 0;
- i$2 = i$2 + (1) >> 0;
- if ((h === hashsep) && lastmatch <= (i$2 - sep.length >> 0) && s.substring((i$2 - sep.length >> 0), i$2) === sep) {
- n = n + (1) >> 0;
- lastmatch = i$2;
- }
- }
- return n;
- };
- $pkg.Count = Count;
- Contains = function(s, substr) {
- var $ptr, s, substr;
- return Index(s, substr) >= 0;
- };
- $pkg.Contains = Contains;
- ContainsRune = function(s, r) {
- var $ptr, r, s;
- return IndexRune(s, r) >= 0;
- };
- $pkg.ContainsRune = ContainsRune;
- Index = function(s, sep) {
- var $ptr, _tuple, h, hashsep, i, i$1, n, pow, s, sep, x, x$1;
- n = sep.length;
- if (n === 0) {
- return 0;
- } else if (n === 1) {
- return IndexByte(s, sep.charCodeAt(0));
- } else if (n === s.length) {
- if (sep === s) {
- return 0;
- }
- return -1;
- } else if (n > s.length) {
- return -1;
- }
- _tuple = hashStr(sep); hashsep = _tuple[0]; pow = _tuple[1];
- h = 0;
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- h = ((((h >>> 16 << 16) * 16777619 >>> 0) + (h << 16 >>> 16) * 16777619) >>> 0) + (s.charCodeAt(i) >>> 0) >>> 0;
- i = i + (1) >> 0;
- }
- if ((h === hashsep) && s.substring(0, n) === sep) {
- return 0;
- }
- i$1 = n;
- while (true) {
- if (!(i$1 < s.length)) { break; }
- h = (x = 16777619, (((h >>> 16 << 16) * x >>> 0) + (h << 16 >>> 16) * x) >>> 0);
- h = h + ((s.charCodeAt(i$1) >>> 0)) >>> 0;
- h = h - ((x$1 = (s.charCodeAt((i$1 - n >> 0)) >>> 0), (((pow >>> 16 << 16) * x$1 >>> 0) + (pow << 16 >>> 16) * x$1) >>> 0)) >>> 0;
- i$1 = i$1 + (1) >> 0;
- if ((h === hashsep) && s.substring((i$1 - n >> 0), i$1) === sep) {
- return i$1 - n >> 0;
- }
- }
- return -1;
- };
- $pkg.Index = Index;
- LastIndex = function(s, sep) {
- var $ptr, _tuple, c, h, hashsep, i, i$1, i$2, last, n, pow, s, sep, x, x$1;
- n = sep.length;
- if (n === 0) {
- return s.length;
- } else if (n === 1) {
- c = sep.charCodeAt(0);
- i = s.length - 1 >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- if (s.charCodeAt(i) === c) {
- return i;
- }
- i = i - (1) >> 0;
- }
- return -1;
- } else if (n === s.length) {
- if (sep === s) {
- return 0;
- }
- return -1;
- } else if (n > s.length) {
- return -1;
- }
- _tuple = hashStrRev(sep); hashsep = _tuple[0]; pow = _tuple[1];
- last = s.length - n >> 0;
- h = 0;
- i$1 = s.length - 1 >> 0;
- while (true) {
- if (!(i$1 >= last)) { break; }
- h = ((((h >>> 16 << 16) * 16777619 >>> 0) + (h << 16 >>> 16) * 16777619) >>> 0) + (s.charCodeAt(i$1) >>> 0) >>> 0;
- i$1 = i$1 - (1) >> 0;
- }
- if ((h === hashsep) && s.substring(last) === sep) {
- return last;
- }
- i$2 = last - 1 >> 0;
- while (true) {
- if (!(i$2 >= 0)) { break; }
- h = (x = 16777619, (((h >>> 16 << 16) * x >>> 0) + (h << 16 >>> 16) * x) >>> 0);
- h = h + ((s.charCodeAt(i$2) >>> 0)) >>> 0;
- h = h - ((x$1 = (s.charCodeAt((i$2 + n >> 0)) >>> 0), (((pow >>> 16 << 16) * x$1 >>> 0) + (pow << 16 >>> 16) * x$1) >>> 0)) >>> 0;
- if ((h === hashsep) && s.substring(i$2, (i$2 + n >> 0)) === sep) {
- return i$2;
- }
- i$2 = i$2 - (1) >> 0;
- }
- return -1;
- };
- $pkg.LastIndex = LastIndex;
- IndexRune = function(s, r) {
- var $ptr, _i, _ref, _rune, c, i, r, s;
- if (r < 128) {
- return IndexByte(s, (r << 24 >>> 24));
- } else {
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- c = _rune[0];
- if (c === r) {
- return i;
- }
- _i += _rune[1];
- }
- }
- return -1;
- };
- $pkg.IndexRune = IndexRune;
- IndexAny = function(s, chars) {
- var $ptr, _i, _i$1, _ref, _ref$1, _rune, _rune$1, c, chars, i, m, s;
- if (chars.length > 0) {
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- c = _rune[0];
- _ref$1 = chars;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.length)) { break; }
- _rune$1 = $decodeRune(_ref$1, _i$1);
- m = _rune$1[0];
- if (c === m) {
- return i;
- }
- _i$1 += _rune$1[1];
- }
- _i += _rune[1];
- }
- }
- return -1;
- };
- $pkg.IndexAny = IndexAny;
- genSplit = function(s, sep, sepSave, n) {
- var $ptr, a, c, i, n, na, s, sep, sepSave, start;
- if (n === 0) {
- return sliceType$3.nil;
- }
- if (sep === "") {
- return explode(s, n);
- }
- if (n < 0) {
- n = Count(s, sep) + 1 >> 0;
- }
- c = sep.charCodeAt(0);
- start = 0;
- a = $makeSlice(sliceType$3, n);
- na = 0;
- i = 0;
- while (true) {
- if (!((i + sep.length >> 0) <= s.length && (na + 1 >> 0) < n)) { break; }
- if ((s.charCodeAt(i) === c) && ((sep.length === 1) || s.substring(i, (i + sep.length >> 0)) === sep)) {
- ((na < 0 || na >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + na] = s.substring(start, (i + sepSave >> 0)));
- na = na + (1) >> 0;
- start = i + sep.length >> 0;
- i = i + ((sep.length - 1 >> 0)) >> 0;
- }
- i = i + (1) >> 0;
- }
- ((na < 0 || na >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + na] = s.substring(start));
- return $subslice(a, 0, (na + 1 >> 0));
- };
- Split = function(s, sep) {
- var $ptr, s, sep;
- return genSplit(s, sep, 0, -1);
- };
- $pkg.Split = Split;
- Join = function(a, sep) {
- var $ptr, _i, _ref, a, b, bp, i, n, s, sep;
- if (a.$length === 0) {
- return "";
- }
- if (a.$length === 1) {
- return (0 >= a.$length ? $throwRuntimeError("index out of range") : a.$array[a.$offset + 0]);
- }
- n = sep.length * ((a.$length - 1 >> 0)) >> 0;
- i = 0;
- while (true) {
- if (!(i < a.$length)) { break; }
- n = n + (((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]).length) >> 0;
- i = i + (1) >> 0;
- }
- b = $makeSlice(sliceType, n);
- bp = $copyString(b, (0 >= a.$length ? $throwRuntimeError("index out of range") : a.$array[a.$offset + 0]));
- _ref = $subslice(a, 1);
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- bp = bp + ($copyString($subslice(b, bp), sep)) >> 0;
- bp = bp + ($copyString($subslice(b, bp), s)) >> 0;
- _i++;
- }
- return $bytesToString(b);
- };
- $pkg.Join = Join;
- HasPrefix = function(s, prefix) {
- var $ptr, prefix, s;
- return s.length >= prefix.length && s.substring(0, prefix.length) === prefix;
- };
- $pkg.HasPrefix = HasPrefix;
- HasSuffix = function(s, suffix) {
- var $ptr, s, suffix;
- return s.length >= suffix.length && s.substring((s.length - suffix.length >> 0)) === suffix;
- };
- $pkg.HasSuffix = HasSuffix;
- Map = function(mapping, s) {
- var $ptr, _i, _r, _ref, _rune, b, c, i, mapping, maxbytes, nb, nbytes, r, s, wid, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _rune = $f._rune; b = $f.b; c = $f.c; i = $f.i; mapping = $f.mapping; maxbytes = $f.maxbytes; nb = $f.nb; nbytes = $f.nbytes; r = $f.r; s = $f.s; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- maxbytes = s.length;
- nbytes = 0;
- b = sliceType.nil;
- _ref = s;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.length)) { break; } */ if(!(_i < _ref.length)) { $s = 2; continue; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- c = _rune[0];
- _r = mapping(c); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- r = _r;
- if (b === sliceType.nil) {
- if (r === c) {
- _i += _rune[1];
- /* continue; */ $s = 1; continue;
- }
- b = $makeSlice(sliceType, maxbytes);
- nbytes = $copyString(b, s.substring(0, i));
- }
- if (r >= 0) {
- wid = 1;
- if (r >= 128) {
- wid = utf8.RuneLen(r);
- }
- if ((nbytes + wid >> 0) > maxbytes) {
- maxbytes = (maxbytes * 2 >> 0) + 4 >> 0;
- nb = $makeSlice(sliceType, maxbytes);
- $copySlice(nb, $subslice(b, 0, nbytes));
- b = nb;
- }
- nbytes = nbytes + (utf8.EncodeRune($subslice(b, nbytes, maxbytes), r)) >> 0;
- }
- _i += _rune[1];
- /* } */ $s = 1; continue; case 2:
- if (b === sliceType.nil) {
- return s;
- }
- return $bytesToString($subslice(b, 0, nbytes));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._rune = _rune; $f.b = b; $f.c = c; $f.i = i; $f.mapping = mapping; $f.maxbytes = maxbytes; $f.nb = nb; $f.nbytes = nbytes; $f.r = r; $f.s = s; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Map = Map;
- Repeat = function(s, count) {
- var $ptr, b, bp, count, s;
- b = $makeSlice(sliceType, (s.length * count >> 0));
- bp = $copyString(b, s);
- while (true) {
- if (!(bp < b.$length)) { break; }
- $copySlice($subslice(b, bp), $subslice(b, 0, bp));
- bp = bp * (2) >> 0;
- }
- return $bytesToString(b);
- };
- $pkg.Repeat = Repeat;
- ToUpper = function(s) {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = Map(unicode.ToUpper, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ToUpper }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ToUpper = ToUpper;
- ToLower = function(s) {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = Map(unicode.ToLower, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ToLower }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ToLower = ToLower;
- TrimLeftFunc = function(s, f) {
- var $ptr, _r, f, i, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; i = $f.i; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = indexFunc(s, f, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- i = _r;
- if (i === -1) {
- return "";
- }
- return s.substring(i);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimLeftFunc }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.i = i; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimLeftFunc = TrimLeftFunc;
- TrimRightFunc = function(s, f) {
- var $ptr, _r, _tuple, f, i, s, wid, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; i = $f.i; s = $f.s; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = lastIndexFunc(s, f, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- i = _r;
- if (i >= 0 && s.charCodeAt(i) >= 128) {
- _tuple = utf8.DecodeRuneInString(s.substring(i)); wid = _tuple[1];
- i = i + (wid) >> 0;
- } else {
- i = i + (1) >> 0;
- }
- return s.substring(0, i);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimRightFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.s = s; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimRightFunc = TrimRightFunc;
- TrimFunc = function(s, f) {
- var $ptr, _r, _r$1, f, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; f = $f.f; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = TrimLeftFunc(s, f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = TrimRightFunc(_r, f); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimFunc = TrimFunc;
- indexFunc = function(s, f, truth) {
- var $ptr, _r, _tuple, f, r, s, start, truth, wid, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; r = $f.r; s = $f.s; start = $f.start; truth = $f.truth; wid = $f.wid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- start = 0;
- /* while (true) { */ case 1:
- /* if (!(start < s.length)) { break; } */ if(!(start < s.length)) { $s = 2; continue; }
- wid = 1;
- r = (s.charCodeAt(start) >> 0);
- if (r >= 128) {
- _tuple = utf8.DecodeRuneInString(s.substring(start)); r = _tuple[0]; wid = _tuple[1];
- }
- _r = f(r); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r === truth) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_r === truth) { */ case 3:
- return start;
- /* } */ case 4:
- start = start + (wid) >> 0;
- /* } */ $s = 1; continue; case 2:
- return -1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: indexFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.r = r; $f.s = s; $f.start = start; $f.truth = truth; $f.wid = wid; $f.$s = $s; $f.$r = $r; return $f;
- };
- lastIndexFunc = function(s, f, truth) {
- var $ptr, _r, _tuple, f, i, r, s, size, truth, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; i = $f.i; r = $f.r; s = $f.s; size = $f.size; truth = $f.truth; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = s.length;
- /* while (true) { */ case 1:
- /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 2; continue; }
- _tuple = utf8.DecodeLastRuneInString(s.substring(0, i)); r = _tuple[0]; size = _tuple[1];
- i = i - (size) >> 0;
- _r = f(r); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r === truth) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_r === truth) { */ case 3:
- return i;
- /* } */ case 4:
- /* } */ $s = 1; continue; case 2:
- return -1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: lastIndexFunc }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.i = i; $f.r = r; $f.s = s; $f.size = size; $f.truth = truth; $f.$s = $s; $f.$r = $r; return $f;
- };
- TrimSpace = function(s) {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = TrimFunc(s, unicode.IsSpace); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TrimSpace }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TrimSpace = TrimSpace;
- TrimSuffix = function(s, suffix) {
- var $ptr, s, suffix;
- if (HasSuffix(s, suffix)) {
- return s.substring(0, (s.length - suffix.length >> 0));
- }
- return s;
- };
- $pkg.TrimSuffix = TrimSuffix;
- Replace = function(s, old, new$1, n) {
- var $ptr, _tuple, i, j, m, n, new$1, old, s, start, t, w, wid;
- if (old === new$1 || (n === 0)) {
- return s;
- }
- m = Count(s, old);
- if (m === 0) {
- return s;
- } else if (n < 0 || m < n) {
- n = m;
- }
- t = $makeSlice(sliceType, (s.length + (n * ((new$1.length - old.length >> 0)) >> 0) >> 0));
- w = 0;
- start = 0;
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- j = start;
- if (old.length === 0) {
- if (i > 0) {
- _tuple = utf8.DecodeRuneInString(s.substring(start)); wid = _tuple[1];
- j = j + (wid) >> 0;
- }
- } else {
- j = j + (Index(s.substring(start), old)) >> 0;
- }
- w = w + ($copyString($subslice(t, w), s.substring(start, j))) >> 0;
- w = w + ($copyString($subslice(t, w), new$1)) >> 0;
- start = j + old.length >> 0;
- i = i + (1) >> 0;
- }
- w = w + ($copyString($subslice(t, w), s.substring(start))) >> 0;
- return $bytesToString($subslice(t, 0, w));
- };
- $pkg.Replace = Replace;
- ptrType$5.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType, $Int64], [$Int, $error], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "UnreadByte", name: "UnreadByte", pkg: "", typ: $funcType([], [$error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer], [$Int64, $error], false)}];
- Reader.init([{prop: "s", name: "s", pkg: "strings", typ: $String, tag: ""}, {prop: "i", name: "i", pkg: "strings", typ: $Int64, tag: ""}, {prop: "prevRune", name: "prevRune", pkg: "strings", typ: $Int, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["time"] = (function() {
- var $pkg = {}, $init, errors, js, nosync, runtime, strings, syscall, runtimeTimer, ParseError, Timer, Time, Month, Weekday, Duration, Location, zone, zoneTrans, sliceType, sliceType$1, sliceType$2, ptrType, structType, chanType, funcType, arrayType, sliceType$3, arrayType$1, arrayType$2, ptrType$1, chanType$2, funcType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$6, std0x, longDayNames, shortDayNames, shortMonthNames, longMonthNames, atoiError, errBad, errLeadingInt, unitMap, months, days, daysBefore, utcLoc, nonAsciiName, localLoc, nonAsciiName$1, localOnce, zoneinfo, badData, zoneDirs, _map, _key, _tuple, _r, initLocal, runtimeNano, Sleep, startTimer, stopTimer, startsWithLowerCase, nextStdChunk, match, lookup, appendUint, atoi, formatNano, quote, isDigit, getnum, cutspace, skip, Parse, parse, parseTimeZone, parseGMT, parseNanoseconds, leadingInt, ParseDuration, when, AfterFunc, goFunc, absWeekday, absClock, fmtFrac, fmtInt, absDate, Unix, isLeap, norm, Date, div, FixedZone;
- errors = $packages["errors"];
- js = $packages["github.com/gopherjs/gopherjs/js"];
- nosync = $packages["github.com/gopherjs/gopherjs/nosync"];
- runtime = $packages["runtime"];
- strings = $packages["strings"];
- syscall = $packages["syscall"];
- runtimeTimer = $pkg.runtimeTimer = $newType(0, $kindStruct, "time.runtimeTimer", "runtimeTimer", "time", function(i_, when_, period_, f_, arg_, timeout_, active_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.i = 0;
- this.when = new $Int64(0, 0);
- this.period = new $Int64(0, 0);
- this.f = $throwNilPointerError;
- this.arg = $ifaceNil;
- this.timeout = null;
- this.active = false;
- return;
- }
- this.i = i_;
- this.when = when_;
- this.period = period_;
- this.f = f_;
- this.arg = arg_;
- this.timeout = timeout_;
- this.active = active_;
- });
- ParseError = $pkg.ParseError = $newType(0, $kindStruct, "time.ParseError", "ParseError", "time", function(Layout_, Value_, LayoutElem_, ValueElem_, Message_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Layout = "";
- this.Value = "";
- this.LayoutElem = "";
- this.ValueElem = "";
- this.Message = "";
- return;
- }
- this.Layout = Layout_;
- this.Value = Value_;
- this.LayoutElem = LayoutElem_;
- this.ValueElem = ValueElem_;
- this.Message = Message_;
- });
- Timer = $pkg.Timer = $newType(0, $kindStruct, "time.Timer", "Timer", "time", function(C_, r_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.C = chanType$2.nil;
- this.r = new runtimeTimer.ptr();
- return;
- }
- this.C = C_;
- this.r = r_;
- });
- Time = $pkg.Time = $newType(0, $kindStruct, "time.Time", "Time", "time", function(sec_, nsec_, loc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.sec = new $Int64(0, 0);
- this.nsec = 0;
- this.loc = ptrType$1.nil;
- return;
- }
- this.sec = sec_;
- this.nsec = nsec_;
- this.loc = loc_;
- });
- Month = $pkg.Month = $newType(4, $kindInt, "time.Month", "Month", "time", null);
- Weekday = $pkg.Weekday = $newType(4, $kindInt, "time.Weekday", "Weekday", "time", null);
- Duration = $pkg.Duration = $newType(8, $kindInt64, "time.Duration", "Duration", "time", null);
- Location = $pkg.Location = $newType(0, $kindStruct, "time.Location", "Location", "time", function(name_, zone_, tx_, cacheStart_, cacheEnd_, cacheZone_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = "";
- this.zone = sliceType$1.nil;
- this.tx = sliceType$2.nil;
- this.cacheStart = new $Int64(0, 0);
- this.cacheEnd = new $Int64(0, 0);
- this.cacheZone = ptrType.nil;
- return;
- }
- this.name = name_;
- this.zone = zone_;
- this.tx = tx_;
- this.cacheStart = cacheStart_;
- this.cacheEnd = cacheEnd_;
- this.cacheZone = cacheZone_;
- });
- zone = $pkg.zone = $newType(0, $kindStruct, "time.zone", "zone", "time", function(name_, offset_, isDST_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = "";
- this.offset = 0;
- this.isDST = false;
- return;
- }
- this.name = name_;
- this.offset = offset_;
- this.isDST = isDST_;
- });
- zoneTrans = $pkg.zoneTrans = $newType(0, $kindStruct, "time.zoneTrans", "zoneTrans", "time", function(when_, index_, isstd_, isutc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.when = new $Int64(0, 0);
- this.index = 0;
- this.isstd = false;
- this.isutc = false;
- return;
- }
- this.when = when_;
- this.index = index_;
- this.isstd = isstd_;
- this.isutc = isutc_;
- });
- sliceType = $sliceType($String);
- sliceType$1 = $sliceType(zone);
- sliceType$2 = $sliceType(zoneTrans);
- ptrType = $ptrType(zone);
- structType = $structType([]);
- chanType = $chanType(structType, false, false);
- funcType = $funcType([], [], false);
- arrayType = $arrayType($Uint8, 32);
- sliceType$3 = $sliceType($Uint8);
- arrayType$1 = $arrayType($Uint8, 9);
- arrayType$2 = $arrayType($Uint8, 64);
- ptrType$1 = $ptrType(Location);
- chanType$2 = $chanType(Time, false, true);
- funcType$1 = $funcType([$emptyInterface, $Uintptr], [], false);
- ptrType$2 = $ptrType(js.Object);
- ptrType$3 = $ptrType(ParseError);
- ptrType$4 = $ptrType(Timer);
- ptrType$6 = $ptrType(Time);
- initLocal = function() {
- var $ptr, d, i, j, s;
- d = new ($global.Date)();
- s = $internalize(d, $String);
- i = strings.IndexByte(s, 40);
- j = strings.IndexByte(s, 41);
- if ((i === -1) || (j === -1)) {
- localLoc.name = "UTC";
- return;
- }
- localLoc.name = s.substring((i + 1 >> 0), j);
- localLoc.zone = new sliceType$1([new zone.ptr(localLoc.name, ($parseInt(d.getTimezoneOffset()) >> 0) * -60 >> 0, false)]);
- };
- runtimeNano = function() {
- var $ptr;
- return $mul64($internalize(new ($global.Date)().getTime(), $Int64), new $Int64(0, 1000000));
- };
- Sleep = function(d) {
- var $ptr, _r$1, c, d, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; c = $f.c; d = $f.d; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = [c];
- c[0] = new chanType(0);
- $global.setTimeout($externalize((function(c) { return function() {
- var $ptr;
- $close(c[0]);
- }; })(c), funcType), ((x = $div64(d, new Duration(0, 1000000), false), x.$low + ((x.$high >> 31) * 4294967296)) >> 0));
- _r$1 = $recv(c[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Sleep }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.c = c; $f.d = d; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Sleep = Sleep;
- startTimer = function(t) {
- var $ptr, diff, t, x, x$1;
- t.active = true;
- diff = $div64(((x = t.when, x$1 = runtimeNano(), new $Int64(x.$high - x$1.$high, x.$low - x$1.$low))), new $Int64(0, 1000000), false);
- if ((diff.$high > 0 || (diff.$high === 0 && diff.$low > 2147483647))) {
- return;
- }
- if ((diff.$high < 0 || (diff.$high === 0 && diff.$low < 0))) {
- diff = new $Int64(0, 0);
- }
- t.timeout = $global.setTimeout($externalize((function() {
- var $ptr, x$2, x$3, x$4;
- t.active = false;
- $go(t.f, [t.arg, 0]);
- if (!((x$2 = t.period, (x$2.$high === 0 && x$2.$low === 0)))) {
- t.when = (x$3 = t.when, x$4 = t.period, new $Int64(x$3.$high + x$4.$high, x$3.$low + x$4.$low));
- startTimer(t);
- }
- }), funcType), $externalize(new $Int64(diff.$high + 0, diff.$low + 1), $Int64));
- };
- stopTimer = function(t) {
- var $ptr, t, wasActive;
- $global.clearTimeout(t.timeout);
- wasActive = t.active;
- t.active = false;
- return wasActive;
- };
- startsWithLowerCase = function(str) {
- var $ptr, c, str;
- if (str.length === 0) {
- return false;
- }
- c = str.charCodeAt(0);
- return 97 <= c && c <= 122;
- };
- nextStdChunk = function(layout) {
- var $ptr, _ref, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$44, _tmp$45, _tmp$46, _tmp$47, _tmp$48, _tmp$49, _tmp$5, _tmp$50, _tmp$51, _tmp$52, _tmp$53, _tmp$54, _tmp$55, _tmp$56, _tmp$57, _tmp$58, _tmp$59, _tmp$6, _tmp$60, _tmp$61, _tmp$62, _tmp$63, _tmp$64, _tmp$65, _tmp$66, _tmp$67, _tmp$68, _tmp$69, _tmp$7, _tmp$70, _tmp$71, _tmp$72, _tmp$73, _tmp$74, _tmp$75, _tmp$76, _tmp$77, _tmp$78, _tmp$79, _tmp$8, _tmp$80, _tmp$9, c, ch, i, j, layout, prefix, std, std$1, suffix, x;
- prefix = "";
- std = 0;
- suffix = "";
- i = 0;
- while (true) {
- if (!(i < layout.length)) { break; }
- c = (layout.charCodeAt(i) >> 0);
- _ref = c;
- if (_ref === 74) {
- if (layout.length >= (i + 3 >> 0) && layout.substring(i, (i + 3 >> 0)) === "Jan") {
- if (layout.length >= (i + 7 >> 0) && layout.substring(i, (i + 7 >> 0)) === "January") {
- _tmp = layout.substring(0, i); _tmp$1 = 257; _tmp$2 = layout.substring((i + 7 >> 0)); prefix = _tmp; std = _tmp$1; suffix = _tmp$2;
- return [prefix, std, suffix];
- }
- if (!startsWithLowerCase(layout.substring((i + 3 >> 0)))) {
- _tmp$3 = layout.substring(0, i); _tmp$4 = 258; _tmp$5 = layout.substring((i + 3 >> 0)); prefix = _tmp$3; std = _tmp$4; suffix = _tmp$5;
- return [prefix, std, suffix];
- }
- }
- } else if (_ref === 77) {
- if (layout.length >= (i + 3 >> 0)) {
- if (layout.substring(i, (i + 3 >> 0)) === "Mon") {
- if (layout.length >= (i + 6 >> 0) && layout.substring(i, (i + 6 >> 0)) === "Monday") {
- _tmp$6 = layout.substring(0, i); _tmp$7 = 261; _tmp$8 = layout.substring((i + 6 >> 0)); prefix = _tmp$6; std = _tmp$7; suffix = _tmp$8;
- return [prefix, std, suffix];
- }
- if (!startsWithLowerCase(layout.substring((i + 3 >> 0)))) {
- _tmp$9 = layout.substring(0, i); _tmp$10 = 262; _tmp$11 = layout.substring((i + 3 >> 0)); prefix = _tmp$9; std = _tmp$10; suffix = _tmp$11;
- return [prefix, std, suffix];
- }
- }
- if (layout.substring(i, (i + 3 >> 0)) === "MST") {
- _tmp$12 = layout.substring(0, i); _tmp$13 = 21; _tmp$14 = layout.substring((i + 3 >> 0)); prefix = _tmp$12; std = _tmp$13; suffix = _tmp$14;
- return [prefix, std, suffix];
- }
- }
- } else if (_ref === 48) {
- if (layout.length >= (i + 2 >> 0) && 49 <= layout.charCodeAt((i + 1 >> 0)) && layout.charCodeAt((i + 1 >> 0)) <= 54) {
- _tmp$15 = layout.substring(0, i); _tmp$16 = (x = layout.charCodeAt((i + 1 >> 0)) - 49 << 24 >>> 24, ((x < 0 || x >= std0x.length) ? $throwRuntimeError("index out of range") : std0x[x])); _tmp$17 = layout.substring((i + 2 >> 0)); prefix = _tmp$15; std = _tmp$16; suffix = _tmp$17;
- return [prefix, std, suffix];
- }
- } else if (_ref === 49) {
- if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 53)) {
- _tmp$18 = layout.substring(0, i); _tmp$19 = 522; _tmp$20 = layout.substring((i + 2 >> 0)); prefix = _tmp$18; std = _tmp$19; suffix = _tmp$20;
- return [prefix, std, suffix];
- }
- _tmp$21 = layout.substring(0, i); _tmp$22 = 259; _tmp$23 = layout.substring((i + 1 >> 0)); prefix = _tmp$21; std = _tmp$22; suffix = _tmp$23;
- return [prefix, std, suffix];
- } else if (_ref === 50) {
- if (layout.length >= (i + 4 >> 0) && layout.substring(i, (i + 4 >> 0)) === "2006") {
- _tmp$24 = layout.substring(0, i); _tmp$25 = 273; _tmp$26 = layout.substring((i + 4 >> 0)); prefix = _tmp$24; std = _tmp$25; suffix = _tmp$26;
- return [prefix, std, suffix];
- }
- _tmp$27 = layout.substring(0, i); _tmp$28 = 263; _tmp$29 = layout.substring((i + 1 >> 0)); prefix = _tmp$27; std = _tmp$28; suffix = _tmp$29;
- return [prefix, std, suffix];
- } else if (_ref === 95) {
- if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 50)) {
- _tmp$30 = layout.substring(0, i); _tmp$31 = 264; _tmp$32 = layout.substring((i + 2 >> 0)); prefix = _tmp$30; std = _tmp$31; suffix = _tmp$32;
- return [prefix, std, suffix];
- }
- } else if (_ref === 51) {
- _tmp$33 = layout.substring(0, i); _tmp$34 = 523; _tmp$35 = layout.substring((i + 1 >> 0)); prefix = _tmp$33; std = _tmp$34; suffix = _tmp$35;
- return [prefix, std, suffix];
- } else if (_ref === 52) {
- _tmp$36 = layout.substring(0, i); _tmp$37 = 525; _tmp$38 = layout.substring((i + 1 >> 0)); prefix = _tmp$36; std = _tmp$37; suffix = _tmp$38;
- return [prefix, std, suffix];
- } else if (_ref === 53) {
- _tmp$39 = layout.substring(0, i); _tmp$40 = 527; _tmp$41 = layout.substring((i + 1 >> 0)); prefix = _tmp$39; std = _tmp$40; suffix = _tmp$41;
- return [prefix, std, suffix];
- } else if (_ref === 80) {
- if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 77)) {
- _tmp$42 = layout.substring(0, i); _tmp$43 = 531; _tmp$44 = layout.substring((i + 2 >> 0)); prefix = _tmp$42; std = _tmp$43; suffix = _tmp$44;
- return [prefix, std, suffix];
- }
- } else if (_ref === 112) {
- if (layout.length >= (i + 2 >> 0) && (layout.charCodeAt((i + 1 >> 0)) === 109)) {
- _tmp$45 = layout.substring(0, i); _tmp$46 = 532; _tmp$47 = layout.substring((i + 2 >> 0)); prefix = _tmp$45; std = _tmp$46; suffix = _tmp$47;
- return [prefix, std, suffix];
- }
- } else if (_ref === 45) {
- if (layout.length >= (i + 7 >> 0) && layout.substring(i, (i + 7 >> 0)) === "-070000") {
- _tmp$48 = layout.substring(0, i); _tmp$49 = 27; _tmp$50 = layout.substring((i + 7 >> 0)); prefix = _tmp$48; std = _tmp$49; suffix = _tmp$50;
- return [prefix, std, suffix];
- }
- if (layout.length >= (i + 9 >> 0) && layout.substring(i, (i + 9 >> 0)) === "-07:00:00") {
- _tmp$51 = layout.substring(0, i); _tmp$52 = 30; _tmp$53 = layout.substring((i + 9 >> 0)); prefix = _tmp$51; std = _tmp$52; suffix = _tmp$53;
- return [prefix, std, suffix];
- }
- if (layout.length >= (i + 5 >> 0) && layout.substring(i, (i + 5 >> 0)) === "-0700") {
- _tmp$54 = layout.substring(0, i); _tmp$55 = 26; _tmp$56 = layout.substring((i + 5 >> 0)); prefix = _tmp$54; std = _tmp$55; suffix = _tmp$56;
- return [prefix, std, suffix];
- }
- if (layout.length >= (i + 6 >> 0) && layout.substring(i, (i + 6 >> 0)) === "-07:00") {
- _tmp$57 = layout.substring(0, i); _tmp$58 = 29; _tmp$59 = layout.substring((i + 6 >> 0)); prefix = _tmp$57; std = _tmp$58; suffix = _tmp$59;
- return [prefix, std, suffix];
- }
- if (layout.length >= (i + 3 >> 0) && layout.substring(i, (i + 3 >> 0)) === "-07") {
- _tmp$60 = layout.substring(0, i); _tmp$61 = 28; _tmp$62 = layout.substring((i + 3 >> 0)); prefix = _tmp$60; std = _tmp$61; suffix = _tmp$62;
- return [prefix, std, suffix];
- }
- } else if (_ref === 90) {
- if (layout.length >= (i + 7 >> 0) && layout.substring(i, (i + 7 >> 0)) === "Z070000") {
- _tmp$63 = layout.substring(0, i); _tmp$64 = 23; _tmp$65 = layout.substring((i + 7 >> 0)); prefix = _tmp$63; std = _tmp$64; suffix = _tmp$65;
- return [prefix, std, suffix];
- }
- if (layout.length >= (i + 9 >> 0) && layout.substring(i, (i + 9 >> 0)) === "Z07:00:00") {
- _tmp$66 = layout.substring(0, i); _tmp$67 = 25; _tmp$68 = layout.substring((i + 9 >> 0)); prefix = _tmp$66; std = _tmp$67; suffix = _tmp$68;
- return [prefix, std, suffix];
- }
- if (layout.length >= (i + 5 >> 0) && layout.substring(i, (i + 5 >> 0)) === "Z0700") {
- _tmp$69 = layout.substring(0, i); _tmp$70 = 22; _tmp$71 = layout.substring((i + 5 >> 0)); prefix = _tmp$69; std = _tmp$70; suffix = _tmp$71;
- return [prefix, std, suffix];
- }
- if (layout.length >= (i + 6 >> 0) && layout.substring(i, (i + 6 >> 0)) === "Z07:00") {
- _tmp$72 = layout.substring(0, i); _tmp$73 = 24; _tmp$74 = layout.substring((i + 6 >> 0)); prefix = _tmp$72; std = _tmp$73; suffix = _tmp$74;
- return [prefix, std, suffix];
- }
- } else if (_ref === 46) {
- if ((i + 1 >> 0) < layout.length && ((layout.charCodeAt((i + 1 >> 0)) === 48) || (layout.charCodeAt((i + 1 >> 0)) === 57))) {
- ch = layout.charCodeAt((i + 1 >> 0));
- j = i + 1 >> 0;
- while (true) {
- if (!(j < layout.length && (layout.charCodeAt(j) === ch))) { break; }
- j = j + (1) >> 0;
- }
- if (!isDigit(layout, j)) {
- std$1 = 31;
- if (layout.charCodeAt((i + 1 >> 0)) === 57) {
- std$1 = 32;
- }
- std$1 = std$1 | ((((j - ((i + 1 >> 0)) >> 0)) << 16 >> 0));
- _tmp$75 = layout.substring(0, i); _tmp$76 = std$1; _tmp$77 = layout.substring(j); prefix = _tmp$75; std = _tmp$76; suffix = _tmp$77;
- return [prefix, std, suffix];
- }
- }
- }
- i = i + (1) >> 0;
- }
- _tmp$78 = layout; _tmp$79 = 0; _tmp$80 = ""; prefix = _tmp$78; std = _tmp$79; suffix = _tmp$80;
- return [prefix, std, suffix];
- };
- match = function(s1, s2) {
- var $ptr, c1, c2, i, s1, s2;
- i = 0;
- while (true) {
- if (!(i < s1.length)) { break; }
- c1 = s1.charCodeAt(i);
- c2 = s2.charCodeAt(i);
- if (!((c1 === c2))) {
- c1 = (c1 | (32)) >>> 0;
- c2 = (c2 | (32)) >>> 0;
- if (!((c1 === c2)) || c1 < 97 || c1 > 122) {
- return false;
- }
- }
- i = i + (1) >> 0;
- }
- return true;
- };
- lookup = function(tab, val) {
- var $ptr, _i, _ref, i, tab, v, val;
- _ref = tab;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- v = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (val.length >= v.length && match(val.substring(0, v.length), v)) {
- return [i, val.substring(v.length), $ifaceNil];
- }
- _i++;
- }
- return [-1, val, errBad];
- };
- appendUint = function(b, x, pad) {
- var $ptr, _q, _q$1, _r$1, _r$2, b, buf, n, pad, x;
- if (x < 10) {
- if (!((pad === 0))) {
- b = $append(b, pad);
- }
- return $append(b, ((48 + x >>> 0) << 24 >>> 24));
- }
- if (x < 100) {
- b = $append(b, ((48 + (_q = x / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >>> 0) << 24 >>> 24));
- b = $append(b, ((48 + (_r$1 = x % 10, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0) << 24 >>> 24));
- return b;
- }
- buf = $clone(arrayType.zero(), arrayType);
- n = 32;
- if (x === 0) {
- return $append(b, 48);
- }
- while (true) {
- if (!(x >= 10)) { break; }
- n = n - (1) >> 0;
- ((n < 0 || n >= buf.length) ? $throwRuntimeError("index out of range") : buf[n] = (((_r$2 = x % 10, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24));
- x = (_q$1 = x / (10), (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero"));
- }
- n = n - (1) >> 0;
- ((n < 0 || n >= buf.length) ? $throwRuntimeError("index out of range") : buf[n] = ((x + 48 >>> 0) << 24 >>> 24));
- return $appendSlice(b, $subslice(new sliceType$3(buf), n));
- };
- atoi = function(s) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple$1, err, neg, q, rem, s, x;
- x = 0;
- err = $ifaceNil;
- neg = false;
- if (!(s === "") && ((s.charCodeAt(0) === 45) || (s.charCodeAt(0) === 43))) {
- neg = s.charCodeAt(0) === 45;
- s = s.substring(1);
- }
- _tuple$1 = leadingInt(s); q = _tuple$1[0]; rem = _tuple$1[1]; err = _tuple$1[2];
- x = ((q.$low + ((q.$high >> 31) * 4294967296)) >> 0);
- if (!($interfaceIsEqual(err, $ifaceNil)) || !(rem === "")) {
- _tmp = 0; _tmp$1 = atoiError; x = _tmp; err = _tmp$1;
- return [x, err];
- }
- if (neg) {
- x = -x;
- }
- _tmp$2 = x; _tmp$3 = $ifaceNil; x = _tmp$2; err = _tmp$3;
- return [x, err];
- };
- formatNano = function(b, nanosec, n, trim) {
- var $ptr, _q, _r$1, b, buf, n, nanosec, start, trim, u, x;
- u = nanosec;
- buf = $clone(arrayType$1.zero(), arrayType$1);
- start = 9;
- while (true) {
- if (!(start > 0)) { break; }
- start = start - (1) >> 0;
- ((start < 0 || start >= buf.length) ? $throwRuntimeError("index out of range") : buf[start] = (((_r$1 = u % 10, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) + 48 >>> 0) << 24 >>> 24));
- u = (_q = u / (10), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- }
- if (n > 9) {
- n = 9;
- }
- if (trim) {
- while (true) {
- if (!(n > 0 && ((x = n - 1 >> 0, ((x < 0 || x >= buf.length) ? $throwRuntimeError("index out of range") : buf[x])) === 48))) { break; }
- n = n - (1) >> 0;
- }
- if (n === 0) {
- return b;
- }
- }
- b = $append(b, 46);
- return $appendSlice(b, $subslice(new sliceType$3(buf), 0, n));
- };
- Time.ptr.prototype.String = function() {
- var $ptr, _r$1, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.Format("2006-01-02 15:04:05.999999999 -0700 MST"); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.String = function() { return this.$val.String(); };
- Time.ptr.prototype.Format = function(layout) {
- var $ptr, _q, _q$1, _q$2, _q$3, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _tuple$1, _tuple$2, _tuple$3, _tuple$4, abs, absoffset, b, buf, day, hour, hr, hr$1, layout, m, max, min, month, name, offset, prefix, s, sec, std, suffix, t, y, y$1, year, zone$1, zone$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$2; _q$3 = $f._q$3; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; abs = $f.abs; absoffset = $f.absoffset; b = $f.b; buf = $f.buf; day = $f.day; hour = $f.hour; hr = $f.hr; hr$1 = $f.hr$1; layout = $f.layout; m = $f.m; max = $f.max; min = $f.min; month = $f.month; name = $f.name; offset = $f.offset; prefix = $f.prefix; s = $f.s; sec = $f.sec; std = $f.std; suffix = $f.suffix; t = $f.t; y = $f.y; y$1 = $f.y$1; year = $f.year; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.locabs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; name = _tuple$1[0]; offset = _tuple$1[1]; abs = _tuple$1[2];
- year = -1;
- month = 0;
- day = 0;
- hour = -1;
- min = 0;
- sec = 0;
- b = sliceType$3.nil;
- buf = $clone(arrayType$2.zero(), arrayType$2);
- max = layout.length + 10 >> 0;
- if (max <= 64) {
- b = $subslice(new sliceType$3(buf), 0, 0);
- } else {
- b = $makeSlice(sliceType$3, 0, max);
- }
- while (true) {
- if (!(!(layout === ""))) { break; }
- _tuple$2 = nextStdChunk(layout); prefix = _tuple$2[0]; std = _tuple$2[1]; suffix = _tuple$2[2];
- if (!(prefix === "")) {
- b = $appendSlice(b, new sliceType$3($stringToBytes(prefix)));
- }
- if (std === 0) {
- break;
- }
- layout = suffix;
- if (year < 0 && !(((std & 256) === 0))) {
- _tuple$3 = absDate(abs, true); year = _tuple$3[0]; month = _tuple$3[1]; day = _tuple$3[2];
- }
- if (hour < 0 && !(((std & 512) === 0))) {
- _tuple$4 = absClock(abs); hour = _tuple$4[0]; min = _tuple$4[1]; sec = _tuple$4[2];
- }
- _ref = std & 65535;
- switch (0) { default: if (_ref === 274) {
- y = year;
- if (y < 0) {
- y = -y;
- }
- b = appendUint(b, ((_r$2 = y % 100, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) >>> 0), 48);
- } else if (_ref === 273) {
- y$1 = year;
- if (year <= -1000) {
- b = $append(b, 45);
- y$1 = -y$1;
- } else if (year <= -100) {
- b = $appendSlice(b, new sliceType$3($stringToBytes("-0")));
- y$1 = -y$1;
- } else if (year <= -10) {
- b = $appendSlice(b, new sliceType$3($stringToBytes("-00")));
- y$1 = -y$1;
- } else if (year < 0) {
- b = $appendSlice(b, new sliceType$3($stringToBytes("-000")));
- y$1 = -y$1;
- } else if (year < 10) {
- b = $appendSlice(b, new sliceType$3($stringToBytes("000")));
- } else if (year < 100) {
- b = $appendSlice(b, new sliceType$3($stringToBytes("00")));
- } else if (year < 1000) {
- b = $append(b, 48);
- }
- b = appendUint(b, (y$1 >>> 0), 0);
- } else if (_ref === 258) {
- b = $appendSlice(b, new sliceType$3($stringToBytes(new Month(month).String().substring(0, 3))));
- } else if (_ref === 257) {
- m = new Month(month).String();
- b = $appendSlice(b, new sliceType$3($stringToBytes(m)));
- } else if (_ref === 259) {
- b = appendUint(b, (month >>> 0), 0);
- } else if (_ref === 260) {
- b = appendUint(b, (month >>> 0), 48);
- } else if (_ref === 262) {
- b = $appendSlice(b, new sliceType$3($stringToBytes(new Weekday(absWeekday(abs)).String().substring(0, 3))));
- } else if (_ref === 261) {
- s = new Weekday(absWeekday(abs)).String();
- b = $appendSlice(b, new sliceType$3($stringToBytes(s)));
- } else if (_ref === 263) {
- b = appendUint(b, (day >>> 0), 0);
- } else if (_ref === 264) {
- b = appendUint(b, (day >>> 0), 32);
- } else if (_ref === 265) {
- b = appendUint(b, (day >>> 0), 48);
- } else if (_ref === 522) {
- b = appendUint(b, (hour >>> 0), 48);
- } else if (_ref === 523) {
- hr = (_r$3 = hour % 12, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero"));
- if (hr === 0) {
- hr = 12;
- }
- b = appendUint(b, (hr >>> 0), 0);
- } else if (_ref === 524) {
- hr$1 = (_r$4 = hour % 12, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero"));
- if (hr$1 === 0) {
- hr$1 = 12;
- }
- b = appendUint(b, (hr$1 >>> 0), 48);
- } else if (_ref === 525) {
- b = appendUint(b, (min >>> 0), 0);
- } else if (_ref === 526) {
- b = appendUint(b, (min >>> 0), 48);
- } else if (_ref === 527) {
- b = appendUint(b, (sec >>> 0), 0);
- } else if (_ref === 528) {
- b = appendUint(b, (sec >>> 0), 48);
- } else if (_ref === 531) {
- if (hour >= 12) {
- b = $appendSlice(b, new sliceType$3($stringToBytes("PM")));
- } else {
- b = $appendSlice(b, new sliceType$3($stringToBytes("AM")));
- }
- } else if (_ref === 532) {
- if (hour >= 12) {
- b = $appendSlice(b, new sliceType$3($stringToBytes("pm")));
- } else {
- b = $appendSlice(b, new sliceType$3($stringToBytes("am")));
- }
- } else if (_ref === 22 || _ref === 24 || _ref === 23 || _ref === 25 || _ref === 26 || _ref === 29 || _ref === 27 || _ref === 30) {
- if ((offset === 0) && ((std === 22) || (std === 24) || (std === 23) || (std === 25))) {
- b = $append(b, 90);
- break;
- }
- zone$1 = (_q = offset / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- absoffset = offset;
- if (zone$1 < 0) {
- b = $append(b, 45);
- zone$1 = -zone$1;
- absoffset = -absoffset;
- } else {
- b = $append(b, 43);
- }
- b = appendUint(b, ((_q$1 = zone$1 / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero")) >>> 0), 48);
- if ((std === 24) || (std === 29) || (std === 25) || (std === 30)) {
- b = $append(b, 58);
- }
- b = appendUint(b, ((_r$5 = zone$1 % 60, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")) >>> 0), 48);
- if ((std === 23) || (std === 27) || (std === 30) || (std === 25)) {
- if ((std === 30) || (std === 25)) {
- b = $append(b, 58);
- }
- b = appendUint(b, ((_r$6 = absoffset % 60, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")) >>> 0), 48);
- }
- } else if (_ref === 21) {
- if (!(name === "")) {
- b = $appendSlice(b, new sliceType$3($stringToBytes(name)));
- break;
- }
- zone$2 = (_q$2 = offset / 60, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero"));
- if (zone$2 < 0) {
- b = $append(b, 45);
- zone$2 = -zone$2;
- } else {
- b = $append(b, 43);
- }
- b = appendUint(b, ((_q$3 = zone$2 / 60, (_q$3 === _q$3 && _q$3 !== 1/0 && _q$3 !== -1/0) ? _q$3 >> 0 : $throwRuntimeError("integer divide by zero")) >>> 0), 48);
- b = appendUint(b, ((_r$7 = zone$2 % 60, _r$7 === _r$7 ? _r$7 : $throwRuntimeError("integer divide by zero")) >>> 0), 48);
- } else if (_ref === 31 || _ref === 32) {
- b = formatNano(b, (t.Nanosecond() >>> 0), std >> 16 >> 0, (std & 65535) === 32);
- } }
- }
- return $bytesToString(b);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Format }; } $f.$ptr = $ptr; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$2; $f._q$3 = _q$3; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.abs = abs; $f.absoffset = absoffset; $f.b = b; $f.buf = buf; $f.day = day; $f.hour = hour; $f.hr = hr; $f.hr$1 = hr$1; $f.layout = layout; $f.m = m; $f.max = max; $f.min = min; $f.month = month; $f.name = name; $f.offset = offset; $f.prefix = prefix; $f.s = s; $f.sec = sec; $f.std = std; $f.suffix = suffix; $f.t = t; $f.y = y; $f.y$1 = y$1; $f.year = year; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Format = function(layout) { return this.$val.Format(layout); };
- quote = function(s) {
- var $ptr, s;
- return "\"" + s + "\"";
- };
- ParseError.ptr.prototype.Error = function() {
- var $ptr, e;
- e = this;
- if (e.Message === "") {
- return "parsing time " + quote(e.Value) + " as " + quote(e.Layout) + ": cannot parse " + quote(e.ValueElem) + " as " + quote(e.LayoutElem);
- }
- return "parsing time " + quote(e.Value) + e.Message;
- };
- ParseError.prototype.Error = function() { return this.$val.Error(); };
- isDigit = function(s, i) {
- var $ptr, c, i, s;
- if (s.length <= i) {
- return false;
- }
- c = s.charCodeAt(i);
- return 48 <= c && c <= 57;
- };
- getnum = function(s, fixed) {
- var $ptr, fixed, s;
- if (!isDigit(s, 0)) {
- return [0, s, errBad];
- }
- if (!isDigit(s, 1)) {
- if (fixed) {
- return [0, s, errBad];
- }
- return [((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0), s.substring(1), $ifaceNil];
- }
- return [(((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0) * 10 >> 0) + ((s.charCodeAt(1) - 48 << 24 >>> 24) >> 0) >> 0, s.substring(2), $ifaceNil];
- };
- cutspace = function(s) {
- var $ptr, s;
- while (true) {
- if (!(s.length > 0 && (s.charCodeAt(0) === 32))) { break; }
- s = s.substring(1);
- }
- return s;
- };
- skip = function(value, prefix) {
- var $ptr, prefix, value;
- while (true) {
- if (!(prefix.length > 0)) { break; }
- if (prefix.charCodeAt(0) === 32) {
- if (value.length > 0 && !((value.charCodeAt(0) === 32))) {
- return [value, errBad];
- }
- prefix = cutspace(prefix);
- value = cutspace(value);
- continue;
- }
- if ((value.length === 0) || !((value.charCodeAt(0) === prefix.charCodeAt(0)))) {
- return [value, errBad];
- }
- prefix = prefix.substring(1);
- value = value.substring(1);
- }
- return [value, $ifaceNil];
- };
- Parse = function(layout, value) {
- var $ptr, _r$1, layout, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; layout = $f.layout; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$1 = parse(layout, value, $pkg.UTC, $pkg.Local); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Parse }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.layout = layout; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Parse = Parse;
- parse = function(layout, value, defaultLocation, local) {
- var $ptr, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, _ref$2, _ref$3, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$29, _tmp$3, _tmp$30, _tmp$31, _tmp$32, _tmp$33, _tmp$34, _tmp$35, _tmp$36, _tmp$37, _tmp$38, _tmp$39, _tmp$4, _tmp$40, _tmp$41, _tmp$42, _tmp$43, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple$1, _tuple$10, _tuple$11, _tuple$12, _tuple$13, _tuple$14, _tuple$15, _tuple$16, _tuple$17, _tuple$18, _tuple$19, _tuple$2, _tuple$20, _tuple$21, _tuple$22, _tuple$23, _tuple$24, _tuple$25, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, alayout, amSet, avalue, day, defaultLocation, err, hour, hour$1, hr, i, layout, local, min, min$1, mm, month, n, n$1, name, ndigit, nsec, offset, offset$1, ok, ok$1, p, pmSet, prefix, rangeErrString, sec, seconds, sign, ss, std, stdstr, suffix, t, t$1, value, x, x$1, x$2, x$3, x$4, x$5, year, z, zoneName, zoneOffset, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$17 = $f._tmp$17; _tmp$18 = $f._tmp$18; _tmp$19 = $f._tmp$19; _tmp$2 = $f._tmp$2; _tmp$20 = $f._tmp$20; _tmp$21 = $f._tmp$21; _tmp$22 = $f._tmp$22; _tmp$23 = $f._tmp$23; _tmp$24 = $f._tmp$24; _tmp$25 = $f._tmp$25; _tmp$26 = $f._tmp$26; _tmp$27 = $f._tmp$27; _tmp$28 = $f._tmp$28; _tmp$29 = $f._tmp$29; _tmp$3 = $f._tmp$3; _tmp$30 = $f._tmp$30; _tmp$31 = $f._tmp$31; _tmp$32 = $f._tmp$32; _tmp$33 = $f._tmp$33; _tmp$34 = $f._tmp$34; _tmp$35 = $f._tmp$35; _tmp$36 = $f._tmp$36; _tmp$37 = $f._tmp$37; _tmp$38 = $f._tmp$38; _tmp$39 = $f._tmp$39; _tmp$4 = $f._tmp$4; _tmp$40 = $f._tmp$40; _tmp$41 = $f._tmp$41; _tmp$42 = $f._tmp$42; _tmp$43 = $f._tmp$43; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$11 = $f._tuple$11; _tuple$12 = $f._tuple$12; _tuple$13 = $f._tuple$13; _tuple$14 = $f._tuple$14; _tuple$15 = $f._tuple$15; _tuple$16 = $f._tuple$16; _tuple$17 = $f._tuple$17; _tuple$18 = $f._tuple$18; _tuple$19 = $f._tuple$19; _tuple$2 = $f._tuple$2; _tuple$20 = $f._tuple$20; _tuple$21 = $f._tuple$21; _tuple$22 = $f._tuple$22; _tuple$23 = $f._tuple$23; _tuple$24 = $f._tuple$24; _tuple$25 = $f._tuple$25; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; alayout = $f.alayout; amSet = $f.amSet; avalue = $f.avalue; day = $f.day; defaultLocation = $f.defaultLocation; err = $f.err; hour = $f.hour; hour$1 = $f.hour$1; hr = $f.hr; i = $f.i; layout = $f.layout; local = $f.local; min = $f.min; min$1 = $f.min$1; mm = $f.mm; month = $f.month; n = $f.n; n$1 = $f.n$1; name = $f.name; ndigit = $f.ndigit; nsec = $f.nsec; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; pmSet = $f.pmSet; prefix = $f.prefix; rangeErrString = $f.rangeErrString; sec = $f.sec; seconds = $f.seconds; sign = $f.sign; ss = $f.ss; std = $f.std; stdstr = $f.stdstr; suffix = $f.suffix; t = $f.t; t$1 = $f.t$1; value = $f.value; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; year = $f.year; z = $f.z; zoneName = $f.zoneName; zoneOffset = $f.zoneOffset; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tmp = layout; _tmp$1 = value; alayout = _tmp; avalue = _tmp$1;
- rangeErrString = "";
- amSet = false;
- pmSet = false;
- year = 0;
- month = 1;
- day = 1;
- hour = 0;
- min = 0;
- sec = 0;
- nsec = 0;
- z = ptrType$1.nil;
- zoneOffset = -1;
- zoneName = "";
- while (true) {
- err = $ifaceNil;
- _tuple$1 = nextStdChunk(layout); prefix = _tuple$1[0]; std = _tuple$1[1]; suffix = _tuple$1[2];
- stdstr = layout.substring(prefix.length, (layout.length - suffix.length >> 0));
- _tuple$2 = skip(value, prefix); value = _tuple$2[0]; err = _tuple$2[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, prefix, value, "")];
- }
- if (std === 0) {
- if (!((value.length === 0))) {
- return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, "", value, ": extra text: " + value)];
- }
- break;
- }
- layout = suffix;
- p = "";
- _ref = std & 65535;
- switch (0) { default: if (_ref === 274) {
- if (value.length < 2) {
- err = errBad;
- break;
- }
- _tmp$2 = value.substring(0, 2); _tmp$3 = value.substring(2); p = _tmp$2; value = _tmp$3;
- _tuple$3 = atoi(p); year = _tuple$3[0]; err = _tuple$3[1];
- if (year >= 69) {
- year = year + (1900) >> 0;
- } else {
- year = year + (2000) >> 0;
- }
- } else if (_ref === 273) {
- if (value.length < 4 || !isDigit(value, 0)) {
- err = errBad;
- break;
- }
- _tmp$4 = value.substring(0, 4); _tmp$5 = value.substring(4); p = _tmp$4; value = _tmp$5;
- _tuple$4 = atoi(p); year = _tuple$4[0]; err = _tuple$4[1];
- } else if (_ref === 258) {
- _tuple$5 = lookup(shortMonthNames, value); month = _tuple$5[0]; value = _tuple$5[1]; err = _tuple$5[2];
- } else if (_ref === 257) {
- _tuple$6 = lookup(longMonthNames, value); month = _tuple$6[0]; value = _tuple$6[1]; err = _tuple$6[2];
- } else if (_ref === 259 || _ref === 260) {
- _tuple$7 = getnum(value, std === 260); month = _tuple$7[0]; value = _tuple$7[1]; err = _tuple$7[2];
- if (month <= 0 || 12 < month) {
- rangeErrString = "month";
- }
- } else if (_ref === 262) {
- _tuple$8 = lookup(shortDayNames, value); value = _tuple$8[1]; err = _tuple$8[2];
- } else if (_ref === 261) {
- _tuple$9 = lookup(longDayNames, value); value = _tuple$9[1]; err = _tuple$9[2];
- } else if (_ref === 263 || _ref === 264 || _ref === 265) {
- if ((std === 264) && value.length > 0 && (value.charCodeAt(0) === 32)) {
- value = value.substring(1);
- }
- _tuple$10 = getnum(value, std === 265); day = _tuple$10[0]; value = _tuple$10[1]; err = _tuple$10[2];
- if (day < 0 || 31 < day) {
- rangeErrString = "day";
- }
- } else if (_ref === 522) {
- _tuple$11 = getnum(value, false); hour = _tuple$11[0]; value = _tuple$11[1]; err = _tuple$11[2];
- if (hour < 0 || 24 <= hour) {
- rangeErrString = "hour";
- }
- } else if (_ref === 523 || _ref === 524) {
- _tuple$12 = getnum(value, std === 524); hour = _tuple$12[0]; value = _tuple$12[1]; err = _tuple$12[2];
- if (hour < 0 || 12 < hour) {
- rangeErrString = "hour";
- }
- } else if (_ref === 525 || _ref === 526) {
- _tuple$13 = getnum(value, std === 526); min = _tuple$13[0]; value = _tuple$13[1]; err = _tuple$13[2];
- if (min < 0 || 60 <= min) {
- rangeErrString = "minute";
- }
- } else if (_ref === 527 || _ref === 528) {
- _tuple$14 = getnum(value, std === 528); sec = _tuple$14[0]; value = _tuple$14[1]; err = _tuple$14[2];
- if (sec < 0 || 60 <= sec) {
- rangeErrString = "second";
- }
- if (value.length >= 2 && (value.charCodeAt(0) === 46) && isDigit(value, 1)) {
- _tuple$15 = nextStdChunk(layout); std = _tuple$15[1];
- std = std & (65535);
- if ((std === 31) || (std === 32)) {
- break;
- }
- n = 2;
- while (true) {
- if (!(n < value.length && isDigit(value, n))) { break; }
- n = n + (1) >> 0;
- }
- _tuple$16 = parseNanoseconds(value, n); nsec = _tuple$16[0]; rangeErrString = _tuple$16[1]; err = _tuple$16[2];
- value = value.substring(n);
- }
- } else if (_ref === 531) {
- if (value.length < 2) {
- err = errBad;
- break;
- }
- _tmp$6 = value.substring(0, 2); _tmp$7 = value.substring(2); p = _tmp$6; value = _tmp$7;
- _ref$1 = p;
- if (_ref$1 === "PM") {
- pmSet = true;
- } else if (_ref$1 === "AM") {
- amSet = true;
- } else {
- err = errBad;
- }
- } else if (_ref === 532) {
- if (value.length < 2) {
- err = errBad;
- break;
- }
- _tmp$8 = value.substring(0, 2); _tmp$9 = value.substring(2); p = _tmp$8; value = _tmp$9;
- _ref$2 = p;
- if (_ref$2 === "pm") {
- pmSet = true;
- } else if (_ref$2 === "am") {
- amSet = true;
- } else {
- err = errBad;
- }
- } else if (_ref === 22 || _ref === 24 || _ref === 23 || _ref === 25 || _ref === 26 || _ref === 28 || _ref === 29 || _ref === 27 || _ref === 30) {
- if (((std === 22) || (std === 24)) && value.length >= 1 && (value.charCodeAt(0) === 90)) {
- value = value.substring(1);
- z = $pkg.UTC;
- break;
- }
- _tmp$10 = ""; _tmp$11 = ""; _tmp$12 = ""; _tmp$13 = ""; sign = _tmp$10; hour$1 = _tmp$11; min$1 = _tmp$12; seconds = _tmp$13;
- if ((std === 24) || (std === 29)) {
- if (value.length < 6) {
- err = errBad;
- break;
- }
- if (!((value.charCodeAt(3) === 58))) {
- err = errBad;
- break;
- }
- _tmp$14 = value.substring(0, 1); _tmp$15 = value.substring(1, 3); _tmp$16 = value.substring(4, 6); _tmp$17 = "00"; _tmp$18 = value.substring(6); sign = _tmp$14; hour$1 = _tmp$15; min$1 = _tmp$16; seconds = _tmp$17; value = _tmp$18;
- } else if (std === 28) {
- if (value.length < 3) {
- err = errBad;
- break;
- }
- _tmp$19 = value.substring(0, 1); _tmp$20 = value.substring(1, 3); _tmp$21 = "00"; _tmp$22 = "00"; _tmp$23 = value.substring(3); sign = _tmp$19; hour$1 = _tmp$20; min$1 = _tmp$21; seconds = _tmp$22; value = _tmp$23;
- } else if ((std === 25) || (std === 30)) {
- if (value.length < 9) {
- err = errBad;
- break;
- }
- if (!((value.charCodeAt(3) === 58)) || !((value.charCodeAt(6) === 58))) {
- err = errBad;
- break;
- }
- _tmp$24 = value.substring(0, 1); _tmp$25 = value.substring(1, 3); _tmp$26 = value.substring(4, 6); _tmp$27 = value.substring(7, 9); _tmp$28 = value.substring(9); sign = _tmp$24; hour$1 = _tmp$25; min$1 = _tmp$26; seconds = _tmp$27; value = _tmp$28;
- } else if ((std === 23) || (std === 27)) {
- if (value.length < 7) {
- err = errBad;
- break;
- }
- _tmp$29 = value.substring(0, 1); _tmp$30 = value.substring(1, 3); _tmp$31 = value.substring(3, 5); _tmp$32 = value.substring(5, 7); _tmp$33 = value.substring(7); sign = _tmp$29; hour$1 = _tmp$30; min$1 = _tmp$31; seconds = _tmp$32; value = _tmp$33;
- } else {
- if (value.length < 5) {
- err = errBad;
- break;
- }
- _tmp$34 = value.substring(0, 1); _tmp$35 = value.substring(1, 3); _tmp$36 = value.substring(3, 5); _tmp$37 = "00"; _tmp$38 = value.substring(5); sign = _tmp$34; hour$1 = _tmp$35; min$1 = _tmp$36; seconds = _tmp$37; value = _tmp$38;
- }
- _tmp$39 = 0; _tmp$40 = 0; _tmp$41 = 0; hr = _tmp$39; mm = _tmp$40; ss = _tmp$41;
- _tuple$17 = atoi(hour$1); hr = _tuple$17[0]; err = _tuple$17[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- _tuple$18 = atoi(min$1); mm = _tuple$18[0]; err = _tuple$18[1];
- }
- if ($interfaceIsEqual(err, $ifaceNil)) {
- _tuple$19 = atoi(seconds); ss = _tuple$19[0]; err = _tuple$19[1];
- }
- zoneOffset = ((((hr * 60 >> 0) + mm >> 0)) * 60 >> 0) + ss >> 0;
- _ref$3 = sign.charCodeAt(0);
- if (_ref$3 === 43) {
- } else if (_ref$3 === 45) {
- zoneOffset = -zoneOffset;
- } else {
- err = errBad;
- }
- } else if (_ref === 21) {
- if (value.length >= 3 && value.substring(0, 3) === "UTC") {
- z = $pkg.UTC;
- value = value.substring(3);
- break;
- }
- _tuple$20 = parseTimeZone(value); n$1 = _tuple$20[0]; ok = _tuple$20[1];
- if (!ok) {
- err = errBad;
- break;
- }
- _tmp$42 = value.substring(0, n$1); _tmp$43 = value.substring(n$1); zoneName = _tmp$42; value = _tmp$43;
- } else if (_ref === 31) {
- ndigit = 1 + ((std >> 16 >> 0)) >> 0;
- if (value.length < ndigit) {
- err = errBad;
- break;
- }
- _tuple$21 = parseNanoseconds(value, ndigit); nsec = _tuple$21[0]; rangeErrString = _tuple$21[1]; err = _tuple$21[2];
- value = value.substring(ndigit);
- } else if (_ref === 32) {
- if (value.length < 2 || !((value.charCodeAt(0) === 46)) || value.charCodeAt(1) < 48 || 57 < value.charCodeAt(1)) {
- break;
- }
- i = 0;
- while (true) {
- if (!(i < 9 && (i + 1 >> 0) < value.length && 48 <= value.charCodeAt((i + 1 >> 0)) && value.charCodeAt((i + 1 >> 0)) <= 57)) { break; }
- i = i + (1) >> 0;
- }
- _tuple$22 = parseNanoseconds(value, 1 + i >> 0); nsec = _tuple$22[0]; rangeErrString = _tuple$22[1]; err = _tuple$22[2];
- value = value.substring((1 + i >> 0));
- } }
- if (!(rangeErrString === "")) {
- return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, stdstr, value, ": " + rangeErrString + " out of range")];
- }
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, stdstr, value, "")];
- }
- }
- if (pmSet && hour < 12) {
- hour = hour + (12) >> 0;
- } else if (amSet && (hour === 12)) {
- hour = 0;
- }
- /* */ if (!(z === ptrType$1.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(z === ptrType$1.nil)) { */ case 1:
- _r$1 = Date(year, (month >> 0), day, hour, min, sec, nsec, z); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return [_r$1, $ifaceNil];
- /* } */ case 2:
- /* */ if (!((zoneOffset === -1))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!((zoneOffset === -1))) { */ case 4:
- _r$2 = Date(year, (month >> 0), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- t = $clone(_r$2, Time);
- t.sec = (x = t.sec, x$1 = new $Int64(0, zoneOffset), new $Int64(x.$high - x$1.$high, x.$low - x$1.$low));
- _r$3 = local.lookup((x$2 = t.sec, new $Int64(x$2.$high + -15, x$2.$low + 2288912640))); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$23 = _r$3; name = _tuple$23[0]; offset = _tuple$23[1];
- if ((offset === zoneOffset) && (zoneName === "" || name === zoneName)) {
- t.loc = local;
- return [t, $ifaceNil];
- }
- t.loc = FixedZone(zoneName, zoneOffset);
- return [t, $ifaceNil];
- /* } */ case 5:
- /* */ if (!(zoneName === "")) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!(zoneName === "")) { */ case 8:
- _r$4 = Date(year, (month >> 0), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- t$1 = $clone(_r$4, Time);
- _r$5 = local.lookupName(zoneName, (x$3 = t$1.sec, new $Int64(x$3.$high + -15, x$3.$low + 2288912640))); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _tuple$24 = _r$5; offset$1 = _tuple$24[0]; ok$1 = _tuple$24[2];
- if (ok$1) {
- t$1.sec = (x$4 = t$1.sec, x$5 = new $Int64(0, offset$1), new $Int64(x$4.$high - x$5.$high, x$4.$low - x$5.$low));
- t$1.loc = local;
- return [t$1, $ifaceNil];
- }
- if (zoneName.length > 3 && zoneName.substring(0, 3) === "GMT") {
- _tuple$25 = atoi(zoneName.substring(3)); offset$1 = _tuple$25[0];
- offset$1 = offset$1 * (3600) >> 0;
- }
- t$1.loc = FixedZone(zoneName, offset$1);
- return [t$1, $ifaceNil];
- /* } */ case 9:
- _r$6 = Date(year, (month >> 0), day, hour, min, sec, nsec, defaultLocation); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return [_r$6, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parse }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$17 = _tmp$17; $f._tmp$18 = _tmp$18; $f._tmp$19 = _tmp$19; $f._tmp$2 = _tmp$2; $f._tmp$20 = _tmp$20; $f._tmp$21 = _tmp$21; $f._tmp$22 = _tmp$22; $f._tmp$23 = _tmp$23; $f._tmp$24 = _tmp$24; $f._tmp$25 = _tmp$25; $f._tmp$26 = _tmp$26; $f._tmp$27 = _tmp$27; $f._tmp$28 = _tmp$28; $f._tmp$29 = _tmp$29; $f._tmp$3 = _tmp$3; $f._tmp$30 = _tmp$30; $f._tmp$31 = _tmp$31; $f._tmp$32 = _tmp$32; $f._tmp$33 = _tmp$33; $f._tmp$34 = _tmp$34; $f._tmp$35 = _tmp$35; $f._tmp$36 = _tmp$36; $f._tmp$37 = _tmp$37; $f._tmp$38 = _tmp$38; $f._tmp$39 = _tmp$39; $f._tmp$4 = _tmp$4; $f._tmp$40 = _tmp$40; $f._tmp$41 = _tmp$41; $f._tmp$42 = _tmp$42; $f._tmp$43 = _tmp$43; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$11 = _tuple$11; $f._tuple$12 = _tuple$12; $f._tuple$13 = _tuple$13; $f._tuple$14 = _tuple$14; $f._tuple$15 = _tuple$15; $f._tuple$16 = _tuple$16; $f._tuple$17 = _tuple$17; $f._tuple$18 = _tuple$18; $f._tuple$19 = _tuple$19; $f._tuple$2 = _tuple$2; $f._tuple$20 = _tuple$20; $f._tuple$21 = _tuple$21; $f._tuple$22 = _tuple$22; $f._tuple$23 = _tuple$23; $f._tuple$24 = _tuple$24; $f._tuple$25 = _tuple$25; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.alayout = alayout; $f.amSet = amSet; $f.avalue = avalue; $f.day = day; $f.defaultLocation = defaultLocation; $f.err = err; $f.hour = hour; $f.hour$1 = hour$1; $f.hr = hr; $f.i = i; $f.layout = layout; $f.local = local; $f.min = min; $f.min$1 = min$1; $f.mm = mm; $f.month = month; $f.n = n; $f.n$1 = n$1; $f.name = name; $f.ndigit = ndigit; $f.nsec = nsec; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.pmSet = pmSet; $f.prefix = prefix; $f.rangeErrString = rangeErrString; $f.sec = sec; $f.seconds = seconds; $f.sign = sign; $f.ss = ss; $f.std = std; $f.stdstr = stdstr; $f.suffix = suffix; $f.t = t; $f.t$1 = t$1; $f.value = value; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.year = year; $f.z = z; $f.zoneName = zoneName; $f.zoneOffset = zoneOffset; $f.$s = $s; $f.$r = $r; return $f;
- };
- parseTimeZone = function(value) {
- var $ptr, _ref, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, c, length, nUpper, ok, value;
- length = 0;
- ok = false;
- if (value.length < 3) {
- _tmp = 0; _tmp$1 = false; length = _tmp; ok = _tmp$1;
- return [length, ok];
- }
- if (value.length >= 4 && (value.substring(0, 4) === "ChST" || value.substring(0, 4) === "MeST")) {
- _tmp$2 = 4; _tmp$3 = true; length = _tmp$2; ok = _tmp$3;
- return [length, ok];
- }
- if (value.substring(0, 3) === "GMT") {
- length = parseGMT(value);
- _tmp$4 = length; _tmp$5 = true; length = _tmp$4; ok = _tmp$5;
- return [length, ok];
- }
- nUpper = 0;
- nUpper = 0;
- while (true) {
- if (!(nUpper < 6)) { break; }
- if (nUpper >= value.length) {
- break;
- }
- c = value.charCodeAt(nUpper);
- if (c < 65 || 90 < c) {
- break;
- }
- nUpper = nUpper + (1) >> 0;
- }
- _ref = nUpper;
- if (_ref === 0 || _ref === 1 || _ref === 2 || _ref === 6) {
- _tmp$6 = 0; _tmp$7 = false; length = _tmp$6; ok = _tmp$7;
- return [length, ok];
- } else if (_ref === 5) {
- if (value.charCodeAt(4) === 84) {
- _tmp$8 = 5; _tmp$9 = true; length = _tmp$8; ok = _tmp$9;
- return [length, ok];
- }
- } else if (_ref === 4) {
- if (value.charCodeAt(3) === 84) {
- _tmp$10 = 4; _tmp$11 = true; length = _tmp$10; ok = _tmp$11;
- return [length, ok];
- }
- } else if (_ref === 3) {
- _tmp$12 = 3; _tmp$13 = true; length = _tmp$12; ok = _tmp$13;
- return [length, ok];
- }
- _tmp$14 = 0; _tmp$15 = false; length = _tmp$14; ok = _tmp$15;
- return [length, ok];
- };
- parseGMT = function(value) {
- var $ptr, _tuple$1, err, rem, sign, value, x;
- value = value.substring(3);
- if (value.length === 0) {
- return 3;
- }
- sign = value.charCodeAt(0);
- if (!((sign === 45)) && !((sign === 43))) {
- return 3;
- }
- _tuple$1 = leadingInt(value.substring(1)); x = _tuple$1[0]; rem = _tuple$1[1]; err = _tuple$1[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return 3;
- }
- if (sign === 45) {
- x = new $Int64(-x.$high, -x.$low);
- }
- if ((x.$high === 0 && x.$low === 0) || (x.$high < -1 || (x.$high === -1 && x.$low < 4294967282)) || (0 < x.$high || (0 === x.$high && 12 < x.$low))) {
- return 3;
- }
- return (3 + value.length >> 0) - rem.length >> 0;
- };
- parseNanoseconds = function(value, nbytes) {
- var $ptr, _tuple$1, err, i, nbytes, ns, rangeErrString, scaleDigits, value;
- ns = 0;
- rangeErrString = "";
- err = $ifaceNil;
- if (!((value.charCodeAt(0) === 46))) {
- err = errBad;
- return [ns, rangeErrString, err];
- }
- _tuple$1 = atoi(value.substring(1, nbytes)); ns = _tuple$1[0]; err = _tuple$1[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [ns, rangeErrString, err];
- }
- if (ns < 0 || 1000000000 <= ns) {
- rangeErrString = "fractional second";
- return [ns, rangeErrString, err];
- }
- scaleDigits = 10 - nbytes >> 0;
- i = 0;
- while (true) {
- if (!(i < scaleDigits)) { break; }
- ns = ns * (10) >> 0;
- i = i + (1) >> 0;
- }
- return [ns, rangeErrString, err];
- };
- leadingInt = function(s) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, c, err, i, rem, s, x, x$1, x$2, x$3;
- x = new $Int64(0, 0);
- rem = "";
- err = $ifaceNil;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- c = s.charCodeAt(i);
- if (c < 48 || c > 57) {
- break;
- }
- if ((x.$high > 214748364 || (x.$high === 214748364 && x.$low >= 3435973835))) {
- _tmp = new $Int64(0, 0); _tmp$1 = ""; _tmp$2 = errLeadingInt; x = _tmp; rem = _tmp$1; err = _tmp$2;
- return [x, rem, err];
- }
- x = (x$1 = (x$2 = $mul64(x, new $Int64(0, 10)), x$3 = new $Int64(0, c), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)), new $Int64(x$1.$high - 0, x$1.$low - 48));
- i = i + (1) >> 0;
- }
- _tmp$3 = x; _tmp$4 = s.substring(i); _tmp$5 = $ifaceNil; x = _tmp$3; rem = _tmp$4; err = _tmp$5;
- return [x, rem, err];
- };
- ParseDuration = function(s) {
- var $ptr, _entry, _tuple$1, _tuple$2, _tuple$3, c, c$1, err, f, g, i, n, neg, ok, orig, pl, pl$1, post, pre, s, scale, u, unit, x;
- orig = s;
- f = 0;
- neg = false;
- if (!(s === "")) {
- c = s.charCodeAt(0);
- if ((c === 45) || (c === 43)) {
- neg = c === 45;
- s = s.substring(1);
- }
- }
- if (s === "0") {
- return [new Duration(0, 0), $ifaceNil];
- }
- if (s === "") {
- return [new Duration(0, 0), errors.New("time: invalid duration " + orig)];
- }
- while (true) {
- if (!(!(s === ""))) { break; }
- g = 0;
- x = new $Int64(0, 0);
- err = $ifaceNil;
- if (!((s.charCodeAt(0) === 46) || (48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57))) {
- return [new Duration(0, 0), errors.New("time: invalid duration " + orig)];
- }
- pl = s.length;
- _tuple$1 = leadingInt(s); x = _tuple$1[0]; s = _tuple$1[1]; err = _tuple$1[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [new Duration(0, 0), errors.New("time: invalid duration " + orig)];
- }
- g = $flatten64(x);
- pre = !((pl === s.length));
- post = false;
- if (!(s === "") && (s.charCodeAt(0) === 46)) {
- s = s.substring(1);
- pl$1 = s.length;
- _tuple$2 = leadingInt(s); x = _tuple$2[0]; s = _tuple$2[1]; err = _tuple$2[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [new Duration(0, 0), errors.New("time: invalid duration " + orig)];
- }
- scale = 1;
- n = pl$1 - s.length >> 0;
- while (true) {
- if (!(n > 0)) { break; }
- scale = scale * (10);
- n = n - (1) >> 0;
- }
- g = g + ($flatten64(x) / scale);
- post = !((pl$1 === s.length));
- }
- if (!pre && !post) {
- return [new Duration(0, 0), errors.New("time: invalid duration " + orig)];
- }
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- c$1 = s.charCodeAt(i);
- if ((c$1 === 46) || (48 <= c$1 && c$1 <= 57)) {
- break;
- }
- i = i + (1) >> 0;
- }
- if (i === 0) {
- return [new Duration(0, 0), errors.New("time: missing unit in duration " + orig)];
- }
- u = s.substring(0, i);
- s = s.substring(i);
- _tuple$3 = (_entry = unitMap[$String.keyFor(u)], _entry !== undefined ? [_entry.v, true] : [0, false]); unit = _tuple$3[0]; ok = _tuple$3[1];
- if (!ok) {
- return [new Duration(0, 0), errors.New("time: unknown unit " + u + " in duration " + orig)];
- }
- f = f + (g * unit);
- }
- if (neg) {
- f = -f;
- }
- if (f < -9.223372036854776e+18 || f > 9.223372036854776e+18) {
- return [new Duration(0, 0), errors.New("time: overflow parsing duration")];
- }
- return [new Duration(0, f), $ifaceNil];
- };
- $pkg.ParseDuration = ParseDuration;
- when = function(d) {
- var $ptr, d, t, x, x$1;
- if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) {
- return runtimeNano();
- }
- t = (x = runtimeNano(), x$1 = new $Int64(d.$high, d.$low), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low));
- if ((t.$high < 0 || (t.$high === 0 && t.$low < 0))) {
- t = new $Int64(2147483647, 4294967295);
- }
- return t;
- };
- Timer.ptr.prototype.Stop = function() {
- var $ptr, t;
- t = this;
- if (t.r.f === $throwNilPointerError) {
- $panic(new $String("time: Stop called on uninitialized Timer"));
- }
- return stopTimer(t.r);
- };
- Timer.prototype.Stop = function() { return this.$val.Stop(); };
- Timer.ptr.prototype.Reset = function(d) {
- var $ptr, active, d, t, w;
- t = this;
- if (t.r.f === $throwNilPointerError) {
- $panic(new $String("time: Reset called on uninitialized Timer"));
- }
- w = when(d);
- active = stopTimer(t.r);
- t.r.when = w;
- startTimer(t.r);
- return active;
- };
- Timer.prototype.Reset = function(d) { return this.$val.Reset(d); };
- AfterFunc = function(d, f) {
- var $ptr, d, f, t;
- t = new Timer.ptr(chanType$2.nil, new runtimeTimer.ptr(0, when(d), new $Int64(0, 0), goFunc, new funcType(f), null, false));
- startTimer(t.r);
- return t;
- };
- $pkg.AfterFunc = AfterFunc;
- goFunc = function(arg, seq) {
- var $ptr, arg, seq;
- $go($assertType(arg, funcType), []);
- };
- Time.ptr.prototype.After = function(u) {
- var $ptr, t, u, x, x$1, x$2, x$3;
- t = $clone(this, Time);
- u = $clone(u, Time);
- return (x = t.sec, x$1 = u.sec, (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low > x$1.$low))) || (x$2 = t.sec, x$3 = u.sec, (x$2.$high === x$3.$high && x$2.$low === x$3.$low)) && t.nsec > u.nsec;
- };
- Time.prototype.After = function(u) { return this.$val.After(u); };
- Time.ptr.prototype.Before = function(u) {
- var $ptr, t, u, x, x$1, x$2, x$3;
- t = $clone(this, Time);
- u = $clone(u, Time);
- return (x = t.sec, x$1 = u.sec, (x.$high < x$1.$high || (x.$high === x$1.$high && x.$low < x$1.$low))) || (x$2 = t.sec, x$3 = u.sec, (x$2.$high === x$3.$high && x$2.$low === x$3.$low)) && t.nsec < u.nsec;
- };
- Time.prototype.Before = function(u) { return this.$val.Before(u); };
- Time.ptr.prototype.Equal = function(u) {
- var $ptr, t, u, x, x$1;
- t = $clone(this, Time);
- u = $clone(u, Time);
- return (x = t.sec, x$1 = u.sec, (x.$high === x$1.$high && x.$low === x$1.$low)) && (t.nsec === u.nsec);
- };
- Time.prototype.Equal = function(u) { return this.$val.Equal(u); };
- Month.prototype.String = function() {
- var $ptr, m, x;
- m = this.$val;
- return (x = m - 1 >> 0, ((x < 0 || x >= months.length) ? $throwRuntimeError("index out of range") : months[x]));
- };
- $ptrType(Month).prototype.String = function() { return new Month(this.$get()).String(); };
- Weekday.prototype.String = function() {
- var $ptr, d;
- d = this.$val;
- return ((d < 0 || d >= days.length) ? $throwRuntimeError("index out of range") : days[d]);
- };
- $ptrType(Weekday).prototype.String = function() { return new Weekday(this.$get()).String(); };
- Time.ptr.prototype.IsZero = function() {
- var $ptr, t, x;
- t = $clone(this, Time);
- return (x = t.sec, (x.$high === 0 && x.$low === 0)) && (t.nsec === 0);
- };
- Time.prototype.IsZero = function() { return this.$val.IsZero(); };
- Time.ptr.prototype.abs = function() {
- var $ptr, _r$1, _r$2, _tuple$1, l, offset, sec, t, x, x$1, x$2, x$3, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; l = $f.l; offset = $f.offset; sec = $f.sec; t = $f.t; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- l = t.loc;
- /* */ if (l === ptrType$1.nil || l === localLoc) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (l === ptrType$1.nil || l === localLoc) { */ case 1:
- _r$1 = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- l = _r$1;
- /* } */ case 2:
- sec = (x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640));
- /* */ if (!(l === utcLoc)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(l === utcLoc)) { */ case 4:
- /* */ if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { */ case 6:
- sec = (x$3 = new $Int64(0, l.cacheZone.offset), new $Int64(sec.$high + x$3.$high, sec.$low + x$3.$low));
- $s = 8; continue;
- /* } else { */ case 7:
- _r$2 = l.lookup(sec); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; offset = _tuple$1[1];
- sec = (x$4 = new $Int64(0, offset), new $Int64(sec.$high + x$4.$high, sec.$low + x$4.$low));
- /* } */ case 8:
- /* } */ case 5:
- return (x$5 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$5.$high, x$5.$low));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.abs }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.l = l; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.abs = function() { return this.$val.abs(); };
- Time.ptr.prototype.locabs = function() {
- var $ptr, _r$1, _r$2, _tuple$1, abs, l, name, offset, sec, t, x, x$1, x$2, x$3, x$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; abs = $f.abs; l = $f.l; name = $f.name; offset = $f.offset; sec = $f.sec; t = $f.t; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- name = "";
- offset = 0;
- abs = new $Uint64(0, 0);
- t = $clone(this, Time);
- l = t.loc;
- /* */ if (l === ptrType$1.nil || l === localLoc) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (l === ptrType$1.nil || l === localLoc) { */ case 1:
- _r$1 = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- l = _r$1;
- /* } */ case 2:
- sec = (x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640));
- /* */ if (!(l === utcLoc)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(l === utcLoc)) { */ case 4:
- /* */ if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!(l.cacheZone === ptrType.nil) && (x$1 = l.cacheStart, (x$1.$high < sec.$high || (x$1.$high === sec.$high && x$1.$low <= sec.$low))) && (x$2 = l.cacheEnd, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { */ case 7:
- name = l.cacheZone.name;
- offset = l.cacheZone.offset;
- $s = 9; continue;
- /* } else { */ case 8:
- _r$2 = l.lookup(sec); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; name = _tuple$1[0]; offset = _tuple$1[1];
- /* } */ case 9:
- sec = (x$3 = new $Int64(0, offset), new $Int64(sec.$high + x$3.$high, sec.$low + x$3.$low));
- $s = 6; continue;
- /* } else { */ case 5:
- name = "UTC";
- /* } */ case 6:
- abs = (x$4 = new $Int64(sec.$high + 2147483646, sec.$low + 450480384), new $Uint64(x$4.$high, x$4.$low));
- return [name, offset, abs];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.locabs }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.abs = abs; $f.l = l; $f.name = name; $f.offset = offset; $f.sec = sec; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.locabs = function() { return this.$val.locabs(); };
- Time.ptr.prototype.Date = function() {
- var $ptr, _r$1, _tuple$1, day, month, t, year, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; day = $f.day; month = $f.month; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- year = 0;
- month = 0;
- day = 0;
- t = $clone(this, Time);
- _r$1 = t.date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; year = _tuple$1[0]; month = _tuple$1[1]; day = _tuple$1[2];
- return [year, month, day];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Date }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.day = day; $f.month = month; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Date = function() { return this.$val.Date(); };
- Time.ptr.prototype.Year = function() {
- var $ptr, _r$1, _tuple$1, t, year, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; year = _tuple$1[0];
- return year;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Year }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.t = t; $f.year = year; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Year = function() { return this.$val.Year(); };
- Time.ptr.prototype.Month = function() {
- var $ptr, _r$1, _tuple$1, month, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; month = $f.month; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; month = _tuple$1[1];
- return month;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Month }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.month = month; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Month = function() { return this.$val.Month(); };
- Time.ptr.prototype.Day = function() {
- var $ptr, _r$1, _tuple$1, day, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; day = $f.day; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; day = _tuple$1[2];
- return day;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Day }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.day = day; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Day = function() { return this.$val.Day(); };
- Time.ptr.prototype.Weekday = function() {
- var $ptr, _r$1, _r$2, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = absWeekday(_r$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Weekday }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Weekday = function() { return this.$val.Weekday(); };
- absWeekday = function(abs) {
- var $ptr, _q, abs, sec;
- sec = $div64((new $Uint64(abs.$high + 0, abs.$low + 86400)), new $Uint64(0, 604800), true);
- return ((_q = (sec.$low >> 0) / 86400, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0);
- };
- Time.ptr.prototype.ISOWeek = function() {
- var $ptr, _q, _r$1, _r$2, _r$3, _r$4, _r$5, _tuple$1, day, dec31wday, jan1wday, month, t, wday, week, yday, year, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple$1 = $f._tuple$1; day = $f.day; dec31wday = $f.dec31wday; jan1wday = $f.jan1wday; month = $f.month; t = $f.t; wday = $f.wday; week = $f.week; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- year = 0;
- week = 0;
- t = $clone(this, Time);
- _r$1 = t.date(true); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; year = _tuple$1[0]; month = _tuple$1[1]; day = _tuple$1[2]; yday = _tuple$1[3];
- _r$3 = t.Weekday(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- wday = (_r$2 = ((_r$3 + 6 >> 0) >> 0) % 7, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero"));
- week = (_q = (((yday - wday >> 0) + 7 >> 0)) / 7, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- jan1wday = (_r$4 = (((wday - yday >> 0) + 371 >> 0)) % 7, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero"));
- if (1 <= jan1wday && jan1wday <= 3) {
- week = week + (1) >> 0;
- }
- if (week === 0) {
- year = year - (1) >> 0;
- week = 52;
- if ((jan1wday === 4) || ((jan1wday === 5) && isLeap(year))) {
- week = week + (1) >> 0;
- }
- }
- if ((month === 12) && day >= 29 && wday < 3) {
- dec31wday = (_r$5 = (((wday + 31 >> 0) - day >> 0)) % 7, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero"));
- if (0 <= dec31wday && dec31wday <= 2) {
- year = year + (1) >> 0;
- week = 1;
- }
- }
- return [year, week];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.ISOWeek }; } $f.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple$1 = _tuple$1; $f.day = day; $f.dec31wday = dec31wday; $f.jan1wday = jan1wday; $f.month = month; $f.t = t; $f.wday = wday; $f.week = week; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.ISOWeek = function() { return this.$val.ISOWeek(); };
- Time.ptr.prototype.Clock = function() {
- var $ptr, _r$1, _r$2, _tuple$1, hour, min, sec, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; hour = $f.hour; min = $f.min; sec = $f.sec; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- hour = 0;
- min = 0;
- sec = 0;
- t = $clone(this, Time);
- _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = absClock(_r$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; hour = _tuple$1[0]; min = _tuple$1[1]; sec = _tuple$1[2];
- return [hour, min, sec];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Clock }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.hour = hour; $f.min = min; $f.sec = sec; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Clock = function() { return this.$val.Clock(); };
- absClock = function(abs) {
- var $ptr, _q, _q$1, abs, hour, min, sec;
- hour = 0;
- min = 0;
- sec = 0;
- sec = ($div64(abs, new $Uint64(0, 86400), true).$low >> 0);
- hour = (_q = sec / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- sec = sec - ((hour * 3600 >> 0)) >> 0;
- min = (_q$1 = sec / 60, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"));
- sec = sec - ((min * 60 >> 0)) >> 0;
- return [hour, min, sec];
- };
- Time.ptr.prototype.Hour = function() {
- var $ptr, _q, _r$1, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return (_q = ($div64(_r$1, new $Uint64(0, 86400), true).$low >> 0) / 3600, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Hour }; } $f.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Hour = function() { return this.$val.Hour(); };
- Time.ptr.prototype.Minute = function() {
- var $ptr, _q, _r$1, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return (_q = ($div64(_r$1, new $Uint64(0, 3600), true).$low >> 0) / 60, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Minute }; } $f.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Minute = function() { return this.$val.Minute(); };
- Time.ptr.prototype.Second = function() {
- var $ptr, _r$1, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return ($div64(_r$1, new $Uint64(0, 60), true).$low >> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Second }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Second = function() { return this.$val.Second(); };
- Time.ptr.prototype.Nanosecond = function() {
- var $ptr, t;
- t = $clone(this, Time);
- return (t.nsec >> 0);
- };
- Time.prototype.Nanosecond = function() { return this.$val.Nanosecond(); };
- Time.ptr.prototype.YearDay = function() {
- var $ptr, _r$1, _tuple$1, t, yday, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; t = $f.t; yday = $f.yday; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.date(false); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; yday = _tuple$1[3];
- return yday + 1 >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.YearDay }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.t = t; $f.yday = yday; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.YearDay = function() { return this.$val.YearDay(); };
- Duration.prototype.String = function() {
- var $ptr, _tuple$1, _tuple$2, buf, d, neg, prec, u, w;
- d = this;
- buf = $clone(arrayType.zero(), arrayType);
- w = 32;
- u = new $Uint64(d.$high, d.$low);
- neg = (d.$high < 0 || (d.$high === 0 && d.$low < 0));
- if (neg) {
- u = new $Uint64(-u.$high, -u.$low);
- }
- if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000000))) {
- prec = 0;
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 115);
- w = w - (1) >> 0;
- if ((u.$high === 0 && u.$low === 0)) {
- return "0";
- } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000))) {
- prec = 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 110);
- } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000000))) {
- prec = 3;
- w = w - (1) >> 0;
- $copyString($subslice(new sliceType$3(buf), w), "\xC2\xB5");
- } else {
- prec = 6;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 109);
- }
- _tuple$1 = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, prec); w = _tuple$1[0]; u = _tuple$1[1];
- w = fmtInt($subslice(new sliceType$3(buf), 0, w), u);
- } else {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 115);
- _tuple$2 = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, 9); w = _tuple$2[0]; u = _tuple$2[1];
- w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true));
- u = $div64(u, (new $Uint64(0, 60)), false);
- if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 109);
- w = fmtInt($subslice(new sliceType$3(buf), 0, w), $div64(u, new $Uint64(0, 60), true));
- u = $div64(u, (new $Uint64(0, 60)), false);
- if ((u.$high > 0 || (u.$high === 0 && u.$low > 0))) {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 104);
- w = fmtInt($subslice(new sliceType$3(buf), 0, w), u);
- }
- }
- }
- if (neg) {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 45);
- }
- return $bytesToString($subslice(new sliceType$3(buf), w));
- };
- $ptrType(Duration).prototype.String = function() { return this.$get().String(); };
- fmtFrac = function(buf, v, prec) {
- var $ptr, _tmp, _tmp$1, buf, digit, i, nv, nw, prec, print, v, w;
- nw = 0;
- nv = new $Uint64(0, 0);
- w = buf.$length;
- print = false;
- i = 0;
- while (true) {
- if (!(i < prec)) { break; }
- digit = $div64(v, new $Uint64(0, 10), true);
- print = print || !((digit.$high === 0 && digit.$low === 0));
- if (print) {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + w] = (digit.$low << 24 >>> 24) + 48 << 24 >>> 24);
- }
- v = $div64(v, (new $Uint64(0, 10)), false);
- i = i + (1) >> 0;
- }
- if (print) {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + w] = 46);
- }
- _tmp = w; _tmp$1 = v; nw = _tmp; nv = _tmp$1;
- return [nw, nv];
- };
- fmtInt = function(buf, v) {
- var $ptr, buf, v, w;
- w = buf.$length;
- if ((v.$high === 0 && v.$low === 0)) {
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + w] = 48);
- } else {
- while (true) {
- if (!((v.$high > 0 || (v.$high === 0 && v.$low > 0)))) { break; }
- w = w - (1) >> 0;
- ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + w] = ($div64(v, new $Uint64(0, 10), true).$low << 24 >>> 24) + 48 << 24 >>> 24);
- v = $div64(v, (new $Uint64(0, 10)), false);
- }
- }
- return w;
- };
- Duration.prototype.Nanoseconds = function() {
- var $ptr, d;
- d = this;
- return new $Int64(d.$high, d.$low);
- };
- $ptrType(Duration).prototype.Nanoseconds = function() { return this.$get().Nanoseconds(); };
- Duration.prototype.Seconds = function() {
- var $ptr, d, nsec, sec;
- d = this;
- sec = $div64(d, new Duration(0, 1000000000), false);
- nsec = $div64(d, new Duration(0, 1000000000), true);
- return $flatten64(sec) + $flatten64(nsec) * 1e-09;
- };
- $ptrType(Duration).prototype.Seconds = function() { return this.$get().Seconds(); };
- Duration.prototype.Minutes = function() {
- var $ptr, d, min, nsec;
- d = this;
- min = $div64(d, new Duration(13, 4165425152), false);
- nsec = $div64(d, new Duration(13, 4165425152), true);
- return $flatten64(min) + $flatten64(nsec) * 1.6666666666666667e-11;
- };
- $ptrType(Duration).prototype.Minutes = function() { return this.$get().Minutes(); };
- Duration.prototype.Hours = function() {
- var $ptr, d, hour, nsec;
- d = this;
- hour = $div64(d, new Duration(838, 817405952), false);
- nsec = $div64(d, new Duration(838, 817405952), true);
- return $flatten64(hour) + $flatten64(nsec) * 2.777777777777778e-13;
- };
- $ptrType(Duration).prototype.Hours = function() { return this.$get().Hours(); };
- Time.ptr.prototype.Add = function(d) {
- var $ptr, d, nsec, t, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7;
- t = $clone(this, Time);
- t.sec = (x = t.sec, x$1 = (x$2 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$2.$high, x$2.$low)), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low));
- nsec = t.nsec + ((x$3 = $div64(d, new Duration(0, 1000000000), true), x$3.$low + ((x$3.$high >> 31) * 4294967296)) >> 0) >> 0;
- if (nsec >= 1000000000) {
- t.sec = (x$4 = t.sec, x$5 = new $Int64(0, 1), new $Int64(x$4.$high + x$5.$high, x$4.$low + x$5.$low));
- nsec = nsec - (1000000000) >> 0;
- } else if (nsec < 0) {
- t.sec = (x$6 = t.sec, x$7 = new $Int64(0, 1), new $Int64(x$6.$high - x$7.$high, x$6.$low - x$7.$low));
- nsec = nsec + (1000000000) >> 0;
- }
- t.nsec = nsec;
- return t;
- };
- Time.prototype.Add = function(d) { return this.$val.Add(d); };
- Time.ptr.prototype.Sub = function(u) {
- var $ptr, d, t, u, x, x$1, x$2, x$3, x$4;
- t = $clone(this, Time);
- u = $clone(u, Time);
- d = (x = $mul64((x$1 = (x$2 = t.sec, x$3 = u.sec, new $Int64(x$2.$high - x$3.$high, x$2.$low - x$3.$low)), new Duration(x$1.$high, x$1.$low)), new Duration(0, 1000000000)), x$4 = new Duration(0, (t.nsec - u.nsec >> 0)), new Duration(x.$high + x$4.$high, x.$low + x$4.$low));
- if (u.Add(d).Equal(t)) {
- return d;
- } else if (t.Before(u)) {
- return new Duration(-2147483648, 0);
- } else {
- return new Duration(2147483647, 4294967295);
- }
- };
- Time.prototype.Sub = function(u) { return this.$val.Sub(u); };
- Time.ptr.prototype.AddDate = function(years, months$1, days$1) {
- var $ptr, _r$1, _r$2, _r$3, _tuple$1, _tuple$2, day, days$1, hour, min, month, months$1, sec, t, year, years, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; day = $f.day; days$1 = $f.days$1; hour = $f.hour; min = $f.min; month = $f.month; months$1 = $f.months$1; sec = $f.sec; t = $f.t; year = $f.year; years = $f.years; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.Date(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; year = _tuple$1[0]; month = _tuple$1[1]; day = _tuple$1[2];
- _r$2 = t.Clock(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$2 = _r$2; hour = _tuple$2[0]; min = _tuple$2[1]; sec = _tuple$2[2];
- _r$3 = Date(year + years >> 0, month + (months$1 >> 0) >> 0, day + days$1 >> 0, hour, min, sec, (t.nsec >> 0), t.loc); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AddDate }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.day = day; $f.days$1 = days$1; $f.hour = hour; $f.min = min; $f.month = month; $f.months$1 = months$1; $f.sec = sec; $f.t = t; $f.year = year; $f.years = years; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.AddDate = function(years, months$1, days$1) { return this.$val.AddDate(years, months$1, days$1); };
- Time.ptr.prototype.date = function(full) {
- var $ptr, _r$1, _r$2, _tuple$1, day, full, month, t, yday, year, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; day = $f.day; full = $f.full; month = $f.month; t = $f.t; yday = $f.yday; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- year = 0;
- month = 0;
- day = 0;
- yday = 0;
- t = $clone(this, Time);
- _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = absDate(_r$1, full); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; year = _tuple$1[0]; month = _tuple$1[1]; day = _tuple$1[2]; yday = _tuple$1[3];
- return [year, month, day, yday];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.date }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.day = day; $f.full = full; $f.month = month; $f.t = t; $f.yday = yday; $f.year = year; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.date = function(full) { return this.$val.date(full); };
- absDate = function(abs, full) {
- var $ptr, _q, abs, begin, d, day, end, full, month, n, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, yday, year;
- year = 0;
- month = 0;
- day = 0;
- yday = 0;
- d = $div64(abs, new $Uint64(0, 86400), false);
- n = $div64(d, new $Uint64(0, 146097), false);
- y = $mul64(new $Uint64(0, 400), n);
- d = (x = $mul64(new $Uint64(0, 146097), n), new $Uint64(d.$high - x.$high, d.$low - x.$low));
- n = $div64(d, new $Uint64(0, 36524), false);
- n = (x$1 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$1.$high, n.$low - x$1.$low));
- y = (x$2 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high + x$2.$high, y.$low + x$2.$low));
- d = (x$3 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high - x$3.$high, d.$low - x$3.$low));
- n = $div64(d, new $Uint64(0, 1461), false);
- y = (x$4 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high + x$4.$high, y.$low + x$4.$low));
- d = (x$5 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high - x$5.$high, d.$low - x$5.$low));
- n = $div64(d, new $Uint64(0, 365), false);
- n = (x$6 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$6.$high, n.$low - x$6.$low));
- y = (x$7 = n, new $Uint64(y.$high + x$7.$high, y.$low + x$7.$low));
- d = (x$8 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high - x$8.$high, d.$low - x$8.$low));
- year = ((x$9 = (x$10 = new $Int64(y.$high, y.$low), new $Int64(x$10.$high + -69, x$10.$low + 4075721025)), x$9.$low + ((x$9.$high >> 31) * 4294967296)) >> 0);
- yday = (d.$low >> 0);
- if (!full) {
- return [year, month, day, yday];
- }
- day = yday;
- if (isLeap(year)) {
- if (day > 59) {
- day = day - (1) >> 0;
- } else if (day === 59) {
- month = 2;
- day = 29;
- return [year, month, day, yday];
- }
- }
- month = ((_q = day / 31, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0);
- end = ((x$11 = month + 1 >> 0, ((x$11 < 0 || x$11 >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[x$11])) >> 0);
- begin = 0;
- if (day >= end) {
- month = month + (1) >> 0;
- begin = end;
- } else {
- begin = (((month < 0 || month >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[month]) >> 0);
- }
- month = month + (1) >> 0;
- day = (day - begin >> 0) + 1 >> 0;
- return [year, month, day, yday];
- };
- Time.ptr.prototype.UTC = function() {
- var $ptr, t;
- t = $clone(this, Time);
- t.loc = $pkg.UTC;
- return t;
- };
- Time.prototype.UTC = function() { return this.$val.UTC(); };
- Time.ptr.prototype.Local = function() {
- var $ptr, t;
- t = $clone(this, Time);
- t.loc = $pkg.Local;
- return t;
- };
- Time.prototype.Local = function() { return this.$val.Local(); };
- Time.ptr.prototype.In = function(loc) {
- var $ptr, loc, t;
- t = $clone(this, Time);
- if (loc === ptrType$1.nil) {
- $panic(new $String("time: missing Location in call to Time.In"));
- }
- t.loc = loc;
- return t;
- };
- Time.prototype.In = function(loc) { return this.$val.In(loc); };
- Time.ptr.prototype.Location = function() {
- var $ptr, l, t;
- t = $clone(this, Time);
- l = t.loc;
- if (l === ptrType$1.nil) {
- l = $pkg.UTC;
- }
- return l;
- };
- Time.prototype.Location = function() { return this.$val.Location(); };
- Time.ptr.prototype.Zone = function() {
- var $ptr, _r$1, _tuple$1, name, offset, t, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; name = $f.name; offset = $f.offset; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- name = "";
- offset = 0;
- t = $clone(this, Time);
- _r$1 = t.loc.lookup((x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640))); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; name = _tuple$1[0]; offset = _tuple$1[1];
- return [name, offset];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Zone }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.name = name; $f.offset = offset; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.Zone = function() { return this.$val.Zone(); };
- Time.ptr.prototype.Unix = function() {
- var $ptr, t, x;
- t = $clone(this, Time);
- return (x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640));
- };
- Time.prototype.Unix = function() { return this.$val.Unix(); };
- Time.ptr.prototype.UnixNano = function() {
- var $ptr, t, x, x$1, x$2;
- t = $clone(this, Time);
- return (x = $mul64(((x$1 = t.sec, new $Int64(x$1.$high + -15, x$1.$low + 2288912640))), new $Int64(0, 1000000000)), x$2 = new $Int64(0, t.nsec), new $Int64(x.$high + x$2.$high, x.$low + x$2.$low));
- };
- Time.prototype.UnixNano = function() { return this.$val.UnixNano(); };
- Time.ptr.prototype.MarshalBinary = function() {
- var $ptr, _q, _r$1, _r$2, _tuple$1, enc, offset, offsetMin, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; enc = $f.enc; offset = $f.offset; offsetMin = $f.offsetMin; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- offsetMin = 0;
- /* */ if (t.Location() === utcLoc) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (t.Location() === utcLoc) { */ case 1:
- offsetMin = -1;
- $s = 3; continue;
- /* } else { */ case 2:
- _r$1 = t.Zone(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; offset = _tuple$1[1];
- if (!(((_r$2 = offset % 60, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0))) {
- return [sliceType$3.nil, errors.New("Time.MarshalBinary: zone offset has fractional minute")];
- }
- offset = (_q = offset / (60), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- if (offset < -32768 || (offset === -1) || offset > 32767) {
- return [sliceType$3.nil, errors.New("Time.MarshalBinary: unexpected zone offset")];
- }
- offsetMin = (offset << 16 >> 16);
- /* } */ case 3:
- enc = new sliceType$3([1, ($shiftRightInt64(t.sec, 56).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 48).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 40).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 32).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 24).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 16).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 8).$low << 24 >>> 24), (t.sec.$low << 24 >>> 24), ((t.nsec >> 24 >> 0) << 24 >>> 24), ((t.nsec >> 16 >> 0) << 24 >>> 24), ((t.nsec >> 8 >> 0) << 24 >>> 24), (t.nsec << 24 >>> 24), ((offsetMin >> 8 << 16 >> 16) << 24 >>> 24), (offsetMin << 24 >>> 24)]);
- return [enc, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalBinary }; } $f.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.enc = enc; $f.offset = offset; $f.offsetMin = offsetMin; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.MarshalBinary = function() { return this.$val.MarshalBinary(); };
- Time.ptr.prototype.UnmarshalBinary = function(data$1) {
- var $ptr, _r$1, _tuple$1, buf, data$1, localoff, offset, t, x, x$1, x$10, x$11, x$12, x$13, x$14, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; buf = $f.buf; data$1 = $f.data$1; localoff = $f.localoff; offset = $f.offset; t = $f.t; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- buf = data$1;
- if (buf.$length === 0) {
- return errors.New("Time.UnmarshalBinary: no data");
- }
- if (!(((0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]) === 1))) {
- return errors.New("Time.UnmarshalBinary: unsupported version");
- }
- if (!((buf.$length === 15))) {
- return errors.New("Time.UnmarshalBinary: invalid length");
- }
- buf = $subslice(buf, 1);
- t.sec = (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = new $Int64(0, (7 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 7])), x$7 = $shiftLeft64(new $Int64(0, (6 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 6])), 8), new $Int64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64(new $Int64(0, (5 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 5])), 16), new $Int64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64(new $Int64(0, (4 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 4])), 24), new $Int64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64(new $Int64(0, (3 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 3])), 32), new $Int64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64(new $Int64(0, (2 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 2])), 40), new $Int64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64(new $Int64(0, (1 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 1])), 48), new $Int64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64(new $Int64(0, (0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0])), 56), new $Int64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0));
- buf = $subslice(buf, 8);
- t.nsec = ((((3 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 3]) >> 0) | (((2 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 2]) >> 0) << 8 >> 0)) | (((1 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 1]) >> 0) << 16 >> 0)) | (((0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]) >> 0) << 24 >> 0);
- buf = $subslice(buf, 4);
- offset = ((((1 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 1]) << 16 >> 16) | (((0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]) << 16 >> 16) << 8 << 16 >> 16)) >> 0) * 60 >> 0;
- /* */ if (offset === -60) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (offset === -60) { */ case 1:
- t.loc = utcLoc;
- $s = 3; continue;
- /* } else { */ case 2:
- _r$1 = $pkg.Local.lookup((x$14 = t.sec, new $Int64(x$14.$high + -15, x$14.$low + 2288912640))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; localoff = _tuple$1[1];
- /* */ if (offset === localoff) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (offset === localoff) { */ case 5:
- t.loc = $pkg.Local;
- $s = 7; continue;
- /* } else { */ case 6:
- t.loc = FixedZone("", offset);
- /* } */ case 7:
- /* } */ case 3:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalBinary }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.data$1 = data$1; $f.localoff = localoff; $f.offset = offset; $f.t = t; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.UnmarshalBinary = function(data$1) { return this.$val.UnmarshalBinary(data$1); };
- Time.ptr.prototype.GobEncode = function() {
- var $ptr, _r$1, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.MarshalBinary(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobEncode }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.GobEncode = function() { return this.$val.GobEncode(); };
- Time.ptr.prototype.GobDecode = function(data$1) {
- var $ptr, _r$1, data$1, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; data$1 = $f.data$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r$1 = t.UnmarshalBinary(data$1); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobDecode }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.data$1 = data$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.GobDecode = function(data$1) { return this.$val.GobDecode(data$1); };
- Time.ptr.prototype.MarshalJSON = function() {
- var $ptr, _r$1, _r$2, t, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- y = _r$1;
- /* */ if (y < 0 || y >= 10000) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (y < 0 || y >= 10000) { */ case 2:
- return [sliceType$3.nil, errors.New("Time.MarshalJSON: year outside of range [0,9999]")];
- /* } */ case 3:
- _r$2 = t.Format("\"2006-01-02T15:04:05.999999999Z07:00\""); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return [new sliceType$3($stringToBytes(_r$2)), $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalJSON }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.MarshalJSON = function() { return this.$val.MarshalJSON(); };
- Time.ptr.prototype.UnmarshalJSON = function(data$1) {
- var $ptr, _r$1, _tuple$1, data$1, err, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; data$1 = $f.data$1; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- err = $ifaceNil;
- t = this;
- _r$1 = Parse("\"2006-01-02T15:04:05Z07:00\"", $bytesToString(data$1)); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; $copy(t, _tuple$1[0], Time); err = _tuple$1[1];
- return err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalJSON }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.data$1 = data$1; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.UnmarshalJSON = function(data$1) { return this.$val.UnmarshalJSON(data$1); };
- Time.ptr.prototype.MarshalText = function() {
- var $ptr, _r$1, _r$2, t, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = $clone(this, Time);
- _r$1 = t.Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- y = _r$1;
- /* */ if (y < 0 || y >= 10000) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (y < 0 || y >= 10000) { */ case 2:
- return [sliceType$3.nil, errors.New("Time.MarshalText: year outside of range [0,9999]")];
- /* } */ case 3:
- _r$2 = t.Format("2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return [new sliceType$3($stringToBytes(_r$2)), $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalText }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.t = t; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.MarshalText = function() { return this.$val.MarshalText(); };
- Time.ptr.prototype.UnmarshalText = function(data$1) {
- var $ptr, _r$1, _tuple$1, data$1, err, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; data$1 = $f.data$1; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- err = $ifaceNil;
- t = this;
- _r$1 = Parse("2006-01-02T15:04:05Z07:00", $bytesToString(data$1)); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; $copy(t, _tuple$1[0], Time); err = _tuple$1[1];
- return err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalText }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.data$1 = data$1; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Time.prototype.UnmarshalText = function(data$1) { return this.$val.UnmarshalText(data$1); };
- Unix = function(sec, nsec) {
- var $ptr, n, nsec, sec, x, x$1, x$2, x$3;
- if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0)) || (nsec.$high > 0 || (nsec.$high === 0 && nsec.$low >= 1000000000))) {
- n = $div64(nsec, new $Int64(0, 1000000000), false);
- sec = (x = n, new $Int64(sec.$high + x.$high, sec.$low + x.$low));
- nsec = (x$1 = $mul64(n, new $Int64(0, 1000000000)), new $Int64(nsec.$high - x$1.$high, nsec.$low - x$1.$low));
- if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0))) {
- nsec = (x$2 = new $Int64(0, 1000000000), new $Int64(nsec.$high + x$2.$high, nsec.$low + x$2.$low));
- sec = (x$3 = new $Int64(0, 1), new $Int64(sec.$high - x$3.$high, sec.$low - x$3.$low));
- }
- }
- return new Time.ptr(new $Int64(sec.$high + 14, sec.$low + 2006054656), ((nsec.$low + ((nsec.$high >> 31) * 4294967296)) >> 0), $pkg.Local);
- };
- $pkg.Unix = Unix;
- isLeap = function(year) {
- var $ptr, _r$1, _r$2, _r$3, year;
- return ((_r$1 = year % 4, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0) && (!(((_r$2 = year % 100, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0)) || ((_r$3 = year % 400, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 0));
- };
- norm = function(hi, lo, base) {
- var $ptr, _q, _q$1, _tmp, _tmp$1, base, hi, lo, n, n$1, nhi, nlo;
- nhi = 0;
- nlo = 0;
- if (lo < 0) {
- n = (_q = ((-lo - 1 >> 0)) / base, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) + 1 >> 0;
- hi = hi - (n) >> 0;
- lo = lo + ((n * base >> 0)) >> 0;
- }
- if (lo >= base) {
- n$1 = (_q$1 = lo / base, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"));
- hi = hi + (n$1) >> 0;
- lo = lo - ((n$1 * base >> 0)) >> 0;
- }
- _tmp = hi; _tmp$1 = lo; nhi = _tmp; nlo = _tmp$1;
- return [nhi, nlo];
- };
- Date = function(year, month, day, hour, min, sec, nsec, loc) {
- var $ptr, _r$1, _r$2, _r$3, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, abs, d, day, end, hour, loc, m, min, month, n, nsec, offset, sec, start, unix, utc, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, year, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; abs = $f.abs; d = $f.d; day = $f.day; end = $f.end; hour = $f.hour; loc = $f.loc; m = $f.m; min = $f.min; month = $f.month; n = $f.n; nsec = $f.nsec; offset = $f.offset; sec = $f.sec; start = $f.start; unix = $f.unix; utc = $f.utc; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; y = $f.y; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (loc === ptrType$1.nil) {
- $panic(new $String("time: missing Location in call to Date"));
- }
- m = (month >> 0) - 1 >> 0;
- _tuple$1 = norm(year, m, 12); year = _tuple$1[0]; m = _tuple$1[1];
- month = (m >> 0) + 1 >> 0;
- _tuple$2 = norm(sec, nsec, 1000000000); sec = _tuple$2[0]; nsec = _tuple$2[1];
- _tuple$3 = norm(min, sec, 60); min = _tuple$3[0]; sec = _tuple$3[1];
- _tuple$4 = norm(hour, min, 60); hour = _tuple$4[0]; min = _tuple$4[1];
- _tuple$5 = norm(day, hour, 24); day = _tuple$5[0]; hour = _tuple$5[1];
- y = (x = (x$1 = new $Int64(0, year), new $Int64(x$1.$high - -69, x$1.$low - 4075721025)), new $Uint64(x.$high, x.$low));
- n = $div64(y, new $Uint64(0, 400), false);
- y = (x$2 = $mul64(new $Uint64(0, 400), n), new $Uint64(y.$high - x$2.$high, y.$low - x$2.$low));
- d = $mul64(new $Uint64(0, 146097), n);
- n = $div64(y, new $Uint64(0, 100), false);
- y = (x$3 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high - x$3.$high, y.$low - x$3.$low));
- d = (x$4 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high + x$4.$high, d.$low + x$4.$low));
- n = $div64(y, new $Uint64(0, 4), false);
- y = (x$5 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high - x$5.$high, y.$low - x$5.$low));
- d = (x$6 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high + x$6.$high, d.$low + x$6.$low));
- n = y;
- d = (x$7 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high + x$7.$high, d.$low + x$7.$low));
- d = (x$8 = new $Uint64(0, (x$9 = month - 1 >> 0, ((x$9 < 0 || x$9 >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[x$9]))), new $Uint64(d.$high + x$8.$high, d.$low + x$8.$low));
- if (isLeap(year) && month >= 3) {
- d = (x$10 = new $Uint64(0, 1), new $Uint64(d.$high + x$10.$high, d.$low + x$10.$low));
- }
- d = (x$11 = new $Uint64(0, (day - 1 >> 0)), new $Uint64(d.$high + x$11.$high, d.$low + x$11.$low));
- abs = $mul64(d, new $Uint64(0, 86400));
- abs = (x$12 = new $Uint64(0, (((hour * 3600 >> 0) + (min * 60 >> 0) >> 0) + sec >> 0)), new $Uint64(abs.$high + x$12.$high, abs.$low + x$12.$low));
- unix = (x$13 = new $Int64(abs.$high, abs.$low), new $Int64(x$13.$high + -2147483647, x$13.$low + 3844486912));
- _r$1 = loc.lookup(unix); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$6 = _r$1; offset = _tuple$6[1]; start = _tuple$6[3]; end = _tuple$6[4];
- /* */ if (!((offset === 0))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((offset === 0))) { */ case 2:
- utc = (x$14 = new $Int64(0, offset), new $Int64(unix.$high - x$14.$high, unix.$low - x$14.$low));
- /* */ if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { $s = 4; continue; }
- /* */ if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ((utc.$high < start.$high || (utc.$high === start.$high && utc.$low < start.$low))) { */ case 4:
- _r$2 = loc.lookup(new $Int64(start.$high - 0, start.$low - 1)); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$7 = _r$2; offset = _tuple$7[1];
- $s = 6; continue;
- /* } else if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { */ case 5:
- _r$3 = loc.lookup(end); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$8 = _r$3; offset = _tuple$8[1];
- /* } */ case 6:
- unix = (x$15 = new $Int64(0, offset), new $Int64(unix.$high - x$15.$high, unix.$low - x$15.$low));
- /* } */ case 3:
- return new Time.ptr(new $Int64(unix.$high + 14, unix.$low + 2006054656), (nsec >> 0), loc);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Date }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f.abs = abs; $f.d = d; $f.day = day; $f.end = end; $f.hour = hour; $f.loc = loc; $f.m = m; $f.min = min; $f.month = month; $f.n = n; $f.nsec = nsec; $f.offset = offset; $f.sec = sec; $f.start = start; $f.unix = unix; $f.utc = utc; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.y = y; $f.year = year; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Date = Date;
- Time.ptr.prototype.Truncate = function(d) {
- var $ptr, _tuple$1, d, r, t;
- t = $clone(this, Time);
- if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) {
- return t;
- }
- _tuple$1 = div(t, d); r = _tuple$1[1];
- return t.Add(new Duration(-r.$high, -r.$low));
- };
- Time.prototype.Truncate = function(d) { return this.$val.Truncate(d); };
- Time.ptr.prototype.Round = function(d) {
- var $ptr, _tuple$1, d, r, t, x;
- t = $clone(this, Time);
- if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) {
- return t;
- }
- _tuple$1 = div(t, d); r = _tuple$1[1];
- if ((x = new Duration(r.$high + r.$high, r.$low + r.$low), (x.$high < d.$high || (x.$high === d.$high && x.$low < d.$low)))) {
- return t.Add(new Duration(-r.$high, -r.$low));
- }
- return t.Add(new Duration(d.$high - r.$high, d.$low - r.$low));
- };
- Time.prototype.Round = function(d) { return this.$val.Round(d); };
- div = function(t, d) {
- var $ptr, _q, _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, d, d0, d1, d1$1, neg, nsec, qmod2, r, sec, t, tmp, u0, u0x, u1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- qmod2 = 0;
- r = new Duration(0, 0);
- t = $clone(t, Time);
- neg = false;
- nsec = t.nsec;
- if ((x = t.sec, (x.$high < 0 || (x.$high === 0 && x.$low < 0)))) {
- neg = true;
- t.sec = (x$1 = t.sec, new $Int64(-x$1.$high, -x$1.$low));
- nsec = -nsec;
- if (nsec < 0) {
- nsec = nsec + (1000000000) >> 0;
- t.sec = (x$2 = t.sec, x$3 = new $Int64(0, 1), new $Int64(x$2.$high - x$3.$high, x$2.$low - x$3.$low));
- }
- }
- if ((d.$high < 0 || (d.$high === 0 && d.$low < 1000000000)) && (x$4 = $div64(new Duration(0, 1000000000), (new Duration(d.$high + d.$high, d.$low + d.$low)), true), (x$4.$high === 0 && x$4.$low === 0))) {
- qmod2 = ((_q = nsec / ((d.$low + ((d.$high >> 31) * 4294967296)) >> 0), (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0) & 1;
- r = new Duration(0, (_r$1 = nsec % ((d.$low + ((d.$high >> 31) * 4294967296)) >> 0), _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")));
- } else if ((x$5 = $div64(d, new Duration(0, 1000000000), true), (x$5.$high === 0 && x$5.$low === 0))) {
- d1 = (x$6 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$6.$high, x$6.$low));
- qmod2 = ((x$7 = $div64(t.sec, d1, false), x$7.$low + ((x$7.$high >> 31) * 4294967296)) >> 0) & 1;
- r = (x$8 = $mul64((x$9 = $div64(t.sec, d1, true), new Duration(x$9.$high, x$9.$low)), new Duration(0, 1000000000)), x$10 = new Duration(0, nsec), new Duration(x$8.$high + x$10.$high, x$8.$low + x$10.$low));
- } else {
- sec = (x$11 = t.sec, new $Uint64(x$11.$high, x$11.$low));
- tmp = $mul64(($shiftRightUint64(sec, 32)), new $Uint64(0, 1000000000));
- u1 = $shiftRightUint64(tmp, 32);
- u0 = $shiftLeft64(tmp, 32);
- tmp = $mul64(new $Uint64(sec.$high & 0, (sec.$low & 4294967295) >>> 0), new $Uint64(0, 1000000000));
- _tmp = u0; _tmp$1 = new $Uint64(u0.$high + tmp.$high, u0.$low + tmp.$low); u0x = _tmp; u0 = _tmp$1;
- if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) {
- u1 = (x$12 = new $Uint64(0, 1), new $Uint64(u1.$high + x$12.$high, u1.$low + x$12.$low));
- }
- _tmp$2 = u0; _tmp$3 = (x$13 = new $Uint64(0, nsec), new $Uint64(u0.$high + x$13.$high, u0.$low + x$13.$low)); u0x = _tmp$2; u0 = _tmp$3;
- if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) {
- u1 = (x$14 = new $Uint64(0, 1), new $Uint64(u1.$high + x$14.$high, u1.$low + x$14.$low));
- }
- d1$1 = new $Uint64(d.$high, d.$low);
- while (true) {
- if (!(!((x$15 = $shiftRightUint64(d1$1, 63), (x$15.$high === 0 && x$15.$low === 1))))) { break; }
- d1$1 = $shiftLeft64(d1$1, (1));
- }
- d0 = new $Uint64(0, 0);
- while (true) {
- qmod2 = 0;
- if ((u1.$high > d1$1.$high || (u1.$high === d1$1.$high && u1.$low > d1$1.$low)) || (u1.$high === d1$1.$high && u1.$low === d1$1.$low) && (u0.$high > d0.$high || (u0.$high === d0.$high && u0.$low >= d0.$low))) {
- qmod2 = 1;
- _tmp$4 = u0; _tmp$5 = new $Uint64(u0.$high - d0.$high, u0.$low - d0.$low); u0x = _tmp$4; u0 = _tmp$5;
- if ((u0.$high > u0x.$high || (u0.$high === u0x.$high && u0.$low > u0x.$low))) {
- u1 = (x$16 = new $Uint64(0, 1), new $Uint64(u1.$high - x$16.$high, u1.$low - x$16.$low));
- }
- u1 = (x$17 = d1$1, new $Uint64(u1.$high - x$17.$high, u1.$low - x$17.$low));
- }
- if ((d1$1.$high === 0 && d1$1.$low === 0) && (x$18 = new $Uint64(d.$high, d.$low), (d0.$high === x$18.$high && d0.$low === x$18.$low))) {
- break;
- }
- d0 = $shiftRightUint64(d0, (1));
- d0 = (x$19 = $shiftLeft64((new $Uint64(d1$1.$high & 0, (d1$1.$low & 1) >>> 0)), 63), new $Uint64(d0.$high | x$19.$high, (d0.$low | x$19.$low) >>> 0));
- d1$1 = $shiftRightUint64(d1$1, (1));
- }
- r = new Duration(u0.$high, u0.$low);
- }
- if (neg && !((r.$high === 0 && r.$low === 0))) {
- qmod2 = (qmod2 ^ (1)) >> 0;
- r = new Duration(d.$high - r.$high, d.$low - r.$low);
- }
- return [qmod2, r];
- };
- Location.ptr.prototype.get = function() {
- var $ptr, l, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- l = this;
- if (l === ptrType$1.nil) {
- return utcLoc;
- }
- /* */ if (l === localLoc) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (l === localLoc) { */ case 1:
- $r = localOnce.Do(initLocal); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- return l;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.get }; } $f.$ptr = $ptr; $f.l = l; $f.$s = $s; $f.$r = $r; return $f;
- };
- Location.prototype.get = function() { return this.$val.get(); };
- Location.ptr.prototype.String = function() {
- var $ptr, _r$1, l, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- l = this;
- _r$1 = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1.name;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.l = l; $f.$s = $s; $f.$r = $r; return $f;
- };
- Location.prototype.String = function() { return this.$val.String(); };
- FixedZone = function(name, offset) {
- var $ptr, l, name, offset, x;
- l = new Location.ptr(name, new sliceType$1([new zone.ptr(name, offset, false)]), new sliceType$2([new zoneTrans.ptr(new $Int64(-2147483648, 0), 0, false, false)]), new $Int64(-2147483648, 0), new $Int64(2147483647, 4294967295), ptrType.nil);
- l.cacheZone = (x = l.zone, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]));
- return l;
- };
- $pkg.FixedZone = FixedZone;
- Location.ptr.prototype.lookup = function(sec) {
- var $ptr, _q, _r$1, end, hi, isDST, l, lim, lo, m, name, offset, sec, start, tx, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, zone$1, zone$2, zone$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; end = $f.end; hi = $f.hi; isDST = $f.isDST; l = $f.l; lim = $f.lim; lo = $f.lo; m = $f.m; name = $f.name; offset = $f.offset; sec = $f.sec; start = $f.start; tx = $f.tx; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; zone$1 = $f.zone$1; zone$2 = $f.zone$2; zone$3 = $f.zone$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- name = "";
- offset = 0;
- isDST = false;
- start = new $Int64(0, 0);
- end = new $Int64(0, 0);
- l = this;
- _r$1 = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- l = _r$1;
- if (l.zone.$length === 0) {
- name = "UTC";
- offset = 0;
- isDST = false;
- start = new $Int64(-2147483648, 0);
- end = new $Int64(2147483647, 4294967295);
- return [name, offset, isDST, start, end];
- }
- zone$1 = l.cacheZone;
- if (!(zone$1 === ptrType.nil) && (x = l.cacheStart, (x.$high < sec.$high || (x.$high === sec.$high && x.$low <= sec.$low))) && (x$1 = l.cacheEnd, (sec.$high < x$1.$high || (sec.$high === x$1.$high && sec.$low < x$1.$low)))) {
- name = zone$1.name;
- offset = zone$1.offset;
- isDST = zone$1.isDST;
- start = l.cacheStart;
- end = l.cacheEnd;
- return [name, offset, isDST, start, end];
- }
- if ((l.tx.$length === 0) || (x$2 = (x$3 = l.tx, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0])).when, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) {
- zone$2 = (x$4 = l.zone, x$5 = l.lookupFirstZone(), ((x$5 < 0 || x$5 >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + x$5]));
- name = zone$2.name;
- offset = zone$2.offset;
- isDST = zone$2.isDST;
- start = new $Int64(-2147483648, 0);
- if (l.tx.$length > 0) {
- end = (x$6 = l.tx, (0 >= x$6.$length ? $throwRuntimeError("index out of range") : x$6.$array[x$6.$offset + 0])).when;
- } else {
- end = new $Int64(2147483647, 4294967295);
- }
- return [name, offset, isDST, start, end];
- }
- tx = l.tx;
- end = new $Int64(2147483647, 4294967295);
- lo = 0;
- hi = tx.$length;
- while (true) {
- if (!((hi - lo >> 0) > 1)) { break; }
- m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- lim = ((m < 0 || m >= tx.$length) ? $throwRuntimeError("index out of range") : tx.$array[tx.$offset + m]).when;
- if ((sec.$high < lim.$high || (sec.$high === lim.$high && sec.$low < lim.$low))) {
- end = lim;
- hi = m;
- } else {
- lo = m;
- }
- }
- zone$3 = (x$7 = l.zone, x$8 = ((lo < 0 || lo >= tx.$length) ? $throwRuntimeError("index out of range") : tx.$array[tx.$offset + lo]).index, ((x$8 < 0 || x$8 >= x$7.$length) ? $throwRuntimeError("index out of range") : x$7.$array[x$7.$offset + x$8]));
- name = zone$3.name;
- offset = zone$3.offset;
- isDST = zone$3.isDST;
- start = ((lo < 0 || lo >= tx.$length) ? $throwRuntimeError("index out of range") : tx.$array[tx.$offset + lo]).when;
- return [name, offset, isDST, start, end];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookup }; } $f.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $f.end = end; $f.hi = hi; $f.isDST = isDST; $f.l = l; $f.lim = lim; $f.lo = lo; $f.m = m; $f.name = name; $f.offset = offset; $f.sec = sec; $f.start = start; $f.tx = tx; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.zone$3 = zone$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Location.prototype.lookup = function(sec) { return this.$val.lookup(sec); };
- Location.ptr.prototype.lookupFirstZone = function() {
- var $ptr, _i, _ref, l, x, x$1, x$2, x$3, x$4, x$5, zi, zi$1;
- l = this;
- if (!l.firstZoneUsed()) {
- return 0;
- }
- if (l.tx.$length > 0 && (x = l.zone, x$1 = (x$2 = l.tx, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])).index, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).isDST) {
- zi = ((x$3 = l.tx, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0])).index >> 0) - 1 >> 0;
- while (true) {
- if (!(zi >= 0)) { break; }
- if (!(x$4 = l.zone, ((zi < 0 || zi >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + zi])).isDST) {
- return zi;
- }
- zi = zi - (1) >> 0;
- }
- }
- _ref = l.zone;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- zi$1 = _i;
- if (!(x$5 = l.zone, ((zi$1 < 0 || zi$1 >= x$5.$length) ? $throwRuntimeError("index out of range") : x$5.$array[x$5.$offset + zi$1])).isDST) {
- return zi$1;
- }
- _i++;
- }
- return 0;
- };
- Location.prototype.lookupFirstZone = function() { return this.$val.lookupFirstZone(); };
- Location.ptr.prototype.firstZoneUsed = function() {
- var $ptr, _i, _ref, l, tx;
- l = this;
- _ref = l.tx;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- tx = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), zoneTrans);
- if (tx.index === 0) {
- return true;
- }
- _i++;
- }
- return false;
- };
- Location.prototype.firstZoneUsed = function() { return this.$val.firstZoneUsed(); };
- Location.ptr.prototype.lookupName = function(name, unix) {
- var $ptr, _i, _i$1, _r$1, _r$2, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple$1, i, i$1, isDST, isDST$1, l, nam, name, offset, offset$1, ok, unix, x, x$1, x$2, zone$1, zone$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple$1 = $f._tuple$1; i = $f.i; i$1 = $f.i$1; isDST = $f.isDST; isDST$1 = $f.isDST$1; l = $f.l; nam = $f.nam; name = $f.name; offset = $f.offset; offset$1 = $f.offset$1; ok = $f.ok; unix = $f.unix; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; zone$1 = $f.zone$1; zone$2 = $f.zone$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- offset = 0;
- isDST = false;
- ok = false;
- l = this;
- _r$1 = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- l = _r$1;
- _ref = l.zone;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- i = _i;
- zone$1 = (x = l.zone, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- /* */ if (zone$1.name === name) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (zone$1.name === name) { */ case 4:
- _r$2 = l.lookup((x$1 = new $Int64(0, zone$1.offset), new $Int64(unix.$high - x$1.$high, unix.$low - x$1.$low))); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; nam = _tuple$1[0]; offset$1 = _tuple$1[1]; isDST$1 = _tuple$1[2];
- if (nam === zone$1.name) {
- _tmp = offset$1; _tmp$1 = isDST$1; _tmp$2 = true; offset = _tmp; isDST = _tmp$1; ok = _tmp$2;
- return [offset, isDST, ok];
- }
- /* } */ case 5:
- _i++;
- /* } */ $s = 2; continue; case 3:
- _ref$1 = l.zone;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- i$1 = _i$1;
- zone$2 = (x$2 = l.zone, ((i$1 < 0 || i$1 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$1]));
- if (zone$2.name === name) {
- _tmp$3 = zone$2.offset; _tmp$4 = zone$2.isDST; _tmp$5 = true; offset = _tmp$3; isDST = _tmp$4; ok = _tmp$5;
- return [offset, isDST, ok];
- }
- _i$1++;
- }
- return [offset, isDST, ok];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookupName }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple$1 = _tuple$1; $f.i = i; $f.i$1 = i$1; $f.isDST = isDST; $f.isDST$1 = isDST$1; $f.l = l; $f.nam = nam; $f.name = name; $f.offset = offset; $f.offset$1 = offset$1; $f.ok = ok; $f.unix = unix; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.zone$1 = zone$1; $f.zone$2 = zone$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Location.prototype.lookupName = function(name, unix) { return this.$val.lookupName(name, unix); };
- ptrType$3.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$4.methods = [{prop: "Stop", name: "Stop", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([Duration], [$Bool], false)}];
- Time.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "After", name: "After", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Before", name: "Before", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "Equal", name: "Equal", pkg: "", typ: $funcType([Time], [$Bool], false)}, {prop: "IsZero", name: "IsZero", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "abs", name: "abs", pkg: "time", typ: $funcType([], [$Uint64], false)}, {prop: "locabs", name: "locabs", pkg: "time", typ: $funcType([], [$String, $Int, $Uint64], false)}, {prop: "Date", name: "Date", pkg: "", typ: $funcType([], [$Int, Month, $Int], false)}, {prop: "Year", name: "Year", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Month", name: "Month", pkg: "", typ: $funcType([], [Month], false)}, {prop: "Day", name: "Day", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Weekday", name: "Weekday", pkg: "", typ: $funcType([], [Weekday], false)}, {prop: "ISOWeek", name: "ISOWeek", pkg: "", typ: $funcType([], [$Int, $Int], false)}, {prop: "Clock", name: "Clock", pkg: "", typ: $funcType([], [$Int, $Int, $Int], false)}, {prop: "Hour", name: "Hour", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Minute", name: "Minute", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Second", name: "Second", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Nanosecond", name: "Nanosecond", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "YearDay", name: "YearDay", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([Time], [Duration], false)}, {prop: "AddDate", name: "AddDate", pkg: "", typ: $funcType([$Int, $Int, $Int], [Time], false)}, {prop: "date", name: "date", pkg: "time", typ: $funcType([$Bool], [$Int, Month, $Int, $Int], false)}, {prop: "UTC", name: "UTC", pkg: "", typ: $funcType([], [Time], false)}, {prop: "Local", name: "Local", pkg: "", typ: $funcType([], [Time], false)}, {prop: "In", name: "In", pkg: "", typ: $funcType([ptrType$1], [Time], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Zone", name: "Zone", pkg: "", typ: $funcType([], [$String, $Int], false)}, {prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "UnixNano", name: "UnixNano", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "MarshalBinary", name: "MarshalBinary", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType$3, $error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([Duration], [Time], false)}, {prop: "Round", name: "Round", pkg: "", typ: $funcType([Duration], [Time], false)}];
- ptrType$6.methods = [{prop: "UnmarshalBinary", name: "UnmarshalBinary", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType$3], [$error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType$3], [$error], false)}];
- Month.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- Weekday.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- Duration.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Nanoseconds", name: "Nanoseconds", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seconds", name: "Seconds", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Minutes", name: "Minutes", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Hours", name: "Hours", pkg: "", typ: $funcType([], [$Float64], false)}];
- ptrType$1.methods = [{prop: "get", name: "get", pkg: "time", typ: $funcType([], [ptrType$1], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "lookup", name: "lookup", pkg: "time", typ: $funcType([$Int64], [$String, $Int, $Bool, $Int64, $Int64], false)}, {prop: "lookupFirstZone", name: "lookupFirstZone", pkg: "time", typ: $funcType([], [$Int], false)}, {prop: "firstZoneUsed", name: "firstZoneUsed", pkg: "time", typ: $funcType([], [$Bool], false)}, {prop: "lookupName", name: "lookupName", pkg: "time", typ: $funcType([$String, $Int64], [$Int, $Bool, $Bool], false)}];
- runtimeTimer.init([{prop: "i", name: "i", pkg: "time", typ: $Int32, tag: ""}, {prop: "when", name: "when", pkg: "time", typ: $Int64, tag: ""}, {prop: "period", name: "period", pkg: "time", typ: $Int64, tag: ""}, {prop: "f", name: "f", pkg: "time", typ: funcType$1, tag: ""}, {prop: "arg", name: "arg", pkg: "time", typ: $emptyInterface, tag: ""}, {prop: "timeout", name: "timeout", pkg: "time", typ: ptrType$2, tag: ""}, {prop: "active", name: "active", pkg: "time", typ: $Bool, tag: ""}]);
- ParseError.init([{prop: "Layout", name: "Layout", pkg: "", typ: $String, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: ""}, {prop: "LayoutElem", name: "LayoutElem", pkg: "", typ: $String, tag: ""}, {prop: "ValueElem", name: "ValueElem", pkg: "", typ: $String, tag: ""}, {prop: "Message", name: "Message", pkg: "", typ: $String, tag: ""}]);
- Timer.init([{prop: "C", name: "C", pkg: "", typ: chanType$2, tag: ""}, {prop: "r", name: "r", pkg: "time", typ: runtimeTimer, tag: ""}]);
- Time.init([{prop: "sec", name: "sec", pkg: "time", typ: $Int64, tag: ""}, {prop: "nsec", name: "nsec", pkg: "time", typ: $Int32, tag: ""}, {prop: "loc", name: "loc", pkg: "time", typ: ptrType$1, tag: ""}]);
- Location.init([{prop: "name", name: "name", pkg: "time", typ: $String, tag: ""}, {prop: "zone", name: "zone", pkg: "time", typ: sliceType$1, tag: ""}, {prop: "tx", name: "tx", pkg: "time", typ: sliceType$2, tag: ""}, {prop: "cacheStart", name: "cacheStart", pkg: "time", typ: $Int64, tag: ""}, {prop: "cacheEnd", name: "cacheEnd", pkg: "time", typ: $Int64, tag: ""}, {prop: "cacheZone", name: "cacheZone", pkg: "time", typ: ptrType, tag: ""}]);
- zone.init([{prop: "name", name: "name", pkg: "time", typ: $String, tag: ""}, {prop: "offset", name: "offset", pkg: "time", typ: $Int, tag: ""}, {prop: "isDST", name: "isDST", pkg: "time", typ: $Bool, tag: ""}]);
- zoneTrans.init([{prop: "when", name: "when", pkg: "time", typ: $Int64, tag: ""}, {prop: "index", name: "index", pkg: "time", typ: $Uint8, tag: ""}, {prop: "isstd", name: "isstd", pkg: "time", typ: $Bool, tag: ""}, {prop: "isutc", name: "isutc", pkg: "time", typ: $Bool, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = nosync.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = syscall.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- localLoc = new Location.ptr();
- localOnce = new nosync.Once.ptr();
- std0x = $toNativeArray($kindInt, [260, 265, 524, 526, 528, 274]);
- longDayNames = new sliceType(["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]);
- shortDayNames = new sliceType(["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]);
- shortMonthNames = new sliceType(["---", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]);
- longMonthNames = new sliceType(["---", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]);
- atoiError = errors.New("time: invalid number");
- errBad = errors.New("bad value for field");
- errLeadingInt = errors.New("time: bad [0-9]*");
- months = $toNativeArray($kindString, ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]);
- days = $toNativeArray($kindString, ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]);
- unitMap = (_map = new $Map(), _key = "ns", _map[$String.keyFor(_key)] = { k: _key, v: 1 }, _key = "us", _map[$String.keyFor(_key)] = { k: _key, v: 1000 }, _key = "\xC2\xB5s", _map[$String.keyFor(_key)] = { k: _key, v: 1000 }, _key = "\xCE\xBCs", _map[$String.keyFor(_key)] = { k: _key, v: 1000 }, _key = "ms", _map[$String.keyFor(_key)] = { k: _key, v: 1e+06 }, _key = "s", _map[$String.keyFor(_key)] = { k: _key, v: 1e+09 }, _key = "m", _map[$String.keyFor(_key)] = { k: _key, v: 6e+10 }, _key = "h", _map[$String.keyFor(_key)] = { k: _key, v: 3.6e+12 }, _map);
- daysBefore = $toNativeArray($kindInt32, [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]);
- utcLoc = new Location.ptr("UTC", sliceType$1.nil, sliceType$2.nil, new $Int64(0, 0), new $Int64(0, 0), ptrType.nil);
- $pkg.UTC = utcLoc;
- $pkg.Local = localLoc;
- _r = syscall.Getenv("ZONEINFO"); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; zoneinfo = _tuple[0];
- badData = errors.New("malformed time zone information");
- zoneDirs = new sliceType(["/usr/share/zoneinfo/", "/usr/share/lib/zoneinfo/", "/usr/lib/locale/TZ/", runtime.GOROOT() + "/lib/time/zoneinfo.zip"]);
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["os"] = (function() {
- var $pkg = {}, $init, errors, js, io, runtime, sync, atomic, syscall, time, PathError, SyscallError, LinkError, File, file, dirInfo, FileInfo, FileMode, fileStat, sliceType, ptrType, sliceType$1, sliceType$2, ptrType$2, ptrType$3, ptrType$4, arrayType, ptrType$11, funcType$1, ptrType$12, ptrType$14, ptrType$15, errFinished, lstat, useSyscallwd, supportsCloseOnExec, runtime_args, init, NewSyscallError, IsNotExist, isNotExist, Open, fixCount, sigpipe, syscallMode, NewFile, epipecheck, OpenFile, Lstat, basename, init$1, useSyscallwdDarwin, IsPathSeparator, init$2, Exit, fileInfoFromStat, timespecToTime, init$3;
- errors = $packages["errors"];
- js = $packages["github.com/gopherjs/gopherjs/js"];
- io = $packages["io"];
- runtime = $packages["runtime"];
- sync = $packages["sync"];
- atomic = $packages["sync/atomic"];
- syscall = $packages["syscall"];
- time = $packages["time"];
- PathError = $pkg.PathError = $newType(0, $kindStruct, "os.PathError", "PathError", "os", function(Op_, Path_, Err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Op = "";
- this.Path = "";
- this.Err = $ifaceNil;
- return;
- }
- this.Op = Op_;
- this.Path = Path_;
- this.Err = Err_;
- });
- SyscallError = $pkg.SyscallError = $newType(0, $kindStruct, "os.SyscallError", "SyscallError", "os", function(Syscall_, Err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Syscall = "";
- this.Err = $ifaceNil;
- return;
- }
- this.Syscall = Syscall_;
- this.Err = Err_;
- });
- LinkError = $pkg.LinkError = $newType(0, $kindStruct, "os.LinkError", "LinkError", "os", function(Op_, Old_, New_, Err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Op = "";
- this.Old = "";
- this.New = "";
- this.Err = $ifaceNil;
- return;
- }
- this.Op = Op_;
- this.Old = Old_;
- this.New = New_;
- this.Err = Err_;
- });
- File = $pkg.File = $newType(0, $kindStruct, "os.File", "File", "os", function(file_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.file = ptrType$11.nil;
- return;
- }
- this.file = file_;
- });
- file = $pkg.file = $newType(0, $kindStruct, "os.file", "file", "os", function(fd_, name_, dirinfo_, nepipe_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.fd = 0;
- this.name = "";
- this.dirinfo = ptrType.nil;
- this.nepipe = 0;
- return;
- }
- this.fd = fd_;
- this.name = name_;
- this.dirinfo = dirinfo_;
- this.nepipe = nepipe_;
- });
- dirInfo = $pkg.dirInfo = $newType(0, $kindStruct, "os.dirInfo", "dirInfo", "os", function(buf_, nbuf_, bufp_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.buf = sliceType$1.nil;
- this.nbuf = 0;
- this.bufp = 0;
- return;
- }
- this.buf = buf_;
- this.nbuf = nbuf_;
- this.bufp = bufp_;
- });
- FileInfo = $pkg.FileInfo = $newType(8, $kindInterface, "os.FileInfo", "FileInfo", "os", null);
- FileMode = $pkg.FileMode = $newType(4, $kindUint32, "os.FileMode", "FileMode", "os", null);
- fileStat = $pkg.fileStat = $newType(0, $kindStruct, "os.fileStat", "fileStat", "os", function(name_, size_, mode_, modTime_, sys_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = "";
- this.size = new $Int64(0, 0);
- this.mode = 0;
- this.modTime = new time.Time.ptr();
- this.sys = $ifaceNil;
- return;
- }
- this.name = name_;
- this.size = size_;
- this.mode = mode_;
- this.modTime = modTime_;
- this.sys = sys_;
- });
- sliceType = $sliceType($String);
- ptrType = $ptrType(dirInfo);
- sliceType$1 = $sliceType($Uint8);
- sliceType$2 = $sliceType(FileInfo);
- ptrType$2 = $ptrType(File);
- ptrType$3 = $ptrType(PathError);
- ptrType$4 = $ptrType(LinkError);
- arrayType = $arrayType($Uint8, 32);
- ptrType$11 = $ptrType(file);
- funcType$1 = $funcType([ptrType$11], [$error], false);
- ptrType$12 = $ptrType($Int32);
- ptrType$14 = $ptrType(fileStat);
- ptrType$15 = $ptrType(SyscallError);
- runtime_args = function() {
- var $ptr;
- return $pkg.Args;
- };
- init = function() {
- var $ptr, argv, i, process;
- process = $global.process;
- if (!(process === undefined)) {
- argv = process.argv;
- $pkg.Args = $makeSlice(sliceType, ($parseInt(argv.length) - 1 >> 0));
- i = 0;
- while (true) {
- if (!(i < ($parseInt(argv.length) - 1 >> 0))) { break; }
- ((i < 0 || i >= $pkg.Args.$length) ? $throwRuntimeError("index out of range") : $pkg.Args.$array[$pkg.Args.$offset + i] = $internalize(argv[(i + 1 >> 0)], $String));
- i = i + (1) >> 0;
- }
- }
- if ($pkg.Args.$length === 0) {
- $pkg.Args = new sliceType(["?"]);
- }
- };
- File.ptr.prototype.readdirnames = function(n) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, _tuple$2, d, err, errno, f, n, names, nb, nc, size;
- names = sliceType.nil;
- err = $ifaceNil;
- f = this;
- if (f.file.dirinfo === ptrType.nil) {
- f.file.dirinfo = new dirInfo.ptr();
- f.file.dirinfo.buf = $makeSlice(sliceType$1, 4096);
- }
- d = f.file.dirinfo;
- size = n;
- if (size <= 0) {
- size = 100;
- n = -1;
- }
- names = $makeSlice(sliceType, 0, size);
- while (true) {
- if (!(!((n === 0)))) { break; }
- if (d.bufp >= d.nbuf) {
- d.bufp = 0;
- errno = $ifaceNil;
- _tuple$1 = syscall.ReadDirent(f.file.fd, d.buf);
- _tuple = fixCount(_tuple$1[0], _tuple$1[1]); d.nbuf = _tuple[0]; errno = _tuple[1];
- if (!($interfaceIsEqual(errno, $ifaceNil))) {
- _tmp = names; _tmp$1 = NewSyscallError("readdirent", errno); names = _tmp; err = _tmp$1;
- return [names, err];
- }
- if (d.nbuf <= 0) {
- break;
- }
- }
- _tmp$2 = 0; _tmp$3 = 0; nb = _tmp$2; nc = _tmp$3;
- _tuple$2 = syscall.ParseDirent($subslice(d.buf, d.bufp, d.nbuf), n, names); nb = _tuple$2[0]; nc = _tuple$2[1]; names = _tuple$2[2];
- d.bufp = d.bufp + (nb) >> 0;
- n = n - (nc) >> 0;
- }
- if (n >= 0 && (names.$length === 0)) {
- _tmp$4 = names; _tmp$5 = io.EOF; names = _tmp$4; err = _tmp$5;
- return [names, err];
- }
- _tmp$6 = names; _tmp$7 = $ifaceNil; names = _tmp$6; err = _tmp$7;
- return [names, err];
- };
- File.prototype.readdirnames = function(n) { return this.$val.readdirnames(n); };
- File.ptr.prototype.Readdir = function(n) {
- var $ptr, _r, _tmp, _tmp$1, _tuple, err, f, fi, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; fi = $f.fi; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- fi = sliceType$2.nil;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = sliceType$2.nil; _tmp$1 = $pkg.ErrInvalid; fi = _tmp; err = _tmp$1;
- return [fi, err];
- }
- _r = f.readdir(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; fi = _tuple[0]; err = _tuple[1];
- return [fi, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdir }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.fi = fi; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.Readdir = function(n) { return this.$val.Readdir(n); };
- File.ptr.prototype.Readdirnames = function(n) {
- var $ptr, _tmp, _tmp$1, _tuple, err, f, n, names;
- names = sliceType.nil;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = sliceType.nil; _tmp$1 = $pkg.ErrInvalid; names = _tmp; err = _tmp$1;
- return [names, err];
- }
- _tuple = f.readdirnames(n); names = _tuple[0]; err = _tuple[1];
- return [names, err];
- };
- File.prototype.Readdirnames = function(n) { return this.$val.Readdirnames(n); };
- PathError.ptr.prototype.Error = function() {
- var $ptr, _r, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return e.Op + " " + e.Path + ": " + _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- PathError.prototype.Error = function() { return this.$val.Error(); };
- SyscallError.ptr.prototype.Error = function() {
- var $ptr, _r, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return e.Syscall + ": " + _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- SyscallError.prototype.Error = function() { return this.$val.Error(); };
- NewSyscallError = function(syscall$1, err) {
- var $ptr, err, syscall$1;
- if ($interfaceIsEqual(err, $ifaceNil)) {
- return $ifaceNil;
- }
- return new SyscallError.ptr(syscall$1, err);
- };
- $pkg.NewSyscallError = NewSyscallError;
- IsNotExist = function(err) {
- var $ptr, err;
- return isNotExist(err);
- };
- $pkg.IsNotExist = IsNotExist;
- isNotExist = function(err) {
- var $ptr, _ref, err, pe, pe$1, pe$2;
- _ref = err;
- if (_ref === $ifaceNil) {
- pe = _ref;
- return false;
- } else if ($assertType(_ref, ptrType$3, true)[1]) {
- pe$1 = _ref.$val;
- err = pe$1.Err;
- } else if ($assertType(_ref, ptrType$4, true)[1]) {
- pe$2 = _ref.$val;
- err = pe$2.Err;
- }
- return $interfaceIsEqual(err, new syscall.Errno(2)) || $interfaceIsEqual(err, $pkg.ErrNotExist);
- };
- File.ptr.prototype.Name = function() {
- var $ptr, f;
- f = this;
- return f.file.name;
- };
- File.prototype.Name = function() { return this.$val.Name(); };
- LinkError.ptr.prototype.Error = function() {
- var $ptr, _r, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- _r = e.Err.Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return e.Op + " " + e.Old + " " + e.New + ": " + _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: LinkError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- LinkError.prototype.Error = function() { return this.$val.Error(); };
- File.ptr.prototype.Read = function(b) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, b, e, err, f, n;
- n = 0;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = 0; _tmp$1 = $pkg.ErrInvalid; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- _tuple = f.read(b); n = _tuple[0]; e = _tuple[1];
- if (n < 0) {
- n = 0;
- }
- if ((n === 0) && b.$length > 0 && $interfaceIsEqual(e, $ifaceNil)) {
- _tmp$2 = 0; _tmp$3 = io.EOF; n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- err = new PathError.ptr("read", f.file.name, e);
- }
- _tmp$4 = n; _tmp$5 = err; n = _tmp$4; err = _tmp$5;
- return [n, err];
- };
- File.prototype.Read = function(b) { return this.$val.Read(b); };
- File.ptr.prototype.ReadAt = function(b, off) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, f, m, n, off, x;
- n = 0;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = 0; _tmp$1 = $pkg.ErrInvalid; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- while (true) {
- if (!(b.$length > 0)) { break; }
- _tuple = f.pread(b, off); m = _tuple[0]; e = _tuple[1];
- if ((m === 0) && $interfaceIsEqual(e, $ifaceNil)) {
- _tmp$2 = n; _tmp$3 = io.EOF; n = _tmp$2; err = _tmp$3;
- return [n, err];
- }
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- err = new PathError.ptr("read", f.file.name, e);
- break;
- }
- n = n + (m) >> 0;
- b = $subslice(b, m);
- off = (x = new $Int64(0, m), new $Int64(off.$high + x.$high, off.$low + x.$low));
- }
- return [n, err];
- };
- File.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); };
- File.ptr.prototype.Write = function(b) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, f, n;
- n = 0;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = 0; _tmp$1 = $pkg.ErrInvalid; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- _tuple = f.write(b); n = _tuple[0]; e = _tuple[1];
- if (n < 0) {
- n = 0;
- }
- if (!((n === b.$length))) {
- err = io.ErrShortWrite;
- }
- epipecheck(f, e);
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- err = new PathError.ptr("write", f.file.name, e);
- }
- _tmp$2 = n; _tmp$3 = err; n = _tmp$2; err = _tmp$3;
- return [n, err];
- };
- File.prototype.Write = function(b) { return this.$val.Write(b); };
- File.ptr.prototype.WriteAt = function(b, off) {
- var $ptr, _tmp, _tmp$1, _tuple, b, e, err, f, m, n, off, x;
- n = 0;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = 0; _tmp$1 = $pkg.ErrInvalid; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- while (true) {
- if (!(b.$length > 0)) { break; }
- _tuple = f.pwrite(b, off); m = _tuple[0]; e = _tuple[1];
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- err = new PathError.ptr("write", f.file.name, e);
- break;
- }
- n = n + (m) >> 0;
- b = $subslice(b, m);
- off = (x = new $Int64(0, m), new $Int64(off.$high + x.$high, off.$low + x.$low));
- }
- return [n, err];
- };
- File.prototype.WriteAt = function(b, off) { return this.$val.WriteAt(b, off); };
- File.ptr.prototype.Seek = function(offset, whence) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, e, err, f, offset, r, ret, whence;
- ret = new $Int64(0, 0);
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = new $Int64(0, 0); _tmp$1 = $pkg.ErrInvalid; ret = _tmp; err = _tmp$1;
- return [ret, err];
- }
- _tuple = f.seek(offset, whence); r = _tuple[0]; e = _tuple[1];
- if ($interfaceIsEqual(e, $ifaceNil) && !(f.file.dirinfo === ptrType.nil) && !((r.$high === 0 && r.$low === 0))) {
- e = new syscall.Errno(21);
- }
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- _tmp$2 = new $Int64(0, 0); _tmp$3 = new PathError.ptr("seek", f.file.name, e); ret = _tmp$2; err = _tmp$3;
- return [ret, err];
- }
- _tmp$4 = r; _tmp$5 = $ifaceNil; ret = _tmp$4; err = _tmp$5;
- return [ret, err];
- };
- File.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); };
- File.ptr.prototype.WriteString = function(s) {
- var $ptr, _tmp, _tmp$1, _tuple, err, f, ret, s;
- ret = 0;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = 0; _tmp$1 = $pkg.ErrInvalid; ret = _tmp; err = _tmp$1;
- return [ret, err];
- }
- _tuple = f.Write(new sliceType$1($stringToBytes(s))); ret = _tuple[0]; err = _tuple[1];
- return [ret, err];
- };
- File.prototype.WriteString = function(s) { return this.$val.WriteString(s); };
- File.ptr.prototype.Chdir = function() {
- var $ptr, e, f;
- f = this;
- if (f === ptrType$2.nil) {
- return $pkg.ErrInvalid;
- }
- e = syscall.Fchdir(f.file.fd);
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- return new PathError.ptr("chdir", f.file.name, e);
- }
- return $ifaceNil;
- };
- File.prototype.Chdir = function() { return this.$val.Chdir(); };
- Open = function(name) {
- var $ptr, _tuple, err, file$1, name;
- file$1 = ptrType$2.nil;
- err = $ifaceNil;
- _tuple = OpenFile(name, 0, 0); file$1 = _tuple[0]; err = _tuple[1];
- return [file$1, err];
- };
- $pkg.Open = Open;
- fixCount = function(n, err) {
- var $ptr, err, n;
- if (n < 0) {
- n = 0;
- }
- return [n, err];
- };
- sigpipe = function() {
- $panic("Native function not implemented: os.sigpipe");
- };
- syscallMode = function(i) {
- var $ptr, i, o;
- o = 0;
- o = (o | ((new FileMode(i).Perm() >>> 0))) >>> 0;
- if (!((((i & 8388608) >>> 0) === 0))) {
- o = (o | (2048)) >>> 0;
- }
- if (!((((i & 4194304) >>> 0) === 0))) {
- o = (o | (1024)) >>> 0;
- }
- if (!((((i & 1048576) >>> 0) === 0))) {
- o = (o | (512)) >>> 0;
- }
- return o;
- };
- File.ptr.prototype.Chmod = function(mode) {
- var $ptr, e, f, mode;
- f = this;
- if (f === ptrType$2.nil) {
- return $pkg.ErrInvalid;
- }
- e = syscall.Fchmod(f.file.fd, syscallMode(mode));
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- return new PathError.ptr("chmod", f.file.name, e);
- }
- return $ifaceNil;
- };
- File.prototype.Chmod = function(mode) { return this.$val.Chmod(mode); };
- File.ptr.prototype.Chown = function(uid, gid) {
- var $ptr, e, f, gid, uid;
- f = this;
- if (f === ptrType$2.nil) {
- return $pkg.ErrInvalid;
- }
- e = syscall.Fchown(f.file.fd, uid, gid);
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- return new PathError.ptr("chown", f.file.name, e);
- }
- return $ifaceNil;
- };
- File.prototype.Chown = function(uid, gid) { return this.$val.Chown(uid, gid); };
- File.ptr.prototype.Truncate = function(size) {
- var $ptr, e, f, size;
- f = this;
- if (f === ptrType$2.nil) {
- return $pkg.ErrInvalid;
- }
- e = syscall.Ftruncate(f.file.fd, size);
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- return new PathError.ptr("truncate", f.file.name, e);
- }
- return $ifaceNil;
- };
- File.prototype.Truncate = function(size) { return this.$val.Truncate(size); };
- File.ptr.prototype.Sync = function() {
- var $ptr, e, err, f;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- err = $pkg.ErrInvalid;
- return err;
- }
- e = syscall.Fsync(f.file.fd);
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- err = NewSyscallError("fsync", e);
- return err;
- }
- err = $ifaceNil;
- return err;
- };
- File.prototype.Sync = function() { return this.$val.Sync(); };
- File.ptr.prototype.Fd = function() {
- var $ptr, f;
- f = this;
- if (f === ptrType$2.nil) {
- return 4294967295;
- }
- return (f.file.fd >>> 0);
- };
- File.prototype.Fd = function() { return this.$val.Fd(); };
- NewFile = function(fd, name) {
- var $ptr, f, fd, fdi, name;
- fdi = (fd >> 0);
- if (fdi < 0) {
- return ptrType$2.nil;
- }
- f = new File.ptr(new file.ptr(fdi, name, ptrType.nil, 0));
- runtime.SetFinalizer(f.file, new funcType$1($methodExpr(ptrType$11.prototype.close)));
- return f;
- };
- $pkg.NewFile = NewFile;
- epipecheck = function(file$1, e) {
- var $ptr, e, file$1;
- if ($interfaceIsEqual(e, new syscall.Errno(32))) {
- if (atomic.AddInt32((file$1.$ptr_nepipe || (file$1.$ptr_nepipe = new ptrType$12(function() { return this.$target.file.nepipe; }, function($v) { this.$target.file.nepipe = $v; }, file$1))), 1) >= 10) {
- sigpipe();
- }
- } else {
- atomic.StoreInt32((file$1.$ptr_nepipe || (file$1.$ptr_nepipe = new ptrType$12(function() { return this.$target.file.nepipe; }, function($v) { this.$target.file.nepipe = $v; }, file$1))), 0);
- }
- };
- OpenFile = function(name, flag, perm) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, e, err, file$1, flag, name, perm, r;
- file$1 = ptrType$2.nil;
- err = $ifaceNil;
- _tuple = syscall.Open(name, flag | 16777216, syscallMode(perm)); r = _tuple[0]; e = _tuple[1];
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- _tmp = ptrType$2.nil; _tmp$1 = new PathError.ptr("open", name, e); file$1 = _tmp; err = _tmp$1;
- return [file$1, err];
- }
- if (!supportsCloseOnExec) {
- syscall.CloseOnExec(r);
- }
- _tmp$2 = NewFile((r >>> 0), name); _tmp$3 = $ifaceNil; file$1 = _tmp$2; err = _tmp$3;
- return [file$1, err];
- };
- $pkg.OpenFile = OpenFile;
- File.ptr.prototype.Close = function() {
- var $ptr, f;
- f = this;
- if (f === ptrType$2.nil) {
- return $pkg.ErrInvalid;
- }
- return f.file.close();
- };
- File.prototype.Close = function() { return this.$val.Close(); };
- file.ptr.prototype.close = function() {
- var $ptr, e, err, file$1;
- file$1 = this;
- if (file$1 === ptrType$11.nil || file$1.fd < 0) {
- return new syscall.Errno(22);
- }
- err = $ifaceNil;
- e = syscall.Close(file$1.fd);
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- err = new PathError.ptr("close", file$1.name, e);
- }
- file$1.fd = -1;
- runtime.SetFinalizer(file$1, $ifaceNil);
- return err;
- };
- file.prototype.close = function() { return this.$val.close(); };
- File.ptr.prototype.Stat = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, err, f, fi, stat;
- fi = $ifaceNil;
- err = $ifaceNil;
- f = this;
- if (f === ptrType$2.nil) {
- _tmp = $ifaceNil; _tmp$1 = $pkg.ErrInvalid; fi = _tmp; err = _tmp$1;
- return [fi, err];
- }
- stat = $clone(new syscall.Stat_t.ptr(), syscall.Stat_t);
- err = syscall.Fstat(f.file.fd, stat);
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- _tmp$2 = $ifaceNil; _tmp$3 = new PathError.ptr("stat", f.file.name, err); fi = _tmp$2; err = _tmp$3;
- return [fi, err];
- }
- _tmp$4 = fileInfoFromStat(stat, f.file.name); _tmp$5 = $ifaceNil; fi = _tmp$4; err = _tmp$5;
- return [fi, err];
- };
- File.prototype.Stat = function() { return this.$val.Stat(); };
- Lstat = function(name) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, err, fi, name, stat;
- fi = $ifaceNil;
- err = $ifaceNil;
- stat = $clone(new syscall.Stat_t.ptr(), syscall.Stat_t);
- err = syscall.Lstat(name, stat);
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- _tmp = $ifaceNil; _tmp$1 = new PathError.ptr("lstat", name, err); fi = _tmp; err = _tmp$1;
- return [fi, err];
- }
- _tmp$2 = fileInfoFromStat(stat, name); _tmp$3 = $ifaceNil; fi = _tmp$2; err = _tmp$3;
- return [fi, err];
- };
- $pkg.Lstat = Lstat;
- File.ptr.prototype.readdir = function(n) {
- var $ptr, _i, _r, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, dirname, err, f, fi, filename, fip, lerr, n, names, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; dirname = $f.dirname; err = $f.err; f = $f.f; fi = $f.fi; filename = $f.filename; fip = $f.fip; lerr = $f.lerr; n = $f.n; names = $f.names; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- fi = sliceType$2.nil;
- err = $ifaceNil;
- f = this;
- dirname = f.file.name;
- if (dirname === "") {
- dirname = ".";
- }
- _tuple = f.Readdirnames(n); names = _tuple[0]; err = _tuple[1];
- fi = $makeSlice(sliceType$2, 0, names.$length);
- _ref = names;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- filename = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = lstat(dirname + "/" + filename); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = _r; fip = _tuple$1[0]; lerr = _tuple$1[1];
- if (IsNotExist(lerr)) {
- _i++;
- /* continue; */ $s = 1; continue;
- }
- if (!($interfaceIsEqual(lerr, $ifaceNil))) {
- _tmp = fi; _tmp$1 = lerr; fi = _tmp; err = _tmp$1;
- return [fi, err];
- }
- fi = $append(fi, fip);
- _i++;
- /* } */ $s = 1; continue; case 2:
- _tmp$2 = fi; _tmp$3 = err; fi = _tmp$2; err = _tmp$3;
- return [fi, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdir }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.dirname = dirname; $f.err = err; $f.f = f; $f.fi = fi; $f.filename = filename; $f.fip = fip; $f.lerr = lerr; $f.n = n; $f.names = names; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.readdir = function(n) { return this.$val.readdir(n); };
- File.ptr.prototype.read = function(b) {
- var $ptr, _tuple, _tuple$1, b, err, f, n;
- n = 0;
- err = $ifaceNil;
- f = this;
- if (true && b.$length > 1073741824) {
- b = $subslice(b, 0, 1073741824);
- }
- _tuple$1 = syscall.Read(f.file.fd, b);
- _tuple = fixCount(_tuple$1[0], _tuple$1[1]); n = _tuple[0]; err = _tuple[1];
- return [n, err];
- };
- File.prototype.read = function(b) { return this.$val.read(b); };
- File.ptr.prototype.pread = function(b, off) {
- var $ptr, _tuple, _tuple$1, b, err, f, n, off;
- n = 0;
- err = $ifaceNil;
- f = this;
- if (true && b.$length > 1073741824) {
- b = $subslice(b, 0, 1073741824);
- }
- _tuple$1 = syscall.Pread(f.file.fd, b, off);
- _tuple = fixCount(_tuple$1[0], _tuple$1[1]); n = _tuple[0]; err = _tuple[1];
- return [n, err];
- };
- File.prototype.pread = function(b, off) { return this.$val.pread(b, off); };
- File.ptr.prototype.write = function(b) {
- var $ptr, _tmp, _tmp$1, _tuple, _tuple$1, b, bcap, err, err$1, f, m, n;
- n = 0;
- err = $ifaceNil;
- f = this;
- while (true) {
- bcap = b;
- if (true && bcap.$length > 1073741824) {
- bcap = $subslice(bcap, 0, 1073741824);
- }
- _tuple$1 = syscall.Write(f.file.fd, bcap);
- _tuple = fixCount(_tuple$1[0], _tuple$1[1]); m = _tuple[0]; err$1 = _tuple[1];
- n = n + (m) >> 0;
- if (0 < m && m < bcap.$length || $interfaceIsEqual(err$1, new syscall.Errno(4))) {
- b = $subslice(b, m);
- continue;
- }
- if (true && !((bcap.$length === b.$length)) && $interfaceIsEqual(err$1, $ifaceNil)) {
- b = $subslice(b, m);
- continue;
- }
- _tmp = n; _tmp$1 = err$1; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- };
- File.prototype.write = function(b) { return this.$val.write(b); };
- File.ptr.prototype.pwrite = function(b, off) {
- var $ptr, _tuple, _tuple$1, b, err, f, n, off;
- n = 0;
- err = $ifaceNil;
- f = this;
- if (true && b.$length > 1073741824) {
- b = $subslice(b, 0, 1073741824);
- }
- _tuple$1 = syscall.Pwrite(f.file.fd, b, off);
- _tuple = fixCount(_tuple$1[0], _tuple$1[1]); n = _tuple[0]; err = _tuple[1];
- return [n, err];
- };
- File.prototype.pwrite = function(b, off) { return this.$val.pwrite(b, off); };
- File.ptr.prototype.seek = function(offset, whence) {
- var $ptr, _tuple, err, f, offset, ret, whence;
- ret = new $Int64(0, 0);
- err = $ifaceNil;
- f = this;
- _tuple = syscall.Seek(f.file.fd, offset, whence); ret = _tuple[0]; err = _tuple[1];
- return [ret, err];
- };
- File.prototype.seek = function(offset, whence) { return this.$val.seek(offset, whence); };
- basename = function(name) {
- var $ptr, i, name;
- i = name.length - 1 >> 0;
- while (true) {
- if (!(i > 0 && (name.charCodeAt(i) === 47))) { break; }
- name = name.substring(0, i);
- i = i - (1) >> 0;
- }
- i = i - (1) >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- if (name.charCodeAt(i) === 47) {
- name = name.substring((i + 1 >> 0));
- break;
- }
- i = i - (1) >> 0;
- }
- return name;
- };
- init$1 = function() {
- var $ptr;
- useSyscallwd = useSyscallwdDarwin;
- };
- useSyscallwdDarwin = function(err) {
- var $ptr, err;
- return !($interfaceIsEqual(err, new syscall.Errno(45)));
- };
- IsPathSeparator = function(c) {
- var $ptr, c;
- return 47 === c;
- };
- $pkg.IsPathSeparator = IsPathSeparator;
- init$2 = function() {
- var $ptr;
- $pkg.Args = runtime_args();
- };
- Exit = function(code) {
- var $ptr, code;
- syscall.Exit(code);
- };
- $pkg.Exit = Exit;
- fileInfoFromStat = function(st, name) {
- var $ptr, _ref, fs, name, st;
- fs = new fileStat.ptr(basename(name), st.Size, 0, $clone(timespecToTime(st.Mtimespec), time.Time), st);
- fs.mode = (((st.Mode & 511) >>> 0) >>> 0);
- _ref = (st.Mode & 61440) >>> 0;
- if (_ref === 24576 || _ref === 57344) {
- fs.mode = (fs.mode | (67108864)) >>> 0;
- } else if (_ref === 8192) {
- fs.mode = (fs.mode | (69206016)) >>> 0;
- } else if (_ref === 16384) {
- fs.mode = (fs.mode | (2147483648)) >>> 0;
- } else if (_ref === 4096) {
- fs.mode = (fs.mode | (33554432)) >>> 0;
- } else if (_ref === 40960) {
- fs.mode = (fs.mode | (134217728)) >>> 0;
- } else if (_ref === 32768) {
- } else if (_ref === 49152) {
- fs.mode = (fs.mode | (16777216)) >>> 0;
- }
- if (!((((st.Mode & 1024) >>> 0) === 0))) {
- fs.mode = (fs.mode | (4194304)) >>> 0;
- }
- if (!((((st.Mode & 2048) >>> 0) === 0))) {
- fs.mode = (fs.mode | (8388608)) >>> 0;
- }
- if (!((((st.Mode & 512) >>> 0) === 0))) {
- fs.mode = (fs.mode | (1048576)) >>> 0;
- }
- return fs;
- };
- timespecToTime = function(ts) {
- var $ptr, ts;
- ts = $clone(ts, syscall.Timespec);
- return time.Unix(ts.Sec, ts.Nsec);
- };
- init$3 = function() {
- var $ptr, _i, _ref, _rune, _tuple, err, i, osver;
- _tuple = syscall.Sysctl("kern.osrelease"); osver = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return;
- }
- i = 0;
- _ref = osver;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- if (!((osver.charCodeAt(i) === 46))) {
- _i += _rune[1];
- continue;
- }
- _i += _rune[1];
- }
- if (i > 2 || (i === 2) && osver.charCodeAt(0) >= 49 && osver.charCodeAt(1) >= 49) {
- supportsCloseOnExec = true;
- }
- };
- FileMode.prototype.String = function() {
- var $ptr, _i, _i$1, _ref, _ref$1, _rune, _rune$1, buf, c, c$1, i, i$1, m, w, y, y$1;
- m = this.$val;
- buf = $clone(arrayType.zero(), arrayType);
- w = 0;
- _ref = "dalTLDpSugct";
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- c = _rune[0];
- if (!((((m & (((y = ((31 - i >> 0) >>> 0), y < 32 ? (1 << y) : 0) >>> 0))) >>> 0) === 0))) {
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = (c << 24 >>> 24));
- w = w + (1) >> 0;
- }
- _i += _rune[1];
- }
- if (w === 0) {
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 45);
- w = w + (1) >> 0;
- }
- _ref$1 = "rwxrwxrwx";
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.length)) { break; }
- _rune$1 = $decodeRune(_ref$1, _i$1);
- i$1 = _i$1;
- c$1 = _rune$1[0];
- if (!((((m & (((y$1 = ((8 - i$1 >> 0) >>> 0), y$1 < 32 ? (1 << y$1) : 0) >>> 0))) >>> 0) === 0))) {
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = (c$1 << 24 >>> 24));
- } else {
- ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 45);
- }
- w = w + (1) >> 0;
- _i$1 += _rune$1[1];
- }
- return $bytesToString($subslice(new sliceType$1(buf), 0, w));
- };
- $ptrType(FileMode).prototype.String = function() { return new FileMode(this.$get()).String(); };
- FileMode.prototype.IsDir = function() {
- var $ptr, m;
- m = this.$val;
- return !((((m & 2147483648) >>> 0) === 0));
- };
- $ptrType(FileMode).prototype.IsDir = function() { return new FileMode(this.$get()).IsDir(); };
- FileMode.prototype.IsRegular = function() {
- var $ptr, m;
- m = this.$val;
- return ((m & 2399141888) >>> 0) === 0;
- };
- $ptrType(FileMode).prototype.IsRegular = function() { return new FileMode(this.$get()).IsRegular(); };
- FileMode.prototype.Perm = function() {
- var $ptr, m;
- m = this.$val;
- return (m & 511) >>> 0;
- };
- $ptrType(FileMode).prototype.Perm = function() { return new FileMode(this.$get()).Perm(); };
- fileStat.ptr.prototype.Name = function() {
- var $ptr, fs;
- fs = this;
- return fs.name;
- };
- fileStat.prototype.Name = function() { return this.$val.Name(); };
- fileStat.ptr.prototype.IsDir = function() {
- var $ptr, fs;
- fs = this;
- return new FileMode(fs.Mode()).IsDir();
- };
- fileStat.prototype.IsDir = function() { return this.$val.IsDir(); };
- fileStat.ptr.prototype.Size = function() {
- var $ptr, fs;
- fs = this;
- return fs.size;
- };
- fileStat.prototype.Size = function() { return this.$val.Size(); };
- fileStat.ptr.prototype.Mode = function() {
- var $ptr, fs;
- fs = this;
- return fs.mode;
- };
- fileStat.prototype.Mode = function() { return this.$val.Mode(); };
- fileStat.ptr.prototype.ModTime = function() {
- var $ptr, fs;
- fs = this;
- return fs.modTime;
- };
- fileStat.prototype.ModTime = function() { return this.$val.ModTime(); };
- fileStat.ptr.prototype.Sys = function() {
- var $ptr, fs;
- fs = this;
- return fs.sys;
- };
- fileStat.prototype.Sys = function() { return this.$val.Sys(); };
- ptrType$3.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$15.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$2.methods = [{prop: "readdirnames", name: "readdirnames", pkg: "os", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Readdir", name: "Readdir", pkg: "", typ: $funcType([$Int], [sliceType$2, $error], false)}, {prop: "Readdirnames", name: "Readdirnames", pkg: "", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType$1, $Int64], [$Int, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "WriteAt", name: "WriteAt", pkg: "", typ: $funcType([sliceType$1, $Int64], [$Int, $error], false)}, {prop: "Seek", name: "Seek", pkg: "", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "Chdir", name: "Chdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Chmod", name: "Chmod", pkg: "", typ: $funcType([FileMode], [$error], false)}, {prop: "Chown", name: "Chown", pkg: "", typ: $funcType([$Int, $Int], [$error], false)}, {prop: "Truncate", name: "Truncate", pkg: "", typ: $funcType([$Int64], [$error], false)}, {prop: "Sync", name: "Sync", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Fd", name: "Fd", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([], [FileInfo, $error], false)}, {prop: "readdir", name: "readdir", pkg: "os", typ: $funcType([$Int], [sliceType$2, $error], false)}, {prop: "read", name: "read", pkg: "os", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "pread", name: "pread", pkg: "os", typ: $funcType([sliceType$1, $Int64], [$Int, $error], false)}, {prop: "write", name: "write", pkg: "os", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "pwrite", name: "pwrite", pkg: "os", typ: $funcType([sliceType$1, $Int64], [$Int, $error], false)}, {prop: "seek", name: "seek", pkg: "os", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}];
- ptrType$11.methods = [{prop: "close", name: "close", pkg: "os", typ: $funcType([], [$error], false)}];
- FileMode.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsRegular", name: "IsRegular", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Perm", name: "Perm", pkg: "", typ: $funcType([], [FileMode], false)}];
- ptrType$14.methods = [{prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}];
- PathError.init([{prop: "Op", name: "Op", pkg: "", typ: $String, tag: ""}, {prop: "Path", name: "Path", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]);
- SyscallError.init([{prop: "Syscall", name: "Syscall", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]);
- LinkError.init([{prop: "Op", name: "Op", pkg: "", typ: $String, tag: ""}, {prop: "Old", name: "Old", pkg: "", typ: $String, tag: ""}, {prop: "New", name: "New", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]);
- File.init([{prop: "file", name: "", pkg: "os", typ: ptrType$11, tag: ""}]);
- file.init([{prop: "fd", name: "fd", pkg: "os", typ: $Int, tag: ""}, {prop: "name", name: "name", pkg: "os", typ: $String, tag: ""}, {prop: "dirinfo", name: "dirinfo", pkg: "os", typ: ptrType, tag: ""}, {prop: "nepipe", name: "nepipe", pkg: "os", typ: $Int32, tag: ""}]);
- dirInfo.init([{prop: "buf", name: "buf", pkg: "os", typ: sliceType$1, tag: ""}, {prop: "nbuf", name: "nbuf", pkg: "os", typ: $Int, tag: ""}, {prop: "bufp", name: "bufp", pkg: "os", typ: $Int, tag: ""}]);
- FileInfo.init([{prop: "IsDir", name: "IsDir", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ModTime", name: "ModTime", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Mode", name: "Mode", pkg: "", typ: $funcType([], [FileMode], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Sys", name: "Sys", pkg: "", typ: $funcType([], [$emptyInterface], false)}]);
- fileStat.init([{prop: "name", name: "name", pkg: "os", typ: $String, tag: ""}, {prop: "size", name: "size", pkg: "os", typ: $Int64, tag: ""}, {prop: "mode", name: "mode", pkg: "os", typ: FileMode, tag: ""}, {prop: "modTime", name: "modTime", pkg: "os", typ: time.Time, tag: ""}, {prop: "sys", name: "sys", pkg: "os", typ: $emptyInterface, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = atomic.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = syscall.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = time.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.Args = sliceType.nil;
- supportsCloseOnExec = false;
- $pkg.ErrInvalid = errors.New("invalid argument");
- $pkg.ErrPermission = errors.New("permission denied");
- $pkg.ErrExist = errors.New("file already exists");
- $pkg.ErrNotExist = errors.New("file does not exist");
- errFinished = errors.New("os: process already finished");
- $pkg.Stdin = NewFile((syscall.Stdin >>> 0), "/dev/stdin");
- $pkg.Stdout = NewFile((syscall.Stdout >>> 0), "/dev/stdout");
- $pkg.Stderr = NewFile((syscall.Stderr >>> 0), "/dev/stderr");
- useSyscallwd = (function(param) {
- var $ptr, param;
- return true;
- });
- lstat = Lstat;
- init();
- init$1();
- init$2();
- init$3();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["fmt"] = (function() {
- var $pkg = {}, $init, errors, io, math, os, reflect, strconv, sync, utf8, fmtFlags, fmt, State, Formatter, Stringer, GoStringer, buffer, pp, runeUnreader, ScanState, scanError, ss, ssave, sliceType, sliceType$1, arrayType, sliceType$2, ptrType, ptrType$1, ptrType$2, ptrType$5, arrayType$1, arrayType$2, ptrType$25, funcType, padZeroBytes, padSpaceBytes, trueBytes, falseBytes, commaSpaceBytes, nilAngleBytes, nilParenBytes, nilBytes, mapBytes, percentBangBytes, missingBytes, badIndexBytes, panicBytes, extraBytes, irparenBytes, bytesBytes, badWidthBytes, badPrecBytes, noVerbBytes, ppFree, intBits, uintptrBits, byteType, space, ssFree, complexError, boolError, _r, _r$1, init, doPrec, newPrinter, Fprintf, Printf, Sprintf, Errorf, Fprint, Print, Fprintln, Println, Sprintln, getField, parsenum, intFromArg, parseArgNumber, isSpace, notSpace, indexRune;
- errors = $packages["errors"];
- io = $packages["io"];
- math = $packages["math"];
- os = $packages["os"];
- reflect = $packages["reflect"];
- strconv = $packages["strconv"];
- sync = $packages["sync"];
- utf8 = $packages["unicode/utf8"];
- fmtFlags = $pkg.fmtFlags = $newType(0, $kindStruct, "fmt.fmtFlags", "fmtFlags", "fmt", function(widPresent_, precPresent_, minus_, plus_, sharp_, space_, unicode_, uniQuote_, zero_, plusV_, sharpV_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.widPresent = false;
- this.precPresent = false;
- this.minus = false;
- this.plus = false;
- this.sharp = false;
- this.space = false;
- this.unicode = false;
- this.uniQuote = false;
- this.zero = false;
- this.plusV = false;
- this.sharpV = false;
- return;
- }
- this.widPresent = widPresent_;
- this.precPresent = precPresent_;
- this.minus = minus_;
- this.plus = plus_;
- this.sharp = sharp_;
- this.space = space_;
- this.unicode = unicode_;
- this.uniQuote = uniQuote_;
- this.zero = zero_;
- this.plusV = plusV_;
- this.sharpV = sharpV_;
- });
- fmt = $pkg.fmt = $newType(0, $kindStruct, "fmt.fmt", "fmt", "fmt", function(intbuf_, buf_, wid_, prec_, fmtFlags_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.intbuf = arrayType$2.zero();
- this.buf = ptrType$1.nil;
- this.wid = 0;
- this.prec = 0;
- this.fmtFlags = new fmtFlags.ptr();
- return;
- }
- this.intbuf = intbuf_;
- this.buf = buf_;
- this.wid = wid_;
- this.prec = prec_;
- this.fmtFlags = fmtFlags_;
- });
- State = $pkg.State = $newType(8, $kindInterface, "fmt.State", "State", "fmt", null);
- Formatter = $pkg.Formatter = $newType(8, $kindInterface, "fmt.Formatter", "Formatter", "fmt", null);
- Stringer = $pkg.Stringer = $newType(8, $kindInterface, "fmt.Stringer", "Stringer", "fmt", null);
- GoStringer = $pkg.GoStringer = $newType(8, $kindInterface, "fmt.GoStringer", "GoStringer", "fmt", null);
- buffer = $pkg.buffer = $newType(12, $kindSlice, "fmt.buffer", "buffer", "fmt", null);
- pp = $pkg.pp = $newType(0, $kindStruct, "fmt.pp", "pp", "fmt", function(n_, panicking_, erroring_, buf_, arg_, value_, reordered_, goodArgNum_, runeBuf_, fmt_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.n = 0;
- this.panicking = false;
- this.erroring = false;
- this.buf = buffer.nil;
- this.arg = $ifaceNil;
- this.value = new reflect.Value.ptr();
- this.reordered = false;
- this.goodArgNum = false;
- this.runeBuf = arrayType$1.zero();
- this.fmt = new fmt.ptr();
- return;
- }
- this.n = n_;
- this.panicking = panicking_;
- this.erroring = erroring_;
- this.buf = buf_;
- this.arg = arg_;
- this.value = value_;
- this.reordered = reordered_;
- this.goodArgNum = goodArgNum_;
- this.runeBuf = runeBuf_;
- this.fmt = fmt_;
- });
- runeUnreader = $pkg.runeUnreader = $newType(8, $kindInterface, "fmt.runeUnreader", "runeUnreader", "fmt", null);
- ScanState = $pkg.ScanState = $newType(8, $kindInterface, "fmt.ScanState", "ScanState", "fmt", null);
- scanError = $pkg.scanError = $newType(0, $kindStruct, "fmt.scanError", "scanError", "fmt", function(err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.err = $ifaceNil;
- return;
- }
- this.err = err_;
- });
- ss = $pkg.ss = $newType(0, $kindStruct, "fmt.ss", "ss", "fmt", function(rr_, buf_, peekRune_, prevRune_, count_, atEOF_, ssave_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.rr = $ifaceNil;
- this.buf = buffer.nil;
- this.peekRune = 0;
- this.prevRune = 0;
- this.count = 0;
- this.atEOF = false;
- this.ssave = new ssave.ptr();
- return;
- }
- this.rr = rr_;
- this.buf = buf_;
- this.peekRune = peekRune_;
- this.prevRune = prevRune_;
- this.count = count_;
- this.atEOF = atEOF_;
- this.ssave = ssave_;
- });
- ssave = $pkg.ssave = $newType(0, $kindStruct, "fmt.ssave", "ssave", "fmt", function(validSave_, nlIsEnd_, nlIsSpace_, argLimit_, limit_, maxWid_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.validSave = false;
- this.nlIsEnd = false;
- this.nlIsSpace = false;
- this.argLimit = 0;
- this.limit = 0;
- this.maxWid = 0;
- return;
- }
- this.validSave = validSave_;
- this.nlIsEnd = nlIsEnd_;
- this.nlIsSpace = nlIsSpace_;
- this.argLimit = argLimit_;
- this.limit = limit_;
- this.maxWid = maxWid_;
- });
- sliceType = $sliceType($Uint8);
- sliceType$1 = $sliceType($emptyInterface);
- arrayType = $arrayType($Uint16, 2);
- sliceType$2 = $sliceType(arrayType);
- ptrType = $ptrType(pp);
- ptrType$1 = $ptrType(buffer);
- ptrType$2 = $ptrType(reflect.rtype);
- ptrType$5 = $ptrType(ss);
- arrayType$1 = $arrayType($Uint8, 4);
- arrayType$2 = $arrayType($Uint8, 65);
- ptrType$25 = $ptrType(fmt);
- funcType = $funcType([$Int32], [$Bool], false);
- init = function() {
- var $ptr, i;
- i = 0;
- while (true) {
- if (!(i < 65)) { break; }
- ((i < 0 || i >= padZeroBytes.$length) ? $throwRuntimeError("index out of range") : padZeroBytes.$array[padZeroBytes.$offset + i] = 48);
- ((i < 0 || i >= padSpaceBytes.$length) ? $throwRuntimeError("index out of range") : padSpaceBytes.$array[padSpaceBytes.$offset + i] = 32);
- i = i + (1) >> 0;
- }
- };
- fmt.ptr.prototype.clearflags = function() {
- var $ptr, f;
- f = this;
- $copy(f.fmtFlags, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false, false, false), fmtFlags);
- };
- fmt.prototype.clearflags = function() { return this.$val.clearflags(); };
- fmt.ptr.prototype.init = function(buf) {
- var $ptr, buf, f;
- f = this;
- f.buf = buf;
- f.clearflags();
- };
- fmt.prototype.init = function(buf) { return this.$val.init(buf); };
- fmt.ptr.prototype.computePadding = function(width) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, f, left, leftWidth, padding, rightWidth, w, width;
- padding = sliceType.nil;
- leftWidth = 0;
- rightWidth = 0;
- f = this;
- left = !f.fmtFlags.minus;
- w = f.wid;
- if (w < 0) {
- left = false;
- w = -w;
- }
- w = w - (width) >> 0;
- if (w > 0) {
- if (left && f.fmtFlags.zero) {
- _tmp = padZeroBytes; _tmp$1 = w; _tmp$2 = 0; padding = _tmp; leftWidth = _tmp$1; rightWidth = _tmp$2;
- return [padding, leftWidth, rightWidth];
- }
- if (left) {
- _tmp$3 = padSpaceBytes; _tmp$4 = w; _tmp$5 = 0; padding = _tmp$3; leftWidth = _tmp$4; rightWidth = _tmp$5;
- return [padding, leftWidth, rightWidth];
- } else {
- _tmp$6 = padSpaceBytes; _tmp$7 = 0; _tmp$8 = w; padding = _tmp$6; leftWidth = _tmp$7; rightWidth = _tmp$8;
- return [padding, leftWidth, rightWidth];
- }
- }
- return [padding, leftWidth, rightWidth];
- };
- fmt.prototype.computePadding = function(width) { return this.$val.computePadding(width); };
- fmt.ptr.prototype.writePadding = function(n, padding) {
- var $ptr, f, m, n, padding;
- f = this;
- while (true) {
- if (!(n > 0)) { break; }
- m = n;
- if (m > 65) {
- m = 65;
- }
- f.buf.Write($subslice(padding, 0, m));
- n = n - (m) >> 0;
- }
- };
- fmt.prototype.writePadding = function(n, padding) { return this.$val.writePadding(n, padding); };
- fmt.ptr.prototype.pad = function(b) {
- var $ptr, _tuple, b, f, left, padding, right;
- f = this;
- if (!f.fmtFlags.widPresent || (f.wid === 0)) {
- f.buf.Write(b);
- return;
- }
- _tuple = f.computePadding(utf8.RuneCount(b)); padding = _tuple[0]; left = _tuple[1]; right = _tuple[2];
- if (left > 0) {
- f.writePadding(left, padding);
- }
- f.buf.Write(b);
- if (right > 0) {
- f.writePadding(right, padding);
- }
- };
- fmt.prototype.pad = function(b) { return this.$val.pad(b); };
- fmt.ptr.prototype.padString = function(s) {
- var $ptr, _tuple, f, left, padding, right, s;
- f = this;
- if (!f.fmtFlags.widPresent || (f.wid === 0)) {
- f.buf.WriteString(s);
- return;
- }
- _tuple = f.computePadding(utf8.RuneCountInString(s)); padding = _tuple[0]; left = _tuple[1]; right = _tuple[2];
- if (left > 0) {
- f.writePadding(left, padding);
- }
- f.buf.WriteString(s);
- if (right > 0) {
- f.writePadding(right, padding);
- }
- };
- fmt.prototype.padString = function(s) { return this.$val.padString(s); };
- fmt.ptr.prototype.fmt_boolean = function(v) {
- var $ptr, f, v;
- f = this;
- if (v) {
- f.pad(trueBytes);
- } else {
- f.pad(falseBytes);
- }
- };
- fmt.prototype.fmt_boolean = function(v) { return this.$val.fmt_boolean(v); };
- fmt.ptr.prototype.integer = function(a, base, signedness, digits) {
- var $ptr, _ref, _ref$1, a, base, buf, digits, f, i, j, negative, next, prec, runeWidth, signedness, ua, width, width$1, x, x$1, x$2, x$3;
- f = this;
- if (f.fmtFlags.precPresent && (f.prec === 0) && (a.$high === 0 && a.$low === 0)) {
- return;
- }
- buf = $subslice(new sliceType(f.intbuf), 0);
- if (f.fmtFlags.widPresent) {
- width = f.wid;
- if ((base.$high === 0 && base.$low === 16) && f.fmtFlags.sharp) {
- width = width + (2) >> 0;
- }
- if (width > 65) {
- buf = $makeSlice(sliceType, width);
- }
- }
- negative = signedness && (a.$high < 0 || (a.$high === 0 && a.$low < 0));
- if (negative) {
- a = new $Int64(-a.$high, -a.$low);
- }
- prec = 0;
- if (f.fmtFlags.precPresent) {
- prec = f.prec;
- f.fmtFlags.zero = false;
- } else if (f.fmtFlags.zero && f.fmtFlags.widPresent && !f.fmtFlags.minus && f.wid > 0) {
- prec = f.wid;
- if (negative || f.fmtFlags.plus || f.fmtFlags.space) {
- prec = prec - (1) >> 0;
- }
- }
- i = buf.$length;
- ua = new $Uint64(a.$high, a.$low);
- _ref = base;
- if ((_ref.$high === 0 && _ref.$low === 10)) {
- while (true) {
- if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 10)))) { break; }
- i = i - (1) >> 0;
- next = $div64(ua, new $Uint64(0, 10), false);
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((x = new $Uint64(0 + ua.$high, 48 + ua.$low), x$1 = $mul64(next, new $Uint64(0, 10)), new $Uint64(x.$high - x$1.$high, x.$low - x$1.$low)).$low << 24 >>> 24));
- ua = next;
- }
- } else if ((_ref.$high === 0 && _ref.$low === 16)) {
- while (true) {
- if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 16)))) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(new $Uint64(ua.$high & 0, (ua.$low & 15) >>> 0))));
- ua = $shiftRightUint64(ua, (4));
- }
- } else if ((_ref.$high === 0 && _ref.$low === 8)) {
- while (true) {
- if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 8)))) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((x$2 = new $Uint64(ua.$high & 0, (ua.$low & 7) >>> 0), new $Uint64(0 + x$2.$high, 48 + x$2.$low)).$low << 24 >>> 24));
- ua = $shiftRightUint64(ua, (3));
- }
- } else if ((_ref.$high === 0 && _ref.$low === 2)) {
- while (true) {
- if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 2)))) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((x$3 = new $Uint64(ua.$high & 0, (ua.$low & 1) >>> 0), new $Uint64(0 + x$3.$high, 48 + x$3.$low)).$low << 24 >>> 24));
- ua = $shiftRightUint64(ua, (1));
- }
- } else {
- $panic(new $String("fmt: unknown base; can't happen"));
- }
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(ua)));
- while (true) {
- if (!(i > 0 && prec > (buf.$length - i >> 0))) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 48);
- }
- if (f.fmtFlags.sharp) {
- _ref$1 = base;
- if ((_ref$1.$high === 0 && _ref$1.$low === 8)) {
- if (!((((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i]) === 48))) {
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 48);
- }
- } else if ((_ref$1.$high === 0 && _ref$1.$low === 16)) {
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = (120 + digits.charCodeAt(10) << 24 >>> 24) - 97 << 24 >>> 24);
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 48);
- }
- }
- if (f.fmtFlags.unicode) {
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 43);
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 85);
- }
- if (negative) {
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 45);
- } else if (f.fmtFlags.plus) {
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 43);
- } else if (f.fmtFlags.space) {
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 32);
- }
- if (f.fmtFlags.unicode && f.fmtFlags.uniQuote && (a.$high > 0 || (a.$high === 0 && a.$low >= 0)) && (a.$high < 0 || (a.$high === 0 && a.$low <= 1114111)) && strconv.IsPrint(((a.$low + ((a.$high >> 31) * 4294967296)) >> 0))) {
- runeWidth = utf8.RuneLen(((a.$low + ((a.$high >> 31) * 4294967296)) >> 0));
- width$1 = (2 + runeWidth >> 0) + 1 >> 0;
- $copySlice($subslice(buf, (i - width$1 >> 0)), $subslice(buf, i));
- i = i - (width$1) >> 0;
- j = buf.$length - width$1 >> 0;
- ((j < 0 || j >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + j] = 32);
- j = j + (1) >> 0;
- ((j < 0 || j >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + j] = 39);
- j = j + (1) >> 0;
- utf8.EncodeRune($subslice(buf, j), ((a.$low + ((a.$high >> 31) * 4294967296)) >> 0));
- j = j + (runeWidth) >> 0;
- ((j < 0 || j >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + j] = 39);
- }
- f.pad($subslice(buf, i));
- };
- fmt.prototype.integer = function(a, base, signedness, digits) { return this.$val.integer(a, base, signedness, digits); };
- fmt.ptr.prototype.truncate = function(s) {
- var $ptr, _i, _ref, _rune, f, i, n, s;
- f = this;
- if (f.fmtFlags.precPresent && f.prec < utf8.RuneCountInString(s)) {
- n = f.prec;
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- if (n === 0) {
- s = s.substring(0, i);
- break;
- }
- n = n - (1) >> 0;
- _i += _rune[1];
- }
- }
- return s;
- };
- fmt.prototype.truncate = function(s) { return this.$val.truncate(s); };
- fmt.ptr.prototype.fmt_s = function(s) {
- var $ptr, f, s;
- f = this;
- s = f.truncate(s);
- f.padString(s);
- };
- fmt.prototype.fmt_s = function(s) { return this.$val.fmt_s(s); };
- fmt.ptr.prototype.fmt_sbx = function(s, b, digits) {
- var $ptr, b, buf, c, digits, f, i, n, s, x;
- f = this;
- n = b.$length;
- if (b === sliceType.nil) {
- n = s.length;
- }
- x = (digits.charCodeAt(10) - 97 << 24 >>> 24) + 120 << 24 >>> 24;
- buf = sliceType.nil;
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- if (i > 0 && f.fmtFlags.space) {
- buf = $append(buf, 32);
- }
- if (f.fmtFlags.sharp && (f.fmtFlags.space || (i === 0))) {
- buf = $append(buf, 48, x);
- }
- c = 0;
- if (b === sliceType.nil) {
- c = s.charCodeAt(i);
- } else {
- c = ((i < 0 || i >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + i]);
- }
- buf = $append(buf, digits.charCodeAt((c >>> 4 << 24 >>> 24)), digits.charCodeAt(((c & 15) >>> 0)));
- i = i + (1) >> 0;
- }
- f.pad(buf);
- };
- fmt.prototype.fmt_sbx = function(s, b, digits) { return this.$val.fmt_sbx(s, b, digits); };
- fmt.ptr.prototype.fmt_sx = function(s, digits) {
- var $ptr, digits, f, s;
- f = this;
- if (f.fmtFlags.precPresent && f.prec < s.length) {
- s = s.substring(0, f.prec);
- }
- f.fmt_sbx(s, sliceType.nil, digits);
- };
- fmt.prototype.fmt_sx = function(s, digits) { return this.$val.fmt_sx(s, digits); };
- fmt.ptr.prototype.fmt_bx = function(b, digits) {
- var $ptr, b, digits, f;
- f = this;
- if (f.fmtFlags.precPresent && f.prec < b.$length) {
- b = $subslice(b, 0, f.prec);
- }
- f.fmt_sbx("", b, digits);
- };
- fmt.prototype.fmt_bx = function(b, digits) { return this.$val.fmt_bx(b, digits); };
- fmt.ptr.prototype.fmt_q = function(s) {
- var $ptr, f, quoted, s;
- f = this;
- s = f.truncate(s);
- quoted = "";
- if (f.fmtFlags.sharp && strconv.CanBackquote(s)) {
- quoted = "`" + s + "`";
- } else {
- if (f.fmtFlags.plus) {
- quoted = strconv.QuoteToASCII(s);
- } else {
- quoted = strconv.Quote(s);
- }
- }
- f.padString(quoted);
- };
- fmt.prototype.fmt_q = function(s) { return this.$val.fmt_q(s); };
- fmt.ptr.prototype.fmt_qc = function(c) {
- var $ptr, c, f, quoted;
- f = this;
- quoted = sliceType.nil;
- if (f.fmtFlags.plus) {
- quoted = strconv.AppendQuoteRuneToASCII($subslice(new sliceType(f.intbuf), 0, 0), ((c.$low + ((c.$high >> 31) * 4294967296)) >> 0));
- } else {
- quoted = strconv.AppendQuoteRune($subslice(new sliceType(f.intbuf), 0, 0), ((c.$low + ((c.$high >> 31) * 4294967296)) >> 0));
- }
- f.pad(quoted);
- };
- fmt.prototype.fmt_qc = function(c) { return this.$val.fmt_qc(c); };
- doPrec = function(f, def) {
- var $ptr, def, f;
- if (f.fmtFlags.precPresent) {
- return f.prec;
- }
- return def;
- };
- fmt.ptr.prototype.formatFloat = function(v, verb, prec, n) {
- var $ptr, f, n, num, prec, v, verb, $deferred;
- /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- f = this;
- num = strconv.AppendFloat($subslice(new sliceType(f.intbuf), 0, 1), v, verb, prec, n);
- if (((1 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 1]) === 45) || ((1 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 1]) === 43)) {
- num = $subslice(num, 1);
- } else {
- (0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0] = 43);
- }
- if (math.IsInf(v, 0)) {
- if (f.fmtFlags.zero) {
- $deferred.push([(function() {
- var $ptr;
- f.fmtFlags.zero = true;
- }), []]);
- f.fmtFlags.zero = false;
- }
- }
- if (f.fmtFlags.zero && f.fmtFlags.widPresent && f.wid > num.$length) {
- if (f.fmtFlags.space && v >= 0) {
- f.buf.WriteByte(32);
- f.wid = f.wid - (1) >> 0;
- } else if (f.fmtFlags.plus || v < 0) {
- f.buf.WriteByte((0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0]));
- f.wid = f.wid - (1) >> 0;
- }
- f.pad($subslice(num, 1));
- return;
- }
- if (f.fmtFlags.space && ((0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0]) === 43)) {
- (0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0] = 32);
- f.pad(num);
- return;
- }
- if (f.fmtFlags.plus || ((0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0]) === 45) || math.IsInf(v, 0)) {
- f.pad(num);
- return;
- }
- f.pad($subslice(num, 1));
- /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); }
- };
- fmt.prototype.formatFloat = function(v, verb, prec, n) { return this.$val.formatFloat(v, verb, prec, n); };
- fmt.ptr.prototype.fmt_e64 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 101, doPrec(f, 6), 64);
- };
- fmt.prototype.fmt_e64 = function(v) { return this.$val.fmt_e64(v); };
- fmt.ptr.prototype.fmt_E64 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 69, doPrec(f, 6), 64);
- };
- fmt.prototype.fmt_E64 = function(v) { return this.$val.fmt_E64(v); };
- fmt.ptr.prototype.fmt_f64 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 102, doPrec(f, 6), 64);
- };
- fmt.prototype.fmt_f64 = function(v) { return this.$val.fmt_f64(v); };
- fmt.ptr.prototype.fmt_g64 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 103, doPrec(f, -1), 64);
- };
- fmt.prototype.fmt_g64 = function(v) { return this.$val.fmt_g64(v); };
- fmt.ptr.prototype.fmt_G64 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 71, doPrec(f, -1), 64);
- };
- fmt.prototype.fmt_G64 = function(v) { return this.$val.fmt_G64(v); };
- fmt.ptr.prototype.fmt_fb64 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 98, 0, 64);
- };
- fmt.prototype.fmt_fb64 = function(v) { return this.$val.fmt_fb64(v); };
- fmt.ptr.prototype.fmt_e32 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 101, doPrec(f, 6), 32);
- };
- fmt.prototype.fmt_e32 = function(v) { return this.$val.fmt_e32(v); };
- fmt.ptr.prototype.fmt_E32 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 69, doPrec(f, 6), 32);
- };
- fmt.prototype.fmt_E32 = function(v) { return this.$val.fmt_E32(v); };
- fmt.ptr.prototype.fmt_f32 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 102, doPrec(f, 6), 32);
- };
- fmt.prototype.fmt_f32 = function(v) { return this.$val.fmt_f32(v); };
- fmt.ptr.prototype.fmt_g32 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 103, doPrec(f, -1), 32);
- };
- fmt.prototype.fmt_g32 = function(v) { return this.$val.fmt_g32(v); };
- fmt.ptr.prototype.fmt_G32 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 71, doPrec(f, -1), 32);
- };
- fmt.prototype.fmt_G32 = function(v) { return this.$val.fmt_G32(v); };
- fmt.ptr.prototype.fmt_fb32 = function(v) {
- var $ptr, f, v;
- f = this;
- f.formatFloat(v, 98, 0, 32);
- };
- fmt.prototype.fmt_fb32 = function(v) { return this.$val.fmt_fb32(v); };
- fmt.ptr.prototype.fmt_c64 = function(v, verb) {
- var $ptr, f, v, verb;
- f = this;
- f.fmt_complex(v.$real, v.$imag, 32, verb);
- };
- fmt.prototype.fmt_c64 = function(v, verb) { return this.$val.fmt_c64(v, verb); };
- fmt.ptr.prototype.fmt_c128 = function(v, verb) {
- var $ptr, f, v, verb;
- f = this;
- f.fmt_complex(v.$real, v.$imag, 64, verb);
- };
- fmt.prototype.fmt_c128 = function(v, verb) { return this.$val.fmt_c128(v, verb); };
- fmt.ptr.prototype.fmt_complex = function(r, j, size, verb) {
- var $ptr, _ref, f, i, j, oldPlus, oldSpace, oldWid, r, size, verb;
- f = this;
- f.buf.WriteByte(40);
- oldPlus = f.fmtFlags.plus;
- oldSpace = f.fmtFlags.space;
- oldWid = f.wid;
- i = 0;
- while (true) {
- _ref = verb;
- if (_ref === 98) {
- f.formatFloat(r, 98, 0, size);
- } else if (_ref === 101) {
- f.formatFloat(r, 101, doPrec(f, 6), size);
- } else if (_ref === 69) {
- f.formatFloat(r, 69, doPrec(f, 6), size);
- } else if (_ref === 102 || _ref === 70) {
- f.formatFloat(r, 102, doPrec(f, 6), size);
- } else if (_ref === 103) {
- f.formatFloat(r, 103, doPrec(f, -1), size);
- } else if (_ref === 71) {
- f.formatFloat(r, 71, doPrec(f, -1), size);
- }
- if (!((i === 0))) {
- break;
- }
- f.fmtFlags.plus = true;
- f.fmtFlags.space = false;
- f.wid = oldWid;
- r = j;
- i = i + (1) >> 0;
- }
- f.fmtFlags.space = oldSpace;
- f.fmtFlags.plus = oldPlus;
- f.wid = oldWid;
- f.buf.Write(irparenBytes);
- };
- fmt.prototype.fmt_complex = function(r, j, size, verb) { return this.$val.fmt_complex(r, j, size, verb); };
- $ptrType(buffer).prototype.Write = function(p) {
- var $ptr, _tmp, _tmp$1, b, err, n, p;
- n = 0;
- err = $ifaceNil;
- b = this;
- b.$set($appendSlice(b.$get(), p));
- _tmp = p.$length; _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- };
- $ptrType(buffer).prototype.WriteString = function(s) {
- var $ptr, _tmp, _tmp$1, b, err, n, s;
- n = 0;
- err = $ifaceNil;
- b = this;
- b.$set($appendSlice(b.$get(), new buffer($stringToBytes(s))));
- _tmp = s.length; _tmp$1 = $ifaceNil; n = _tmp; err = _tmp$1;
- return [n, err];
- };
- $ptrType(buffer).prototype.WriteByte = function(c) {
- var $ptr, b, c;
- b = this;
- b.$set($append(b.$get(), c));
- return $ifaceNil;
- };
- $ptrType(buffer).prototype.WriteRune = function(r) {
- var $ptr, b, bp, n, r, w, x;
- bp = this;
- if (r < 128) {
- bp.$set($append(bp.$get(), (r << 24 >>> 24)));
- return $ifaceNil;
- }
- b = bp.$get();
- n = b.$length;
- while (true) {
- if (!((n + 4 >> 0) > b.$capacity)) { break; }
- b = $append(b, 0);
- }
- w = utf8.EncodeRune((x = $subslice(b, n, (n + 4 >> 0)), $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length)), r);
- bp.$set($subslice(b, 0, (n + w >> 0)));
- return $ifaceNil;
- };
- newPrinter = function() {
- var $ptr, _r$2, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = ppFree.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- p = $assertType(_r$2, ptrType);
- p.panicking = false;
- p.erroring = false;
- p.fmt.init((p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))));
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newPrinter }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.ptr.prototype.free = function() {
- var $ptr, p;
- p = this;
- if (p.buf.$capacity > 1024) {
- return;
- }
- p.buf = $subslice(p.buf, 0, 0);
- p.arg = $ifaceNil;
- p.value = new reflect.Value.ptr(ptrType$2.nil, 0, 0);
- ppFree.Put(p);
- };
- pp.prototype.free = function() { return this.$val.free(); };
- pp.ptr.prototype.Width = function() {
- var $ptr, _tmp, _tmp$1, ok, p, wid;
- wid = 0;
- ok = false;
- p = this;
- _tmp = p.fmt.wid; _tmp$1 = p.fmt.fmtFlags.widPresent; wid = _tmp; ok = _tmp$1;
- return [wid, ok];
- };
- pp.prototype.Width = function() { return this.$val.Width(); };
- pp.ptr.prototype.Precision = function() {
- var $ptr, _tmp, _tmp$1, ok, p, prec;
- prec = 0;
- ok = false;
- p = this;
- _tmp = p.fmt.prec; _tmp$1 = p.fmt.fmtFlags.precPresent; prec = _tmp; ok = _tmp$1;
- return [prec, ok];
- };
- pp.prototype.Precision = function() { return this.$val.Precision(); };
- pp.ptr.prototype.Flag = function(b) {
- var $ptr, _ref, b, p;
- p = this;
- _ref = b;
- if (_ref === 45) {
- return p.fmt.fmtFlags.minus;
- } else if (_ref === 43) {
- return p.fmt.fmtFlags.plus;
- } else if (_ref === 35) {
- return p.fmt.fmtFlags.sharp;
- } else if (_ref === 32) {
- return p.fmt.fmtFlags.space;
- } else if (_ref === 48) {
- return p.fmt.fmtFlags.zero;
- }
- return false;
- };
- pp.prototype.Flag = function(b) { return this.$val.Flag(b); };
- pp.ptr.prototype.add = function(c) {
- var $ptr, c, p;
- p = this;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(c);
- };
- pp.prototype.add = function(c) { return this.$val.add(c); };
- pp.ptr.prototype.Write = function(b) {
- var $ptr, _tuple, b, err, p, ret;
- ret = 0;
- err = $ifaceNil;
- p = this;
- _tuple = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(b); ret = _tuple[0]; err = _tuple[1];
- return [ret, err];
- };
- pp.prototype.Write = function(b) { return this.$val.Write(b); };
- Fprintf = function(w, format, a) {
- var $ptr, _r$2, _r$3, _tuple, a, err, format, n, p, w, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; a = $f.a; err = $f.err; format = $f.format; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _r$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- p = _r$2;
- $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = w.Write((x = p.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; n = _tuple[0]; err = _tuple[1];
- p.free();
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Fprintf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.format = format; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Fprintf = Fprintf;
- Printf = function(format, a) {
- var $ptr, _r$2, _tuple, a, err, format, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _tuple = $f._tuple; a = $f.a; err = $f.err; format = $f.format; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _r$2 = Fprintf(os.Stdout, format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; n = _tuple[0]; err = _tuple[1];
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Printf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.format = format; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Printf = Printf;
- Sprintf = function(format, a) {
- var $ptr, _r$2, a, format, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; a = $f.a; format = $f.format; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- p = _r$2;
- $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- s = $bytesToString(p.buf);
- p.free();
- return s;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Sprintf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.a = a; $f.format = format; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Sprintf = Sprintf;
- Errorf = function(format, a) {
- var $ptr, _r$2, _r$3, a, format, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; a = $f.a; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = Sprintf(format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = errors.New(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Errorf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.a = a; $f.format = format; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Errorf = Errorf;
- Fprint = function(w, a) {
- var $ptr, _r$2, _r$3, _tuple, a, err, n, p, w, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _r$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- p = _r$2;
- $r = p.doPrint(a, false, false); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = w.Write((x = p.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; n = _tuple[0]; err = _tuple[1];
- p.free();
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Fprint }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Fprint = Fprint;
- Print = function(a) {
- var $ptr, _r$2, _tuple, a, err, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _r$2 = Fprint(os.Stdout, a); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; n = _tuple[0]; err = _tuple[1];
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Print }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Print = Print;
- Fprintln = function(w, a) {
- var $ptr, _r$2, _r$3, _tuple, a, err, n, p, w, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; p = $f.p; w = $f.w; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _r$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- p = _r$2;
- $r = p.doPrint(a, true, true); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = w.Write((x = p.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; n = _tuple[0]; err = _tuple[1];
- p.free();
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Fprintln }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.p = p; $f.w = w; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Fprintln = Fprintln;
- Println = function(a) {
- var $ptr, _r$2, _tuple, a, err, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _tuple = $f._tuple; a = $f.a; err = $f.err; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- _r$2 = Fprintln(os.Stdout, a); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; n = _tuple[0]; err = _tuple[1];
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Println }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Println = Println;
- Sprintln = function(a) {
- var $ptr, _r$2, a, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; a = $f.a; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- p = _r$2;
- $r = p.doPrint(a, true, true); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- s = $bytesToString(p.buf);
- p.free();
- return s;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Sprintln }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.a = a; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Sprintln = Sprintln;
- getField = function(v, i) {
- var $ptr, _r$2, _r$3, i, v, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$2 = v.Field(i); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- val = _r$2;
- /* */ if ((val.Kind() === 20) && !val.IsNil()) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ((val.Kind() === 20) && !val.IsNil()) { */ case 2:
- _r$3 = val.Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- val = _r$3;
- /* } */ case 3:
- return val;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: getField }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- parsenum = function(s, start, end) {
- var $ptr, _tmp, _tmp$1, _tmp$2, end, isnum, newi, num, s, start;
- num = 0;
- isnum = false;
- newi = 0;
- if (start >= end) {
- _tmp = 0; _tmp$1 = false; _tmp$2 = end; num = _tmp; isnum = _tmp$1; newi = _tmp$2;
- return [num, isnum, newi];
- }
- newi = start;
- while (true) {
- if (!(newi < end && 48 <= s.charCodeAt(newi) && s.charCodeAt(newi) <= 57)) { break; }
- num = (num * 10 >> 0) + ((s.charCodeAt(newi) - 48 << 24 >>> 24) >> 0) >> 0;
- isnum = true;
- newi = newi + (1) >> 0;
- }
- return [num, isnum, newi];
- };
- pp.ptr.prototype.unknownType = function(v) {
- var $ptr, _r$2, _r$3, p, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; p = $f.p; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- v = v;
- if (!v.IsValid()) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes);
- return;
- }
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63);
- _r$2 = v.Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(63);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.unknownType }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.p = p; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.unknownType = function(v) { return this.$val.unknownType(v); };
- pp.ptr.prototype.badVerb = function(verb) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, p, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; p = $f.p; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- p.erroring = true;
- p.add(37);
- p.add(33);
- p.add(verb);
- p.add(40);
- /* */ if (!($interfaceIsEqual(p.arg, $ifaceNil))) { $s = 1; continue; }
- /* */ if (p.value.IsValid()) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(p.arg, $ifaceNil))) { */ case 1:
- _r$2 = reflect.TypeOf(p.arg).String(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- p.add(61);
- _r$4 = p.printArg(p.arg, 118, 0); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- $s = 4; continue;
- /* } else if (p.value.IsValid()) { */ case 2:
- _r$5 = p.value.Type().String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$5); /* */ $s = 9; case 9: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- p.add(61);
- _r$7 = p.printValue(p.value, 118, 0); /* */ $s = 10; case 10: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$7;
- $s = 4; continue;
- /* } else { */ case 3:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes);
- /* } */ case 4:
- p.add(41);
- p.erroring = false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.badVerb }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f.p = p; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.badVerb = function(verb) { return this.$val.badVerb(verb); };
- pp.ptr.prototype.fmtBool = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 116 || _ref === 118) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_ref === 116 || _ref === 118) { */ case 1:
- p.fmt.fmt_boolean(v);
- $s = 3; continue;
- /* } else { */ case 2:
- $r = p.badVerb(verb); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBool }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtBool = function(v, verb) { return this.$val.fmtBool(v, verb); };
- pp.ptr.prototype.fmtC = function(c) {
- var $ptr, c, p, r, w, x;
- p = this;
- r = ((c.$low + ((c.$high >> 31) * 4294967296)) >> 0);
- if (!((x = new $Int64(0, r), (x.$high === c.$high && x.$low === c.$low)))) {
- r = 65533;
- }
- w = utf8.EncodeRune($subslice(new sliceType(p.runeBuf), 0, 4), r);
- p.fmt.pad($subslice(new sliceType(p.runeBuf), 0, w));
- };
- pp.prototype.fmtC = function(c) { return this.$val.fmtC(c); };
- pp.ptr.prototype.fmtInt64 = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 98) { $s = 1; continue; }
- /* */ if (_ref === 99) { $s = 2; continue; }
- /* */ if (_ref === 100 || _ref === 118) { $s = 3; continue; }
- /* */ if (_ref === 111) { $s = 4; continue; }
- /* */ if (_ref === 113) { $s = 5; continue; }
- /* */ if (_ref === 120) { $s = 6; continue; }
- /* */ if (_ref === 85) { $s = 7; continue; }
- /* */ if (_ref === 88) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref === 98) { */ case 1:
- p.fmt.integer(v, new $Uint64(0, 2), true, "0123456789abcdef");
- $s = 10; continue;
- /* } else if (_ref === 99) { */ case 2:
- p.fmtC(v);
- $s = 10; continue;
- /* } else if (_ref === 100 || _ref === 118) { */ case 3:
- p.fmt.integer(v, new $Uint64(0, 10), true, "0123456789abcdef");
- $s = 10; continue;
- /* } else if (_ref === 111) { */ case 4:
- p.fmt.integer(v, new $Uint64(0, 8), true, "0123456789abcdef");
- $s = 10; continue;
- /* } else if (_ref === 113) { */ case 5:
- /* */ if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { */ case 11:
- p.fmt.fmt_qc(v);
- $s = 13; continue;
- /* } else { */ case 12:
- $r = p.badVerb(verb); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 13:
- $s = 10; continue;
- /* } else if (_ref === 120) { */ case 6:
- p.fmt.integer(v, new $Uint64(0, 16), true, "0123456789abcdef");
- $s = 10; continue;
- /* } else if (_ref === 85) { */ case 7:
- p.fmtUnicode(v);
- $s = 10; continue;
- /* } else if (_ref === 88) { */ case 8:
- p.fmt.integer(v, new $Uint64(0, 16), true, "0123456789ABCDEF");
- $s = 10; continue;
- /* } else { */ case 9:
- $r = p.badVerb(verb); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtInt64 }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtInt64 = function(v, verb) { return this.$val.fmtInt64(v, verb); };
- pp.ptr.prototype.fmt0x64 = function(v, leading0x) {
- var $ptr, leading0x, p, sharp, v;
- p = this;
- sharp = p.fmt.fmtFlags.sharp;
- p.fmt.fmtFlags.sharp = leading0x;
- p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 16), false, "0123456789abcdef");
- p.fmt.fmtFlags.sharp = sharp;
- };
- pp.prototype.fmt0x64 = function(v, leading0x) { return this.$val.fmt0x64(v, leading0x); };
- pp.ptr.prototype.fmtUnicode = function(v) {
- var $ptr, p, prec, precPresent, sharp, v;
- p = this;
- precPresent = p.fmt.fmtFlags.precPresent;
- sharp = p.fmt.fmtFlags.sharp;
- p.fmt.fmtFlags.sharp = false;
- prec = p.fmt.prec;
- if (!precPresent) {
- p.fmt.prec = 4;
- p.fmt.fmtFlags.precPresent = true;
- }
- p.fmt.fmtFlags.unicode = true;
- p.fmt.fmtFlags.uniQuote = sharp;
- p.fmt.integer(v, new $Uint64(0, 16), false, "0123456789ABCDEF");
- p.fmt.fmtFlags.unicode = false;
- p.fmt.fmtFlags.uniQuote = false;
- p.fmt.prec = prec;
- p.fmt.fmtFlags.precPresent = precPresent;
- p.fmt.fmtFlags.sharp = sharp;
- };
- pp.prototype.fmtUnicode = function(v) { return this.$val.fmtUnicode(v); };
- pp.ptr.prototype.fmtUint64 = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 98) { $s = 1; continue; }
- /* */ if (_ref === 99) { $s = 2; continue; }
- /* */ if (_ref === 100) { $s = 3; continue; }
- /* */ if (_ref === 118) { $s = 4; continue; }
- /* */ if (_ref === 111) { $s = 5; continue; }
- /* */ if (_ref === 113) { $s = 6; continue; }
- /* */ if (_ref === 120) { $s = 7; continue; }
- /* */ if (_ref === 88) { $s = 8; continue; }
- /* */ if (_ref === 85) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_ref === 98) { */ case 1:
- p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 2), false, "0123456789abcdef");
- $s = 11; continue;
- /* } else if (_ref === 99) { */ case 2:
- p.fmtC(new $Int64(v.$high, v.$low));
- $s = 11; continue;
- /* } else if (_ref === 100) { */ case 3:
- p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 10), false, "0123456789abcdef");
- $s = 11; continue;
- /* } else if (_ref === 118) { */ case 4:
- if (p.fmt.fmtFlags.sharpV) {
- p.fmt0x64(v, true);
- } else {
- p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 10), false, "0123456789abcdef");
- }
- $s = 11; continue;
- /* } else if (_ref === 111) { */ case 5:
- p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 8), false, "0123456789abcdef");
- $s = 11; continue;
- /* } else if (_ref === 113) { */ case 6:
- /* */ if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { */ case 12:
- p.fmt.fmt_qc(new $Int64(v.$high, v.$low));
- $s = 14; continue;
- /* } else { */ case 13:
- $r = p.badVerb(verb); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- $s = 11; continue;
- /* } else if (_ref === 120) { */ case 7:
- p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 16), false, "0123456789abcdef");
- $s = 11; continue;
- /* } else if (_ref === 88) { */ case 8:
- p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 16), false, "0123456789ABCDEF");
- $s = 11; continue;
- /* } else if (_ref === 85) { */ case 9:
- p.fmtUnicode(new $Int64(v.$high, v.$low));
- $s = 11; continue;
- /* } else { */ case 10:
- $r = p.badVerb(verb); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtUint64 }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtUint64 = function(v, verb) { return this.$val.fmtUint64(v, verb); };
- pp.ptr.prototype.fmtFloat32 = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 98) { $s = 1; continue; }
- /* */ if (_ref === 101) { $s = 2; continue; }
- /* */ if (_ref === 69) { $s = 3; continue; }
- /* */ if (_ref === 102 || _ref === 70) { $s = 4; continue; }
- /* */ if (_ref === 103 || _ref === 118) { $s = 5; continue; }
- /* */ if (_ref === 71) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 98) { */ case 1:
- p.fmt.fmt_fb32(v);
- $s = 8; continue;
- /* } else if (_ref === 101) { */ case 2:
- p.fmt.fmt_e32(v);
- $s = 8; continue;
- /* } else if (_ref === 69) { */ case 3:
- p.fmt.fmt_E32(v);
- $s = 8; continue;
- /* } else if (_ref === 102 || _ref === 70) { */ case 4:
- p.fmt.fmt_f32(v);
- $s = 8; continue;
- /* } else if (_ref === 103 || _ref === 118) { */ case 5:
- p.fmt.fmt_g32(v);
- $s = 8; continue;
- /* } else if (_ref === 71) { */ case 6:
- p.fmt.fmt_G32(v);
- $s = 8; continue;
- /* } else { */ case 7:
- $r = p.badVerb(verb); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtFloat32 }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtFloat32 = function(v, verb) { return this.$val.fmtFloat32(v, verb); };
- pp.ptr.prototype.fmtFloat64 = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 98) { $s = 1; continue; }
- /* */ if (_ref === 101) { $s = 2; continue; }
- /* */ if (_ref === 69) { $s = 3; continue; }
- /* */ if (_ref === 102 || _ref === 70) { $s = 4; continue; }
- /* */ if (_ref === 103 || _ref === 118) { $s = 5; continue; }
- /* */ if (_ref === 71) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 98) { */ case 1:
- p.fmt.fmt_fb64(v);
- $s = 8; continue;
- /* } else if (_ref === 101) { */ case 2:
- p.fmt.fmt_e64(v);
- $s = 8; continue;
- /* } else if (_ref === 69) { */ case 3:
- p.fmt.fmt_E64(v);
- $s = 8; continue;
- /* } else if (_ref === 102 || _ref === 70) { */ case 4:
- p.fmt.fmt_f64(v);
- $s = 8; continue;
- /* } else if (_ref === 103 || _ref === 118) { */ case 5:
- p.fmt.fmt_g64(v);
- $s = 8; continue;
- /* } else if (_ref === 71) { */ case 6:
- p.fmt.fmt_G64(v);
- $s = 8; continue;
- /* } else { */ case 7:
- $r = p.badVerb(verb); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtFloat64 }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtFloat64 = function(v, verb) { return this.$val.fmtFloat64(v, verb); };
- pp.ptr.prototype.fmtComplex64 = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 98 || _ref === 101 || _ref === 69 || _ref === 102 || _ref === 70 || _ref === 103 || _ref === 71) { $s = 1; continue; }
- /* */ if (_ref === 118) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_ref === 98 || _ref === 101 || _ref === 69 || _ref === 102 || _ref === 70 || _ref === 103 || _ref === 71) { */ case 1:
- p.fmt.fmt_c64(v, verb);
- $s = 4; continue;
- /* } else if (_ref === 118) { */ case 2:
- p.fmt.fmt_c64(v, 103);
- $s = 4; continue;
- /* } else { */ case 3:
- $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtComplex64 }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtComplex64 = function(v, verb) { return this.$val.fmtComplex64(v, verb); };
- pp.ptr.prototype.fmtComplex128 = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 98 || _ref === 101 || _ref === 69 || _ref === 102 || _ref === 70 || _ref === 103 || _ref === 71) { $s = 1; continue; }
- /* */ if (_ref === 118) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_ref === 98 || _ref === 101 || _ref === 69 || _ref === 102 || _ref === 70 || _ref === 103 || _ref === 71) { */ case 1:
- p.fmt.fmt_c128(v, verb);
- $s = 4; continue;
- /* } else if (_ref === 118) { */ case 2:
- p.fmt.fmt_c128(v, 103);
- $s = 4; continue;
- /* } else { */ case 3:
- $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtComplex128 }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtComplex128 = function(v, verb) { return this.$val.fmtComplex128(v, verb); };
- pp.ptr.prototype.fmtString = function(v, verb) {
- var $ptr, _ref, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = verb;
- /* */ if (_ref === 118) { $s = 1; continue; }
- /* */ if (_ref === 115) { $s = 2; continue; }
- /* */ if (_ref === 120) { $s = 3; continue; }
- /* */ if (_ref === 88) { $s = 4; continue; }
- /* */ if (_ref === 113) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref === 118) { */ case 1:
- if (p.fmt.fmtFlags.sharpV) {
- p.fmt.fmt_q(v);
- } else {
- p.fmt.fmt_s(v);
- }
- $s = 7; continue;
- /* } else if (_ref === 115) { */ case 2:
- p.fmt.fmt_s(v);
- $s = 7; continue;
- /* } else if (_ref === 120) { */ case 3:
- p.fmt.fmt_sx(v, "0123456789abcdef");
- $s = 7; continue;
- /* } else if (_ref === 88) { */ case 4:
- p.fmt.fmt_sx(v, "0123456789ABCDEF");
- $s = 7; continue;
- /* } else if (_ref === 113) { */ case 5:
- p.fmt.fmt_q(v);
- $s = 7; continue;
- /* } else { */ case 6:
- $r = p.badVerb(verb); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtString }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtString = function(v, verb) { return this.$val.fmtString(v, verb); };
- pp.ptr.prototype.fmtBytes = function(v, verb, typ, depth) {
- var $ptr, _i, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, c, depth, i, p, typ, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; c = $f.c; depth = $f.depth; i = $f.i; p = $f.p; typ = $f.typ; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if ((verb === 118) || (verb === 100)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((verb === 118) || (verb === 100)) { */ case 1:
- /* */ if (p.fmt.fmtFlags.sharpV) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (p.fmt.fmtFlags.sharpV) { */ case 3:
- /* */ if (v === sliceType.nil) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (v === sliceType.nil) { */ case 6:
- /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 8:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("[]byte(nil)");
- $s = 10; continue;
- /* } else { */ case 9:
- _r$2 = typ.String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilParenBytes);
- /* } */ case 10:
- return;
- /* } */ case 7:
- /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 13:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(bytesBytes);
- $s = 15; continue;
- /* } else { */ case 14:
- _r$4 = typ.String(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$4); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$5;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123);
- /* } */ case 15:
- $s = 5; continue;
- /* } else { */ case 4:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91);
- /* } */ case 5:
- _ref = v;
- _i = 0;
- /* while (true) { */ case 18:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 19; continue; }
- i = _i;
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (i > 0) {
- if (p.fmt.fmtFlags.sharpV) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(commaSpaceBytes);
- } else {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32);
- }
- }
- _r$6 = p.printArg(new $Uint8(c), 118, depth + 1 >> 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- _i++;
- /* } */ $s = 18; continue; case 19:
- if (p.fmt.fmtFlags.sharpV) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125);
- } else {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93);
- }
- return;
- /* } */ case 2:
- _ref$1 = verb;
- /* */ if (_ref$1 === 115) { $s = 21; continue; }
- /* */ if (_ref$1 === 120) { $s = 22; continue; }
- /* */ if (_ref$1 === 88) { $s = 23; continue; }
- /* */ if (_ref$1 === 113) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (_ref$1 === 115) { */ case 21:
- p.fmt.fmt_s($bytesToString(v));
- $s = 26; continue;
- /* } else if (_ref$1 === 120) { */ case 22:
- p.fmt.fmt_bx(v, "0123456789abcdef");
- $s = 26; continue;
- /* } else if (_ref$1 === 88) { */ case 23:
- p.fmt.fmt_bx(v, "0123456789ABCDEF");
- $s = 26; continue;
- /* } else if (_ref$1 === 113) { */ case 24:
- p.fmt.fmt_q($bytesToString(v));
- $s = 26; continue;
- /* } else { */ case 25:
- $r = p.badVerb(verb); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 26:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBytes }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f.c = c; $f.depth = depth; $f.i = i; $f.p = p; $f.typ = typ; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtBytes = function(v, verb, typ, depth) { return this.$val.fmtBytes(v, verb, typ, depth); };
- pp.ptr.prototype.fmtPointer = function(value, verb) {
- var $ptr, _r$2, _r$3, _ref, _ref$1, p, u, use0x64, value, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; p = $f.p; u = $f.u; use0x64 = $f.use0x64; value = $f.value; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- value = value;
- use0x64 = true;
- _ref = verb;
- /* */ if (_ref === 112 || _ref === 118) { $s = 1; continue; }
- /* */ if (_ref === 98 || _ref === 100 || _ref === 111 || _ref === 120 || _ref === 88) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_ref === 112 || _ref === 118) { */ case 1:
- $s = 4; continue;
- /* } else if (_ref === 98 || _ref === 100 || _ref === 111 || _ref === 120 || _ref === 88) { */ case 2:
- use0x64 = false;
- $s = 4; continue;
- /* } else { */ case 3:
- $r = p.badVerb(verb); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 4:
- u = 0;
- _ref$1 = value.Kind();
- /* */ if (_ref$1 === 18 || _ref$1 === 19 || _ref$1 === 21 || _ref$1 === 22 || _ref$1 === 23 || _ref$1 === 26) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref$1 === 18 || _ref$1 === 19 || _ref$1 === 21 || _ref$1 === 22 || _ref$1 === 23 || _ref$1 === 26) { */ case 6:
- u = value.Pointer();
- $s = 8; continue;
- /* } else { */ case 7:
- $r = p.badVerb(verb); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 8:
- /* */ if (p.fmt.fmtFlags.sharpV) { $s = 10; continue; }
- /* */ if ((verb === 118) && (u === 0)) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (p.fmt.fmtFlags.sharpV) { */ case 10:
- p.add(40);
- _r$2 = value.Type().String(); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$2); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- p.add(41);
- p.add(40);
- if (u === 0) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilBytes);
- } else {
- p.fmt0x64(new $Uint64(0, u.constructor === Number ? u : 1), true);
- }
- p.add(41);
- $s = 13; continue;
- /* } else if ((verb === 118) && (u === 0)) { */ case 11:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes);
- $s = 13; continue;
- /* } else { */ case 12:
- /* */ if (use0x64) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (use0x64) { */ case 16:
- p.fmt0x64(new $Uint64(0, u.constructor === Number ? u : 1), !p.fmt.fmtFlags.sharp);
- $s = 18; continue;
- /* } else { */ case 17:
- $r = p.fmtUint64(new $Uint64(0, u.constructor === Number ? u : 1), verb); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- /* } */ case 13:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtPointer }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.p = p; $f.u = u; $f.use0x64 = use0x64; $f.value = value; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.fmtPointer = function(value, verb) { return this.$val.fmtPointer(value, verb); };
- pp.ptr.prototype.catchPanic = function(arg, verb) {
- var $ptr, _r$2, _r$3, arg, err, p, v, verb, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; arg = $f.arg; err = $f.err; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- err = $recover();
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 1:
- _r$2 = reflect.ValueOf(arg); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- /* */ if ((v.Kind() === 22) && v.IsNil()) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ((v.Kind() === 22) && v.IsNil()) { */ case 4:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes);
- return;
- /* } */ case 5:
- if (p.panicking) {
- $panic(err);
- }
- p.fmt.clearflags();
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(percentBangBytes);
- p.add(verb);
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(panicBytes);
- p.panicking = true;
- _r$3 = p.printArg(err, 118, 0); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- p.panicking = false;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41);
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.catchPanic }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.arg = arg; $f.err = err; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.catchPanic = function(arg, verb) { return this.$val.catchPanic(arg, verb); };
- pp.ptr.prototype.clearSpecialFlags = function() {
- var $ptr, p, plusV, sharpV;
- plusV = false;
- sharpV = false;
- p = this;
- plusV = p.fmt.fmtFlags.plusV;
- if (plusV) {
- p.fmt.fmtFlags.plus = true;
- p.fmt.fmtFlags.plusV = false;
- }
- sharpV = p.fmt.fmtFlags.sharpV;
- if (sharpV) {
- p.fmt.fmtFlags.sharp = true;
- p.fmt.fmtFlags.sharpV = false;
- }
- return [plusV, sharpV];
- };
- pp.prototype.clearSpecialFlags = function() { return this.$val.clearSpecialFlags(); };
- pp.ptr.prototype.restoreSpecialFlags = function(plusV, sharpV) {
- var $ptr, p, plusV, sharpV;
- p = this;
- if (plusV) {
- p.fmt.fmtFlags.plus = false;
- p.fmt.fmtFlags.plusV = true;
- }
- if (sharpV) {
- p.fmt.fmtFlags.sharp = false;
- p.fmt.fmtFlags.sharpV = true;
- }
- };
- pp.prototype.restoreSpecialFlags = function(plusV, sharpV) { return this.$val.restoreSpecialFlags(plusV, sharpV); };
- pp.ptr.prototype.handleMethods = function(verb, depth) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, depth, formatter, handled, ok, ok$1, p, stringer, v, v$1, verb, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; depth = $f.depth; formatter = $f.formatter; handled = $f.handled; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; stringer = $f.stringer; v = $f.v; v$1 = $f.v$1; verb = $f.verb; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- handled = false;
- p = this;
- if (p.erroring) {
- return handled;
- }
- _tuple = $assertType(p.arg, Formatter, true); formatter = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- handled = true;
- _tuple$1 = p.clearSpecialFlags();
- $deferred.push([$methodVal(p, "restoreSpecialFlags"), [_tuple$1[0], _tuple$1[1]]]);
- $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]);
- $r = formatter.Format(p, verb); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return handled;
- /* } */ case 2:
- /* */ if (p.fmt.fmtFlags.sharpV) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (p.fmt.fmtFlags.sharpV) { */ case 4:
- _tuple$2 = $assertType(p.arg, GoStringer, true); stringer = _tuple$2[0]; ok$1 = _tuple$2[1];
- /* */ if (ok$1) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (ok$1) { */ case 7:
- handled = true;
- $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]);
- _r$2 = stringer.GoString(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = p.fmt.fmt_s(_r$2); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return handled;
- /* } */ case 8:
- $s = 6; continue;
- /* } else { */ case 5:
- _ref = verb;
- /* */ if (_ref === 118 || _ref === 115 || _ref === 120 || _ref === 88 || _ref === 113) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_ref === 118 || _ref === 115 || _ref === 120 || _ref === 88 || _ref === 113) { */ case 11:
- _ref$1 = p.arg;
- /* */ if ($assertType(_ref$1, $error, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref$1, Stringer, true)[1]) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if ($assertType(_ref$1, $error, true)[1]) { */ case 13:
- v = _ref$1;
- handled = true;
- $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]);
- _r$3 = v.Error(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = p.printArg(new $String(_r$3), verb, depth); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- return handled;
- $s = 15; continue;
- /* } else if ($assertType(_ref$1, Stringer, true)[1]) { */ case 14:
- v$1 = _ref$1;
- handled = true;
- $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]);
- _r$5 = v$1.String(); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = p.printArg(new $String(_r$5), verb, depth); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- return handled;
- /* } */ case 15:
- /* } */ case 12:
- /* } */ case 6:
- handled = false;
- return handled;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return handled; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: pp.ptr.prototype.handleMethods }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.depth = depth; $f.formatter = formatter; $f.handled = handled; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.stringer = stringer; $f.v = v; $f.v$1 = v$1; $f.verb = verb; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- pp.prototype.handleMethods = function(verb, depth) { return this.$val.handleMethods(verb, depth); };
- pp.ptr.prototype.printArg = function(arg, verb, depth) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, arg, depth, f, f$1, f$10, f$11, f$12, f$13, f$14, f$15, f$16, f$17, f$18, f$2, f$3, f$4, f$5, f$6, f$7, f$8, f$9, handled, p, verb, wasString, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; arg = $f.arg; depth = $f.depth; f = $f.f; f$1 = $f.f$1; f$10 = $f.f$10; f$11 = $f.f$11; f$12 = $f.f$12; f$13 = $f.f$13; f$14 = $f.f$14; f$15 = $f.f$15; f$16 = $f.f$16; f$17 = $f.f$17; f$18 = $f.f$18; f$2 = $f.f$2; f$3 = $f.f$3; f$4 = $f.f$4; f$5 = $f.f$5; f$6 = $f.f$6; f$7 = $f.f$7; f$8 = $f.f$8; f$9 = $f.f$9; handled = $f.handled; p = $f.p; verb = $f.verb; wasString = $f.wasString; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- wasString = false;
- p = this;
- p.arg = arg;
- p.value = new reflect.Value.ptr(ptrType$2.nil, 0, 0);
- /* */ if ($interfaceIsEqual(arg, $ifaceNil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ($interfaceIsEqual(arg, $ifaceNil)) { */ case 1:
- /* */ if ((verb === 84) || (verb === 118)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ((verb === 84) || (verb === 118)) { */ case 3:
- p.fmt.pad(nilAngleBytes);
- $s = 5; continue;
- /* } else { */ case 4:
- $r = p.badVerb(verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- wasString = false;
- return wasString;
- /* } */ case 2:
- _ref = verb;
- /* */ if (_ref === 84) { $s = 7; continue; }
- /* */ if (_ref === 112) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref === 84) { */ case 7:
- _r$2 = reflect.TypeOf(arg).String(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.printArg(new $String(_r$2), 115, 0); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- wasString = false;
- return wasString;
- $s = 9; continue;
- /* } else if (_ref === 112) { */ case 8:
- _r$4 = reflect.ValueOf(arg); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = p.fmtPointer(_r$4, verb); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- wasString = false;
- return wasString;
- /* } */ case 9:
- _ref$1 = arg;
- /* */ if ($assertType(_ref$1, $Bool, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref$1, $Float32, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref$1, $Float64, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref$1, $Complex64, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref$1, $Complex128, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref$1, $Int, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref$1, $Int8, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref$1, $Int16, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref$1, $Int32, true)[1]) { $s = 22; continue; }
- /* */ if ($assertType(_ref$1, $Int64, true)[1]) { $s = 23; continue; }
- /* */ if ($assertType(_ref$1, $Uint, true)[1]) { $s = 24; continue; }
- /* */ if ($assertType(_ref$1, $Uint8, true)[1]) { $s = 25; continue; }
- /* */ if ($assertType(_ref$1, $Uint16, true)[1]) { $s = 26; continue; }
- /* */ if ($assertType(_ref$1, $Uint32, true)[1]) { $s = 27; continue; }
- /* */ if ($assertType(_ref$1, $Uint64, true)[1]) { $s = 28; continue; }
- /* */ if ($assertType(_ref$1, $Uintptr, true)[1]) { $s = 29; continue; }
- /* */ if ($assertType(_ref$1, $String, true)[1]) { $s = 30; continue; }
- /* */ if ($assertType(_ref$1, sliceType, true)[1]) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if ($assertType(_ref$1, $Bool, true)[1]) { */ case 14:
- f = _ref$1.$val;
- $r = p.fmtBool(f, verb); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Float32, true)[1]) { */ case 15:
- f$1 = _ref$1.$val;
- $r = p.fmtFloat32(f$1, verb); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Float64, true)[1]) { */ case 16:
- f$2 = _ref$1.$val;
- $r = p.fmtFloat64(f$2, verb); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Complex64, true)[1]) { */ case 17:
- f$3 = _ref$1.$val;
- $r = p.fmtComplex64(f$3, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Complex128, true)[1]) { */ case 18:
- f$4 = _ref$1.$val;
- $r = p.fmtComplex128(f$4, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Int, true)[1]) { */ case 19:
- f$5 = _ref$1.$val;
- $r = p.fmtInt64(new $Int64(0, f$5), verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Int8, true)[1]) { */ case 20:
- f$6 = _ref$1.$val;
- $r = p.fmtInt64(new $Int64(0, f$6), verb); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Int16, true)[1]) { */ case 21:
- f$7 = _ref$1.$val;
- $r = p.fmtInt64(new $Int64(0, f$7), verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Int32, true)[1]) { */ case 22:
- f$8 = _ref$1.$val;
- $r = p.fmtInt64(new $Int64(0, f$8), verb); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Int64, true)[1]) { */ case 23:
- f$9 = _ref$1.$val;
- $r = p.fmtInt64(f$9, verb); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Uint, true)[1]) { */ case 24:
- f$10 = _ref$1.$val;
- $r = p.fmtUint64(new $Uint64(0, f$10), verb); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Uint8, true)[1]) { */ case 25:
- f$11 = _ref$1.$val;
- $r = p.fmtUint64(new $Uint64(0, f$11), verb); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Uint16, true)[1]) { */ case 26:
- f$12 = _ref$1.$val;
- $r = p.fmtUint64(new $Uint64(0, f$12), verb); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Uint32, true)[1]) { */ case 27:
- f$13 = _ref$1.$val;
- $r = p.fmtUint64(new $Uint64(0, f$13), verb); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Uint64, true)[1]) { */ case 28:
- f$14 = _ref$1.$val;
- $r = p.fmtUint64(f$14, verb); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $Uintptr, true)[1]) { */ case 29:
- f$15 = _ref$1.$val;
- $r = p.fmtUint64(new $Uint64(0, f$15.constructor === Number ? f$15 : 1), verb); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, $String, true)[1]) { */ case 30:
- f$16 = _ref$1.$val;
- $r = p.fmtString(f$16, verb); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- wasString = (verb === 115) || (verb === 118);
- $s = 33; continue;
- /* } else if ($assertType(_ref$1, sliceType, true)[1]) { */ case 31:
- f$17 = _ref$1.$val;
- $r = p.fmtBytes(f$17, verb, $ifaceNil, depth); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- wasString = verb === 115;
- $s = 33; continue;
- /* } else { */ case 32:
- f$18 = _ref$1;
- _r$5 = p.handleMethods(verb, depth); /* */ $s = 52; case 52: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- handled = _r$5;
- /* */ if (handled) { $s = 53; continue; }
- /* */ $s = 54; continue;
- /* if (handled) { */ case 53:
- wasString = false;
- return wasString;
- /* } */ case 54:
- _r$6 = reflect.ValueOf(arg); /* */ $s = 55; case 55: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = p.printReflectValue(_r$6, verb, depth); /* */ $s = 56; case 56: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- wasString = _r$7;
- return wasString;
- /* } */ case 33:
- p.arg = $ifaceNil;
- return wasString;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printArg }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f.arg = arg; $f.depth = depth; $f.f = f; $f.f$1 = f$1; $f.f$10 = f$10; $f.f$11 = f$11; $f.f$12 = f$12; $f.f$13 = f$13; $f.f$14 = f$14; $f.f$15 = f$15; $f.f$16 = f$16; $f.f$17 = f$17; $f.f$18 = f$18; $f.f$2 = f$2; $f.f$3 = f$3; $f.f$4 = f$4; $f.f$5 = f$5; $f.f$6 = f$6; $f.f$7 = f$7; $f.f$8 = f$8; $f.f$9 = f$9; $f.handled = handled; $f.p = p; $f.verb = verb; $f.wasString = wasString; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.printArg = function(arg, verb, depth) { return this.$val.printArg(arg, verb, depth); };
- pp.ptr.prototype.printValue = function(value, verb, depth) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, depth, handled, p, value, verb, wasString, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; depth = $f.depth; handled = $f.handled; p = $f.p; value = $f.value; verb = $f.verb; wasString = $f.wasString; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- wasString = false;
- p = this;
- value = value;
- /* */ if (!value.IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!value.IsValid()) { */ case 1:
- /* */ if ((verb === 84) || (verb === 118)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ((verb === 84) || (verb === 118)) { */ case 3:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes);
- $s = 5; continue;
- /* } else { */ case 4:
- $r = p.badVerb(verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- wasString = false;
- return wasString;
- /* } */ case 2:
- _ref = verb;
- /* */ if (_ref === 84) { $s = 7; continue; }
- /* */ if (_ref === 112) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref === 84) { */ case 7:
- _r$2 = value.Type().String(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.printArg(new $String(_r$2), 115, 0); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- wasString = false;
- return wasString;
- $s = 9; continue;
- /* } else if (_ref === 112) { */ case 8:
- $r = p.fmtPointer(value, verb); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- wasString = false;
- return wasString;
- /* } */ case 9:
- p.arg = $ifaceNil;
- /* */ if (value.CanInterface()) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (value.CanInterface()) { */ case 13:
- _r$4 = value.Interface(); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- p.arg = _r$4;
- /* } */ case 14:
- _r$5 = p.handleMethods(verb, depth); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- handled = _r$5;
- /* */ if (handled) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (handled) { */ case 17:
- wasString = false;
- return wasString;
- /* } */ case 18:
- _r$6 = p.printReflectValue(value, verb, depth); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- wasString = _r$6;
- return wasString;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printValue }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f.depth = depth; $f.handled = handled; $f.p = p; $f.value = value; $f.verb = verb; $f.wasString = wasString; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.printValue = function(value, verb, depth) { return this.$val.printValue(value, verb, depth); };
- pp.ptr.prototype.printReflectValue = function(value, verb, depth) {
- var $ptr, _i, _i$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _v, a, bytes, depth, f, f$1, i, i$1, i$2, i$3, key, keys, oldValue, p, t, typ, v, v$1, value, value$1, verb, wasString, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _v = $f._v; a = $f.a; bytes = $f.bytes; depth = $f.depth; f = $f.f; f$1 = $f.f$1; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; key = $f.key; keys = $f.keys; oldValue = $f.oldValue; p = $f.p; t = $f.t; typ = $f.typ; v = $f.v; v$1 = $f.v$1; value = $f.value; value$1 = $f.value$1; verb = $f.verb; wasString = $f.wasString; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- wasString = false;
- p = this;
- value = value;
- oldValue = p.value;
- p.value = value;
- f = value;
- _ref = f.Kind();
- /* */ if (_ref === 1) { $s = 1; continue; }
- /* */ if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { $s = 2; continue; }
- /* */ if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { $s = 3; continue; }
- /* */ if (_ref === 13 || _ref === 14) { $s = 4; continue; }
- /* */ if (_ref === 15 || _ref === 16) { $s = 5; continue; }
- /* */ if (_ref === 24) { $s = 6; continue; }
- /* */ if (_ref === 21) { $s = 7; continue; }
- /* */ if (_ref === 25) { $s = 8; continue; }
- /* */ if (_ref === 20) { $s = 9; continue; }
- /* */ if (_ref === 17 || _ref === 23) { $s = 10; continue; }
- /* */ if (_ref === 22) { $s = 11; continue; }
- /* */ if (_ref === 18 || _ref === 19 || _ref === 26) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* switch (0) { default: if (_ref === 1) { */ case 1:
- $r = p.fmtBool(f.Bool(), verb); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { */ case 2:
- $r = p.fmtInt64(f.Int(), verb); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { */ case 3:
- $r = p.fmtUint64(f.Uint(), verb); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if (_ref === 13 || _ref === 14) { */ case 4:
- _r$2 = f.Type().Size(); /* */ $s = 21; case 21: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2 === 4) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (_r$2 === 4) { */ case 18:
- $r = p.fmtFloat32($fround(f.Float()), verb); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else { */ case 19:
- $r = p.fmtFloat64(f.Float(), verb); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- $s = 14; continue;
- /* } else if (_ref === 15 || _ref === 16) { */ case 5:
- _r$3 = f.Type().Size(); /* */ $s = 27; case 27: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3 === 8) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (_r$3 === 8) { */ case 24:
- $r = p.fmtComplex64((x = f.Complex(), new $Complex64(x.$real, x.$imag)), verb); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else { */ case 25:
- $r = p.fmtComplex128(f.Complex(), verb); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 26:
- $s = 14; continue;
- /* } else if (_ref === 24) { */ case 6:
- _r$4 = f.String(); /* */ $s = 30; case 30: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = p.fmtString(_r$4, verb); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if (_ref === 21) { */ case 7:
- /* */ if (p.fmt.fmtFlags.sharpV) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (p.fmt.fmtFlags.sharpV) { */ case 32:
- _r$5 = f.Type().String(); /* */ $s = 35; case 35: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$5); /* */ $s = 36; case 36: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- if (f.IsNil()) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)");
- /* break; */ $s = 14; continue;
- }
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123);
- $s = 34; continue;
- /* } else { */ case 33:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(mapBytes);
- /* } */ case 34:
- _r$7 = f.MapKeys(); /* */ $s = 37; case 37: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- keys = _r$7;
- _ref$1 = keys;
- _i = 0;
- /* while (true) { */ case 38:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 39; continue; }
- i = _i;
- key = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- if (i > 0) {
- if (p.fmt.fmtFlags.sharpV) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(commaSpaceBytes);
- } else {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32);
- }
- }
- _r$8 = p.printValue(key, verb, depth + 1 >> 0); /* */ $s = 40; case 40: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$8;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58);
- _r$9 = f.MapIndex(key); /* */ $s = 41; case 41: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$10 = p.printValue(_r$9, verb, depth + 1 >> 0); /* */ $s = 42; case 42: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$10;
- _i++;
- /* } */ $s = 38; continue; case 39:
- if (p.fmt.fmtFlags.sharpV) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125);
- } else {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93);
- }
- $s = 14; continue;
- /* } else if (_ref === 25) { */ case 8:
- /* */ if (p.fmt.fmtFlags.sharpV) { $s = 43; continue; }
- /* */ $s = 44; continue;
- /* if (p.fmt.fmtFlags.sharpV) { */ case 43:
- _r$11 = value.Type().String(); /* */ $s = 45; case 45: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$12 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$11); /* */ $s = 46; case 46: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _r$12;
- /* } */ case 44:
- p.add(123);
- v = f;
- t = v.Type();
- i$1 = 0;
- /* while (true) { */ case 47:
- /* if (!(i$1 < v.NumField())) { break; } */ if(!(i$1 < v.NumField())) { $s = 48; continue; }
- if (i$1 > 0) {
- if (p.fmt.fmtFlags.sharpV) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(commaSpaceBytes);
- } else {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32);
- }
- }
- /* */ if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { */ case 49:
- _r$13 = t.Field(i$1); /* */ $s = 51; case 51: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- f$1 = $clone(_r$13, reflect.StructField);
- /* */ if (!(f$1.Name === "")) { $s = 52; continue; }
- /* */ $s = 53; continue;
- /* if (!(f$1.Name === "")) { */ case 52:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(f$1.Name);
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58);
- /* } */ case 53:
- /* } */ case 50:
- _r$14 = getField(v, i$1); /* */ $s = 54; case 54: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _r$15 = p.printValue(_r$14, verb, depth + 1 >> 0); /* */ $s = 55; case 55: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _r$15;
- i$1 = i$1 + (1) >> 0;
- /* } */ $s = 47; continue; case 48:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125);
- $s = 14; continue;
- /* } else if (_ref === 20) { */ case 9:
- _r$16 = f.Elem(); /* */ $s = 56; case 56: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- value$1 = _r$16;
- /* */ if (!value$1.IsValid()) { $s = 57; continue; }
- /* */ $s = 58; continue;
- /* if (!value$1.IsValid()) { */ case 57:
- /* */ if (p.fmt.fmtFlags.sharpV) { $s = 60; continue; }
- /* */ $s = 61; continue;
- /* if (p.fmt.fmtFlags.sharpV) { */ case 60:
- _r$17 = f.Type().String(); /* */ $s = 63; case 63: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _r$18 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$17); /* */ $s = 64; case 64: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _r$18;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilParenBytes);
- $s = 62; continue;
- /* } else { */ case 61:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes);
- /* } */ case 62:
- $s = 59; continue;
- /* } else { */ case 58:
- _r$19 = p.printValue(value$1, verb, depth + 1 >> 0); /* */ $s = 65; case 65: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- wasString = _r$19;
- /* } */ case 59:
- $s = 14; continue;
- /* } else if (_ref === 17 || _ref === 23) { */ case 10:
- typ = f.Type();
- _r$20 = typ.Elem(); /* */ $s = 69; case 69: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- _r$21 = _r$20.Kind(); /* */ $s = 70; case 70: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- if (!(_r$21 === 8)) { _v = false; $s = 68; continue s; }
- _r$22 = typ.Elem(); /* */ $s = 71; case 71: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _v = $interfaceIsEqual(_r$22, byteType) || (verb === 115) || (verb === 113) || (verb === 120); case 68:
- /* */ if (_v) { $s = 66; continue; }
- /* */ $s = 67; continue;
- /* if (_v) { */ case 66:
- bytes = sliceType.nil;
- /* */ if (f.Kind() === 23) { $s = 72; continue; }
- /* */ if (f.CanAddr()) { $s = 73; continue; }
- /* */ $s = 74; continue;
- /* if (f.Kind() === 23) { */ case 72:
- _r$23 = f.Bytes(); /* */ $s = 76; case 76: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- bytes = _r$23;
- $s = 75; continue;
- /* } else if (f.CanAddr()) { */ case 73:
- _r$24 = f.Slice(0, f.Len()); /* */ $s = 77; case 77: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$25 = _r$24.Bytes(); /* */ $s = 78; case 78: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- bytes = _r$25;
- $s = 75; continue;
- /* } else { */ case 74:
- bytes = $makeSlice(sliceType, f.Len());
- _ref$2 = bytes;
- _i$1 = 0;
- /* while (true) { */ case 79:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 80; continue; }
- i$2 = _i$1;
- _r$26 = f.Index(i$2); /* */ $s = 81; case 81: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _r$27 = _r$26.Uint(); /* */ $s = 82; case 82: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- ((i$2 < 0 || i$2 >= bytes.$length) ? $throwRuntimeError("index out of range") : bytes.$array[bytes.$offset + i$2] = (_r$27.$low << 24 >>> 24));
- _i$1++;
- /* } */ $s = 79; continue; case 80:
- /* } */ case 75:
- $r = p.fmtBytes(bytes, verb, typ, depth); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- wasString = verb === 115;
- /* break; */ $s = 14; continue;
- /* } */ case 67:
- /* */ if (p.fmt.fmtFlags.sharpV) { $s = 84; continue; }
- /* */ $s = 85; continue;
- /* if (p.fmt.fmtFlags.sharpV) { */ case 84:
- _r$28 = value.Type().String(); /* */ $s = 87; case 87: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _r$29 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$28); /* */ $s = 88; case 88: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _r$29;
- if ((f.Kind() === 23) && f.IsNil()) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)");
- /* break; */ $s = 14; continue;
- }
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123);
- $s = 86; continue;
- /* } else { */ case 85:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91);
- /* } */ case 86:
- i$3 = 0;
- /* while (true) { */ case 89:
- /* if (!(i$3 < f.Len())) { break; } */ if(!(i$3 < f.Len())) { $s = 90; continue; }
- if (i$3 > 0) {
- if (p.fmt.fmtFlags.sharpV) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(commaSpaceBytes);
- } else {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32);
- }
- }
- _r$30 = f.Index(i$3); /* */ $s = 91; case 91: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _r$31 = p.printValue(_r$30, verb, depth + 1 >> 0); /* */ $s = 92; case 92: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- _r$31;
- i$3 = i$3 + (1) >> 0;
- /* } */ $s = 89; continue; case 90:
- if (p.fmt.fmtFlags.sharpV) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125);
- } else {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(93);
- }
- $s = 14; continue;
- /* } else if (_ref === 22) { */ case 11:
- v$1 = f.Pointer();
- /* */ if (!((v$1 === 0)) && (depth === 0)) { $s = 93; continue; }
- /* */ $s = 94; continue;
- /* if (!((v$1 === 0)) && (depth === 0)) { */ case 93:
- _r$32 = f.Elem(); /* */ $s = 95; case 95: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- a = _r$32;
- _ref$3 = a.Kind();
- /* */ if (_ref$3 === 17 || _ref$3 === 23) { $s = 96; continue; }
- /* */ if (_ref$3 === 25) { $s = 97; continue; }
- /* */ if (_ref$3 === 21) { $s = 98; continue; }
- /* */ $s = 99; continue;
- /* if (_ref$3 === 17 || _ref$3 === 23) { */ case 96:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38);
- _r$33 = p.printValue(a, verb, depth + 1 >> 0); /* */ $s = 100; case 100: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- _r$33;
- /* break BigSwitch; */ $s = 14; continue s;
- $s = 99; continue;
- /* } else if (_ref$3 === 25) { */ case 97:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38);
- _r$34 = p.printValue(a, verb, depth + 1 >> 0); /* */ $s = 101; case 101: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _r$34;
- /* break BigSwitch; */ $s = 14; continue s;
- $s = 99; continue;
- /* } else if (_ref$3 === 21) { */ case 98:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38);
- _r$35 = p.printValue(a, verb, depth + 1 >> 0); /* */ $s = 102; case 102: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- _r$35;
- /* break BigSwitch; */ $s = 14; continue s;
- /* } */ case 99:
- /* } */ case 94:
- $r = p.fmtPointer(value, verb); /* */ $s = 103; case 103: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if (_ref === 18 || _ref === 19 || _ref === 26) { */ case 12:
- $r = p.fmtPointer(value, verb); /* */ $s = 104; case 104: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else { */ case 13:
- $r = p.unknownType(f); /* */ $s = 105; case 105: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } } */ case 14:
- p.value = oldValue;
- wasString = wasString;
- return wasString;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printReflectValue }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._v = _v; $f.a = a; $f.bytes = bytes; $f.depth = depth; $f.f = f; $f.f$1 = f$1; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.key = key; $f.keys = keys; $f.oldValue = oldValue; $f.p = p; $f.t = t; $f.typ = typ; $f.v = v; $f.v$1 = v$1; $f.value = value; $f.value$1 = value$1; $f.verb = verb; $f.wasString = wasString; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.printReflectValue = function(value, verb, depth) { return this.$val.printReflectValue(value, verb, depth); };
- intFromArg = function(a, argNum) {
- var $ptr, _tuple, a, argNum, isInt, newArgNum, num;
- num = 0;
- isInt = false;
- newArgNum = 0;
- newArgNum = argNum;
- if (argNum < a.$length) {
- _tuple = $assertType(((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum]), $Int, true); num = _tuple[0]; isInt = _tuple[1];
- newArgNum = argNum + 1 >> 0;
- }
- return [num, isInt, newArgNum];
- };
- parseArgNumber = function(format) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, format, i, index, newi, ok, ok$1, wid, width;
- index = 0;
- wid = 0;
- ok = false;
- i = 1;
- while (true) {
- if (!(i < format.length)) { break; }
- if (format.charCodeAt(i) === 93) {
- _tuple = parsenum(format, 1, i); width = _tuple[0]; ok$1 = _tuple[1]; newi = _tuple[2];
- if (!ok$1 || !((newi === i))) {
- _tmp = 0; _tmp$1 = i + 1 >> 0; _tmp$2 = false; index = _tmp; wid = _tmp$1; ok = _tmp$2;
- return [index, wid, ok];
- }
- _tmp$3 = width - 1 >> 0; _tmp$4 = i + 1 >> 0; _tmp$5 = true; index = _tmp$3; wid = _tmp$4; ok = _tmp$5;
- return [index, wid, ok];
- }
- i = i + (1) >> 0;
- }
- _tmp$6 = 0; _tmp$7 = 1; _tmp$8 = false; index = _tmp$6; wid = _tmp$7; ok = _tmp$8;
- return [index, wid, ok];
- };
- pp.ptr.prototype.argNumber = function(argNum, format, i, numArgs) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, argNum, format, found, i, index, newArgNum, newi, numArgs, ok, p, wid;
- newArgNum = 0;
- newi = 0;
- found = false;
- p = this;
- if (format.length <= i || !((format.charCodeAt(i) === 91))) {
- _tmp = argNum; _tmp$1 = i; _tmp$2 = false; newArgNum = _tmp; newi = _tmp$1; found = _tmp$2;
- return [newArgNum, newi, found];
- }
- p.reordered = true;
- _tuple = parseArgNumber(format.substring(i)); index = _tuple[0]; wid = _tuple[1]; ok = _tuple[2];
- if (ok && 0 <= index && index < numArgs) {
- _tmp$3 = index; _tmp$4 = i + wid >> 0; _tmp$5 = true; newArgNum = _tmp$3; newi = _tmp$4; found = _tmp$5;
- return [newArgNum, newi, found];
- }
- p.goodArgNum = false;
- _tmp$6 = argNum; _tmp$7 = i + wid >> 0; _tmp$8 = true; newArgNum = _tmp$6; newi = _tmp$7; found = _tmp$8;
- return [newArgNum, newi, found];
- };
- pp.prototype.argNumber = function(argNum, format, i, numArgs) { return this.$val.argNumber(argNum, format, i, numArgs); };
- pp.ptr.prototype.doPrintf = function(format, a) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _ref, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, a, afterIndex, arg, arg$1, argNum, c, end, format, i, lasti, p, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; a = $f.a; afterIndex = $f.afterIndex; arg = $f.arg; arg$1 = $f.arg$1; argNum = $f.argNum; c = $f.c; end = $f.end; format = $f.format; i = $f.i; lasti = $f.lasti; p = $f.p; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- end = format.length;
- argNum = 0;
- afterIndex = false;
- p.reordered = false;
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < end)) { break; } */ if(!(i < end)) { $s = 2; continue; }
- p.goodArgNum = true;
- lasti = i;
- while (true) {
- if (!(i < end && !((format.charCodeAt(i) === 37)))) { break; }
- i = i + (1) >> 0;
- }
- if (i > lasti) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(format.substring(lasti, i));
- }
- if (i >= end) {
- /* break; */ $s = 2; continue;
- }
- i = i + (1) >> 0;
- p.fmt.clearflags();
- F:
- while (true) {
- if (!(i < end)) { break; }
- _ref = format.charCodeAt(i);
- if (_ref === 35) {
- p.fmt.fmtFlags.sharp = true;
- } else if (_ref === 48) {
- p.fmt.fmtFlags.zero = true;
- } else if (_ref === 43) {
- p.fmt.fmtFlags.plus = true;
- } else if (_ref === 45) {
- p.fmt.fmtFlags.minus = true;
- } else if (_ref === 32) {
- p.fmt.fmtFlags.space = true;
- } else {
- break F;
- }
- i = i + (1) >> 0;
- }
- _tuple = p.argNumber(argNum, format, i, a.$length); argNum = _tuple[0]; i = _tuple[1]; afterIndex = _tuple[2];
- if (i < end && (format.charCodeAt(i) === 42)) {
- i = i + (1) >> 0;
- _tuple$1 = intFromArg(a, argNum); p.fmt.wid = _tuple$1[0]; p.fmt.fmtFlags.widPresent = _tuple$1[1]; argNum = _tuple$1[2];
- if (!p.fmt.fmtFlags.widPresent) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(badWidthBytes);
- }
- afterIndex = false;
- } else {
- _tuple$2 = parsenum(format, i, end); p.fmt.wid = _tuple$2[0]; p.fmt.fmtFlags.widPresent = _tuple$2[1]; i = _tuple$2[2];
- if (afterIndex && p.fmt.fmtFlags.widPresent) {
- p.goodArgNum = false;
- }
- }
- if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) {
- i = i + (1) >> 0;
- if (afterIndex) {
- p.goodArgNum = false;
- }
- _tuple$3 = p.argNumber(argNum, format, i, a.$length); argNum = _tuple$3[0]; i = _tuple$3[1]; afterIndex = _tuple$3[2];
- if (format.charCodeAt(i) === 42) {
- i = i + (1) >> 0;
- _tuple$4 = intFromArg(a, argNum); p.fmt.prec = _tuple$4[0]; p.fmt.fmtFlags.precPresent = _tuple$4[1]; argNum = _tuple$4[2];
- if (!p.fmt.fmtFlags.precPresent) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(badPrecBytes);
- }
- afterIndex = false;
- } else {
- _tuple$5 = parsenum(format, i, end); p.fmt.prec = _tuple$5[0]; p.fmt.fmtFlags.precPresent = _tuple$5[1]; i = _tuple$5[2];
- if (!p.fmt.fmtFlags.precPresent) {
- p.fmt.prec = 0;
- p.fmt.fmtFlags.precPresent = true;
- }
- }
- }
- if (!afterIndex) {
- _tuple$6 = p.argNumber(argNum, format, i, a.$length); argNum = _tuple$6[0]; i = _tuple$6[1]; afterIndex = _tuple$6[2];
- }
- /* */ if (i >= end) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (i >= end) { */ case 3:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(noVerbBytes);
- /* continue; */ $s = 1; continue;
- /* } */ case 4:
- _tuple$7 = utf8.DecodeRuneInString(format.substring(i)); c = _tuple$7[0]; w = _tuple$7[1];
- i = i + (w) >> 0;
- /* */ if (c === 37) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (c === 37) { */ case 5:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(37);
- /* continue; */ $s = 1; continue;
- /* } */ case 6:
- /* */ if (!p.goodArgNum) { $s = 7; continue; }
- /* */ if (argNum >= a.$length) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!p.goodArgNum) { */ case 7:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(percentBangBytes);
- p.add(c);
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(badIndexBytes);
- /* continue; */ $s = 1; continue;
- $s = 9; continue;
- /* } else if (argNum >= a.$length) { */ case 8:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(percentBangBytes);
- p.add(c);
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(missingBytes);
- /* continue; */ $s = 1; continue;
- /* } */ case 9:
- arg = ((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum]);
- argNum = argNum + (1) >> 0;
- if (c === 118) {
- if (p.fmt.fmtFlags.sharp) {
- p.fmt.fmtFlags.sharp = false;
- p.fmt.fmtFlags.sharpV = true;
- }
- if (p.fmt.fmtFlags.plus) {
- p.fmt.fmtFlags.plus = false;
- p.fmt.fmtFlags.plusV = true;
- }
- }
- _r$2 = p.printArg(arg, c, 0); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* } */ $s = 1; continue; case 2:
- /* */ if (!p.reordered && argNum < a.$length) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!p.reordered && argNum < a.$length) { */ case 11:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(extraBytes);
- /* while (true) { */ case 13:
- /* if (!(argNum < a.$length)) { break; } */ if(!(argNum < a.$length)) { $s = 14; continue; }
- arg$1 = ((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum]);
- /* */ if (!($interfaceIsEqual(arg$1, $ifaceNil))) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!($interfaceIsEqual(arg$1, $ifaceNil))) { */ case 15:
- _r$3 = reflect.TypeOf(arg$1).String(); /* */ $s = 17; case 17: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$3); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61);
- /* } */ case 16:
- _r$5 = p.printArg(arg$1, 118, 0); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$5;
- if ((argNum + 1 >> 0) < a.$length) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(commaSpaceBytes);
- }
- argNum = argNum + (1) >> 0;
- /* } */ $s = 13; continue; case 14:
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41);
- /* } */ case 12:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.a = a; $f.afterIndex = afterIndex; $f.arg = arg; $f.arg$1 = arg$1; $f.argNum = argNum; $f.c = c; $f.end = end; $f.format = format; $f.i = i; $f.lasti = lasti; $f.p = p; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.doPrintf = function(format, a) { return this.$val.doPrintf(format, a); };
- pp.ptr.prototype.doPrint = function(a, addspace, addnewline) {
- var $ptr, _r$2, _r$3, _v, a, addnewline, addspace, arg, argNum, isString, p, prevString, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _v = $f._v; a = $f.a; addnewline = $f.addnewline; addspace = $f.addspace; arg = $f.arg; argNum = $f.argNum; isString = $f.isString; p = $f.p; prevString = $f.prevString; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- prevString = false;
- argNum = 0;
- /* while (true) { */ case 1:
- /* if (!(argNum < a.$length)) { break; } */ if(!(argNum < a.$length)) { $s = 2; continue; }
- p.fmt.clearflags();
- arg = ((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum]);
- /* */ if (argNum > 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (argNum > 0) { */ case 3:
- if (!(!($interfaceIsEqual(arg, $ifaceNil)))) { _v = false; $s = 5; continue s; }
- _r$2 = reflect.TypeOf(arg).Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2 === 24; case 5:
- isString = _v;
- if (addspace || !isString && !prevString) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(32);
- }
- /* } */ case 4:
- _r$3 = p.printArg(arg, 118, 0); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- prevString = _r$3;
- argNum = argNum + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- if (addnewline) {
- (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(10);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrint }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._v = _v; $f.a = a; $f.addnewline = addnewline; $f.addspace = addspace; $f.arg = arg; $f.argNum = argNum; $f.isString = isString; $f.p = p; $f.prevString = prevString; $f.$s = $s; $f.$r = $r; return $f;
- };
- pp.prototype.doPrint = function(a, addspace, addnewline) { return this.$val.doPrint(a, addspace, addnewline); };
- ss.ptr.prototype.Read = function(buf) {
- var $ptr, _tmp, _tmp$1, buf, err, n, s;
- n = 0;
- err = $ifaceNil;
- s = this;
- _tmp = 0; _tmp$1 = errors.New("ScanState's Read should not be called. Use ReadRune"); n = _tmp; err = _tmp$1;
- return [n, err];
- };
- ss.prototype.Read = function(buf) { return this.$val.Read(buf); };
- ss.ptr.prototype.ReadRune = function() {
- var $ptr, _r$2, _tuple, err, r, s, size, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; size = $f.size; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = 0;
- size = 0;
- err = $ifaceNil;
- s = this;
- if (s.peekRune >= 0) {
- s.count = s.count + (1) >> 0;
- r = s.peekRune;
- size = utf8.RuneLen(r);
- s.prevRune = r;
- s.peekRune = -1;
- return [r, size, err];
- }
- if (s.atEOF || s.ssave.nlIsEnd && (s.prevRune === 10) || s.count >= s.ssave.argLimit) {
- err = io.EOF;
- return [r, size, err];
- }
- _r$2 = s.rr.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; r = _tuple[0]; size = _tuple[1]; err = _tuple[2];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- s.count = s.count + (1) >> 0;
- s.prevRune = r;
- } else if ($interfaceIsEqual(err, io.EOF)) {
- s.atEOF = true;
- }
- return [r, size, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.ReadRune }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.size = size; $f.$s = $s; $f.$r = $r; return $f;
- };
- ss.prototype.ReadRune = function() { return this.$val.ReadRune(); };
- ss.ptr.prototype.Width = function() {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, ok, s, wid;
- wid = 0;
- ok = false;
- s = this;
- if (s.ssave.maxWid === 1073741824) {
- _tmp = 0; _tmp$1 = false; wid = _tmp; ok = _tmp$1;
- return [wid, ok];
- }
- _tmp$2 = s.ssave.maxWid; _tmp$3 = true; wid = _tmp$2; ok = _tmp$3;
- return [wid, ok];
- };
- ss.prototype.Width = function() { return this.$val.Width(); };
- ss.ptr.prototype.getRune = function() {
- var $ptr, _r$2, _tuple, err, r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _tuple = $f._tuple; err = $f.err; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = 0;
- s = this;
- _r$2 = s.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; r = _tuple[0]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- if ($interfaceIsEqual(err, io.EOF)) {
- r = -1;
- return r;
- }
- s.error(err);
- }
- return r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.getRune }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._tuple = _tuple; $f.err = err; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- ss.prototype.getRune = function() { return this.$val.getRune(); };
- ss.ptr.prototype.UnreadRune = function() {
- var $ptr, _r$2, _tuple, ok, s, u, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _tuple = $f._tuple; ok = $f.ok; s = $f.s; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _tuple = $assertType(s.rr, runeUnreader, true); u = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _r$2 = u.UnreadRune(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- $s = 3; continue;
- /* } else { */ case 2:
- s.peekRune = s.prevRune;
- /* } */ case 3:
- s.prevRune = -1;
- s.count = s.count - (1) >> 0;
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.UnreadRune }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ok = ok; $f.s = s; $f.u = u; $f.$s = $s; $f.$r = $r; return $f;
- };
- ss.prototype.UnreadRune = function() { return this.$val.UnreadRune(); };
- ss.ptr.prototype.error = function(err) {
- var $ptr, err, s, x;
- s = this;
- $panic((x = new scanError.ptr(err), new x.constructor.elem(x)));
- };
- ss.prototype.error = function(err) { return this.$val.error(err); };
- ss.ptr.prototype.errorString = function(err) {
- var $ptr, err, s, x;
- s = this;
- $panic((x = new scanError.ptr(errors.New(err)), new x.constructor.elem(x)));
- };
- ss.prototype.errorString = function(err) { return this.$val.errorString(err); };
- ss.ptr.prototype.Token = function(skipSpace, f) {
- var $ptr, _r$2, err, f, s, skipSpace, tok, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; err = $f.err; f = $f.f; s = $f.s; skipSpace = $f.skipSpace; tok = $f.tok; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- tok = sliceType.nil;
- err[0] = $ifaceNil;
- s = this;
- $deferred.push([(function(err) { return function() {
- var $ptr, _tuple, e, ok, se;
- e = $recover();
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- _tuple = $assertType(e, scanError, true); se = $clone(_tuple[0], scanError); ok = _tuple[1];
- if (ok) {
- err[0] = se.err;
- } else {
- $panic(e);
- }
- }
- }; })(err), []]);
- if (f === $throwNilPointerError) {
- f = notSpace;
- }
- s.buf = $subslice(s.buf, 0, 0);
- _r$2 = s.token(skipSpace, f); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- tok = _r$2;
- return [tok, err[0]];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [tok, err[0]]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: ss.ptr.prototype.Token }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.err = err; $f.f = f; $f.s = s; $f.skipSpace = skipSpace; $f.tok = tok; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- ss.prototype.Token = function(skipSpace, f) { return this.$val.Token(skipSpace, f); };
- isSpace = function(r) {
- var $ptr, _i, _ref, r, rng, rx;
- if (r >= 65536) {
- return false;
- }
- rx = (r << 16 >>> 16);
- _ref = space;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- rng = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), arrayType);
- if (rx < rng[0]) {
- return false;
- }
- if (rx <= rng[1]) {
- return true;
- }
- _i++;
- }
- return false;
- };
- notSpace = function(r) {
- var $ptr, r;
- return !isSpace(r);
- };
- ss.ptr.prototype.SkipSpace = function() {
- var $ptr, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- $r = s.skipSpace(false); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.SkipSpace }; } $f.$ptr = $ptr; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- ss.prototype.SkipSpace = function() { return this.$val.SkipSpace(); };
- ss.ptr.prototype.free = function(old) {
- var $ptr, old, s;
- s = this;
- old = $clone(old, ssave);
- if (old.validSave) {
- $copy(s.ssave, old, ssave);
- return;
- }
- if (s.buf.$capacity > 1024) {
- return;
- }
- s.buf = $subslice(s.buf, 0, 0);
- s.rr = $ifaceNil;
- ssFree.Put(s);
- };
- ss.prototype.free = function(old) { return this.$val.free(old); };
- ss.ptr.prototype.skipSpace = function(stopAtNewline) {
- var $ptr, _r$2, _r$3, _r$4, _v, r, s, stopAtNewline, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _v = $f._v; r = $f.r; s = $f.s; stopAtNewline = $f.stopAtNewline; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* while (true) { */ case 1:
- _r$2 = s.getRune(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- r = _r$2;
- if (r === -1) {
- return;
- }
- if (!(r === 13)) { _v = false; $s = 6; continue s; }
- _r$3 = s.peek("\n"); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v = _r$3; case 6:
- /* */ if (_v) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_v) { */ case 4:
- /* continue; */ $s = 1; continue;
- /* } */ case 5:
- /* */ if (r === 10) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (r === 10) { */ case 8:
- if (stopAtNewline) {
- /* break; */ $s = 2; continue;
- }
- if (s.ssave.nlIsSpace) {
- /* continue; */ $s = 1; continue;
- }
- s.errorString("unexpected newline");
- return;
- /* } */ case 9:
- /* */ if (!isSpace(r)) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!isSpace(r)) { */ case 10:
- _r$4 = s.UnreadRune(); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- /* break; */ $s = 2; continue;
- /* } */ case 11:
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.skipSpace }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._v = _v; $f.r = r; $f.s = s; $f.stopAtNewline = stopAtNewline; $f.$s = $s; $f.$r = $r; return $f;
- };
- ss.prototype.skipSpace = function(stopAtNewline) { return this.$val.skipSpace(stopAtNewline); };
- ss.ptr.prototype.token = function(skipSpace, f) {
- var $ptr, _r$2, _r$3, _r$4, f, r, s, skipSpace, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; f = $f.f; r = $f.r; s = $f.s; skipSpace = $f.skipSpace; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (skipSpace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (skipSpace) { */ case 1:
- $r = s.skipSpace(false); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* while (true) { */ case 4:
- _r$2 = s.getRune(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- r = _r$2;
- if (r === -1) {
- /* break; */ $s = 5; continue;
- }
- _r$3 = f(r); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!_r$3) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!_r$3) { */ case 7:
- _r$4 = s.UnreadRune(); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- /* break; */ $s = 5; continue;
- /* } */ case 8:
- (s.$ptr_buf || (s.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, s))).WriteRune(r);
- /* } */ $s = 4; continue; case 5:
- return (x = s.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.token }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.f = f; $f.r = r; $f.s = s; $f.skipSpace = skipSpace; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- ss.prototype.token = function(skipSpace, f) { return this.$val.token(skipSpace, f); };
- indexRune = function(s, r) {
- var $ptr, _i, _ref, _rune, c, i, r, s;
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- c = _rune[0];
- if (c === r) {
- return i;
- }
- _i += _rune[1];
- }
- return -1;
- };
- ss.ptr.prototype.peek = function(ok) {
- var $ptr, _r$2, _r$3, ok, r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; ok = $f.ok; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r$2 = s.getRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- r = _r$2;
- /* */ if (!((r === -1))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((r === -1))) { */ case 2:
- _r$3 = s.UnreadRune(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* } */ case 3:
- return indexRune(ok, r) >= 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.peek }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.ok = ok; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- ss.prototype.peek = function(ok) { return this.$val.peek(ok); };
- ptrType$25.methods = [{prop: "clearflags", name: "clearflags", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "init", name: "init", pkg: "fmt", typ: $funcType([ptrType$1], [], false)}, {prop: "computePadding", name: "computePadding", pkg: "fmt", typ: $funcType([$Int], [sliceType, $Int, $Int], false)}, {prop: "writePadding", name: "writePadding", pkg: "fmt", typ: $funcType([$Int, sliceType], [], false)}, {prop: "pad", name: "pad", pkg: "fmt", typ: $funcType([sliceType], [], false)}, {prop: "padString", name: "padString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_boolean", name: "fmt_boolean", pkg: "fmt", typ: $funcType([$Bool], [], false)}, {prop: "integer", name: "integer", pkg: "fmt", typ: $funcType([$Int64, $Uint64, $Bool, $String], [], false)}, {prop: "truncate", name: "truncate", pkg: "fmt", typ: $funcType([$String], [$String], false)}, {prop: "fmt_s", name: "fmt_s", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_sbx", name: "fmt_sbx", pkg: "fmt", typ: $funcType([$String, sliceType, $String], [], false)}, {prop: "fmt_sx", name: "fmt_sx", pkg: "fmt", typ: $funcType([$String, $String], [], false)}, {prop: "fmt_bx", name: "fmt_bx", pkg: "fmt", typ: $funcType([sliceType, $String], [], false)}, {prop: "fmt_q", name: "fmt_q", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_qc", name: "fmt_qc", pkg: "fmt", typ: $funcType([$Int64], [], false)}, {prop: "formatFloat", name: "formatFloat", pkg: "fmt", typ: $funcType([$Float64, $Uint8, $Int, $Int], [], false)}, {prop: "fmt_e64", name: "fmt_e64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_E64", name: "fmt_E64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_f64", name: "fmt_f64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_g64", name: "fmt_g64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_G64", name: "fmt_G64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_fb64", name: "fmt_fb64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_e32", name: "fmt_e32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_E32", name: "fmt_E32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_f32", name: "fmt_f32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_g32", name: "fmt_g32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_G32", name: "fmt_G32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_fb32", name: "fmt_fb32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_c64", name: "fmt_c64", pkg: "fmt", typ: $funcType([$Complex64, $Int32], [], false)}, {prop: "fmt_c128", name: "fmt_c128", pkg: "fmt", typ: $funcType([$Complex128, $Int32], [], false)}, {prop: "fmt_complex", name: "fmt_complex", pkg: "fmt", typ: $funcType([$Float64, $Float64, $Int, $Int32], [], false)}];
- ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [$error], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [$error], false)}];
- ptrType.methods = [{prop: "free", name: "free", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "add", name: "add", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "unknownType", name: "unknownType", pkg: "fmt", typ: $funcType([reflect.Value], [], false)}, {prop: "badVerb", name: "badVerb", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "fmtBool", name: "fmtBool", pkg: "fmt", typ: $funcType([$Bool, $Int32], [], false)}, {prop: "fmtC", name: "fmtC", pkg: "fmt", typ: $funcType([$Int64], [], false)}, {prop: "fmtInt64", name: "fmtInt64", pkg: "fmt", typ: $funcType([$Int64, $Int32], [], false)}, {prop: "fmt0x64", name: "fmt0x64", pkg: "fmt", typ: $funcType([$Uint64, $Bool], [], false)}, {prop: "fmtUnicode", name: "fmtUnicode", pkg: "fmt", typ: $funcType([$Int64], [], false)}, {prop: "fmtUint64", name: "fmtUint64", pkg: "fmt", typ: $funcType([$Uint64, $Int32], [], false)}, {prop: "fmtFloat32", name: "fmtFloat32", pkg: "fmt", typ: $funcType([$Float32, $Int32], [], false)}, {prop: "fmtFloat64", name: "fmtFloat64", pkg: "fmt", typ: $funcType([$Float64, $Int32], [], false)}, {prop: "fmtComplex64", name: "fmtComplex64", pkg: "fmt", typ: $funcType([$Complex64, $Int32], [], false)}, {prop: "fmtComplex128", name: "fmtComplex128", pkg: "fmt", typ: $funcType([$Complex128, $Int32], [], false)}, {prop: "fmtString", name: "fmtString", pkg: "fmt", typ: $funcType([$String, $Int32], [], false)}, {prop: "fmtBytes", name: "fmtBytes", pkg: "fmt", typ: $funcType([sliceType, $Int32, reflect.Type, $Int], [], false)}, {prop: "fmtPointer", name: "fmtPointer", pkg: "fmt", typ: $funcType([reflect.Value, $Int32], [], false)}, {prop: "catchPanic", name: "catchPanic", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32], [], false)}, {prop: "clearSpecialFlags", name: "clearSpecialFlags", pkg: "fmt", typ: $funcType([], [$Bool, $Bool], false)}, {prop: "restoreSpecialFlags", name: "restoreSpecialFlags", pkg: "fmt", typ: $funcType([$Bool, $Bool], [], false)}, {prop: "handleMethods", name: "handleMethods", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Bool], false)}, {prop: "printArg", name: "printArg", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32, $Int], [$Bool], false)}, {prop: "printValue", name: "printValue", pkg: "fmt", typ: $funcType([reflect.Value, $Int32, $Int], [$Bool], false)}, {prop: "printReflectValue", name: "printReflectValue", pkg: "fmt", typ: $funcType([reflect.Value, $Int32, $Int], [$Bool], false)}, {prop: "argNumber", name: "argNumber", pkg: "fmt", typ: $funcType([$Int, $String, $Int, $Int], [$Int, $Int, $Bool], false)}, {prop: "doPrintf", name: "doPrintf", pkg: "fmt", typ: $funcType([$String, sliceType$1], [], false)}, {prop: "doPrint", name: "doPrint", pkg: "fmt", typ: $funcType([sliceType$1, $Bool, $Bool], [], false)}];
- ptrType$5.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "getRune", name: "getRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "mustReadRune", name: "mustReadRune", pkg: "fmt", typ: $funcType([], [$Int32], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "error", name: "error", pkg: "fmt", typ: $funcType([$error], [], false)}, {prop: "errorString", name: "errorString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "Token", name: "Token", pkg: "", typ: $funcType([$Bool, funcType], [sliceType, $error], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "free", name: "free", pkg: "fmt", typ: $funcType([ssave], [], false)}, {prop: "skipSpace", name: "skipSpace", pkg: "fmt", typ: $funcType([$Bool], [], false)}, {prop: "token", name: "token", pkg: "fmt", typ: $funcType([$Bool, funcType], [sliceType], false)}, {prop: "consume", name: "consume", pkg: "fmt", typ: $funcType([$String, $Bool], [$Bool], false)}, {prop: "peek", name: "peek", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "notEOF", name: "notEOF", pkg: "fmt", typ: $funcType([], [], false)}, {prop: "accept", name: "accept", pkg: "fmt", typ: $funcType([$String], [$Bool], false)}, {prop: "okVerb", name: "okVerb", pkg: "fmt", typ: $funcType([$Int32, $String, $String], [$Bool], false)}, {prop: "scanBool", name: "scanBool", pkg: "fmt", typ: $funcType([$Int32], [$Bool], false)}, {prop: "getBase", name: "getBase", pkg: "fmt", typ: $funcType([$Int32], [$Int, $String], false)}, {prop: "scanNumber", name: "scanNumber", pkg: "fmt", typ: $funcType([$String, $Bool], [$String], false)}, {prop: "scanRune", name: "scanRune", pkg: "fmt", typ: $funcType([$Int], [$Int64], false)}, {prop: "scanBasePrefix", name: "scanBasePrefix", pkg: "fmt", typ: $funcType([], [$Int, $String, $Bool], false)}, {prop: "scanInt", name: "scanInt", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Int64], false)}, {prop: "scanUint", name: "scanUint", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Uint64], false)}, {prop: "floatToken", name: "floatToken", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "complexTokens", name: "complexTokens", pkg: "fmt", typ: $funcType([], [$String, $String], false)}, {prop: "convertFloat", name: "convertFloat", pkg: "fmt", typ: $funcType([$String, $Int], [$Float64], false)}, {prop: "scanComplex", name: "scanComplex", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Complex128], false)}, {prop: "convertString", name: "convertString", pkg: "fmt", typ: $funcType([$Int32], [$String], false)}, {prop: "quotedString", name: "quotedString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "hexDigit", name: "hexDigit", pkg: "fmt", typ: $funcType([$Int32], [$Int], false)}, {prop: "hexByte", name: "hexByte", pkg: "fmt", typ: $funcType([], [$Uint8, $Bool], false)}, {prop: "hexString", name: "hexString", pkg: "fmt", typ: $funcType([], [$String], false)}, {prop: "scanOne", name: "scanOne", pkg: "fmt", typ: $funcType([$Int32, $emptyInterface], [], false)}, {prop: "doScan", name: "doScan", pkg: "fmt", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "advance", name: "advance", pkg: "fmt", typ: $funcType([$String], [$Int], false)}, {prop: "doScanf", name: "doScanf", pkg: "fmt", typ: $funcType([$String, sliceType$1], [$Int, $error], false)}];
- fmtFlags.init([{prop: "widPresent", name: "widPresent", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "precPresent", name: "precPresent", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "minus", name: "minus", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "plus", name: "plus", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "sharp", name: "sharp", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "space", name: "space", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "unicode", name: "unicode", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "uniQuote", name: "uniQuote", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "zero", name: "zero", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "plusV", name: "plusV", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "sharpV", name: "sharpV", pkg: "fmt", typ: $Bool, tag: ""}]);
- fmt.init([{prop: "intbuf", name: "intbuf", pkg: "fmt", typ: arrayType$2, tag: ""}, {prop: "buf", name: "buf", pkg: "fmt", typ: ptrType$1, tag: ""}, {prop: "wid", name: "wid", pkg: "fmt", typ: $Int, tag: ""}, {prop: "prec", name: "prec", pkg: "fmt", typ: $Int, tag: ""}, {prop: "fmtFlags", name: "", pkg: "fmt", typ: fmtFlags, tag: ""}]);
- State.init([{prop: "Flag", name: "Flag", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Precision", name: "Precision", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}]);
- Formatter.init([{prop: "Format", name: "Format", pkg: "", typ: $funcType([State, $Int32], [], false)}]);
- Stringer.init([{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]);
- GoStringer.init([{prop: "GoString", name: "GoString", pkg: "", typ: $funcType([], [$String], false)}]);
- buffer.init($Uint8);
- pp.init([{prop: "n", name: "n", pkg: "fmt", typ: $Int, tag: ""}, {prop: "panicking", name: "panicking", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "erroring", name: "erroring", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "buf", name: "buf", pkg: "fmt", typ: buffer, tag: ""}, {prop: "arg", name: "arg", pkg: "fmt", typ: $emptyInterface, tag: ""}, {prop: "value", name: "value", pkg: "fmt", typ: reflect.Value, tag: ""}, {prop: "reordered", name: "reordered", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "goodArgNum", name: "goodArgNum", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "runeBuf", name: "runeBuf", pkg: "fmt", typ: arrayType$1, tag: ""}, {prop: "fmt", name: "fmt", pkg: "fmt", typ: fmt, tag: ""}]);
- runeUnreader.init([{prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}]);
- ScanState.init([{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $Int, $error], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "Token", name: "Token", pkg: "", typ: $funcType([$Bool, funcType], [sliceType, $error], false)}, {prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Width", name: "Width", pkg: "", typ: $funcType([], [$Int, $Bool], false)}]);
- scanError.init([{prop: "err", name: "err", pkg: "fmt", typ: $error, tag: ""}]);
- ss.init([{prop: "rr", name: "rr", pkg: "fmt", typ: io.RuneReader, tag: ""}, {prop: "buf", name: "buf", pkg: "fmt", typ: buffer, tag: ""}, {prop: "peekRune", name: "peekRune", pkg: "fmt", typ: $Int32, tag: ""}, {prop: "prevRune", name: "prevRune", pkg: "fmt", typ: $Int32, tag: ""}, {prop: "count", name: "count", pkg: "fmt", typ: $Int, tag: ""}, {prop: "atEOF", name: "atEOF", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "ssave", name: "", pkg: "fmt", typ: ssave, tag: ""}]);
- ssave.init([{prop: "validSave", name: "validSave", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "nlIsEnd", name: "nlIsEnd", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "nlIsSpace", name: "nlIsSpace", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "argLimit", name: "argLimit", pkg: "fmt", typ: $Int, tag: ""}, {prop: "limit", name: "limit", pkg: "fmt", typ: $Int, tag: ""}, {prop: "maxWid", name: "maxWid", pkg: "fmt", typ: $Int, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = reflect.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- padZeroBytes = $makeSlice(sliceType, 65);
- padSpaceBytes = $makeSlice(sliceType, 65);
- trueBytes = new sliceType($stringToBytes("true"));
- falseBytes = new sliceType($stringToBytes("false"));
- commaSpaceBytes = new sliceType($stringToBytes(", "));
- nilAngleBytes = new sliceType($stringToBytes(""));
- nilParenBytes = new sliceType($stringToBytes("(nil)"));
- nilBytes = new sliceType($stringToBytes("nil"));
- mapBytes = new sliceType($stringToBytes("map["));
- percentBangBytes = new sliceType($stringToBytes("%!"));
- missingBytes = new sliceType($stringToBytes("(MISSING)"));
- badIndexBytes = new sliceType($stringToBytes("(BADINDEX)"));
- panicBytes = new sliceType($stringToBytes("(PANIC="));
- extraBytes = new sliceType($stringToBytes("%!(EXTRA "));
- irparenBytes = new sliceType($stringToBytes("i)"));
- bytesBytes = new sliceType($stringToBytes("[]byte{"));
- badWidthBytes = new sliceType($stringToBytes("%!(BADWIDTH)"));
- badPrecBytes = new sliceType($stringToBytes("%!(BADPREC)"));
- noVerbBytes = new sliceType($stringToBytes("%!(NOVERB)"));
- ppFree = new sync.Pool.ptr(0, 0, sliceType$1.nil, (function() {
- var $ptr;
- return new pp.ptr();
- }));
- _r = reflect.TypeOf(new $Int(0)).Bits(); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- intBits = _r;
- _r$1 = reflect.TypeOf(new $Uintptr(0)).Bits(); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- uintptrBits = _r$1;
- byteType = reflect.TypeOf(new $Uint8(0));
- space = new sliceType$2([$toNativeArray($kindUint16, [9, 13]), $toNativeArray($kindUint16, [32, 32]), $toNativeArray($kindUint16, [133, 133]), $toNativeArray($kindUint16, [160, 160]), $toNativeArray($kindUint16, [5760, 5760]), $toNativeArray($kindUint16, [8192, 8202]), $toNativeArray($kindUint16, [8232, 8233]), $toNativeArray($kindUint16, [8239, 8239]), $toNativeArray($kindUint16, [8287, 8287]), $toNativeArray($kindUint16, [12288, 12288])]);
- ssFree = new sync.Pool.ptr(0, 0, sliceType$1.nil, (function() {
- var $ptr;
- return new ss.ptr();
- }));
- complexError = errors.New("syntax error scanning complex number");
- boolError = errors.New("syntax error scanning boolean");
- init();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["encoding/gob"] = (function() {
- var $pkg = {}, $init, bufio, encoding, errors, fmt, nosync, io, math, os, reflect, atomic, unicode, utf8, decHelper, decoderState, decBuffer, decOp, decInstr, decEngine, emptyStruct, Decoder, gobError, userTypeInfo, typeId, gobType, CommonType, arrayType, gobEncoderType, mapType, sliceType, fieldType, structType, wireType, typeInfo, GobEncoder, GobDecoder, ptrType, sliceType$1, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, ptrType$12, ptrType$13, ptrType$14, structType$1, ptrType$15, structType$2, ptrType$16, structType$3, ptrType$17, structType$4, ptrType$18, structType$5, ptrType$19, structType$6, ptrType$20, structType$7, ptrType$21, ptrType$22, ptrType$23, ptrType$24, ptrType$25, ptrType$26, sliceType$2, sliceType$3, sliceType$4, sliceType$5, sliceType$6, sliceType$7, sliceType$8, sliceType$9, sliceType$10, sliceType$11, sliceType$12, sliceType$13, sliceType$14, sliceType$15, sliceType$16, sliceType$17, sliceType$18, ptrType$27, ptrType$28, ptrType$29, ptrType$30, sliceType$19, ptrType$31, ptrType$32, ptrType$33, ptrType$38, ptrType$39, sliceType$22, mapType$1, ptrType$40, ptrType$41, ptrType$42, mapType$2, mapType$3, mapType$4, mapType$5, mapType$6, mapType$7, ptrType$45, decArrayHelper, decSliceHelper, errBadUint, errBadType, errRange, noValue, decOpTable, decIgnoreOpMap, emptyStructType, errBadCount, spaceForLength, userTypeLock, userTypeCache, gobEncoderInterfaceType, gobDecoderInterfaceType, binaryMarshalerInterfaceType, binaryUnmarshalerInterfaceType, textMarshalerInterfaceType, textUnmarshalerInterfaceType, nextId, typeLock, types, idToType, builtinIdToType, tBool, tInt, tUint, tFloat, tBytes, tString, tComplex, tInterface, tReserved7, tReserved6, tReserved5, tReserved4, tReserved3, tReserved2, tReserved1, tWireType, wireTypeUserInfo, typeInfoMap, registerLock, nameToConcreteType, concreteTypeToName, x, _map$2, _key$2, _map$3, _key$3, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _r$10, _r$11, _r$12, _map$4, _key$4, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$20, x$1, _r$21, decBoolArray, decBoolSlice, decComplex64Array, decComplex64Slice, decComplex128Array, decComplex128Slice, decFloat32Array, decFloat32Slice, decFloat64Array, decFloat64Slice, decIntArray, decIntSlice, decInt16Array, decInt16Slice, decInt32Array, decInt32Slice, decInt64Array, decInt64Slice, decInt8Array, decInt8Slice, decStringArray, decStringSlice, decUintArray, decUintSlice, decUint16Array, decUint16Slice, decUint32Array, decUint32Slice, decUint64Array, decUint64Slice, decUintptrArray, decUintptrSlice, overflow, decodeUintReader, ignoreUint, ignoreTwoUints, decAlloc, decBool, decInt8, decUint8, decInt16, decUint16, decInt32, decUint32, decInt64, decUint64, float64FromBits, float32FromBits, decFloat32, decFloat64, decComplex64, decComplex128, decUint8Slice, decString, ignoreUint8Array, decodeIntoValue, init, allocValue, NewDecoder, toInt, errorf, error_, catchError, validUserType, implementsInterface, userType, setTypeId, init$1, newArrayType, newGobEncoderType, newMapType, newSliceType, newStructType, newTypeObject, isExported, isSent, getBaseType, getType, checkId, bootstrapType, lookupTypeInfo, getTypeInfo, buildTypeInfo, mustGetTypeInfo, RegisterName, Register, registerBasics;
- bufio = $packages["bufio"];
- encoding = $packages["encoding"];
- errors = $packages["errors"];
- fmt = $packages["fmt"];
- nosync = $packages["github.com/gopherjs/gopherjs/nosync"];
- io = $packages["io"];
- math = $packages["math"];
- os = $packages["os"];
- reflect = $packages["reflect"];
- atomic = $packages["sync/atomic"];
- unicode = $packages["unicode"];
- utf8 = $packages["unicode/utf8"];
- decHelper = $pkg.decHelper = $newType(4, $kindFunc, "gob.decHelper", "decHelper", "encoding/gob", null);
- decoderState = $pkg.decoderState = $newType(0, $kindStruct, "gob.decoderState", "decoderState", "encoding/gob", function(dec_, b_, fieldnum_, buf_, next_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.dec = ptrType$40.nil;
- this.b = ptrType$41.nil;
- this.fieldnum = 0;
- this.buf = sliceType$1.nil;
- this.next = ptrType$27.nil;
- return;
- }
- this.dec = dec_;
- this.b = b_;
- this.fieldnum = fieldnum_;
- this.buf = buf_;
- this.next = next_;
- });
- decBuffer = $pkg.decBuffer = $newType(0, $kindStruct, "gob.decBuffer", "decBuffer", "encoding/gob", function(data_, offset_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.data = sliceType$1.nil;
- this.offset = 0;
- return;
- }
- this.data = data_;
- this.offset = offset_;
- });
- decOp = $pkg.decOp = $newType(4, $kindFunc, "gob.decOp", "decOp", "encoding/gob", null);
- decInstr = $pkg.decInstr = $newType(0, $kindStruct, "gob.decInstr", "decInstr", "encoding/gob", function(op_, field_, index_, ovfl_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.op = $throwNilPointerError;
- this.field = 0;
- this.index = sliceType$8.nil;
- this.ovfl = $ifaceNil;
- return;
- }
- this.op = op_;
- this.field = field_;
- this.index = index_;
- this.ovfl = ovfl_;
- });
- decEngine = $pkg.decEngine = $newType(0, $kindStruct, "gob.decEngine", "decEngine", "encoding/gob", function(instr_, numInstr_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.instr = sliceType$19.nil;
- this.numInstr = 0;
- return;
- }
- this.instr = instr_;
- this.numInstr = numInstr_;
- });
- emptyStruct = $pkg.emptyStruct = $newType(0, $kindStruct, "gob.emptyStruct", "emptyStruct", "encoding/gob", function() {
- this.$val = this;
- if (arguments.length === 0) {
- return;
- }
- });
- Decoder = $pkg.Decoder = $newType(0, $kindStruct, "gob.Decoder", "Decoder", "encoding/gob", function(mutex_, r_, buf_, wireType_, decoderCache_, ignorerCache_, freeList_, countBuf_, err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.mutex = new nosync.Mutex.ptr();
- this.r = $ifaceNil;
- this.buf = new decBuffer.ptr();
- this.wireType = false;
- this.decoderCache = false;
- this.ignorerCache = false;
- this.freeList = ptrType$27.nil;
- this.countBuf = sliceType$1.nil;
- this.err = $ifaceNil;
- return;
- }
- this.mutex = mutex_;
- this.r = r_;
- this.buf = buf_;
- this.wireType = wireType_;
- this.decoderCache = decoderCache_;
- this.ignorerCache = ignorerCache_;
- this.freeList = freeList_;
- this.countBuf = countBuf_;
- this.err = err_;
- });
- gobError = $pkg.gobError = $newType(0, $kindStruct, "gob.gobError", "gobError", "encoding/gob", function(err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.err = $ifaceNil;
- return;
- }
- this.err = err_;
- });
- userTypeInfo = $pkg.userTypeInfo = $newType(0, $kindStruct, "gob.userTypeInfo", "userTypeInfo", "encoding/gob", function(user_, base_, indir_, externalEnc_, externalDec_, encIndir_, decIndir_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.user = $ifaceNil;
- this.base = $ifaceNil;
- this.indir = 0;
- this.externalEnc = 0;
- this.externalDec = 0;
- this.encIndir = 0;
- this.decIndir = 0;
- return;
- }
- this.user = user_;
- this.base = base_;
- this.indir = indir_;
- this.externalEnc = externalEnc_;
- this.externalDec = externalDec_;
- this.encIndir = encIndir_;
- this.decIndir = decIndir_;
- });
- typeId = $pkg.typeId = $newType(4, $kindInt32, "gob.typeId", "typeId", "encoding/gob", null);
- gobType = $pkg.gobType = $newType(8, $kindInterface, "gob.gobType", "gobType", "encoding/gob", null);
- CommonType = $pkg.CommonType = $newType(0, $kindStruct, "gob.CommonType", "CommonType", "encoding/gob", function(Name_, Id_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Name = "";
- this.Id = 0;
- return;
- }
- this.Name = Name_;
- this.Id = Id_;
- });
- arrayType = $pkg.arrayType = $newType(0, $kindStruct, "gob.arrayType", "arrayType", "encoding/gob", function(CommonType_, Elem_, Len_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.CommonType = new CommonType.ptr();
- this.Elem = 0;
- this.Len = 0;
- return;
- }
- this.CommonType = CommonType_;
- this.Elem = Elem_;
- this.Len = Len_;
- });
- gobEncoderType = $pkg.gobEncoderType = $newType(0, $kindStruct, "gob.gobEncoderType", "gobEncoderType", "encoding/gob", function(CommonType_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.CommonType = new CommonType.ptr();
- return;
- }
- this.CommonType = CommonType_;
- });
- mapType = $pkg.mapType = $newType(0, $kindStruct, "gob.mapType", "mapType", "encoding/gob", function(CommonType_, Key_, Elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.CommonType = new CommonType.ptr();
- this.Key = 0;
- this.Elem = 0;
- return;
- }
- this.CommonType = CommonType_;
- this.Key = Key_;
- this.Elem = Elem_;
- });
- sliceType = $pkg.sliceType = $newType(0, $kindStruct, "gob.sliceType", "sliceType", "encoding/gob", function(CommonType_, Elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.CommonType = new CommonType.ptr();
- this.Elem = 0;
- return;
- }
- this.CommonType = CommonType_;
- this.Elem = Elem_;
- });
- fieldType = $pkg.fieldType = $newType(0, $kindStruct, "gob.fieldType", "fieldType", "encoding/gob", function(Name_, Id_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Name = "";
- this.Id = 0;
- return;
- }
- this.Name = Name_;
- this.Id = Id_;
- });
- structType = $pkg.structType = $newType(0, $kindStruct, "gob.structType", "structType", "encoding/gob", function(CommonType_, Field_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.CommonType = new CommonType.ptr();
- this.Field = sliceType$22.nil;
- return;
- }
- this.CommonType = CommonType_;
- this.Field = Field_;
- });
- wireType = $pkg.wireType = $newType(0, $kindStruct, "gob.wireType", "wireType", "encoding/gob", function(ArrayT_, SliceT_, StructT_, MapT_, GobEncoderT_, BinaryMarshalerT_, TextMarshalerT_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.ArrayT = ptrType$22.nil;
- this.SliceT = ptrType$23.nil;
- this.StructT = ptrType$24.nil;
- this.MapT = ptrType$25.nil;
- this.GobEncoderT = ptrType$26.nil;
- this.BinaryMarshalerT = ptrType$26.nil;
- this.TextMarshalerT = ptrType$26.nil;
- return;
- }
- this.ArrayT = ArrayT_;
- this.SliceT = SliceT_;
- this.StructT = StructT_;
- this.MapT = MapT_;
- this.GobEncoderT = GobEncoderT_;
- this.BinaryMarshalerT = BinaryMarshalerT_;
- this.TextMarshalerT = TextMarshalerT_;
- });
- typeInfo = $pkg.typeInfo = $newType(0, $kindStruct, "gob.typeInfo", "typeInfo", "encoding/gob", function(id_, encInit_, encoder_, wire_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.id = 0;
- this.encInit = new nosync.Mutex.ptr();
- this.encoder = new atomic.Value.ptr();
- this.wire = ptrType$29.nil;
- return;
- }
- this.id = id_;
- this.encInit = encInit_;
- this.encoder = encoder_;
- this.wire = wire_;
- });
- GobEncoder = $pkg.GobEncoder = $newType(8, $kindInterface, "gob.GobEncoder", "GobEncoder", "encoding/gob", null);
- GobDecoder = $pkg.GobDecoder = $newType(8, $kindInterface, "gob.GobDecoder", "GobDecoder", "encoding/gob", null);
- ptrType = $ptrType(userTypeInfo);
- sliceType$1 = $sliceType($Uint8);
- ptrType$1 = $ptrType(GobEncoder);
- ptrType$2 = $ptrType(GobDecoder);
- ptrType$3 = $ptrType(encoding.BinaryMarshaler);
- ptrType$4 = $ptrType(encoding.BinaryUnmarshaler);
- ptrType$5 = $ptrType(encoding.TextMarshaler);
- ptrType$6 = $ptrType(encoding.TextUnmarshaler);
- ptrType$7 = $ptrType($Bool);
- ptrType$8 = $ptrType($Int);
- ptrType$9 = $ptrType($Uint);
- ptrType$10 = $ptrType($Float64);
- ptrType$11 = $ptrType(sliceType$1);
- ptrType$12 = $ptrType($String);
- ptrType$13 = $ptrType($Complex128);
- ptrType$14 = $ptrType($emptyInterface);
- structType$1 = $structType([{prop: "r7", name: "r7", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- ptrType$15 = $ptrType(structType$1);
- structType$2 = $structType([{prop: "r6", name: "r6", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- ptrType$16 = $ptrType(structType$2);
- structType$3 = $structType([{prop: "r5", name: "r5", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- ptrType$17 = $ptrType(structType$3);
- structType$4 = $structType([{prop: "r4", name: "r4", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- ptrType$18 = $ptrType(structType$4);
- structType$5 = $structType([{prop: "r3", name: "r3", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- ptrType$19 = $ptrType(structType$5);
- structType$6 = $structType([{prop: "r2", name: "r2", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- ptrType$20 = $ptrType(structType$6);
- structType$7 = $structType([{prop: "r1", name: "r1", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- ptrType$21 = $ptrType(structType$7);
- ptrType$22 = $ptrType(arrayType);
- ptrType$23 = $ptrType(sliceType);
- ptrType$24 = $ptrType(structType);
- ptrType$25 = $ptrType(mapType);
- ptrType$26 = $ptrType(gobEncoderType);
- sliceType$2 = $sliceType($Bool);
- sliceType$3 = $sliceType($emptyInterface);
- sliceType$4 = $sliceType($Complex64);
- sliceType$5 = $sliceType($Complex128);
- sliceType$6 = $sliceType($Float32);
- sliceType$7 = $sliceType($Float64);
- sliceType$8 = $sliceType($Int);
- sliceType$9 = $sliceType($Int16);
- sliceType$10 = $sliceType($Int32);
- sliceType$11 = $sliceType($Int64);
- sliceType$12 = $sliceType($Int8);
- sliceType$13 = $sliceType($String);
- sliceType$14 = $sliceType($Uint);
- sliceType$15 = $sliceType($Uint16);
- sliceType$16 = $sliceType($Uint32);
- sliceType$17 = $sliceType($Uint64);
- sliceType$18 = $sliceType($Uintptr);
- ptrType$27 = $ptrType(decoderState);
- ptrType$28 = $ptrType(decOp);
- ptrType$29 = $ptrType(wireType);
- ptrType$30 = $ptrType(decEngine);
- sliceType$19 = $sliceType(decInstr);
- ptrType$31 = $ptrType(ptrType$30);
- ptrType$32 = $ptrType($error);
- ptrType$33 = $ptrType(reflect.rtype);
- ptrType$38 = $ptrType(typeInfo);
- ptrType$39 = $ptrType(fieldType);
- sliceType$22 = $sliceType(ptrType$39);
- mapType$1 = $mapType(reflect.Type, ptrType$38);
- ptrType$40 = $ptrType(Decoder);
- ptrType$41 = $ptrType(decBuffer);
- ptrType$42 = $ptrType(decInstr);
- mapType$2 = $mapType(reflect.Type, ptrType$28);
- mapType$3 = $mapType(reflect.Type, typeId);
- mapType$4 = $mapType(typeId, ptrType$29);
- mapType$5 = $mapType(typeId, ptrType$31);
- mapType$6 = $mapType(reflect.Type, mapType$5);
- mapType$7 = $mapType(typeId, $Bool);
- ptrType$45 = $ptrType(CommonType);
- decBoolArray = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decBoolSlice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decBoolArray }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decBoolSlice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$2, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding bool array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = !((x$2 = state.decodeUint(), (x$2.$high === 0 && x$2.$low === 0))));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decBoolSlice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decComplex64Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decComplex64Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decComplex64Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decComplex64Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, imag, length, ok, ovfl, real, slice, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; imag = $f.imag; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; real = $f.real; slice = $f.slice; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$4, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding complex64 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- real = float32FromBits(state.decodeUint(), ovfl);
- imag = float32FromBits(state.decodeUint(), ovfl);
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = new $Complex64($fround(real), $fround(imag)));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decComplex64Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.imag = imag; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.real = real; $f.slice = slice; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decComplex128Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decComplex128Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decComplex128Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decComplex128Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, imag, length, ok, ovfl, real, slice, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; imag = $f.imag; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; real = $f.real; slice = $f.slice; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$5, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding complex128 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- real = float64FromBits(state.decodeUint());
- imag = float64FromBits(state.decodeUint());
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = new $Complex128(real, imag));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decComplex128Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.imag = imag; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.real = real; $f.slice = slice; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decFloat32Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decFloat32Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decFloat32Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decFloat32Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$6, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding float32 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = $fround(float32FromBits(state.decodeUint(), ovfl)));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decFloat32Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decFloat64Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decFloat64Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decFloat64Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decFloat64Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$7, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding float64 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = float64FromBits(state.decodeUint()));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decFloat64Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decIntArray = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decIntSlice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decIntArray }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decIntSlice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$8, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding int array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeInt();
- if ((x$2.$high < -1 || (x$2.$high === -1 && x$2.$low < 2147483648)) || (0 < x$2.$high || (0 === x$2.$high && 2147483647 < x$2.$low))) {
- error_(ovfl);
- }
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = ((x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decIntSlice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt16Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decInt16Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt16Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt16Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$9, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding int16 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeInt();
- if ((x$2.$high < -1 || (x$2.$high === -1 && x$2.$low < 4294934528)) || (0 < x$2.$high || (0 === x$2.$high && 32767 < x$2.$low))) {
- error_(ovfl);
- }
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = ((x$2.$low + ((x$2.$high >> 31) * 4294967296)) << 16 >> 16));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt16Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt32Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decInt32Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt32Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt32Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$10, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding int32 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeInt();
- if ((x$2.$high < -1 || (x$2.$high === -1 && x$2.$low < 2147483648)) || (0 < x$2.$high || (0 === x$2.$high && 2147483647 < x$2.$low))) {
- error_(ovfl);
- }
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = ((x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt32Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt64Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decInt64Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt64Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt64Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$11, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding int64 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = state.decodeInt());
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt64Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt8Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decInt8Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt8Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decInt8Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$12, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding int8 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeInt();
- if ((x$2.$high < -1 || (x$2.$high === -1 && x$2.$low < 4294967168)) || (0 < x$2.$high || (0 === x$2.$high && 127 < x$2.$low))) {
- error_(ovfl);
- }
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = ((x$2.$low + ((x$2.$high >> 31) * 4294967296)) << 24 >> 24));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decInt8Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decStringArray = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decStringSlice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decStringArray }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decStringSlice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, _tuple$1, data, err, i, length, n, ok, ovfl, slice, state, u, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; data = $f.data; err = $f.err; i = $f.i; length = $f.length; n = $f.n; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; u = $f.u; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$13, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding string array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- u = state.decodeUint();
- n = (u.$low >> 0);
- /* */ if (n < 0 || !((x$2 = new $Uint64(0, n), (x$2.$high === u.$high && x$2.$low === u.$low))) || n > state.b.Len()) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (n < 0 || !((x$2 = new $Uint64(0, n), (x$2.$high === u.$high && x$2.$low === u.$low))) || n > state.b.Len()) { */ case 7:
- $r = errorf("length of string exceeds input size (%d bytes)", new sliceType$3([u])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* */ if (n > state.b.Len()) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (n > state.b.Len()) { */ case 10:
- $r = errorf("string data too long for buffer: %d", new sliceType$3([new $Int(n)])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- data = $makeSlice(sliceType$1, n);
- _tuple$1 = state.b.Read(data); err = _tuple$1[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 13:
- $r = errorf("error decoding string: %s", new sliceType$3([err])); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = $bytesToString(data));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decStringSlice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.data = data; $f.err = err; $f.i = i; $f.length = length; $f.n = n; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.u = u; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUintArray = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decUintSlice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUintArray }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUintSlice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$14, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding uint array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeUint();
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = (x$2.$low >>> 0));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUintSlice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUint16Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decUint16Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUint16Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUint16Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$15, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding uint16 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeUint();
- if ((0 < x$2.$high || (0 === x$2.$high && 65535 < x$2.$low))) {
- error_(ovfl);
- }
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = (x$2.$low << 16 >>> 16));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUint16Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUint32Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decUint32Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUint32Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUint32Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$16, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding uint32 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeUint();
- if ((0 < x$2.$high || (0 === x$2.$high && 4294967295 < x$2.$low))) {
- error_(ovfl);
- }
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = (x$2.$low >>> 0));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUint32Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUint64Array = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decUint64Slice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUint64Array }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUint64Slice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$17, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding uint64 array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = state.decodeUint());
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUint64Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUintptrArray = function(state, v, length, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$22, _r$23, length, ovfl, state, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$22 = $f._r$22; _r$23 = $f._r$23; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.CanAddr()) {
- return false;
- }
- _arg = state;
- _r$22 = v.Slice(0, v.Len()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _arg$2 = length;
- _arg$3 = ovfl;
- _r$23 = decUintptrSlice(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUintptrArray }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decUintptrSlice = function(state, v, length, ovfl) {
- var $ptr, _r$22, _tuple, i, length, ok, ovfl, slice, state, v, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; i = $f.i; length = $f.length; ok = $f.ok; ovfl = $f.ovfl; slice = $f.slice; state = $f.state; v = $f.v; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _r$22 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$22, sliceType$18, true); slice = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return false;
- }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 3; continue; }
- /* */ if (state.b.Len() === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (state.b.Len() === 0) { */ case 4:
- $r = errorf("decoding uintptr array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- x$2 = state.decodeUint();
- if ((0 < x$2.$high || (0 === x$2.$high && 4294967295 < x$2.$low))) {
- error_(ovfl);
- }
- ((i < 0 || i >= slice.$length) ? $throwRuntimeError("index out of range") : slice.$array[slice.$offset + i] = (x$2.$low >>> 0));
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUintptrSlice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.i = i; $f.length = length; $f.ok = ok; $f.ovfl = ovfl; $f.slice = slice; $f.state = state; $f.v = v; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decBuffer.ptr.prototype.Read = function(p) {
- var $ptr, d, n, p;
- d = this;
- n = $copySlice(p, $subslice(d.data, d.offset));
- if ((n === 0) && !((p.$length === 0))) {
- return [0, io.EOF];
- }
- d.offset = d.offset + (n) >> 0;
- return [n, $ifaceNil];
- };
- decBuffer.prototype.Read = function(p) { return this.$val.Read(p); };
- decBuffer.ptr.prototype.Drop = function(n) {
- var $ptr, d, n;
- d = this;
- if (n > d.Len()) {
- $panic(new $String("drop"));
- }
- d.offset = d.offset + (n) >> 0;
- };
- decBuffer.prototype.Drop = function(n) { return this.$val.Drop(n); };
- decBuffer.ptr.prototype.Size = function(n) {
- var $ptr, d, n;
- d = this;
- d.Reset();
- if (d.data.$capacity < n) {
- d.data = $makeSlice(sliceType$1, n);
- } else {
- d.data = $subslice(d.data, 0, n);
- }
- };
- decBuffer.prototype.Size = function(n) { return this.$val.Size(n); };
- decBuffer.ptr.prototype.ReadByte = function() {
- var $ptr, c, d, x$2, x$3;
- d = this;
- if (d.offset >= d.data.$length) {
- return [0, io.EOF];
- }
- c = (x$2 = d.data, x$3 = d.offset, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3]));
- d.offset = d.offset + (1) >> 0;
- return [c, $ifaceNil];
- };
- decBuffer.prototype.ReadByte = function() { return this.$val.ReadByte(); };
- decBuffer.ptr.prototype.Len = function() {
- var $ptr, d;
- d = this;
- return d.data.$length - d.offset >> 0;
- };
- decBuffer.prototype.Len = function() { return this.$val.Len(); };
- decBuffer.ptr.prototype.Bytes = function() {
- var $ptr, d;
- d = this;
- return $subslice(d.data, d.offset);
- };
- decBuffer.prototype.Bytes = function() { return this.$val.Bytes(); };
- decBuffer.ptr.prototype.Reset = function() {
- var $ptr, d;
- d = this;
- d.data = $subslice(d.data, 0, 0);
- d.offset = 0;
- };
- decBuffer.prototype.Reset = function() { return this.$val.Reset(); };
- Decoder.ptr.prototype.newDecoderState = function(buf) {
- var $ptr, buf, d, dec;
- dec = this;
- d = dec.freeList;
- if (d === ptrType$27.nil) {
- d = new decoderState.ptr();
- d.dec = dec;
- d.buf = $makeSlice(sliceType$1, 8);
- } else {
- dec.freeList = d.next;
- }
- d.b = buf;
- return d;
- };
- Decoder.prototype.newDecoderState = function(buf) { return this.$val.newDecoderState(buf); };
- Decoder.ptr.prototype.freeDecoderState = function(d) {
- var $ptr, d, dec;
- dec = this;
- d.next = dec.freeList;
- dec.freeList = d;
- };
- Decoder.prototype.freeDecoderState = function(d) { return this.$val.freeDecoderState(d); };
- overflow = function(name) {
- var $ptr, name;
- return errors.New("value for \"" + name + "\" out of range");
- };
- decodeUintReader = function(r, buf) {
- var $ptr, _i, _r$22, _r$23, _ref, _tmp, _tmp$1, _tmp$2, _tuple, _tuple$1, b, b$1, buf, err, n, r, width, x$2, x$3, x$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$22 = $f._r$22; _r$23 = $f._r$23; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; b$1 = $f.b$1; buf = $f.buf; err = $f.err; n = $f.n; r = $f.r; width = $f.width; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x$2 = new $Uint64(0, 0);
- width = 0;
- err = $ifaceNil;
- width = 1;
- _r$22 = io.ReadFull(r, $subslice(buf, 0, width)); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = _r$22; n = _tuple[0]; err = _tuple[1];
- if (n === 0) {
- return [x$2, width, err];
- }
- b = (0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]);
- if (b <= 127) {
- _tmp = new $Uint64(0, b); _tmp$1 = width; _tmp$2 = $ifaceNil; x$2 = _tmp; width = _tmp$1; err = _tmp$2;
- return [x$2, width, err];
- }
- n = -((b << 24 >> 24) >> 0);
- if (n > 8) {
- err = errBadUint;
- return [x$2, width, err];
- }
- _r$23 = io.ReadFull(r, $subslice(buf, 0, n)); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _tuple$1 = _r$23; width = _tuple$1[0]; err = _tuple$1[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- if ($interfaceIsEqual(err, io.EOF)) {
- err = io.ErrUnexpectedEOF;
- }
- return [x$2, width, err];
- }
- _ref = $subslice(buf, 0, width);
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- b$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- x$2 = (x$3 = $shiftLeft64(x$2, 8), x$4 = new $Uint64(0, b$1), new $Uint64(x$3.$high | x$4.$high, (x$3.$low | x$4.$low) >>> 0));
- _i++;
- }
- width = width + (1) >> 0;
- return [x$2, width, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeUintReader }; } $f.$ptr = $ptr; $f._i = _i; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.b$1 = b$1; $f.buf = buf; $f.err = err; $f.n = n; $f.r = r; $f.width = width; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- decoderState.ptr.prototype.decodeUint = function() {
- var $ptr, _i, _ref, _tuple, _tuple$1, b, b$1, err, n, state, width, x$2, x$3, x$4;
- x$2 = new $Uint64(0, 0);
- state = this;
- _tuple = state.b.ReadByte(); b = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- if (b <= 127) {
- x$2 = new $Uint64(0, b);
- return x$2;
- }
- n = -((b << 24 >> 24) >> 0);
- if (n > 8) {
- error_(errBadUint);
- }
- _tuple$1 = state.b.Read($subslice(state.buf, 0, n)); width = _tuple$1[0]; err = _tuple$1[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- _ref = $subslice(state.buf, 0, width);
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- b$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- x$2 = (x$3 = $shiftLeft64(x$2, 8), x$4 = new $Uint64(0, b$1), new $Uint64(x$3.$high | x$4.$high, (x$3.$low | x$4.$low) >>> 0));
- _i++;
- }
- x$2 = x$2;
- return x$2;
- };
- decoderState.prototype.decodeUint = function() { return this.$val.decodeUint(); };
- decoderState.ptr.prototype.decodeInt = function() {
- var $ptr, state, x$2, x$3, x$4, x$5, x$6;
- state = this;
- x$2 = state.decodeUint();
- if (!((x$3 = new $Uint64(x$2.$high & 0, (x$2.$low & 1) >>> 0), (x$3.$high === 0 && x$3.$low === 0)))) {
- return (x$4 = (x$5 = $shiftRightUint64(x$2, 1), new $Int64(x$5.$high, x$5.$low)), new $Int64(~x$4.$high, ~x$4.$low >>> 0));
- }
- return (x$6 = $shiftRightUint64(x$2, 1), new $Int64(x$6.$high, x$6.$low));
- };
- decoderState.prototype.decodeInt = function() { return this.$val.decodeInt(); };
- ignoreUint = function(i, state, v) {
- var $ptr, i, state, v;
- v = v;
- state.decodeUint();
- };
- ignoreTwoUints = function(i, state, v) {
- var $ptr, i, state, v;
- v = v;
- state.decodeUint();
- state.decodeUint();
- };
- decAlloc = function(v) {
- var $ptr, _r$22, _r$23, _r$24, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- /* while (true) { */ case 1:
- /* if (!(v.Kind() === 22)) { break; } */ if(!(v.Kind() === 22)) { $s = 2; continue; }
- /* */ if (v.IsNil()) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (v.IsNil()) { */ case 3:
- _r$22 = v.Type().Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = reflect.New(_r$22); /* */ $s = 6; case 6: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- $r = v.Set(_r$23); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- _r$24 = v.Elem(); /* */ $s = 8; case 8: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- v = _r$24;
- /* } */ $s = 1; continue; case 2:
- return v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decAlloc }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decBool = function(i, state, value) {
- var $ptr, i, state, value, x$2;
- value = value;
- value.SetBool(!((x$2 = state.decodeUint(), (x$2.$high === 0 && x$2.$low === 0))));
- };
- decInt8 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeInt();
- if ((v.$high < -1 || (v.$high === -1 && v.$low < 4294967168)) || (0 < v.$high || (0 === v.$high && 127 < v.$low))) {
- error_(i.ovfl);
- }
- value.SetInt(v);
- };
- decUint8 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeUint();
- if ((0 < v.$high || (0 === v.$high && 255 < v.$low))) {
- error_(i.ovfl);
- }
- value.SetUint(v);
- };
- decInt16 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeInt();
- if ((v.$high < -1 || (v.$high === -1 && v.$low < 4294934528)) || (0 < v.$high || (0 === v.$high && 32767 < v.$low))) {
- error_(i.ovfl);
- }
- value.SetInt(v);
- };
- decUint16 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeUint();
- if ((0 < v.$high || (0 === v.$high && 65535 < v.$low))) {
- error_(i.ovfl);
- }
- value.SetUint(v);
- };
- decInt32 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeInt();
- if ((v.$high < -1 || (v.$high === -1 && v.$low < 2147483648)) || (0 < v.$high || (0 === v.$high && 2147483647 < v.$low))) {
- error_(i.ovfl);
- }
- value.SetInt(v);
- };
- decUint32 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeUint();
- if ((0 < v.$high || (0 === v.$high && 4294967295 < v.$low))) {
- error_(i.ovfl);
- }
- value.SetUint(v);
- };
- decInt64 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeInt();
- value.SetInt(v);
- };
- decUint64 = function(i, state, value) {
- var $ptr, i, state, v, value;
- value = value;
- v = state.decodeUint();
- value.SetUint(v);
- };
- float64FromBits = function(u) {
- var $ptr, i, u, v, x$2;
- v = new $Uint64(0, 0);
- i = 0;
- while (true) {
- if (!(i < 8)) { break; }
- v = $shiftLeft64(v, (8));
- v = (x$2 = new $Uint64(u.$high & 0, (u.$low & 255) >>> 0), new $Uint64(v.$high | x$2.$high, (v.$low | x$2.$low) >>> 0));
- u = $shiftRightUint64(u, (8));
- i = i + (1) >> 0;
- }
- return math.Float64frombits(v);
- };
- float32FromBits = function(u, ovfl) {
- var $ptr, av, ovfl, u, v;
- v = float64FromBits(u);
- av = v;
- if (av < 0) {
- av = -av;
- }
- if (3.4028234663852886e+38 < av && av <= 1.7976931348623157e+308) {
- error_(ovfl);
- }
- return v;
- };
- decFloat32 = function(i, state, value) {
- var $ptr, i, state, value;
- value = value;
- value.SetFloat(float32FromBits(state.decodeUint(), i.ovfl));
- };
- decFloat64 = function(i, state, value) {
- var $ptr, i, state, value;
- value = value;
- value.SetFloat(float64FromBits(state.decodeUint()));
- };
- decComplex64 = function(i, state, value) {
- var $ptr, i, imag, real, state, value;
- value = value;
- real = float32FromBits(state.decodeUint(), i.ovfl);
- imag = float32FromBits(state.decodeUint(), i.ovfl);
- value.SetComplex(new $Complex128(real, imag));
- };
- decComplex128 = function(i, state, value) {
- var $ptr, i, imag, real, state, value;
- value = value;
- real = float64FromBits(state.decodeUint());
- imag = float64FromBits(state.decodeUint());
- value.SetComplex(new $Complex128(real, imag));
- };
- decUint8Slice = function(i, state, value) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, _tuple, err, i, n, state, u, value, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _tuple = $f._tuple; err = $f.err; i = $f.i; n = $f.n; state = $f.state; u = $f.u; value = $f.value; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- value = value;
- u = state.decodeUint();
- n = (u.$low >> 0);
- /* */ if (n < 0 || !((x$2 = new $Uint64(0, n), (x$2.$high === u.$high && x$2.$low === u.$low)))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n < 0 || !((x$2 = new $Uint64(0, n), (x$2.$high === u.$high && x$2.$low === u.$low)))) { */ case 1:
- $r = errorf("length of %s exceeds input size (%d bytes)", new sliceType$3([value.Type(), u])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ if (n > state.b.Len()) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (n > state.b.Len()) { */ case 4:
- $r = errorf("%s data too long for buffer: %d", new sliceType$3([value.Type(), new $Int(n)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- /* */ if (n > 1073741824) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (n > 1073741824) { */ case 7:
- $r = errorf("byte slice too big: %d", new sliceType$3([new $Int(n)])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* */ if (value.Cap() < n) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (value.Cap() < n) { */ case 10:
- _r$22 = reflect.MakeSlice(value.Type(), n, n); /* */ $s = 13; case 13: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- $r = value.Set(_r$22); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 12; continue;
- /* } else { */ case 11:
- _r$23 = value.Slice(0, n); /* */ $s = 15; case 15: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- $r = value.Set(_r$23); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 12:
- _r$24 = value.Bytes(); /* */ $s = 17; case 17: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$25 = state.b.Read(_r$24); /* */ $s = 18; case 18: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _tuple = _r$25; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 19:
- $r = errorf("error decoding []byte: %s", new sliceType$3([err])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decUint8Slice }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._tuple = _tuple; $f.err = err; $f.i = i; $f.n = n; $f.state = state; $f.u = u; $f.value = value; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- decString = function(i, state, value) {
- var $ptr, _tuple, data, err, i, n, state, u, value, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _tuple = $f._tuple; data = $f.data; err = $f.err; i = $f.i; n = $f.n; state = $f.state; u = $f.u; value = $f.value; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- value = value;
- u = state.decodeUint();
- n = (u.$low >> 0);
- /* */ if (n < 0 || !((x$2 = new $Uint64(0, n), (x$2.$high === u.$high && x$2.$low === u.$low))) || n > state.b.Len()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n < 0 || !((x$2 = new $Uint64(0, n), (x$2.$high === u.$high && x$2.$low === u.$low))) || n > state.b.Len()) { */ case 1:
- $r = errorf("length of %s exceeds input size (%d bytes)", new sliceType$3([value.Type(), u])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ if (n > state.b.Len()) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (n > state.b.Len()) { */ case 4:
- $r = errorf("%s data too long for buffer: %d", new sliceType$3([value.Type(), new $Int(n)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- data = $makeSlice(sliceType$1, n);
- _tuple = state.b.Read(data); err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 7:
- $r = errorf("error decoding string: %s", new sliceType$3([err])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- value.SetString($bytesToString(data));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decString }; } $f.$ptr = $ptr; $f._tuple = _tuple; $f.data = data; $f.err = err; $f.i = i; $f.n = n; $f.state = state; $f.u = u; $f.value = value; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- ignoreUint8Array = function(i, state, value) {
- var $ptr, b, i, state, value;
- value = value;
- b = $makeSlice(sliceType$1, $flatten64(state.decodeUint()));
- state.b.Read(b);
- };
- Decoder.ptr.prototype.decodeSingle = function(engine, ut, value) {
- var $ptr, dec, engine, instr, state, ut, value, x$2, x$3, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dec = $f.dec; engine = $f.engine; instr = $f.instr; state = $f.state; ut = $f.ut; value = $f.value; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- dec = this;
- value = value;
- state = dec.newDecoderState(dec.buf);
- $deferred.push([$methodVal(dec, "freeDecoderState"), [state]]);
- state.fieldnum = 0;
- /* */ if (!((x$2 = state.decodeUint(), (x$2.$high === 0 && x$2.$low === 0)))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((x$2 = state.decodeUint(), (x$2.$high === 0 && x$2.$low === 0)))) { */ case 1:
- $r = errorf("decode: corrupted data: non-zero delta for singleton", new sliceType$3([])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- instr = (x$3 = engine.instr, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0]));
- $r = instr.op(instr, state, value); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeSingle }; } $f.$ptr = $ptr; $f.dec = dec; $f.engine = engine; $f.instr = instr; $f.state = state; $f.ut = ut; $f.value = value; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Decoder.prototype.decodeSingle = function(engine, ut, value) { return this.$val.decodeSingle(engine, ut, value); };
- Decoder.ptr.prototype.decodeStruct = function(engine, ut, value) {
- var $ptr, _r$22, _r$23, dec, delta, engine, field, fieldnum, instr, state, ut, value, x$2, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; dec = $f.dec; delta = $f.delta; engine = $f.engine; field = $f.field; fieldnum = $f.fieldnum; instr = $f.instr; state = $f.state; ut = $f.ut; value = $f.value; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- dec = this;
- value = value;
- state = dec.newDecoderState(dec.buf);
- $deferred.push([$methodVal(dec, "freeDecoderState"), [state]]);
- state.fieldnum = -1;
- /* while (true) { */ case 1:
- /* if (!(state.b.Len() > 0)) { break; } */ if(!(state.b.Len() > 0)) { $s = 2; continue; }
- delta = (state.decodeUint().$low >> 0);
- /* */ if (delta < 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (delta < 0) { */ case 3:
- $r = errorf("decode: corrupted data: negative delta", new sliceType$3([])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- if (delta === 0) {
- /* break; */ $s = 2; continue;
- }
- fieldnum = state.fieldnum + delta >> 0;
- if (fieldnum >= engine.instr.$length) {
- error_(errRange);
- /* break; */ $s = 2; continue;
- }
- instr = (x$2 = engine.instr, ((fieldnum < 0 || fieldnum >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + fieldnum]));
- field = new reflect.Value.ptr();
- /* */ if (!(instr.index === sliceType$8.nil)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!(instr.index === sliceType$8.nil)) { */ case 6:
- _r$22 = value.FieldByIndex(instr.index); /* */ $s = 8; case 8: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- field = _r$22;
- /* */ if (field.Kind() === 22) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (field.Kind() === 22) { */ case 9:
- _r$23 = decAlloc(field); /* */ $s = 11; case 11: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- field = _r$23;
- /* } */ case 10:
- /* } */ case 7:
- $r = instr.op(instr, state, field); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- state.fieldnum = fieldnum;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeStruct }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.dec = dec; $f.delta = delta; $f.engine = engine; $f.field = field; $f.fieldnum = fieldnum; $f.instr = instr; $f.state = state; $f.ut = ut; $f.value = value; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Decoder.prototype.decodeStruct = function(engine, ut, value) { return this.$val.decodeStruct(engine, ut, value); };
- Decoder.ptr.prototype.ignoreStruct = function(engine) {
- var $ptr, dec, delta, engine, fieldnum, instr, state, x$2, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dec = $f.dec; delta = $f.delta; engine = $f.engine; fieldnum = $f.fieldnum; instr = $f.instr; state = $f.state; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- dec = this;
- state = dec.newDecoderState(dec.buf);
- $deferred.push([$methodVal(dec, "freeDecoderState"), [state]]);
- state.fieldnum = -1;
- /* while (true) { */ case 1:
- /* if (!(state.b.Len() > 0)) { break; } */ if(!(state.b.Len() > 0)) { $s = 2; continue; }
- delta = (state.decodeUint().$low >> 0);
- /* */ if (delta < 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (delta < 0) { */ case 3:
- $r = errorf("ignore decode: corrupted data: negative delta", new sliceType$3([])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- if (delta === 0) {
- /* break; */ $s = 2; continue;
- }
- fieldnum = state.fieldnum + delta >> 0;
- if (fieldnum >= engine.instr.$length) {
- error_(errRange);
- }
- instr = (x$2 = engine.instr, ((fieldnum < 0 || fieldnum >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + fieldnum]));
- $r = instr.op(instr, state, noValue); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- state.fieldnum = fieldnum;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.ignoreStruct }; } $f.$ptr = $ptr; $f.dec = dec; $f.delta = delta; $f.engine = engine; $f.fieldnum = fieldnum; $f.instr = instr; $f.state = state; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Decoder.prototype.ignoreStruct = function(engine) { return this.$val.ignoreStruct(engine); };
- Decoder.ptr.prototype.ignoreSingle = function(engine) {
- var $ptr, dec, delta, engine, instr, state, x$2, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dec = $f.dec; delta = $f.delta; engine = $f.engine; instr = $f.instr; state = $f.state; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- dec = this;
- state = dec.newDecoderState(dec.buf);
- $deferred.push([$methodVal(dec, "freeDecoderState"), [state]]);
- state.fieldnum = 0;
- delta = (state.decodeUint().$low >> 0);
- /* */ if (!((delta === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((delta === 0))) { */ case 1:
- $r = errorf("decode: corrupted data: non-zero delta for singleton", new sliceType$3([])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- instr = (x$2 = engine.instr, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0]));
- $r = instr.op(instr, state, noValue); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.ignoreSingle }; } $f.$ptr = $ptr; $f.dec = dec; $f.delta = delta; $f.engine = engine; $f.instr = instr; $f.state = state; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Decoder.prototype.ignoreSingle = function(engine) { return this.$val.ignoreSingle(engine); };
- Decoder.ptr.prototype.decodeArrayHelper = function(state, value, elemOp, length, ovfl, helper) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, _r$26, _v, dec, elemOp, helper, i, instr, isPtr, length, ovfl, state, v, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _v = $f._v; dec = $f.dec; elemOp = $f.elemOp; helper = $f.helper; i = $f.i; instr = $f.instr; isPtr = $f.isPtr; length = $f.length; ovfl = $f.ovfl; state = $f.state; v = $f.v; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- value = value;
- if (!(!(helper === $throwNilPointerError))) { _v = false; $s = 3; continue s; }
- _r$22 = helper(state, value, length, ovfl); /* */ $s = 4; case 4: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _v = _r$22; case 3:
- /* */ if (_v) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v) { */ case 1:
- return;
- /* } */ case 2:
- instr = new decInstr.ptr(elemOp, 0, sliceType$8.nil, ovfl);
- _r$23 = value.Type().Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _r$24 = _r$23.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- isPtr = _r$24 === 22;
- i = 0;
- /* while (true) { */ case 7:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 8; continue; }
- /* */ if (state.b.Len() === 0) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (state.b.Len() === 0) { */ case 9:
- $r = errorf("decoding array or slice: length exceeds input size (%d elements)", new sliceType$3([new $Int(length)])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- _r$25 = value.Index(i); /* */ $s = 12; case 12: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- v = _r$25;
- /* */ if (isPtr) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (isPtr) { */ case 13:
- _r$26 = decAlloc(v); /* */ $s = 15; case 15: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- v = _r$26;
- /* } */ case 14:
- $r = elemOp(instr, state, v); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 7; continue; case 8:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeArrayHelper }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._v = _v; $f.dec = dec; $f.elemOp = elemOp; $f.helper = helper; $f.i = i; $f.instr = instr; $f.isPtr = isPtr; $f.length = length; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeArrayHelper = function(state, value, elemOp, length, ovfl, helper) { return this.$val.decodeArrayHelper(state, value, elemOp, length, ovfl, helper); };
- Decoder.ptr.prototype.decodeArray = function(atyp, state, value, elemOp, length, ovfl, helper) {
- var $ptr, atyp, dec, elemOp, helper, length, n, ovfl, state, value, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; atyp = $f.atyp; dec = $f.dec; elemOp = $f.elemOp; helper = $f.helper; length = $f.length; n = $f.n; ovfl = $f.ovfl; state = $f.state; value = $f.value; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- value = value;
- n = state.decodeUint();
- /* */ if (!((x$2 = new $Uint64(0, length), (n.$high === x$2.$high && n.$low === x$2.$low)))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((x$2 = new $Uint64(0, length), (n.$high === x$2.$high && n.$low === x$2.$low)))) { */ case 1:
- $r = errorf("length mismatch in decodeArray", new sliceType$3([])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- $r = dec.decodeArrayHelper(state, value, elemOp, length, ovfl, helper); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeArray }; } $f.$ptr = $ptr; $f.atyp = atyp; $f.dec = dec; $f.elemOp = elemOp; $f.helper = helper; $f.length = length; $f.n = n; $f.ovfl = ovfl; $f.state = state; $f.value = value; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeArray = function(atyp, state, value, elemOp, length, ovfl, helper) { return this.$val.decodeArray(atyp, state, value, elemOp, length, ovfl, helper); };
- decodeIntoValue = function(state, op, isPtr, value, ovfl) {
- var $ptr, _r$22, instr, isPtr, op, ovfl, state, v, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; instr = $f.instr; isPtr = $f.isPtr; op = $f.op; ovfl = $f.ovfl; state = $f.state; v = $f.v; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- value = value;
- instr = new decInstr.ptr(op, 0, sliceType$8.nil, ovfl);
- v = value;
- /* */ if (isPtr) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (isPtr) { */ case 1:
- _r$22 = decAlloc(value); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- v = _r$22;
- /* } */ case 2:
- $r = op(instr, state, v); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return value;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeIntoValue }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.instr = instr; $f.isPtr = isPtr; $f.op = op; $f.ovfl = ovfl; $f.state = state; $f.v = v; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.ptr.prototype.decodeMap = function(mtyp, state, value, keyOp, elemOp, ovfl) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$30, _r$31, _r$32, dec, elem, elemIsPtr, elemOp, i, key, keyIsPtr, keyOp, mtyp, n, ovfl, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; dec = $f.dec; elem = $f.elem; elemIsPtr = $f.elemIsPtr; elemOp = $f.elemOp; i = $f.i; key = $f.key; keyIsPtr = $f.keyIsPtr; keyOp = $f.keyOp; mtyp = $f.mtyp; n = $f.n; ovfl = $f.ovfl; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- value = value;
- /* */ if (value.IsNil()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (value.IsNil()) { */ case 1:
- _r$22 = reflect.MakeMap(mtyp); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- $r = value.Set(_r$22); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- n = (state.decodeUint().$low >> 0);
- _r$23 = mtyp.Key(); /* */ $s = 5; case 5: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _r$24 = _r$23.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- keyIsPtr = _r$24 === 22;
- _r$25 = mtyp.Elem(); /* */ $s = 7; case 7: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _r$26 = _r$25.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- elemIsPtr = _r$26 === 22;
- i = 0;
- /* while (true) { */ case 9:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 10; continue; }
- _arg = state;
- _arg$1 = keyOp;
- _arg$2 = keyIsPtr;
- _r$27 = mtyp.Key(); /* */ $s = 11; case 11: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _r$28 = allocValue(_r$27); /* */ $s = 12; case 12: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _arg$3 = _r$28;
- _arg$4 = ovfl;
- _r$29 = decodeIntoValue(_arg, _arg$1, _arg$2, _arg$3, _arg$4); /* */ $s = 13; case 13: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- key = _r$29;
- _arg$5 = state;
- _arg$6 = elemOp;
- _arg$7 = elemIsPtr;
- _r$30 = mtyp.Elem(); /* */ $s = 14; case 14: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _r$31 = allocValue(_r$30); /* */ $s = 15; case 15: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- _arg$8 = _r$31;
- _arg$9 = ovfl;
- _r$32 = decodeIntoValue(_arg$5, _arg$6, _arg$7, _arg$8, _arg$9); /* */ $s = 16; case 16: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- elem = _r$32;
- $r = value.SetMapIndex(key, elem); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 9; continue; case 10:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeMap }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f.dec = dec; $f.elem = elem; $f.elemIsPtr = elemIsPtr; $f.elemOp = elemOp; $f.i = i; $f.key = key; $f.keyIsPtr = keyIsPtr; $f.keyOp = keyOp; $f.mtyp = mtyp; $f.n = n; $f.ovfl = ovfl; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeMap = function(mtyp, state, value, keyOp, elemOp, ovfl) { return this.$val.decodeMap(mtyp, state, value, keyOp, elemOp, ovfl); };
- Decoder.ptr.prototype.ignoreArrayHelper = function(state, elemOp, length) {
- var $ptr, dec, elemOp, i, instr, length, state, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dec = $f.dec; elemOp = $f.elemOp; i = $f.i; instr = $f.instr; length = $f.length; state = $f.state; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- instr = new decInstr.ptr(elemOp, 0, sliceType$8.nil, errors.New("no error"));
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < length)) { break; } */ if(!(i < length)) { $s = 2; continue; }
- $r = elemOp(instr, state, noValue); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.ignoreArrayHelper }; } $f.$ptr = $ptr; $f.dec = dec; $f.elemOp = elemOp; $f.i = i; $f.instr = instr; $f.length = length; $f.state = state; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.ignoreArrayHelper = function(state, elemOp, length) { return this.$val.ignoreArrayHelper(state, elemOp, length); };
- Decoder.ptr.prototype.ignoreArray = function(state, elemOp, length) {
- var $ptr, dec, elemOp, length, n, state, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dec = $f.dec; elemOp = $f.elemOp; length = $f.length; n = $f.n; state = $f.state; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- n = state.decodeUint();
- /* */ if (!((x$2 = new $Uint64(0, length), (n.$high === x$2.$high && n.$low === x$2.$low)))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((x$2 = new $Uint64(0, length), (n.$high === x$2.$high && n.$low === x$2.$low)))) { */ case 1:
- $r = errorf("length mismatch in ignoreArray", new sliceType$3([])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- $r = dec.ignoreArrayHelper(state, elemOp, length); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.ignoreArray }; } $f.$ptr = $ptr; $f.dec = dec; $f.elemOp = elemOp; $f.length = length; $f.n = n; $f.state = state; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.ignoreArray = function(state, elemOp, length) { return this.$val.ignoreArray(state, elemOp, length); };
- Decoder.ptr.prototype.ignoreMap = function(state, keyOp, elemOp) {
- var $ptr, dec, elemInstr, elemOp, i, keyInstr, keyOp, n, state, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dec = $f.dec; elemInstr = $f.elemInstr; elemOp = $f.elemOp; i = $f.i; keyInstr = $f.keyInstr; keyOp = $f.keyOp; n = $f.n; state = $f.state; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- n = (state.decodeUint().$low >> 0);
- keyInstr = new decInstr.ptr(keyOp, 0, sliceType$8.nil, errors.New("no error"));
- elemInstr = new decInstr.ptr(elemOp, 0, sliceType$8.nil, errors.New("no error"));
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; }
- $r = keyOp(keyInstr, state, noValue); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = elemOp(elemInstr, state, noValue); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.ignoreMap }; } $f.$ptr = $ptr; $f.dec = dec; $f.elemInstr = elemInstr; $f.elemOp = elemOp; $f.i = i; $f.keyInstr = keyInstr; $f.keyOp = keyOp; $f.n = n; $f.state = state; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.ignoreMap = function(state, keyOp, elemOp) { return this.$val.ignoreMap(state, keyOp, elemOp); };
- Decoder.ptr.prototype.decodeSlice = function(state, value, elemOp, ovfl, helper) {
- var $ptr, _arg, _arg$1, _arg$2, _r$22, _r$23, _r$24, _r$25, _r$26, dec, elemOp, helper, n, nBytes, ovfl, size, state, typ, u, value, x$2, x$3, x$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; dec = $f.dec; elemOp = $f.elemOp; helper = $f.helper; n = $f.n; nBytes = $f.nBytes; ovfl = $f.ovfl; size = $f.size; state = $f.state; typ = $f.typ; u = $f.u; value = $f.value; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- value = value;
- u = state.decodeUint();
- typ = value.Type();
- _r$22 = typ.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = _r$22.Size(); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- size = (x$2 = _r$23, new $Uint64(0, x$2.constructor === Number ? x$2 : 1));
- nBytes = $mul64(u, size);
- n = (u.$low >> 0);
- /* */ if (n < 0 || !((x$3 = new $Uint64(0, n), (x$3.$high === u.$high && x$3.$low === u.$low))) || (nBytes.$high > 0 || (nBytes.$high === 0 && nBytes.$low > 1073741824)) || ((size.$high > 0 || (size.$high === 0 && size.$low > 0)) && !((x$4 = $div64(nBytes, size, false), (x$4.$high === u.$high && x$4.$low === u.$low))))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (n < 0 || !((x$3 = new $Uint64(0, n), (x$3.$high === u.$high && x$3.$low === u.$low))) || (nBytes.$high > 0 || (nBytes.$high === 0 && nBytes.$low > 1073741824)) || ((size.$high > 0 || (size.$high === 0 && size.$low > 0)) && !((x$4 = $div64(nBytes, size, false), (x$4.$high === u.$high && x$4.$low === u.$low))))) { */ case 3:
- _r$24 = typ.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _arg = _r$24;
- _arg$1 = u;
- _arg$2 = size;
- $r = errorf("%s slice too big: %d elements of %d bytes", new sliceType$3([_arg, _arg$1, _arg$2])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- /* */ if (value.Cap() < n) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (value.Cap() < n) { */ case 7:
- _r$25 = reflect.MakeSlice(typ, n, n); /* */ $s = 10; case 10: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- $r = value.Set(_r$25); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 9; continue;
- /* } else { */ case 8:
- _r$26 = value.Slice(0, n); /* */ $s = 12; case 12: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- $r = value.Set(_r$26); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- $r = dec.decodeArrayHelper(state, value, elemOp, n, ovfl, helper); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeSlice }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f.dec = dec; $f.elemOp = elemOp; $f.helper = helper; $f.n = n; $f.nBytes = nBytes; $f.ovfl = ovfl; $f.size = size; $f.state = state; $f.typ = typ; $f.u = u; $f.value = value; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeSlice = function(state, value, elemOp, ovfl, helper) { return this.$val.decodeSlice(state, value, elemOp, ovfl, helper); };
- Decoder.ptr.prototype.ignoreSlice = function(state, elemOp) {
- var $ptr, dec, elemOp, state, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; dec = $f.dec; elemOp = $f.elemOp; state = $f.state; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- $r = dec.ignoreArrayHelper(state, elemOp, (state.decodeUint().$low >> 0)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.ignoreSlice }; } $f.$ptr = $ptr; $f.dec = dec; $f.elemOp = elemOp; $f.state = state; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.ignoreSlice = function(state, elemOp) { return this.$val.ignoreSlice(state, elemOp); };
- Decoder.ptr.prototype.decodeInterface = function(ityp, state, value) {
- var $ptr, _entry, _r$22, _r$23, _r$24, _r$25, _tuple, b, concreteId, dec, ityp, name, nr, ok, state, typ, v, value, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _tuple = $f._tuple; b = $f.b; concreteId = $f.concreteId; dec = $f.dec; ityp = $f.ityp; name = $f.name; nr = $f.nr; ok = $f.ok; state = $f.state; typ = $f.typ; v = $f.v; value = $f.value; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- value = value;
- nr = state.decodeUint();
- /* */ if ((nr.$high < 0 || (nr.$high === 0 && nr.$low < 0)) || (nr.$high > 0 || (nr.$high === 0 && nr.$low > 2147483648))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((nr.$high < 0 || (nr.$high === 0 && nr.$low < 0)) || (nr.$high > 0 || (nr.$high === 0 && nr.$low > 2147483648))) { */ case 1:
- $r = errorf("invalid type name length %d", new sliceType$3([nr])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ if ((x$2 = new $Uint64(0, state.b.Len()), (nr.$high > x$2.$high || (nr.$high === x$2.$high && nr.$low > x$2.$low)))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ((x$2 = new $Uint64(0, state.b.Len()), (nr.$high > x$2.$high || (nr.$high === x$2.$high && nr.$low > x$2.$low)))) { */ case 4:
- $r = errorf("invalid type name length %d: exceeds input size", new sliceType$3([nr])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- b = $makeSlice(sliceType$1, $flatten64(nr));
- state.b.Read(b);
- name = $bytesToString(b);
- /* */ if (name === "") { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (name === "") { */ case 7:
- _r$22 = reflect.Zero(value.Type()); /* */ $s = 9; case 9: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- $r = value.Set(_r$22); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 8:
- /* */ if (name.length > 1024) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (name.length > 1024) { */ case 11:
- $r = errorf("name too long (%d bytes): %.20q...", new sliceType$3([new $Int(name.length), new $String(name)])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 12:
- registerLock.RLock();
- _tuple = (_entry = nameToConcreteType[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); typ = _tuple[0]; ok = _tuple[1];
- registerLock.RUnlock();
- /* */ if (!ok) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!ok) { */ case 14:
- $r = errorf("name not registered for interface: %q", new sliceType$3([new $String(name)])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- _r$23 = dec.decodeTypeSequence(true); /* */ $s = 17; case 17: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- concreteId = _r$23;
- if (concreteId < 0) {
- error_(dec.err);
- }
- state.decodeUint();
- _r$24 = allocValue(typ); /* */ $s = 18; case 18: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- v = _r$24;
- $r = dec.decodeValue(concreteId, v); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!($interfaceIsEqual(dec.err, $ifaceNil))) {
- error_(dec.err);
- }
- _r$25 = typ.AssignableTo(ityp); /* */ $s = 22; case 22: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- /* */ if (!_r$25) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (!_r$25) { */ case 20:
- $r = errorf("%s is not assignable to type %s", new sliceType$3([typ, ityp])); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 21:
- $r = value.Set(v); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeInterface }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._tuple = _tuple; $f.b = b; $f.concreteId = concreteId; $f.dec = dec; $f.ityp = ityp; $f.name = name; $f.nr = nr; $f.ok = ok; $f.state = state; $f.typ = typ; $f.v = v; $f.value = value; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeInterface = function(ityp, state, value) { return this.$val.decodeInterface(ityp, state, value); };
- Decoder.ptr.prototype.ignoreInterface = function(state) {
- var $ptr, _r$22, _tuple, b, dec, err, id, state, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; b = $f.b; dec = $f.dec; err = $f.err; id = $f.id; state = $f.state; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- b = $makeSlice(sliceType$1, $flatten64(state.decodeUint()));
- _tuple = state.b.Read(b); err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- _r$22 = dec.decodeTypeSequence(true); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- id = _r$22;
- if (id < 0) {
- error_(dec.err);
- }
- state.b.Drop((state.decodeUint().$low >> 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.ignoreInterface }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.b = b; $f.dec = dec; $f.err = err; $f.id = id; $f.state = state; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.ignoreInterface = function(state) { return this.$val.ignoreInterface(state); };
- Decoder.ptr.prototype.decodeGobDecoder = function(ut, state, value) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _ref, _tuple, b, dec, err, state, ut, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _ref = $f._ref; _tuple = $f._tuple; b = $f.b; dec = $f.dec; err = $f.err; state = $f.state; ut = $f.ut; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- value = value;
- b = $makeSlice(sliceType$1, $flatten64(state.decodeUint()));
- _tuple = state.b.Read(b); err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- _ref = ut.externalDec;
- /* */ if (_ref === 1) { $s = 1; continue; }
- /* */ if (_ref === 2) { $s = 2; continue; }
- /* */ if (_ref === 3) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_ref === 1) { */ case 1:
- _r$22 = value.Interface(); /* */ $s = 5; case 5: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = $assertType(_r$22, GobDecoder).GobDecode(b); /* */ $s = 6; case 6: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- err = _r$23;
- $s = 4; continue;
- /* } else if (_ref === 2) { */ case 2:
- _r$24 = value.Interface(); /* */ $s = 7; case 7: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$25 = $assertType(_r$24, encoding.BinaryUnmarshaler).UnmarshalBinary(b); /* */ $s = 8; case 8: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- err = _r$25;
- $s = 4; continue;
- /* } else if (_ref === 3) { */ case 3:
- _r$26 = value.Interface(); /* */ $s = 9; case 9: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _r$27 = $assertType(_r$26, encoding.TextUnmarshaler).UnmarshalText(b); /* */ $s = 10; case 10: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- err = _r$27;
- /* } */ case 4:
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeGobDecoder }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._ref = _ref; $f._tuple = _tuple; $f.b = b; $f.dec = dec; $f.err = err; $f.state = state; $f.ut = ut; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeGobDecoder = function(ut, state, value) { return this.$val.decodeGobDecoder(ut, state, value); };
- Decoder.ptr.prototype.ignoreGobDecoder = function(state) {
- var $ptr, _tuple, b, dec, err, state;
- dec = this;
- b = $makeSlice(sliceType$1, $flatten64(state.decodeUint()));
- _tuple = state.b.Read(b); err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- };
- Decoder.prototype.ignoreGobDecoder = function(state) { return this.$val.ignoreGobDecoder(state); };
- Decoder.ptr.prototype.decOpFor = function(wireId, rt, name, inProgress) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _entry, _entry$1, _entry$2, _entry$3, _entry$4, _entry$5, _entry$6, _entry$7, _key$5, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$37, _r$38, _r$39, _r$40, _r$41, _ref, _tuple, _tuple$1, dec, elemId, elemId$1, elemId$2, elemOp, elemOp$1, elemOp$2, enginePtr, err, helper, helper$1, inProgress, k, keyId, keyOp, name, ok, op, opPtr, ovfl, ovfl$1, ovfl$2, rt, t, tt, typ, ut, ut$1, wireId, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _entry$7 = $f._entry$7; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$40 = $f._r$40; _r$41 = $f._r$41; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; dec = $f.dec; elemId = $f.elemId; elemId$1 = $f.elemId$1; elemId$2 = $f.elemId$2; elemOp = $f.elemOp; elemOp$1 = $f.elemOp$1; elemOp$2 = $f.elemOp$2; enginePtr = $f.enginePtr; err = $f.err; helper = $f.helper; helper$1 = $f.helper$1; inProgress = $f.inProgress; k = $f.k; keyId = $f.keyId; keyOp = $f.keyOp; name = $f.name; ok = $f.ok; op = $f.op; opPtr = $f.opPtr; ovfl = $f.ovfl; ovfl$1 = $f.ovfl$1; ovfl$2 = $f.ovfl$2; rt = $f.rt; t = $f.t; tt = $f.tt; typ = $f.typ; ut = $f.ut; ut$1 = $f.ut$1; wireId = $f.wireId; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = [dec];
- elemOp = [elemOp];
- elemOp$1 = [elemOp$1];
- elemOp$2 = [elemOp$2];
- enginePtr = [enginePtr];
- helper = [helper];
- helper$1 = [helper$1];
- keyOp = [keyOp];
- op = [op];
- ovfl = [ovfl];
- ovfl$1 = [ovfl$1];
- ovfl$2 = [ovfl$2];
- t = [t];
- ut = [ut];
- dec[0] = this;
- _r$22 = userType(rt); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- ut$1 = _r$22;
- /* */ if (!((ut$1.externalDec === 0))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((ut$1.externalDec === 0))) { */ case 2:
- _r$23 = dec[0].gobDecodeOpFor(ut$1); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* } */ case 3:
- opPtr = (_entry = inProgress[reflect.Type.keyFor(rt)], _entry !== undefined ? _entry.v : ptrType$28.nil);
- if (!(opPtr === ptrType$28.nil)) {
- return opPtr;
- }
- typ = ut$1.base;
- op[0] = $throwNilPointerError;
- _r$24 = typ.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- k = _r$24;
- if ((k >> 0) < 25) {
- op[0] = ((k < 0 || k >= decOpTable.length) ? $throwRuntimeError("index out of range") : decOpTable[k]);
- }
- /* */ if (op[0] === $throwNilPointerError) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (op[0] === $throwNilPointerError) { */ case 6:
- _key$5 = rt; (inProgress || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: (op.$ptr || (op.$ptr = new ptrType$28(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, op))) };
- t[0] = typ;
- _r$25 = t[0].Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _ref = _r$25;
- /* */ if (_ref === 17) { $s = 9; continue; }
- /* */ if (_ref === 21) { $s = 10; continue; }
- /* */ if (_ref === 23) { $s = 11; continue; }
- /* */ if (_ref === 25) { $s = 12; continue; }
- /* */ if (_ref === 20) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* switch (0) { default: if (_ref === 17) { */ case 9:
- name = "element of " + name;
- elemId = (_entry$1 = dec[0].wireType[typeId.keyFor(wireId)], _entry$1 !== undefined ? _entry$1.v : ptrType$29.nil).ArrayT.Elem;
- _arg = elemId;
- _r$26 = t[0].Elem(); /* */ $s = 15; case 15: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _arg$1 = _r$26;
- _arg$2 = name;
- _arg$3 = inProgress;
- _r$27 = dec[0].decOpFor(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 16; case 16: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- elemOp[0] = _r$27;
- ovfl$2[0] = overflow(name);
- _r$28 = t[0].Elem(); /* */ $s = 17; case 17: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _r$29 = _r$28.Kind(); /* */ $s = 18; case 18: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- helper$1[0] = (_entry$2 = decArrayHelper[reflect.Kind.keyFor(_r$29)], _entry$2 !== undefined ? _entry$2.v : $throwNilPointerError);
- op[0] = (function(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut) { return function $b(i, state, value) {
- var $ptr, _arg$10, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _r$30, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$10 = $f._arg$10; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _r$30 = $f._r$30; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _arg$4 = t[0];
- _arg$5 = state;
- _arg$6 = value;
- _arg$7 = elemOp[0].$get();
- _r$30 = t[0].Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _arg$8 = _r$30;
- _arg$9 = ovfl$2[0];
- _arg$10 = helper$1[0];
- $r = state.dec.decodeArray(_arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _arg$10); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$10 = _arg$10; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._r$30 = _r$30; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut);
- $s = 14; continue;
- /* } else if (_ref === 21) { */ case 10:
- keyId = (_entry$3 = dec[0].wireType[typeId.keyFor(wireId)], _entry$3 !== undefined ? _entry$3.v : ptrType$29.nil).MapT.Key;
- elemId$1 = (_entry$4 = dec[0].wireType[typeId.keyFor(wireId)], _entry$4 !== undefined ? _entry$4.v : ptrType$29.nil).MapT.Elem;
- _arg$4 = keyId;
- _r$30 = t[0].Key(); /* */ $s = 19; case 19: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _arg$5 = _r$30;
- _arg$6 = "key of " + name;
- _arg$7 = inProgress;
- _r$31 = dec[0].decOpFor(_arg$4, _arg$5, _arg$6, _arg$7); /* */ $s = 20; case 20: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- keyOp[0] = _r$31;
- _arg$8 = elemId$1;
- _r$32 = t[0].Elem(); /* */ $s = 21; case 21: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _arg$9 = _r$32;
- _arg$10 = "element of " + name;
- _arg$11 = inProgress;
- _r$33 = dec[0].decOpFor(_arg$8, _arg$9, _arg$10, _arg$11); /* */ $s = 22; case 22: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- elemOp$1[0] = _r$33;
- ovfl[0] = overflow(name);
- op[0] = (function(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.decodeMap(t[0], state, value, keyOp[0].$get(), elemOp$1[0].$get(), ovfl[0]); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut);
- $s = 14; continue;
- /* } else if (_ref === 23) { */ case 11:
- name = "element of " + name;
- _r$34 = t[0].Elem(); /* */ $s = 25; case 25: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _r$35 = _r$34.Kind(); /* */ $s = 26; case 26: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- /* */ if (_r$35 === 8) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_r$35 === 8) { */ case 23:
- op[0] = decUint8Slice;
- /* break; */ $s = 14; continue;
- /* } */ case 24:
- elemId$2 = 0;
- _tuple = (_entry$5 = builtinIdToType[typeId.keyFor(wireId)], _entry$5 !== undefined ? [_entry$5.v, true] : [$ifaceNil, false]); tt = _tuple[0]; ok = _tuple[1];
- if (ok) {
- elemId$2 = $assertType(tt, ptrType$23).Elem;
- } else {
- elemId$2 = (_entry$6 = dec[0].wireType[typeId.keyFor(wireId)], _entry$6 !== undefined ? _entry$6.v : ptrType$29.nil).SliceT.Elem;
- }
- _arg$12 = elemId$2;
- _r$36 = t[0].Elem(); /* */ $s = 27; case 27: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- _arg$13 = _r$36;
- _arg$14 = name;
- _arg$15 = inProgress;
- _r$37 = dec[0].decOpFor(_arg$12, _arg$13, _arg$14, _arg$15); /* */ $s = 28; case 28: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- elemOp$2[0] = _r$37;
- ovfl$1[0] = overflow(name);
- _r$38 = t[0].Elem(); /* */ $s = 29; case 29: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- _r$39 = _r$38.Kind(); /* */ $s = 30; case 30: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- helper[0] = (_entry$7 = decSliceHelper[reflect.Kind.keyFor(_r$39)], _entry$7 !== undefined ? _entry$7.v : $throwNilPointerError);
- op[0] = (function(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.decodeSlice(state, value, elemOp$2[0].$get(), ovfl$1[0], helper[0]); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut);
- $s = 14; continue;
- /* } else if (_ref === 25) { */ case 12:
- _r$40 = userType(typ); /* */ $s = 31; case 31: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- ut[0] = _r$40;
- _r$41 = dec[0].getDecEnginePtr(wireId, ut[0]); /* */ $s = 32; case 32: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- _tuple$1 = _r$41; enginePtr[0] = _tuple$1[0]; err = _tuple$1[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- op[0] = (function(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = dec[0].decodeStruct(enginePtr[0].$get(), ut[0], value); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut);
- $s = 14; continue;
- /* } else if (_ref === 20) { */ case 13:
- op[0] = (function(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.decodeInterface(t[0], state, value); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(dec, elemOp, elemOp$1, elemOp$2, enginePtr, helper, helper$1, keyOp, op, ovfl, ovfl$1, ovfl$2, t, ut);
- /* } } */ case 14:
- /* } */ case 7:
- /* */ if (op[0] === $throwNilPointerError) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* if (op[0] === $throwNilPointerError) { */ case 33:
- $r = errorf("decode can't handle type %s", new sliceType$3([rt])); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 34:
- return (op.$ptr || (op.$ptr = new ptrType$28(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, op)));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decOpFor }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._entry$7 = _entry$7; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.dec = dec; $f.elemId = elemId; $f.elemId$1 = elemId$1; $f.elemId$2 = elemId$2; $f.elemOp = elemOp; $f.elemOp$1 = elemOp$1; $f.elemOp$2 = elemOp$2; $f.enginePtr = enginePtr; $f.err = err; $f.helper = helper; $f.helper$1 = helper$1; $f.inProgress = inProgress; $f.k = k; $f.keyId = keyId; $f.keyOp = keyOp; $f.name = name; $f.ok = ok; $f.op = op; $f.opPtr = opPtr; $f.ovfl = ovfl; $f.ovfl$1 = ovfl$1; $f.ovfl$2 = ovfl$2; $f.rt = rt; $f.t = t; $f.tt = tt; $f.typ = typ; $f.ut = ut; $f.ut$1 = ut$1; $f.wireId = wireId; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decOpFor = function(wireId, rt, name, inProgress) { return this.$val.decOpFor(wireId, rt, name, inProgress); };
- Decoder.ptr.prototype.decIgnoreOpFor = function(wireId) {
- var $ptr, _arg, _arg$1, _entry, _entry$1, _entry$2, _entry$3, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _tuple, _tuple$1, dec, elemId, elemId$1, elemId$2, elemOp, elemOp$1, elemOp$2, enginePtr, err, keyId, keyOp, ok, op, wire, wireId, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; dec = $f.dec; elemId = $f.elemId; elemId$1 = $f.elemId$1; elemId$2 = $f.elemId$2; elemOp = $f.elemOp; elemOp$1 = $f.elemOp$1; elemOp$2 = $f.elemOp$2; enginePtr = $f.enginePtr; err = $f.err; keyId = $f.keyId; keyOp = $f.keyOp; ok = $f.ok; op = $f.op; wire = $f.wire; wireId = $f.wireId; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- elemOp = [elemOp];
- elemOp$1 = [elemOp$1];
- elemOp$2 = [elemOp$2];
- enginePtr = [enginePtr];
- keyOp = [keyOp];
- wire = [wire];
- dec = this;
- _tuple = (_entry = decIgnoreOpMap[typeId.keyFor(wireId)], _entry !== undefined ? [_entry.v, true] : [$throwNilPointerError, false]); op = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!ok) { */ case 1:
- /* */ if (wireId === tInterface) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (wireId === tInterface) { */ case 3:
- op = (function(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.ignoreInterface(state); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire);
- return op;
- /* } */ case 4:
- wire[0] = (_entry$1 = dec.wireType[typeId.keyFor(wireId)], _entry$1 !== undefined ? _entry$1.v : ptrType$29.nil);
- /* */ if (wire[0] === ptrType$29.nil) { $s = 5; continue; }
- /* */ if (!(wire[0].ArrayT === ptrType$22.nil)) { $s = 6; continue; }
- /* */ if (!(wire[0].MapT === ptrType$25.nil)) { $s = 7; continue; }
- /* */ if (!(wire[0].SliceT === ptrType$23.nil)) { $s = 8; continue; }
- /* */ if (!(wire[0].StructT === ptrType$24.nil)) { $s = 9; continue; }
- /* */ if (!(wire[0].GobEncoderT === ptrType$26.nil) || !(wire[0].BinaryMarshalerT === ptrType$26.nil) || !(wire[0].TextMarshalerT === ptrType$26.nil)) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (wire[0] === ptrType$29.nil) { */ case 5:
- _r$22 = new typeId(wireId).string(); /* */ $s = 12; case 12: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg = new $String(_r$22);
- $r = errorf("bad data: undefined type %s", new sliceType$3([_arg])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 11; continue;
- /* } else if (!(wire[0].ArrayT === ptrType$22.nil)) { */ case 6:
- elemId = wire[0].ArrayT.Elem;
- _r$23 = dec.decIgnoreOpFor(elemId); /* */ $s = 14; case 14: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- elemOp[0] = _r$23;
- op = (function(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.ignoreArray(state, elemOp[0], wire[0].ArrayT.Len); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire);
- $s = 11; continue;
- /* } else if (!(wire[0].MapT === ptrType$25.nil)) { */ case 7:
- keyId = (_entry$2 = dec.wireType[typeId.keyFor(wireId)], _entry$2 !== undefined ? _entry$2.v : ptrType$29.nil).MapT.Key;
- elemId$1 = (_entry$3 = dec.wireType[typeId.keyFor(wireId)], _entry$3 !== undefined ? _entry$3.v : ptrType$29.nil).MapT.Elem;
- _r$24 = dec.decIgnoreOpFor(keyId); /* */ $s = 15; case 15: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- keyOp[0] = _r$24;
- _r$25 = dec.decIgnoreOpFor(elemId$1); /* */ $s = 16; case 16: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- elemOp$1[0] = _r$25;
- op = (function(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.ignoreMap(state, keyOp[0], elemOp$1[0]); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire);
- $s = 11; continue;
- /* } else if (!(wire[0].SliceT === ptrType$23.nil)) { */ case 8:
- elemId$2 = wire[0].SliceT.Elem;
- _r$26 = dec.decIgnoreOpFor(elemId$2); /* */ $s = 17; case 17: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- elemOp$2[0] = _r$26;
- op = (function(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.ignoreSlice(state, elemOp$2[0]); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire);
- $s = 11; continue;
- /* } else if (!(wire[0].StructT === ptrType$24.nil)) { */ case 9:
- _r$27 = dec.getIgnoreEnginePtr(wireId); /* */ $s = 18; case 18: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _tuple$1 = _r$27; enginePtr[0] = _tuple$1[0]; err = _tuple$1[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- op = (function(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire) { return function $b(i, state, value) {
- var $ptr, i, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = state.dec.ignoreStruct(enginePtr[0].$get()); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire);
- $s = 11; continue;
- /* } else if (!(wire[0].GobEncoderT === ptrType$26.nil) || !(wire[0].BinaryMarshalerT === ptrType$26.nil) || !(wire[0].TextMarshalerT === ptrType$26.nil)) { */ case 10:
- op = (function(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire) { return function(i, state, value) {
- var $ptr, i, state, value;
- state.dec.ignoreGobDecoder(state);
- }; })(elemOp, elemOp$1, elemOp$2, enginePtr, keyOp, wire);
- /* } */ case 11:
- /* } */ case 2:
- /* */ if (op === $throwNilPointerError) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (op === $throwNilPointerError) { */ case 19:
- _r$28 = new typeId(wireId).string(); /* */ $s = 21; case 21: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$28);
- $r = errorf("bad data: ignore can't handle type %s", new sliceType$3([_arg$1])); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- return op;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decIgnoreOpFor }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.dec = dec; $f.elemId = elemId; $f.elemId$1 = elemId$1; $f.elemId$2 = elemId$2; $f.elemOp = elemOp; $f.elemOp$1 = elemOp$1; $f.elemOp$2 = elemOp$2; $f.enginePtr = enginePtr; $f.err = err; $f.keyId = keyId; $f.keyOp = keyOp; $f.ok = ok; $f.op = op; $f.wire = wire; $f.wireId = wireId; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decIgnoreOpFor = function(wireId) { return this.$val.decIgnoreOpFor(wireId); };
- Decoder.ptr.prototype.gobDecodeOpFor = function(ut) {
- var $ptr, _r$22, dec, i, op, rcvrType, ut, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; dec = $f.dec; i = $f.i; op = $f.op; rcvrType = $f.rcvrType; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- op = [op];
- rcvrType = [rcvrType];
- ut = [ut];
- dec = this;
- rcvrType[0] = ut[0].user;
- /* */ if (ut[0].decIndir === -1) { $s = 1; continue; }
- /* */ if (ut[0].decIndir > 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (ut[0].decIndir === -1) { */ case 1:
- rcvrType[0] = reflect.PtrTo(rcvrType[0]);
- $s = 3; continue;
- /* } else if (ut[0].decIndir > 0) { */ case 2:
- i = 0;
- /* while (true) { */ case 4:
- /* if (!(i < ut[0].decIndir)) { break; } */ if(!(i < ut[0].decIndir)) { $s = 5; continue; }
- _r$22 = rcvrType[0].Elem(); /* */ $s = 6; case 6: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- rcvrType[0] = _r$22;
- i = i + (1) << 24 >> 24;
- /* } */ $s = 4; continue; case 5:
- /* } */ case 3:
- op[0] = $throwNilPointerError;
- op[0] = (function(op, rcvrType, ut) { return function $b(i$1, state, value) {
- var $ptr, _r$23, _v, i$1, state, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$23 = $f._r$23; _v = $f._v; i$1 = $f.i$1; state = $f.state; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (!(!((value.Kind() === 22)))) { _v = false; $s = 3; continue s; }
- _r$23 = rcvrType[0].Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _v = _r$23 === 22; case 3:
- /* */ if (_v) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v) { */ case 1:
- value = value.Addr();
- /* } */ case 2:
- $r = state.dec.decodeGobDecoder(ut[0], state, value); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$23 = _r$23; $f._v = _v; $f.i$1 = i$1; $f.state = state; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(op, rcvrType, ut);
- return (op.$ptr || (op.$ptr = new ptrType$28(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, op)));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.gobDecodeOpFor }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.dec = dec; $f.i = i; $f.op = op; $f.rcvrType = rcvrType; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.gobDecodeOpFor = function(ut) { return this.$val.gobDecodeOpFor(ut); };
- Decoder.ptr.prototype.compatibleType = function(fr, fw, inProgress) {
- var $ptr, MapType, _entry, _entry$1, _entry$2, _key$5, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _ref, _tuple, _tuple$1, _tuple$2, _tuple$3, _v, _v$1, _v$2, array, dec, elem, fr, fw, inProgress, ok, ok$1, ok$2, rhs, sw, t, tt, ut, wire, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; MapType = $f.MapType; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; array = $f.array; dec = $f.dec; elem = $f.elem; fr = $f.fr; fw = $f.fw; inProgress = $f.inProgress; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; rhs = $f.rhs; sw = $f.sw; t = $f.t; tt = $f.tt; ut = $f.ut; wire = $f.wire; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- _tuple = (_entry = inProgress[reflect.Type.keyFor(fr)], _entry !== undefined ? [_entry.v, true] : [0, false]); rhs = _tuple[0]; ok = _tuple[1];
- if (ok) {
- return rhs === fw;
- }
- _key$5 = fr; (inProgress || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: fw };
- _r$22 = userType(fr); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- ut = _r$22;
- _tuple$1 = (_entry$1 = dec.wireType[typeId.keyFor(fw)], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$29.nil, false]); wire = _tuple$1[0]; ok$1 = _tuple$1[1];
- if (!(((ut.externalDec === 1)) === (ok$1 && !(wire.GobEncoderT === ptrType$26.nil))) || !(((ut.externalDec === 2)) === (ok$1 && !(wire.BinaryMarshalerT === ptrType$26.nil))) || !(((ut.externalDec === 3)) === (ok$1 && !(wire.TextMarshalerT === ptrType$26.nil)))) {
- return false;
- }
- if (!((ut.externalDec === 0))) {
- return true;
- }
- t = ut.base;
- _r$23 = t.Kind(); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _ref = _r$23;
- /* */ if (_ref === 1) { $s = 3; continue; }
- /* */ if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { $s = 4; continue; }
- /* */ if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { $s = 5; continue; }
- /* */ if (_ref === 13 || _ref === 14) { $s = 6; continue; }
- /* */ if (_ref === 15 || _ref === 16) { $s = 7; continue; }
- /* */ if (_ref === 24) { $s = 8; continue; }
- /* */ if (_ref === 20) { $s = 9; continue; }
- /* */ if (_ref === 17) { $s = 10; continue; }
- /* */ if (_ref === 21) { $s = 11; continue; }
- /* */ if (_ref === 23) { $s = 12; continue; }
- /* */ if (_ref === 25) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (_ref === 1) { */ case 3:
- return fw === tBool;
- $s = 15; continue;
- /* } else if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { */ case 4:
- return fw === tInt;
- $s = 15; continue;
- /* } else if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { */ case 5:
- return fw === tUint;
- $s = 15; continue;
- /* } else if (_ref === 13 || _ref === 14) { */ case 6:
- return fw === tFloat;
- $s = 15; continue;
- /* } else if (_ref === 15 || _ref === 16) { */ case 7:
- return fw === tComplex;
- $s = 15; continue;
- /* } else if (_ref === 24) { */ case 8:
- return fw === tString;
- $s = 15; continue;
- /* } else if (_ref === 20) { */ case 9:
- return fw === tInterface;
- $s = 15; continue;
- /* } else if (_ref === 17) { */ case 10:
- if (!ok$1 || wire.ArrayT === ptrType$22.nil) {
- return false;
- }
- array = wire.ArrayT;
- _r$24 = t.Len(); /* */ $s = 17; case 17: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- if (!(_r$24 === array.Len)) { _v = false; $s = 16; continue s; }
- _r$25 = t.Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _r$26 = dec.compatibleType(_r$25, array.Elem, inProgress); /* */ $s = 19; case 19: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _v = _r$26; case 16:
- return _v;
- $s = 15; continue;
- /* } else if (_ref === 21) { */ case 11:
- if (!ok$1 || wire.MapT === ptrType$25.nil) {
- return false;
- }
- MapType = wire.MapT;
- _r$27 = t.Key(); /* */ $s = 21; case 21: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _r$28 = dec.compatibleType(_r$27, MapType.Key, inProgress); /* */ $s = 22; case 22: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- if (!(_r$28)) { _v$1 = false; $s = 20; continue s; }
- _r$29 = t.Elem(); /* */ $s = 23; case 23: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _r$30 = dec.compatibleType(_r$29, MapType.Elem, inProgress); /* */ $s = 24; case 24: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _v$1 = _r$30; case 20:
- return _v$1;
- $s = 15; continue;
- /* } else if (_ref === 23) { */ case 12:
- _r$31 = t.Elem(); /* */ $s = 27; case 27: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- _r$32 = _r$31.Kind(); /* */ $s = 28; case 28: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- /* */ if (_r$32 === 8) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if (_r$32 === 8) { */ case 25:
- return fw === tBytes;
- /* } */ case 26:
- sw = ptrType$23.nil;
- _tuple$2 = (_entry$2 = builtinIdToType[typeId.keyFor(fw)], _entry$2 !== undefined ? [_entry$2.v, true] : [$ifaceNil, false]); tt = _tuple$2[0]; ok$2 = _tuple$2[1];
- if (ok$2) {
- _tuple$3 = $assertType(tt, ptrType$23, true); sw = _tuple$3[0];
- } else if (!(wire === ptrType$29.nil)) {
- sw = wire.SliceT;
- }
- _r$33 = t.Elem(); /* */ $s = 29; case 29: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- _r$34 = userType(_r$33); /* */ $s = 30; case 30: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- elem = _r$34.base;
- if (!(!(sw === ptrType$23.nil))) { _v$2 = false; $s = 31; continue s; }
- _r$35 = dec.compatibleType(elem, sw.Elem, inProgress); /* */ $s = 32; case 32: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- _v$2 = _r$35; case 31:
- return _v$2;
- $s = 15; continue;
- /* } else if (_ref === 25) { */ case 13:
- return true;
- $s = 15; continue;
- /* } else { */ case 14:
- return false;
- /* } */ case 15:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.compatibleType }; } $f.$ptr = $ptr; $f.MapType = MapType; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.array = array; $f.dec = dec; $f.elem = elem; $f.fr = fr; $f.fw = fw; $f.inProgress = inProgress; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.rhs = rhs; $f.sw = sw; $f.t = t; $f.tt = tt; $f.ut = ut; $f.wire = wire; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.compatibleType = function(fr, fw, inProgress) { return this.$val.compatibleType(fr, fw, inProgress); };
- Decoder.ptr.prototype.typeString = function(remoteId) {
- var $ptr, _entry, _entry$1, _r$22, dec, remoteId, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _r$22 = $f._r$22; dec = $f.dec; remoteId = $f.remoteId; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- t = (_entry = idToType[typeId.keyFor(remoteId)], _entry !== undefined ? _entry.v : $ifaceNil);
- /* */ if (!($interfaceIsEqual(t, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(t, $ifaceNil))) { */ case 1:
- _r$22 = t.string(); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* } */ case 2:
- return (_entry$1 = dec.wireType[typeId.keyFor(remoteId)], _entry$1 !== undefined ? _entry$1.v : ptrType$29.nil).string();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.typeString }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._r$22 = _r$22; $f.dec = dec; $f.remoteId = remoteId; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.typeString = function(remoteId) { return this.$val.typeString(remoteId); };
- Decoder.ptr.prototype.compileSingle = function(remoteId, ut) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, _r$26, _tmp, _tmp$1, _tmp$2, _tmp$3, dec, engine, err, name, op, ovfl, remoteId, remoteType, rt, ut, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; dec = $f.dec; engine = $f.engine; err = $f.err; name = $f.name; op = $f.op; ovfl = $f.ovfl; remoteId = $f.remoteId; remoteType = $f.remoteType; rt = $f.rt; ut = $f.ut; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- engine = ptrType$30.nil;
- err = $ifaceNil;
- dec = this;
- rt = ut.user;
- engine = new decEngine.ptr();
- engine.instr = $makeSlice(sliceType$19, 1);
- _r$22 = rt.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- name = _r$22;
- _r$23 = dec.compatibleType(rt, remoteId, new $Map()); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- /* */ if (!_r$23) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!_r$23) { */ case 2:
- _r$24 = dec.typeString(remoteId); /* */ $s = 5; case 5: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- remoteType = _r$24;
- _r$25 = ut.base.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- /* */ if ((_r$25 === 20) && !((remoteId === tInterface))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if ((_r$25 === 20) && !((remoteId === tInterface))) { */ case 6:
- _tmp = ptrType$30.nil; _tmp$1 = errors.New("gob: local interface type " + name + " can only be decoded from remote interface type; received concrete type " + remoteType); engine = _tmp; err = _tmp$1;
- return [engine, err];
- /* } */ case 7:
- _tmp$2 = ptrType$30.nil; _tmp$3 = errors.New("gob: decoding into local type " + name + ", received remote type " + remoteType); engine = _tmp$2; err = _tmp$3;
- return [engine, err];
- /* } */ case 3:
- _r$26 = dec.decOpFor(remoteId, rt, name, new $Map()); /* */ $s = 9; case 9: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- op = _r$26;
- ovfl = errors.New("value for \"" + name + "\" out of range");
- $copy((x$2 = engine.instr, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])), new decInstr.ptr(op.$get(), 0, sliceType$8.nil, ovfl), decInstr);
- engine.numInstr = 1;
- return [engine, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.compileSingle }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.dec = dec; $f.engine = engine; $f.err = err; $f.name = name; $f.op = op; $f.ovfl = ovfl; $f.remoteId = remoteId; $f.remoteType = remoteType; $f.rt = rt; $f.ut = ut; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.compileSingle = function(remoteId, ut) { return this.$val.compileSingle(remoteId, ut); };
- Decoder.ptr.prototype.compileIgnoreSingle = function(remoteId) {
- var $ptr, _r$22, _r$23, _r$24, dec, engine, err, op, ovfl, remoteId, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; dec = $f.dec; engine = $f.engine; err = $f.err; op = $f.op; ovfl = $f.ovfl; remoteId = $f.remoteId; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- engine = ptrType$30.nil;
- err = $ifaceNil;
- dec = this;
- engine = new decEngine.ptr();
- engine.instr = $makeSlice(sliceType$19, 1);
- _r$22 = dec.decIgnoreOpFor(remoteId); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- op = _r$22;
- _r$23 = dec.typeString(remoteId); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _r$24 = overflow(_r$23); /* */ $s = 3; case 3: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- ovfl = _r$24;
- $copy((x$2 = engine.instr, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])), new decInstr.ptr(op, 0, sliceType$8.nil, ovfl), decInstr);
- engine.numInstr = 1;
- return [engine, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.compileIgnoreSingle }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f.dec = dec; $f.engine = engine; $f.err = err; $f.op = op; $f.ovfl = ovfl; $f.remoteId = remoteId; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.compileIgnoreSingle = function(remoteId) { return this.$val.compileIgnoreSingle(remoteId); };
- Decoder.ptr.prototype.compileDec = function(remoteId, ut) {
- var $ptr, _entry, _entry$1, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _tuple, _tuple$1, _tuple$2, _tuple$3, dec, engine, err, fieldnum, localField, ok, op, op$1, ovfl, present, remoteId, rt, seen, srt, t, ut, wire, wireField, wireStruct, x$2, x$3, x$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; dec = $f.dec; engine = $f.engine; err = $f.err; fieldnum = $f.fieldnum; localField = $f.localField; ok = $f.ok; op = $f.op; op$1 = $f.op$1; ovfl = $f.ovfl; present = $f.present; remoteId = $f.remoteId; rt = $f.rt; seen = $f.seen; srt = $f.srt; t = $f.t; ut = $f.ut; wire = $f.wire; wireField = $f.wireField; wireStruct = $f.wireStruct; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- engine = ptrType$30.nil;
- err = $ifaceNil;
- dec = this;
- rt = ut.base;
- srt = rt;
- _r$22 = srt.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- /* */ if (!((_r$22 === 25)) || !((ut.externalDec === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r$22 === 25)) || !((ut.externalDec === 0))) { */ case 1:
- _r$23 = dec.compileSingle(remoteId, ut); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _tuple = _r$23; engine = _tuple[0]; err = _tuple[1];
- return [engine, err];
- /* } */ case 2:
- wireStruct = ptrType$24.nil;
- _tuple$1 = (_entry = builtinIdToType[typeId.keyFor(remoteId)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); t = _tuple$1[0]; ok = _tuple$1[1];
- if (ok) {
- _tuple$2 = $assertType(t, ptrType$24, true); wireStruct = _tuple$2[0];
- } else {
- wire = (_entry$1 = dec.wireType[typeId.keyFor(remoteId)], _entry$1 !== undefined ? _entry$1.v : ptrType$29.nil);
- if (wire === ptrType$29.nil) {
- error_(errBadType);
- }
- wireStruct = wire.StructT;
- }
- /* */ if (wireStruct === ptrType$24.nil) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (wireStruct === ptrType$24.nil) { */ case 5:
- $r = errorf("type mismatch in decoder: want struct type %s; got non-struct", new sliceType$3([rt])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- engine = new decEngine.ptr();
- engine.instr = $makeSlice(sliceType$19, wireStruct.Field.$length);
- seen = new $Map();
- fieldnum = 0;
- /* while (true) { */ case 8:
- /* if (!(fieldnum < wireStruct.Field.$length)) { break; } */ if(!(fieldnum < wireStruct.Field.$length)) { $s = 9; continue; }
- wireField = (x$2 = wireStruct.Field, ((fieldnum < 0 || fieldnum >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + fieldnum]));
- /* */ if (wireField.Name === "") { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (wireField.Name === "") { */ case 10:
- $r = errorf("empty name for remote field of type %s", new sliceType$3([new $String(wireStruct.CommonType.Name)])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- ovfl = overflow(wireField.Name);
- _r$24 = srt.FieldByName(wireField.Name); /* */ $s = 13; case 13: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _tuple$3 = _r$24; localField = $clone(_tuple$3[0], reflect.StructField); present = _tuple$3[1];
- /* */ if (!present || !isExported(wireField.Name)) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!present || !isExported(wireField.Name)) { */ case 14:
- _r$25 = dec.decIgnoreOpFor(wireField.Id); /* */ $s = 16; case 16: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- op = _r$25;
- $copy((x$3 = engine.instr, ((fieldnum < 0 || fieldnum >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + fieldnum])), new decInstr.ptr(op, fieldnum, sliceType$8.nil, ovfl), decInstr);
- fieldnum = fieldnum + (1) >> 0;
- /* continue; */ $s = 8; continue;
- /* } */ case 15:
- _r$26 = dec.compatibleType(localField.Type, wireField.Id, new $Map()); /* */ $s = 19; case 19: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- /* */ if (!_r$26) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (!_r$26) { */ case 17:
- $r = errorf("wrong type (%s) for received field %s.%s", new sliceType$3([localField.Type, new $String(wireStruct.CommonType.Name), new $String(wireField.Name)])); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- _r$27 = dec.decOpFor(wireField.Id, localField.Type, localField.Name, seen); /* */ $s = 21; case 21: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- op$1 = _r$27;
- $copy((x$4 = engine.instr, ((fieldnum < 0 || fieldnum >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + fieldnum])), new decInstr.ptr(op$1.$get(), fieldnum, localField.Index, ovfl), decInstr);
- engine.numInstr = engine.numInstr + (1) >> 0;
- fieldnum = fieldnum + (1) >> 0;
- /* } */ $s = 8; continue; case 9:
- return [engine, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.compileDec }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.dec = dec; $f.engine = engine; $f.err = err; $f.fieldnum = fieldnum; $f.localField = localField; $f.ok = ok; $f.op = op; $f.op$1 = op$1; $f.ovfl = ovfl; $f.present = present; $f.remoteId = remoteId; $f.rt = rt; $f.seen = seen; $f.srt = srt; $f.t = t; $f.ut = ut; $f.wire = wire; $f.wireField = wireField; $f.wireStruct = wireStruct; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.compileDec = function(remoteId, ut) { return this.$val.compileDec(remoteId, ut); };
- Decoder.ptr.prototype.getDecEnginePtr = function(remoteId, ut) {
- var $ptr, _entry, _entry$1, _key$5, _key$6, _r$22, _tuple, _tuple$1, _tuple$2, dec, decoderMap, enginePtr, err, ok, remoteId, rt, ut, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _key$5 = $f._key$5; _key$6 = $f._key$6; _r$22 = $f._r$22; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; dec = $f.dec; decoderMap = $f.decoderMap; enginePtr = $f.enginePtr; err = $f.err; ok = $f.ok; remoteId = $f.remoteId; rt = $f.rt; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- enginePtr = ptrType$31.nil;
- err = $ifaceNil;
- dec = this;
- rt = ut.user;
- _tuple = (_entry = dec.decoderCache[reflect.Type.keyFor(rt)], _entry !== undefined ? [_entry.v, true] : [false, false]); decoderMap = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- decoderMap = new $Map();
- _key$5 = rt; (dec.decoderCache || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: decoderMap };
- }
- _tuple$1 = (_entry$1 = decoderMap[typeId.keyFor(remoteId)], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$31.nil, false]); enginePtr = _tuple$1[0]; ok = _tuple$1[1];
- /* */ if (!ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!ok) { */ case 1:
- enginePtr = $newDataPointer(ptrType$30.nil, ptrType$31);
- _key$6 = remoteId; (decoderMap || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$6)] = { k: _key$6, v: enginePtr };
- _r$22 = dec.compileDec(remoteId, ut); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple$2 = _r$22; enginePtr.$set(_tuple$2[0]); err = _tuple$2[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- delete decoderMap[typeId.keyFor(remoteId)];
- }
- /* } */ case 2:
- return [enginePtr, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.getDecEnginePtr }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._key$5 = _key$5; $f._key$6 = _key$6; $f._r$22 = _r$22; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.dec = dec; $f.decoderMap = decoderMap; $f.enginePtr = enginePtr; $f.err = err; $f.ok = ok; $f.remoteId = remoteId; $f.rt = rt; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.getDecEnginePtr = function(remoteId, ut) { return this.$val.getDecEnginePtr(remoteId, ut); };
- Decoder.ptr.prototype.getIgnoreEnginePtr = function(wireId) {
- var $ptr, _arg, _arg$1, _entry, _entry$1, _key$5, _r$22, _r$23, _r$24, _tuple, _tuple$1, _tuple$2, dec, enginePtr, err, ok, wire, wireId, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _entry$1 = $f._entry$1; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; dec = $f.dec; enginePtr = $f.enginePtr; err = $f.err; ok = $f.ok; wire = $f.wire; wireId = $f.wireId; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- enginePtr = ptrType$31.nil;
- err = $ifaceNil;
- dec = this;
- ok = false;
- _tuple = (_entry = dec.ignorerCache[typeId.keyFor(wireId)], _entry !== undefined ? [_entry.v, true] : [ptrType$31.nil, false]); enginePtr = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!ok) { */ case 1:
- enginePtr = $newDataPointer(ptrType$30.nil, ptrType$31);
- _key$5 = wireId; (dec.ignorerCache || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: enginePtr };
- wire = (_entry$1 = dec.wireType[typeId.keyFor(wireId)], _entry$1 !== undefined ? _entry$1.v : ptrType$29.nil);
- /* */ if (!(wire === ptrType$29.nil) && !(wire.StructT === ptrType$24.nil)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(wire === ptrType$29.nil) && !(wire.StructT === ptrType$24.nil)) { */ case 3:
- _arg = wireId;
- _r$22 = userType(emptyStructType); /* */ $s = 6; case 6: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- _r$23 = dec.compileDec(_arg, _arg$1); /* */ $s = 7; case 7: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _tuple$1 = _r$23; enginePtr.$set(_tuple$1[0]); err = _tuple$1[1];
- $s = 5; continue;
- /* } else { */ case 4:
- _r$24 = dec.compileIgnoreSingle(wireId); /* */ $s = 8; case 8: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _tuple$2 = _r$24; enginePtr.$set(_tuple$2[0]); err = _tuple$2[1];
- /* } */ case 5:
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- delete dec.ignorerCache[typeId.keyFor(wireId)];
- }
- /* } */ case 2:
- return [enginePtr, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.getIgnoreEnginePtr }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._entry$1 = _entry$1; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.dec = dec; $f.enginePtr = enginePtr; $f.err = err; $f.ok = ok; $f.wire = wire; $f.wireId = wireId; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.getIgnoreEnginePtr = function(wireId) { return this.$val.getIgnoreEnginePtr(wireId); };
- Decoder.ptr.prototype.decodeValue = function(wireId, value) {
- var $ptr, _entry, _entry$1, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _tuple, _v, base, dec, engine, enginePtr, name, st, ut, value, wireId, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _tuple = $f._tuple; _v = $f._v; base = $f.base; dec = $f.dec; engine = $f.engine; enginePtr = $f.enginePtr; name = $f.name; st = $f.st; ut = $f.ut; value = $f.value; wireId = $f.wireId; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- dec = this;
- value = value;
- $deferred.push([catchError, [(dec.$ptr_err || (dec.$ptr_err = new ptrType$32(function() { return this.$target.err; }, function($v) { this.$target.err = $v; }, dec)))]]);
- /* */ if (!value.IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!value.IsValid()) { */ case 1:
- $r = dec.decodeIgnoredValue(wireId); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- _r$22 = userType(value.Type()); /* */ $s = 4; case 4: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- ut = _r$22;
- base = ut.base;
- enginePtr = ptrType$31.nil;
- _r$23 = dec.getDecEnginePtr(wireId, ut); /* */ $s = 5; case 5: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _tuple = _r$23; enginePtr = _tuple[0]; dec.err = _tuple[1];
- if (!($interfaceIsEqual(dec.err, $ifaceNil))) {
- return;
- }
- _r$24 = decAlloc(value); /* */ $s = 6; case 6: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- value = _r$24;
- engine = enginePtr.$get();
- st = base;
- _r$25 = st.Kind(); /* */ $s = 10; case 10: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- /* */ if ((_r$25 === 25) && (ut.externalDec === 0)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if ((_r$25 === 25) && (ut.externalDec === 0)) { */ case 7:
- if (!(engine.numInstr === 0)) { _v = false; $s = 13; continue s; }
- _r$26 = st.NumField(); /* */ $s = 14; case 14: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _v = _r$26 > 0; case 13:
- /* */ if (_v && !((_entry = dec.wireType[typeId.keyFor(wireId)], _entry !== undefined ? _entry.v : ptrType$29.nil) === ptrType$29.nil) && (_entry$1 = dec.wireType[typeId.keyFor(wireId)], _entry$1 !== undefined ? _entry$1.v : ptrType$29.nil).StructT.Field.$length > 0) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_v && !((_entry = dec.wireType[typeId.keyFor(wireId)], _entry !== undefined ? _entry.v : ptrType$29.nil) === ptrType$29.nil) && (_entry$1 = dec.wireType[typeId.keyFor(wireId)], _entry$1 !== undefined ? _entry$1.v : ptrType$29.nil).StructT.Field.$length > 0) { */ case 11:
- _r$27 = base.Name(); /* */ $s = 15; case 15: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- name = _r$27;
- $r = errorf("type mismatch: no fields matched compiling decoder for %s", new sliceType$3([new $String(name)])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 12:
- $r = dec.decodeStruct(engine, ut, value); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 9; continue;
- /* } else { */ case 8:
- $r = dec.decodeSingle(engine, ut, value); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeValue }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._tuple = _tuple; $f._v = _v; $f.base = base; $f.dec = dec; $f.engine = engine; $f.enginePtr = enginePtr; $f.name = name; $f.st = st; $f.ut = ut; $f.value = value; $f.wireId = wireId; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Decoder.prototype.decodeValue = function(wireId, value) { return this.$val.decodeValue(wireId, value); };
- Decoder.ptr.prototype.decodeIgnoredValue = function(wireId) {
- var $ptr, _entry, _r$22, _tuple, dec, enginePtr, wire, wireId, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r$22 = $f._r$22; _tuple = $f._tuple; dec = $f.dec; enginePtr = $f.enginePtr; wire = $f.wire; wireId = $f.wireId; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- enginePtr = ptrType$31.nil;
- _r$22 = dec.getIgnoreEnginePtr(wireId); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = _r$22; enginePtr = _tuple[0]; dec.err = _tuple[1];
- if (!($interfaceIsEqual(dec.err, $ifaceNil))) {
- return;
- }
- wire = (_entry = dec.wireType[typeId.keyFor(wireId)], _entry !== undefined ? _entry.v : ptrType$29.nil);
- /* */ if (!(wire === ptrType$29.nil) && !(wire.StructT === ptrType$24.nil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!(wire === ptrType$29.nil) && !(wire.StructT === ptrType$24.nil)) { */ case 2:
- $r = dec.ignoreStruct(enginePtr.$get()); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 4; continue;
- /* } else { */ case 3:
- $r = dec.ignoreSingle(enginePtr.$get()); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeIgnoredValue }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r$22 = _r$22; $f._tuple = _tuple; $f.dec = dec; $f.enginePtr = enginePtr; $f.wire = wire; $f.wireId = wireId; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeIgnoredValue = function(wireId) { return this.$val.decodeIgnoredValue(wireId); };
- init = function() {
- var $ptr, _r$22, _r$23, _ref, _ref$1, _tmp, _tmp$1, iop, uop, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; iop = $f.iop; uop = $f.uop; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tmp = $throwNilPointerError; _tmp$1 = $throwNilPointerError; iop = _tmp; uop = _tmp$1;
- _r$22 = reflect.TypeOf(new $Int(0)).Bits(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _ref = _r$22;
- /* */ if (_ref === 32) { $s = 2; continue; }
- /* */ if (_ref === 64) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_ref === 32) { */ case 2:
- iop = decInt32;
- uop = decUint32;
- $s = 5; continue;
- /* } else if (_ref === 64) { */ case 3:
- iop = decInt64;
- uop = decUint64;
- $s = 5; continue;
- /* } else { */ case 4:
- $panic(new $String("gob: unknown size of int/uint"));
- /* } */ case 5:
- decOpTable[2] = iop;
- decOpTable[7] = uop;
- _r$23 = reflect.TypeOf(new $Uintptr(0)).Bits(); /* */ $s = 6; case 6: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _ref$1 = _r$23;
- /* */ if (_ref$1 === 32) { $s = 7; continue; }
- /* */ if (_ref$1 === 64) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref$1 === 32) { */ case 7:
- uop = decUint32;
- $s = 10; continue;
- /* } else if (_ref$1 === 64) { */ case 8:
- uop = decUint64;
- $s = 10; continue;
- /* } else { */ case 9:
- $panic(new $String("gob: unknown size of uintptr"));
- /* } */ case 10:
- decOpTable[12] = uop;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: init }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.iop = iop; $f.uop = uop; $f.$s = $s; $f.$r = $r; return $f;
- };
- allocValue = function(t) {
- var $ptr, _r$22, _r$23, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$22 = reflect.New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = _r$22.Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: allocValue }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- NewDecoder = function(r) {
- var $ptr, _tuple, dec, ok, r;
- dec = new Decoder.ptr();
- _tuple = $assertType(r, io.ByteReader, true); ok = _tuple[1];
- if (!ok) {
- r = bufio.NewReader(r);
- }
- dec.r = r;
- dec.wireType = new $Map();
- dec.decoderCache = new $Map();
- dec.ignorerCache = new $Map();
- dec.countBuf = $makeSlice(sliceType$1, 9);
- return dec;
- };
- $pkg.NewDecoder = NewDecoder;
- Decoder.ptr.prototype.recvType = function(id) {
- var $ptr, _arg, _arg$1, _entry, _key$5, _r$22, dec, id, wire, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _key$5 = $f._key$5; _r$22 = $f._r$22; dec = $f.dec; id = $f.id; wire = $f.wire; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- if (id < 64 || !((_entry = dec.wireType[typeId.keyFor(id)], _entry !== undefined ? _entry.v : ptrType$29.nil) === ptrType$29.nil)) {
- dec.err = errors.New("gob: duplicate type received");
- return;
- }
- wire = new wireType.ptr();
- _arg = tWireType;
- _r$22 = reflect.ValueOf(wire); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- $r = dec.decodeValue(_arg, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!($interfaceIsEqual(dec.err, $ifaceNil))) {
- return;
- }
- _key$5 = id; (dec.wireType || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: wire };
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.recvType }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._key$5 = _key$5; $f._r$22 = _r$22; $f.dec = dec; $f.id = id; $f.wire = wire; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.recvType = function(id) { return this.$val.recvType(id); };
- Decoder.ptr.prototype.recvMessage = function() {
- var $ptr, _r$22, _tuple, dec, err, nbytes, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; dec = $f.dec; err = $f.err; nbytes = $f.nbytes; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- _r$22 = decodeUintReader(dec.r, dec.countBuf); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = _r$22; nbytes = _tuple[0]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- dec.err = err;
- return false;
- }
- if ((nbytes.$high > 0 || (nbytes.$high === 0 && nbytes.$low >= 1073741824))) {
- dec.err = errBadCount;
- return false;
- }
- $r = dec.readMessage((nbytes.$low >> 0)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return $interfaceIsEqual(dec.err, $ifaceNil);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.recvMessage }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.dec = dec; $f.err = err; $f.nbytes = nbytes; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.recvMessage = function() { return this.$val.recvMessage(); };
- Decoder.ptr.prototype.readMessage = function(nbytes) {
- var $ptr, _r$22, _tuple, dec, nbytes, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; dec = $f.dec; nbytes = $f.nbytes; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- if (!((dec.buf.Len() === 0))) {
- $panic(new $String("non-empty decoder buffer"));
- }
- dec.buf.Size(nbytes);
- _r$22 = io.ReadFull(dec.r, dec.buf.Bytes()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = _r$22; dec.err = _tuple[1];
- if (!($interfaceIsEqual(dec.err, $ifaceNil))) {
- if ($interfaceIsEqual(dec.err, io.EOF)) {
- dec.err = io.ErrUnexpectedEOF;
- }
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.readMessage }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.dec = dec; $f.nbytes = nbytes; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.readMessage = function(nbytes) { return this.$val.readMessage(nbytes); };
- toInt = function(x$2) {
- var $ptr, i, x$2, x$3, x$4;
- i = (x$3 = $shiftRightUint64(x$2, 1), new $Int64(x$3.$high, x$3.$low));
- if (!((x$4 = new $Uint64(x$2.$high & 0, (x$2.$low & 1) >>> 0), (x$4.$high === 0 && x$4.$low === 0)))) {
- i = new $Int64(~i.$high, ~i.$low >>> 0);
- }
- return i;
- };
- Decoder.ptr.prototype.nextInt = function() {
- var $ptr, _r$22, _tuple, dec, err, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; dec = $f.dec; err = $f.err; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- _r$22 = decodeUintReader(dec.buf, dec.countBuf); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = _r$22; n = _tuple[0]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- dec.err = err;
- }
- return toInt(n);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.nextInt }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.dec = dec; $f.err = err; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.nextInt = function() { return this.$val.nextInt(); };
- Decoder.ptr.prototype.nextUint = function() {
- var $ptr, _r$22, _tuple, dec, err, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; dec = $f.dec; err = $f.err; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- _r$22 = decodeUintReader(dec.buf, dec.countBuf); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = _r$22; n = _tuple[0]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- dec.err = err;
- }
- return n;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.nextUint }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.dec = dec; $f.err = err; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.nextUint = function() { return this.$val.nextUint(); };
- Decoder.ptr.prototype.decodeTypeSequence = function(isInterface) {
- var $ptr, _r$22, _r$23, _r$24, dec, id, isInterface, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; dec = $f.dec; id = $f.id; isInterface = $f.isInterface; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- /* while (true) { */ case 1:
- /* if (!($interfaceIsEqual(dec.err, $ifaceNil))) { break; } */ if(!($interfaceIsEqual(dec.err, $ifaceNil))) { $s = 2; continue; }
- /* */ if (dec.buf.Len() === 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (dec.buf.Len() === 0) { */ case 3:
- _r$22 = dec.recvMessage(); /* */ $s = 7; case 7: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- /* */ if (!_r$22) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!_r$22) { */ case 5:
- /* break; */ $s = 2; continue;
- /* } */ case 6:
- /* } */ case 4:
- _r$23 = dec.nextInt(); /* */ $s = 8; case 8: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- id = ((x$2 = _r$23, x$2.$low + ((x$2.$high >> 31) * 4294967296)) >> 0);
- if (id >= 0) {
- return id;
- }
- $r = dec.recvType(-id); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (dec.buf.Len() > 0) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (dec.buf.Len() > 0) { */ case 10:
- if (!isInterface) {
- dec.err = errors.New("extra data in buffer");
- /* break; */ $s = 2; continue;
- }
- _r$24 = dec.nextUint(); /* */ $s = 12; case 12: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$24;
- /* } */ case 11:
- /* } */ $s = 1; continue; case 2:
- return -1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.decodeTypeSequence }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f.dec = dec; $f.id = id; $f.isInterface = isInterface; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.decodeTypeSequence = function(isInterface) { return this.$val.decodeTypeSequence(isInterface); };
- Decoder.ptr.prototype.Decode = function(e) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, dec, e, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; dec = $f.dec; e = $f.e; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- /* */ if ($interfaceIsEqual(e, $ifaceNil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ($interfaceIsEqual(e, $ifaceNil)) { */ case 1:
- _r$22 = dec.DecodeValue(new reflect.Value.ptr(ptrType$33.nil, 0, 0)); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* } */ case 2:
- _r$23 = reflect.ValueOf(e); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- value = _r$23;
- _r$24 = value.Type().Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- /* */ if (!((_r$24 === 22))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((_r$24 === 22))) { */ case 5:
- dec.err = errors.New("gob: attempt to decode into a non-pointer");
- return dec.err;
- /* } */ case 6:
- _r$25 = dec.DecodeValue(value); /* */ $s = 8; case 8: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- return _r$25;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.Decode }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f.dec = dec; $f.e = e; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.Decode = function(e) { return this.$val.Decode(e); };
- Decoder.ptr.prototype.DecodeValue = function(v) {
- var $ptr, _r$22, dec, id, v, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; dec = $f.dec; id = $f.id; v = $f.v; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- dec = this;
- v = v;
- if (v.IsValid()) {
- if ((v.Kind() === 22) && !v.IsNil()) {
- } else if (!v.CanSet()) {
- return errors.New("gob: DecodeValue of unassignable value");
- }
- }
- dec.mutex.Lock();
- $deferred.push([$methodVal(dec.mutex, "Unlock"), []]);
- dec.buf.Reset();
- dec.err = $ifaceNil;
- _r$22 = dec.decodeTypeSequence(false); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- id = _r$22;
- /* */ if ($interfaceIsEqual(dec.err, $ifaceNil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($interfaceIsEqual(dec.err, $ifaceNil)) { */ case 2:
- $r = dec.decodeValue(id, v); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- return dec.err;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.DecodeValue }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.dec = dec; $f.id = id; $f.v = v; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Decoder.prototype.DecodeValue = function(v) { return this.$val.DecodeValue(v); };
- errorf = function(format, args) {
- var $ptr, _r$22, args, format, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; args = $f.args; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$22 = fmt.Errorf("gob: " + format, args); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- $r = error_(_r$22); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: errorf }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.args = args; $f.format = format; $f.$s = $s; $f.$r = $r; return $f;
- };
- error_ = function(err) {
- var $ptr, err, x$2;
- $panic((x$2 = new gobError.ptr(err), new x$2.constructor.elem(x$2)));
- };
- catchError = function(err) {
- var $ptr, _tuple, e, err, ge, ok;
- e = $recover();
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- _tuple = $assertType(e, gobError, true); ge = $clone(_tuple[0], gobError); ok = _tuple[1];
- if (!ok) {
- $panic(e);
- }
- err.$set(ge.err);
- }
- return;
- };
- validUserType = function(rt) {
- var $ptr, _entry, _entry$1, _key$5, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$30, _r$31, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, err, indir, indir$1, indir$2, indir$3, ok, ok$1, ok$2, ok$3, pt, rt, slowpoke, ut, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$30 = $f._r$30; _r$31 = $f._r$31; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; err = $f.err; indir = $f.indir; indir$1 = $f.indir$1; indir$2 = $f.indir$2; indir$3 = $f.indir$3; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; ok$3 = $f.ok$3; pt = $f.pt; rt = $f.rt; slowpoke = $f.slowpoke; ut = $f.ut; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- ut = ptrType.nil;
- err = $ifaceNil;
- userTypeLock.RLock();
- ut = (_entry = userTypeCache[reflect.Type.keyFor(rt)], _entry !== undefined ? _entry.v : ptrType.nil);
- userTypeLock.RUnlock();
- if (!(ut === ptrType.nil)) {
- return [ut, err];
- }
- userTypeLock.Lock();
- $deferred.push([$methodVal(userTypeLock, "Unlock"), []]);
- ut = (_entry$1 = userTypeCache[reflect.Type.keyFor(rt)], _entry$1 !== undefined ? _entry$1.v : ptrType.nil);
- if (!(ut === ptrType.nil)) {
- return [ut, err];
- }
- ut = new userTypeInfo.ptr();
- ut.base = rt;
- ut.user = rt;
- slowpoke = ut.base;
- /* while (true) { */ case 1:
- pt = ut.base;
- _r$22 = pt.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- /* */ if (!((_r$22 === 22))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!((_r$22 === 22))) { */ case 3:
- /* break; */ $s = 2; continue;
- /* } */ case 4:
- _r$23 = pt.Elem(); /* */ $s = 6; case 6: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- ut.base = _r$23;
- /* */ if ($interfaceIsEqual(ut.base, slowpoke)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if ($interfaceIsEqual(ut.base, slowpoke)) { */ case 7:
- _r$24 = ut.base.String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$25 = errors.New("can't represent recursive pointer type " + _r$24); /* */ $s = 10; case 10: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _tmp = ptrType.nil; _tmp$1 = _r$25; ut = _tmp; err = _tmp$1;
- return [ut, err];
- /* } */ case 8:
- /* */ if ((_r$26 = ut.indir % 2, _r$26 === _r$26 ? _r$26 : $throwRuntimeError("integer divide by zero")) === 0) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ((_r$26 = ut.indir % 2, _r$26 === _r$26 ? _r$26 : $throwRuntimeError("integer divide by zero")) === 0) { */ case 11:
- _r$27 = slowpoke.Elem(); /* */ $s = 13; case 13: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- slowpoke = _r$27;
- /* } */ case 12:
- ut.indir = ut.indir + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- _r$28 = implementsInterface(ut.user, gobEncoderInterfaceType); /* */ $s = 14; case 14: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _tuple = _r$28; ok = _tuple[0]; indir = _tuple[1];
- /* */ if (ok) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (ok) { */ case 15:
- _tmp$2 = 1; _tmp$3 = indir; ut.externalEnc = _tmp$2; ut.encIndir = _tmp$3;
- $s = 17; continue;
- /* } else { */ case 16:
- _r$29 = implementsInterface(ut.user, binaryMarshalerInterfaceType); /* */ $s = 18; case 18: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _tuple$1 = _r$29; ok$1 = _tuple$1[0]; indir$1 = _tuple$1[1];
- /* */ if (ok$1) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (ok$1) { */ case 19:
- _tmp$4 = 2; _tmp$5 = indir$1; ut.externalEnc = _tmp$4; ut.encIndir = _tmp$5;
- /* } */ case 20:
- /* } */ case 17:
- _r$30 = implementsInterface(ut.user, gobDecoderInterfaceType); /* */ $s = 21; case 21: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _tuple$2 = _r$30; ok$2 = _tuple$2[0]; indir$2 = _tuple$2[1];
- /* */ if (ok$2) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (ok$2) { */ case 22:
- _tmp$6 = 1; _tmp$7 = indir$2; ut.externalDec = _tmp$6; ut.decIndir = _tmp$7;
- $s = 24; continue;
- /* } else { */ case 23:
- _r$31 = implementsInterface(ut.user, binaryUnmarshalerInterfaceType); /* */ $s = 25; case 25: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- _tuple$3 = _r$31; ok$3 = _tuple$3[0]; indir$3 = _tuple$3[1];
- /* */ if (ok$3) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (ok$3) { */ case 26:
- _tmp$8 = 2; _tmp$9 = indir$3; ut.externalDec = _tmp$8; ut.decIndir = _tmp$9;
- /* } */ case 27:
- /* } */ case 24:
- _key$5 = rt; (userTypeCache || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: ut };
- return [ut, err];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [ut, err]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: validUserType }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.err = err; $f.indir = indir; $f.indir$1 = indir$1; $f.indir$2 = indir$2; $f.indir$3 = indir$3; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.ok$3 = ok$3; $f.pt = pt; $f.rt = rt; $f.slowpoke = slowpoke; $f.ut = ut; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- implementsInterface = function(typ, gobEncDecType) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, _r$26, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, gobEncDecType, indir, p, rt, success, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; gobEncDecType = $f.gobEncDecType; indir = $f.indir; p = $f.p; rt = $f.rt; success = $f.success; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- success = false;
- indir = 0;
- if ($interfaceIsEqual(typ, $ifaceNil)) {
- return [success, indir];
- }
- rt = typ;
- /* while (true) { */ case 1:
- _r$22 = rt.Implements(gobEncDecType); /* */ $s = 5; case 5: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- /* */ if (_r$22) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_r$22) { */ case 3:
- _tmp = true; _tmp$1 = indir; success = _tmp; indir = _tmp$1;
- return [success, indir];
- /* } */ case 4:
- p = rt;
- _r$23 = p.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- /* */ if (_r$23 === 22) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_r$23 === 22) { */ case 6:
- indir = indir + (1) << 24 >> 24;
- if (indir > 100) {
- _tmp$2 = false; _tmp$3 = 0; success = _tmp$2; indir = _tmp$3;
- return [success, indir];
- }
- _r$24 = p.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- rt = _r$24;
- /* continue; */ $s = 1; continue;
- /* } */ case 7:
- /* break; */ $s = 2; continue;
- /* } */ $s = 1; continue; case 2:
- _r$25 = typ.Kind(); /* */ $s = 12; case 12: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- /* */ if (!((_r$25 === 22))) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!((_r$25 === 22))) { */ case 10:
- _r$26 = reflect.PtrTo(typ).Implements(gobEncDecType); /* */ $s = 15; case 15: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- /* */ if (_r$26) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (_r$26) { */ case 13:
- _tmp$4 = true; _tmp$5 = -1; success = _tmp$4; indir = _tmp$5;
- return [success, indir];
- /* } */ case 14:
- /* } */ case 11:
- _tmp$6 = false; _tmp$7 = 0; success = _tmp$6; indir = _tmp$7;
- return [success, indir];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: implementsInterface }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f.gobEncDecType = gobEncDecType; $f.indir = indir; $f.p = p; $f.rt = rt; $f.success = success; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- userType = function(rt) {
- var $ptr, _r$22, _tuple, err, rt, ut, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _tuple = $f._tuple; err = $f.err; rt = $f.rt; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$22 = validUserType(rt); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple = _r$22; ut = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- error_(err);
- }
- return ut;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: userType }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._tuple = _tuple; $f.err = err; $f.rt = rt; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f;
- };
- setTypeId = function(typ) {
- var $ptr, _key$5, _r$22, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key$5 = $f._key$5; _r$22 = $f._r$22; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$22 = typ.id(); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- /* */ if (!((_r$22 === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r$22 === 0))) { */ case 1:
- return;
- /* } */ case 2:
- nextId = nextId + (1) >> 0;
- $r = typ.setId(nextId); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _key$5 = nextId; (idToType || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: typ };
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: setTypeId }; } $f.$ptr = $ptr; $f._key$5 = _key$5; $f._r$22 = _r$22; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- typeId.prototype.gobType = function() {
- var $ptr, _entry, t;
- t = this.$val;
- if (t === 0) {
- return $ifaceNil;
- }
- return (_entry = idToType[typeId.keyFor(t)], _entry !== undefined ? _entry.v : $ifaceNil);
- };
- $ptrType(typeId).prototype.gobType = function() { return new typeId(this.$get()).gobType(); };
- typeId.prototype.string = function() {
- var $ptr, _r$22, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this.$val;
- if ($interfaceIsEqual(new typeId(t).gobType(), $ifaceNil)) {
- return "";
- }
- _r$22 = new typeId(t).gobType().string(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: typeId.prototype.string }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(typeId).prototype.string = function() { return new typeId(this.$get()).string(); };
- typeId.prototype.name = function() {
- var $ptr, _r$22, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this.$val;
- if ($interfaceIsEqual(new typeId(t).gobType(), $ifaceNil)) {
- return "";
- }
- _r$22 = new typeId(t).gobType().name(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: typeId.prototype.name }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(typeId).prototype.name = function() { return new typeId(this.$get()).name(); };
- CommonType.ptr.prototype.id = function() {
- var $ptr, t;
- t = this;
- return t.Id;
- };
- CommonType.prototype.id = function() { return this.$val.id(); };
- CommonType.ptr.prototype.setId = function(id) {
- var $ptr, id, t;
- t = this;
- t.Id = id;
- };
- CommonType.prototype.setId = function(id) { return this.$val.setId(id); };
- CommonType.ptr.prototype.string = function() {
- var $ptr, t;
- t = this;
- return t.Name;
- };
- CommonType.prototype.string = function() { return this.$val.string(); };
- CommonType.ptr.prototype.safeString = function(seen) {
- var $ptr, seen, t;
- t = this;
- return t.Name;
- };
- CommonType.prototype.safeString = function(seen) { return this.$val.safeString(seen); };
- CommonType.ptr.prototype.name = function() {
- var $ptr, t;
- t = this;
- return t.Name;
- };
- CommonType.prototype.name = function() { return this.$val.name(); };
- init$1 = function() {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _entry, _i, _key$5, _keys, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _ref, k, v, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _entry = $f._entry; _i = $f._i; _key$5 = $f._key$5; _keys = $f._keys; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _ref = $f._ref; k = $f.k; v = $f.v; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = checkId(16, tWireType); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$22 = mustGetTypeInfo(reflect.TypeOf((x$2 = new arrayType.ptr(new CommonType.ptr(), 0, 0), new x$2.constructor.elem(x$2)))); /* */ $s = 2; case 2: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg = _r$22.id;
- $r = checkId(17, _arg); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$23 = mustGetTypeInfo(reflect.TypeOf((x$3 = new CommonType.ptr("", 0), new x$3.constructor.elem(x$3)))); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _arg$1 = _r$23.id;
- $r = checkId(18, _arg$1); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$24 = mustGetTypeInfo(reflect.TypeOf((x$4 = new sliceType.ptr(new CommonType.ptr(), 0), new x$4.constructor.elem(x$4)))); /* */ $s = 6; case 6: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _arg$2 = _r$24.id;
- $r = checkId(19, _arg$2); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$25 = mustGetTypeInfo(reflect.TypeOf((x$5 = new structType.ptr(new CommonType.ptr(), sliceType$22.nil), new x$5.constructor.elem(x$5)))); /* */ $s = 8; case 8: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _arg$3 = _r$25.id;
- $r = checkId(20, _arg$3); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$26 = mustGetTypeInfo(reflect.TypeOf((x$6 = new fieldType.ptr("", 0), new x$6.constructor.elem(x$6)))); /* */ $s = 10; case 10: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _arg$4 = _r$26.id;
- $r = checkId(21, _arg$4); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$27 = mustGetTypeInfo(reflect.TypeOf((x$7 = new mapType.ptr(new CommonType.ptr(), 0, 0), new x$7.constructor.elem(x$7)))); /* */ $s = 12; case 12: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _arg$5 = _r$27.id;
- $r = checkId(23, _arg$5); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- builtinIdToType = new $Map();
- _ref = idToType;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- k = _entry.k;
- v = _entry.v;
- _key$5 = k; (builtinIdToType || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: v };
- _i++;
- }
- /* */ if (nextId > 64) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (nextId > 64) { */ case 14:
- _r$28 = fmt.Sprintln(new sliceType$3([new $String("nextId too large:"), new typeId(nextId)])); /* */ $s = 16; case 16: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- $panic(new $String(_r$28));
- /* } */ case 15:
- nextId = 64;
- $r = registerBasics(); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$29 = userType(reflect.TypeOf(ptrType$29.nil)); /* */ $s = 18; case 18: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- wireTypeUserInfo = _r$29;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: init$1 }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._entry = _entry; $f._i = _i; $f._key$5 = _key$5; $f._keys = _keys; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._ref = _ref; $f.k = k; $f.v = v; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f;
- };
- newArrayType = function(name) {
- var $ptr, a, name;
- a = new arrayType.ptr(new CommonType.ptr(name, 0), 0, 0);
- return a;
- };
- arrayType.ptr.prototype.init = function(elem, len) {
- var $ptr, _r$22, a, elem, len, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; a = $f.a; elem = $f.elem; len = $f.len; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = this;
- $r = setTypeId(a); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$22 = elem.id(); /* */ $s = 2; case 2: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- a.Elem = _r$22;
- a.Len = len;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: arrayType.ptr.prototype.init }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.a = a; $f.elem = elem; $f.len = len; $f.$s = $s; $f.$r = $r; return $f;
- };
- arrayType.prototype.init = function(elem, len) { return this.$val.init(elem, len); };
- arrayType.ptr.prototype.safeString = function(seen) {
- var $ptr, _arg, _arg$1, _entry, _key$5, _r$22, _r$23, a, seen, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; a = $f.a; seen = $f.seen; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = this;
- if ((_entry = seen[typeId.keyFor(a.CommonType.Id)], _entry !== undefined ? _entry.v : false)) {
- return a.CommonType.Name;
- }
- _key$5 = a.CommonType.Id; (seen || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: true };
- _arg = new $Int(a.Len);
- _r$22 = new typeId(a.Elem).gobType().safeString(seen); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$22);
- _r$23 = fmt.Sprintf("[%d]%s", new sliceType$3([_arg, _arg$1])); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: arrayType.ptr.prototype.safeString }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.a = a; $f.seen = seen; $f.$s = $s; $f.$r = $r; return $f;
- };
- arrayType.prototype.safeString = function(seen) { return this.$val.safeString(seen); };
- arrayType.ptr.prototype.string = function() {
- var $ptr, _r$22, a, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; a = $f.a; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = this;
- _r$22 = a.safeString(new $Map()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: arrayType.ptr.prototype.string }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.a = a; $f.$s = $s; $f.$r = $r; return $f;
- };
- arrayType.prototype.string = function() { return this.$val.string(); };
- newGobEncoderType = function(name) {
- var $ptr, g, name, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; g = $f.g; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- g = new gobEncoderType.ptr(new CommonType.ptr(name, 0));
- $r = setTypeId(g); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return g;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newGobEncoderType }; } $f.$ptr = $ptr; $f.g = g; $f.name = name; $f.$s = $s; $f.$r = $r; return $f;
- };
- gobEncoderType.ptr.prototype.safeString = function(seen) {
- var $ptr, g, seen;
- g = this;
- return g.CommonType.Name;
- };
- gobEncoderType.prototype.safeString = function(seen) { return this.$val.safeString(seen); };
- gobEncoderType.ptr.prototype.string = function() {
- var $ptr, g;
- g = this;
- return g.CommonType.Name;
- };
- gobEncoderType.prototype.string = function() { return this.$val.string(); };
- newMapType = function(name) {
- var $ptr, m, name;
- m = new mapType.ptr(new CommonType.ptr(name, 0), 0, 0);
- return m;
- };
- mapType.ptr.prototype.init = function(key, elem) {
- var $ptr, _r$22, _r$23, elem, key, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; elem = $f.elem; key = $f.key; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- $r = setTypeId(m); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$22 = key.id(); /* */ $s = 2; case 2: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- m.Key = _r$22;
- _r$23 = elem.id(); /* */ $s = 3; case 3: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- m.Elem = _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mapType.ptr.prototype.init }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.elem = elem; $f.key = key; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- mapType.prototype.init = function(key, elem) { return this.$val.init(key, elem); };
- mapType.ptr.prototype.safeString = function(seen) {
- var $ptr, _entry, _key$5, _r$22, _r$23, _r$24, elem, key, m, seen, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; elem = $f.elem; key = $f.key; m = $f.m; seen = $f.seen; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- if ((_entry = seen[typeId.keyFor(m.CommonType.Id)], _entry !== undefined ? _entry.v : false)) {
- return m.CommonType.Name;
- }
- _key$5 = m.CommonType.Id; (seen || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: true };
- _r$22 = new typeId(m.Key).gobType().safeString(seen); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- key = _r$22;
- _r$23 = new typeId(m.Elem).gobType().safeString(seen); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- elem = _r$23;
- _r$24 = fmt.Sprintf("map[%s]%s", new sliceType$3([new $String(key), new $String(elem)])); /* */ $s = 3; case 3: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- return _r$24;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mapType.ptr.prototype.safeString }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f.elem = elem; $f.key = key; $f.m = m; $f.seen = seen; $f.$s = $s; $f.$r = $r; return $f;
- };
- mapType.prototype.safeString = function(seen) { return this.$val.safeString(seen); };
- mapType.ptr.prototype.string = function() {
- var $ptr, _r$22, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- _r$22 = m.safeString(new $Map()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mapType.ptr.prototype.string }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- mapType.prototype.string = function() { return this.$val.string(); };
- newSliceType = function(name) {
- var $ptr, name, s;
- s = new sliceType.ptr(new CommonType.ptr(name, 0), 0);
- return s;
- };
- sliceType.ptr.prototype.init = function(elem) {
- var $ptr, _r$22, _r$23, elem, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; elem = $f.elem; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- $r = setTypeId(s); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$22 = elem.id(); /* */ $s = 4; case 4: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- /* */ if (_r$22 === 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_r$22 === 0) { */ case 2:
- $r = setTypeId(elem); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- _r$23 = elem.id(); /* */ $s = 6; case 6: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- s.Elem = _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sliceType.ptr.prototype.init }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.elem = elem; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- sliceType.prototype.init = function(elem) { return this.$val.init(elem); };
- sliceType.ptr.prototype.safeString = function(seen) {
- var $ptr, _arg, _entry, _key$5, _r$22, _r$23, s, seen, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _entry = $f._entry; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; s = $f.s; seen = $f.seen; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- if ((_entry = seen[typeId.keyFor(s.CommonType.Id)], _entry !== undefined ? _entry.v : false)) {
- return s.CommonType.Name;
- }
- _key$5 = s.CommonType.Id; (seen || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: true };
- _r$22 = new typeId(s.Elem).gobType().safeString(seen); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg = new $String(_r$22);
- _r$23 = fmt.Sprintf("[]%s", new sliceType$3([_arg])); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sliceType.ptr.prototype.safeString }; } $f.$ptr = $ptr; $f._arg = _arg; $f._entry = _entry; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.s = s; $f.seen = seen; $f.$s = $s; $f.$r = $r; return $f;
- };
- sliceType.prototype.safeString = function(seen) { return this.$val.safeString(seen); };
- sliceType.ptr.prototype.string = function() {
- var $ptr, _r$22, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r$22 = s.safeString(new $Map()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sliceType.ptr.prototype.string }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- sliceType.prototype.string = function() { return this.$val.string(); };
- structType.ptr.prototype.safeString = function(seen) {
- var $ptr, _arg, _arg$1, _entry, _i, _key$5, _r$22, _r$23, _ref, _tuple, f, ok, s, seen, str, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _i = $f._i; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; _ref = $f._ref; _tuple = $f._tuple; f = $f.f; ok = $f.ok; s = $f.s; seen = $f.seen; str = $f.str; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- if (s === ptrType$24.nil) {
- return "";
- }
- _tuple = (_entry = seen[typeId.keyFor(s.CommonType.Id)], _entry !== undefined ? [_entry.v, true] : [false, false]); ok = _tuple[1];
- if (ok) {
- return s.CommonType.Name;
- }
- _key$5 = s.CommonType.Id; (seen || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$5)] = { k: _key$5, v: true };
- str = s.CommonType.Name + " = struct { ";
- _ref = s.Field;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _arg = new $String(f.Name);
- _r$22 = new typeId(f.Id).gobType().safeString(seen); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$22);
- _r$23 = fmt.Sprintf("%s %s; ", new sliceType$3([_arg, _arg$1])); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- str = str + (_r$23);
- _i++;
- /* } */ $s = 1; continue; case 2:
- str = str + ("}");
- return str;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.safeString }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._i = _i; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._ref = _ref; $f._tuple = _tuple; $f.f = f; $f.ok = ok; $f.s = s; $f.seen = seen; $f.str = str; $f.$s = $s; $f.$r = $r; return $f;
- };
- structType.prototype.safeString = function(seen) { return this.$val.safeString(seen); };
- structType.ptr.prototype.string = function() {
- var $ptr, _r$22, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r$22 = s.safeString(new $Map()); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.string }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- structType.prototype.string = function() { return this.$val.string(); };
- newStructType = function(name) {
- var $ptr, name, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; name = $f.name; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = new structType.ptr(new CommonType.ptr(name, 0), sliceType$22.nil);
- $r = setTypeId(s); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return s;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newStructType }; } $f.$ptr = $ptr; $f.name = name; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- newTypeObject = function(name, ut, rt) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _key$5, _key$6, _key$7, _key$8, _key$9, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$37, _r$38, _r$39, _r$40, _r$41, _r$42, _r$43, _r$44, _r$45, _r$46, _r$47, _r$48, _r$49, _ref, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, at, err, err$1, f, gt, i, mt, name, rt, st, st$1, t, t$1, tname, typ, type0, type1, ut, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _key$5 = $f._key$5; _key$6 = $f._key$6; _key$7 = $f._key$7; _key$8 = $f._key$8; _key$9 = $f._key$9; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$40 = $f._r$40; _r$41 = $f._r$41; _r$42 = $f._r$42; _r$43 = $f._r$43; _r$44 = $f._r$44; _r$45 = $f._r$45; _r$46 = $f._r$46; _r$47 = $f._r$47; _r$48 = $f._r$48; _r$49 = $f._r$49; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; at = $f.at; err = $f.err; err$1 = $f.err$1; f = $f.f; gt = $f.gt; i = $f.i; mt = $f.mt; name = $f.name; rt = $f.rt; st = $f.st; st$1 = $f.st$1; t = $f.t; t$1 = $f.t$1; tname = $f.tname; typ = $f.typ; type0 = $f.type0; type1 = $f.type1; ut = $f.ut; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- rt = [rt];
- /* */ if (!((ut.externalEnc === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((ut.externalEnc === 0))) { */ case 1:
- _r$22 = newGobEncoderType(name); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return [_r$22, $ifaceNil];
- /* } */ case 2:
- err[0] = $ifaceNil;
- _tmp = $ifaceNil; _tmp$1 = $ifaceNil; type0 = _tmp; type1 = _tmp$1;
- $deferred.push([(function(err, rt) { return function() {
- var $ptr;
- if (!($interfaceIsEqual(err[0], $ifaceNil))) {
- delete types[reflect.Type.keyFor(rt[0])];
- }
- }; })(err, rt), []]);
- t = rt[0];
- _r$23 = t.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _ref = _r$23;
- /* */ if (_ref === 1) { $s = 5; continue; }
- /* */ if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { $s = 6; continue; }
- /* */ if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { $s = 7; continue; }
- /* */ if (_ref === 13 || _ref === 14) { $s = 8; continue; }
- /* */ if (_ref === 15 || _ref === 16) { $s = 9; continue; }
- /* */ if (_ref === 24) { $s = 10; continue; }
- /* */ if (_ref === 20) { $s = 11; continue; }
- /* */ if (_ref === 17) { $s = 12; continue; }
- /* */ if (_ref === 21) { $s = 13; continue; }
- /* */ if (_ref === 23) { $s = 14; continue; }
- /* */ if (_ref === 25) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_ref === 1) { */ case 5:
- return [new typeId(tBool).gobType(), $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { */ case 6:
- return [new typeId(tInt).gobType(), $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { */ case 7:
- return [new typeId(tUint).gobType(), $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 13 || _ref === 14) { */ case 8:
- return [new typeId(tFloat).gobType(), $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 15 || _ref === 16) { */ case 9:
- return [new typeId(tComplex).gobType(), $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 24) { */ case 10:
- return [new typeId(tString).gobType(), $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 20) { */ case 11:
- return [new typeId(tInterface).gobType(), $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 17) { */ case 12:
- at = newArrayType(name);
- _key$5 = rt[0]; (types || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: at };
- _r$24 = t.Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _arg = _r$24;
- _r$25 = getBaseType("", _arg); /* */ $s = 19; case 19: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _tuple = _r$25; type0 = _tuple[0]; err[0] = _tuple[1];
- if (!($interfaceIsEqual(err[0], $ifaceNil))) {
- return [$ifaceNil, err[0]];
- }
- _arg$1 = type0;
- _r$26 = t.Len(); /* */ $s = 20; case 20: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _arg$2 = _r$26;
- $r = at.init(_arg$1, _arg$2); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [at, $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 21) { */ case 13:
- mt = newMapType(name);
- _key$6 = rt[0]; (types || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$6)] = { k: _key$6, v: mt };
- _r$27 = t.Key(); /* */ $s = 22; case 22: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _arg$3 = _r$27;
- _r$28 = getBaseType("", _arg$3); /* */ $s = 23; case 23: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _tuple$1 = _r$28; type0 = _tuple$1[0]; err[0] = _tuple$1[1];
- if (!($interfaceIsEqual(err[0], $ifaceNil))) {
- return [$ifaceNil, err[0]];
- }
- _r$29 = t.Elem(); /* */ $s = 24; case 24: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _arg$4 = _r$29;
- _r$30 = getBaseType("", _arg$4); /* */ $s = 25; case 25: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _tuple$2 = _r$30; type1 = _tuple$2[0]; err[0] = _tuple$2[1];
- if (!($interfaceIsEqual(err[0], $ifaceNil))) {
- return [$ifaceNil, err[0]];
- }
- $r = mt.init(type0, type1); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [mt, $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 23) { */ case 14:
- _r$31 = t.Elem(); /* */ $s = 29; case 29: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- _r$32 = _r$31.Kind(); /* */ $s = 30; case 30: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- /* */ if (_r$32 === 8) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (_r$32 === 8) { */ case 27:
- return [new typeId(tBytes).gobType(), $ifaceNil];
- /* } */ case 28:
- st = newSliceType(name);
- _key$7 = rt[0]; (types || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$7)] = { k: _key$7, v: st };
- _r$33 = t.Elem(); /* */ $s = 31; case 31: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- _r$34 = _r$33.Name(); /* */ $s = 32; case 32: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _arg$5 = _r$34;
- _r$35 = t.Elem(); /* */ $s = 33; case 33: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- _arg$6 = _r$35;
- _r$36 = getBaseType(_arg$5, _arg$6); /* */ $s = 34; case 34: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- _tuple$3 = _r$36; type0 = _tuple$3[0]; err[0] = _tuple$3[1];
- if (!($interfaceIsEqual(err[0], $ifaceNil))) {
- return [$ifaceNil, err[0]];
- }
- $r = st.init(type0); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [st, $ifaceNil];
- $s = 17; continue;
- /* } else if (_ref === 25) { */ case 15:
- _r$37 = newStructType(name); /* */ $s = 36; case 36: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- st$1 = _r$37;
- _key$8 = rt[0]; (types || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$8)] = { k: _key$8, v: st$1 };
- _key$9 = st$1.CommonType.id(); (idToType || $throwRuntimeError("assignment to entry in nil map"))[typeId.keyFor(_key$9)] = { k: _key$9, v: st$1 };
- i = 0;
- /* while (true) { */ case 37:
- _r$38 = t.NumField(); /* */ $s = 39; case 39: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- /* if (!(i < _r$38)) { break; } */ if(!(i < _r$38)) { $s = 38; continue; }
- f = [f];
- _r$39 = t.Field(i); /* */ $s = 40; case 40: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- f[0] = $clone(_r$39, reflect.StructField);
- _r$40 = isSent(f[0]); /* */ $s = 43; case 43: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- /* */ if (!_r$40) { $s = 41; continue; }
- /* */ $s = 42; continue;
- /* if (!_r$40) { */ case 41:
- i = i + (1) >> 0;
- /* continue; */ $s = 37; continue;
- /* } */ case 42:
- _r$41 = userType(f[0].Type); /* */ $s = 44; case 44: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- typ = _r$41.base;
- _r$42 = typ.Name(); /* */ $s = 45; case 45: if($c) { $c = false; _r$42 = _r$42.$blk(); } if (_r$42 && _r$42.$blk !== undefined) { break s; }
- tname = _r$42;
- /* */ if (tname === "") { $s = 46; continue; }
- /* */ $s = 47; continue;
- /* if (tname === "") { */ case 46:
- _r$43 = userType(f[0].Type); /* */ $s = 48; case 48: if($c) { $c = false; _r$43 = _r$43.$blk(); } if (_r$43 && _r$43.$blk !== undefined) { break s; }
- t$1 = _r$43.base;
- _r$44 = t$1.String(); /* */ $s = 49; case 49: if($c) { $c = false; _r$44 = _r$44.$blk(); } if (_r$44 && _r$44.$blk !== undefined) { break s; }
- tname = _r$44;
- /* } */ case 47:
- _r$45 = getBaseType(tname, f[0].Type); /* */ $s = 50; case 50: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- _tuple$4 = _r$45; gt = _tuple$4[0]; err$1 = _tuple$4[1];
- if (!($interfaceIsEqual(err$1, $ifaceNil))) {
- return [$ifaceNil, err$1];
- }
- _r$46 = gt.id(); /* */ $s = 53; case 53: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- /* */ if (_r$46 === 0) { $s = 51; continue; }
- /* */ $s = 52; continue;
- /* if (_r$46 === 0) { */ case 51:
- $r = setTypeId(gt); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 52:
- _r$47 = gt.id(); /* */ $s = 55; case 55: if($c) { $c = false; _r$47 = _r$47.$blk(); } if (_r$47 && _r$47.$blk !== undefined) { break s; }
- st$1.Field = $append(st$1.Field, new fieldType.ptr(f[0].Name, _r$47));
- i = i + (1) >> 0;
- /* } */ $s = 37; continue; case 38:
- return [st$1, $ifaceNil];
- $s = 17; continue;
- /* } else { */ case 16:
- _r$48 = rt[0].String(); /* */ $s = 56; case 56: if($c) { $c = false; _r$48 = _r$48.$blk(); } if (_r$48 && _r$48.$blk !== undefined) { break s; }
- _r$49 = errors.New("gob NewTypeObject can't handle type: " + _r$48); /* */ $s = 57; case 57: if($c) { $c = false; _r$49 = _r$49.$blk(); } if (_r$49 && _r$49.$blk !== undefined) { break s; }
- return [$ifaceNil, _r$49];
- /* } */ case 17:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return [$ifaceNil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: newTypeObject }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._key$5 = _key$5; $f._key$6 = _key$6; $f._key$7 = _key$7; $f._key$8 = _key$8; $f._key$9 = _key$9; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._r$42 = _r$42; $f._r$43 = _r$43; $f._r$44 = _r$44; $f._r$45 = _r$45; $f._r$46 = _r$46; $f._r$47 = _r$47; $f._r$48 = _r$48; $f._r$49 = _r$49; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.at = at; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.gt = gt; $f.i = i; $f.mt = mt; $f.name = name; $f.rt = rt; $f.st = st; $f.st$1 = st$1; $f.t = t; $f.t$1 = t$1; $f.tname = tname; $f.typ = typ; $f.type0 = type0; $f.type1 = type1; $f.ut = ut; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- isExported = function(name) {
- var $ptr, _tuple, name, rune;
- _tuple = utf8.DecodeRuneInString(name); rune = _tuple[0];
- return unicode.IsUpper(rune);
- };
- isSent = function(field) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, _v, field, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _v = $f._v; field = $f.field; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (!isExported(field.Name)) {
- return false;
- }
- typ = field.Type;
- /* while (true) { */ case 1:
- _r$22 = typ.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- /* if (!(_r$22 === 22)) { break; } */ if(!(_r$22 === 22)) { $s = 2; continue; }
- _r$23 = typ.Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- typ = _r$23;
- /* } */ $s = 1; continue; case 2:
- _r$24 = typ.Kind(); /* */ $s = 8; case 8: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- if (_r$24 === 18) { _v = true; $s = 7; continue s; }
- _r$25 = typ.Kind(); /* */ $s = 9; case 9: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _v = _r$25 === 19; case 7:
- /* */ if (_v) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_v) { */ case 5:
- return false;
- /* } */ case 6:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isSent }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._v = _v; $f.field = field; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- getBaseType = function(name, rt) {
- var $ptr, _r$22, _r$23, name, rt, ut, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; name = $f.name; rt = $f.rt; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$22 = userType(rt); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- ut = _r$22;
- _r$23 = getType(name, ut, ut.base); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: getBaseType }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f.name = name; $f.rt = rt; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f;
- };
- getType = function(name, ut, rt) {
- var $ptr, _entry, _key$5, _r$22, _tuple, _tuple$1, err, name, present, rt, typ, ut, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$5 = $f._key$5; _r$22 = $f._r$22; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; err = $f.err; name = $f.name; present = $f.present; rt = $f.rt; typ = $f.typ; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tuple = (_entry = types[reflect.Type.keyFor(rt)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); typ = _tuple[0]; present = _tuple[1];
- if (present) {
- return [typ, $ifaceNil];
- }
- _r$22 = newTypeObject(name, ut, rt); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple$1 = _r$22; typ = _tuple$1[0]; err = _tuple$1[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- _key$5 = rt; (types || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: typ };
- }
- return [typ, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: getType }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.err = err; $f.name = name; $f.present = present; $f.rt = rt; $f.typ = typ; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f;
- };
- checkId = function(want, got) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, got, want, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; got = $f.got; want = $f.want; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!((want === got))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((want === got))) { */ case 1:
- _r$22 = fmt.Fprintf(os.Stderr, "checkId: %d should be %d\n", new sliceType$3([new $Int((got >> 0)), new $Int((want >> 0))])); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$22;
- _r$23 = new typeId(got).name(); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _r$24 = new typeId(got).string(); /* */ $s = 5; case 5: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$25 = new typeId(want).string(); /* */ $s = 6; case 6: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- $panic(new $String("bootstrap type wrong id: " + _r$23 + " " + _r$24 + " not " + _r$25));
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: checkId }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f.got = got; $f.want = want; $f.$s = $s; $f.$r = $r; return $f;
- };
- bootstrapType = function(name, e, expect) {
- var $ptr, _entry, _key$5, _r$22, _r$23, _r$24, _tuple, e, expect, name, present, rt, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$5 = $f._key$5; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _tuple = $f._tuple; e = $f.e; expect = $f.expect; name = $f.name; present = $f.present; rt = $f.rt; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$22 = reflect.TypeOf(e).Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- rt = _r$22;
- _tuple = (_entry = types[reflect.Type.keyFor(rt)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); present = _tuple[1];
- /* */ if (present) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (present) { */ case 2:
- _r$23 = rt.String(); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- $panic(new $String("bootstrap type already present: " + name + ", " + _r$23));
- /* } */ case 3:
- typ = new CommonType.ptr(name, 0);
- _key$5 = rt; (types || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: typ };
- $r = setTypeId(typ); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = checkId(expect, nextId); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$24 = userType(rt); /* */ $s = 7; case 7: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$24;
- return nextId;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: bootstrapType }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$5 = _key$5; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._tuple = _tuple; $f.e = e; $f.expect = expect; $f.name = name; $f.present = present; $f.rt = rt; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- wireType.ptr.prototype.string = function() {
- var $ptr, w;
- w = this;
- if (w === ptrType$29.nil) {
- return "unknown type";
- }
- if (!(w.ArrayT === ptrType$22.nil)) {
- return w.ArrayT.CommonType.Name;
- } else if (!(w.SliceT === ptrType$23.nil)) {
- return w.SliceT.CommonType.Name;
- } else if (!(w.StructT === ptrType$24.nil)) {
- return w.StructT.CommonType.Name;
- } else if (!(w.MapT === ptrType$25.nil)) {
- return w.MapT.CommonType.Name;
- } else if (!(w.GobEncoderT === ptrType$26.nil)) {
- return w.GobEncoderT.CommonType.Name;
- } else if (!(w.BinaryMarshalerT === ptrType$26.nil)) {
- return w.BinaryMarshalerT.CommonType.Name;
- } else if (!(w.TextMarshalerT === ptrType$26.nil)) {
- return w.TextMarshalerT.CommonType.Name;
- }
- return "unknown type";
- };
- wireType.prototype.string = function() { return this.$val.string(); };
- lookupTypeInfo = function(rt) {
- var $ptr, _entry, _tuple, m, rt;
- _tuple = $assertType(typeInfoMap.Load(), mapType$1, true); m = _tuple[0];
- return (_entry = m[reflect.Type.keyFor(rt)], _entry !== undefined ? _entry.v : ptrType$38.nil);
- };
- getTypeInfo = function(ut) {
- var $ptr, _r$22, info, rt, ut, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; info = $f.info; rt = $f.rt; ut = $f.ut; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- rt = ut.base;
- if (!((ut.externalEnc === 0))) {
- rt = ut.user;
- }
- info = lookupTypeInfo(rt);
- if (!(info === ptrType$38.nil)) {
- return [info, $ifaceNil];
- }
- _r$22 = buildTypeInfo(ut, rt); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: getTypeInfo }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f.info = info; $f.rt = rt; $f.ut = ut; $f.$s = $s; $f.$r = $r; return $f;
- };
- buildTypeInfo = function(ut, rt) {
- var $ptr, _entry, _i, _key$5, _key$6, _keys, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$30, _r$31, _ref, _ref$1, _ref$2, _tuple, _tuple$1, _tuple$2, err, err$1, gt, gt$1, info, info$1, k, m, newm, rt, t, typ, userType$1, ut, v, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _key$5 = $f._key$5; _key$6 = $f._key$6; _keys = $f._keys; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$30 = $f._r$30; _r$31 = $f._r$31; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; err = $f.err; err$1 = $f.err$1; gt = $f.gt; gt$1 = $f.gt$1; info = $f.info; info$1 = $f.info$1; k = $f.k; m = $f.m; newm = $f.newm; rt = $f.rt; t = $f.t; typ = $f.typ; userType$1 = $f.userType$1; ut = $f.ut; v = $f.v; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- typeLock.Lock();
- $deferred.push([$methodVal(typeLock, "Unlock"), []]);
- info = lookupTypeInfo(rt);
- if (!(info === ptrType$38.nil)) {
- return [info, $ifaceNil];
- }
- _r$22 = rt.Name(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = getBaseType(_r$22, rt); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _tuple = _r$23; gt = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [ptrType$38.nil, err];
- }
- _r$24 = gt.id(); /* */ $s = 3; case 3: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- info$1 = new typeInfo.ptr(_r$24, new nosync.Mutex.ptr(), new atomic.Value.ptr(), ptrType$29.nil);
- /* */ if (!((ut.externalEnc === 0))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!((ut.externalEnc === 0))) { */ case 4:
- _r$25 = rt.Name(); /* */ $s = 7; case 7: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _r$26 = getType(_r$25, ut, rt); /* */ $s = 8; case 8: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _tuple$1 = _r$26; userType$1 = _tuple$1[0]; err$1 = _tuple$1[1];
- if (!($interfaceIsEqual(err$1, $ifaceNil))) {
- return [ptrType$38.nil, err$1];
- }
- _r$27 = userType$1.id(); /* */ $s = 9; case 9: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _r$28 = new typeId(_r$27).gobType(); /* */ $s = 10; case 10: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- gt$1 = $assertType(_r$28, ptrType$26);
- _ref = ut.externalEnc;
- if (_ref === 1) {
- info$1.wire = new wireType.ptr(ptrType$22.nil, ptrType$23.nil, ptrType$24.nil, ptrType$25.nil, gt$1, ptrType$26.nil, ptrType$26.nil);
- } else if (_ref === 2) {
- info$1.wire = new wireType.ptr(ptrType$22.nil, ptrType$23.nil, ptrType$24.nil, ptrType$25.nil, ptrType$26.nil, gt$1, ptrType$26.nil);
- } else if (_ref === 3) {
- info$1.wire = new wireType.ptr(ptrType$22.nil, ptrType$23.nil, ptrType$24.nil, ptrType$25.nil, ptrType$26.nil, ptrType$26.nil, gt$1);
- }
- rt = ut.user;
- $s = 6; continue;
- /* } else { */ case 5:
- t = new typeId(info$1.id).gobType();
- typ = rt;
- _r$29 = typ.Kind(); /* */ $s = 11; case 11: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _ref$1 = _r$29;
- /* */ if (_ref$1 === 17) { $s = 12; continue; }
- /* */ if (_ref$1 === 21) { $s = 13; continue; }
- /* */ if (_ref$1 === 23) { $s = 14; continue; }
- /* */ if (_ref$1 === 25) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_ref$1 === 17) { */ case 12:
- info$1.wire = new wireType.ptr($assertType(t, ptrType$22), ptrType$23.nil, ptrType$24.nil, ptrType$25.nil, ptrType$26.nil, ptrType$26.nil, ptrType$26.nil);
- $s = 16; continue;
- /* } else if (_ref$1 === 21) { */ case 13:
- info$1.wire = new wireType.ptr(ptrType$22.nil, ptrType$23.nil, ptrType$24.nil, $assertType(t, ptrType$25), ptrType$26.nil, ptrType$26.nil, ptrType$26.nil);
- $s = 16; continue;
- /* } else if (_ref$1 === 23) { */ case 14:
- _r$30 = typ.Elem(); /* */ $s = 19; case 19: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _r$31 = _r$30.Kind(); /* */ $s = 20; case 20: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- /* */ if (!((_r$31 === 8))) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (!((_r$31 === 8))) { */ case 17:
- info$1.wire = new wireType.ptr(ptrType$22.nil, $assertType(t, ptrType$23), ptrType$24.nil, ptrType$25.nil, ptrType$26.nil, ptrType$26.nil, ptrType$26.nil);
- /* } */ case 18:
- $s = 16; continue;
- /* } else if (_ref$1 === 25) { */ case 15:
- info$1.wire = new wireType.ptr(ptrType$22.nil, ptrType$23.nil, $assertType(t, ptrType$24), ptrType$25.nil, ptrType$26.nil, ptrType$26.nil, ptrType$26.nil);
- /* } */ case 16:
- /* } */ case 6:
- newm = new $Map();
- _tuple$2 = $assertType(typeInfoMap.Load(), mapType$1, true); m = _tuple$2[0];
- _ref$2 = m;
- _i = 0;
- _keys = $keys(_ref$2);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref$2[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- k = _entry.k;
- v = _entry.v;
- _key$5 = k; (newm || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: v };
- _i++;
- }
- _key$6 = rt; (newm || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$6)] = { k: _key$6, v: info$1 };
- typeInfoMap.Store(new mapType$1(newm));
- return [info$1, $ifaceNil];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return [ptrType$38.nil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: buildTypeInfo }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._key$5 = _key$5; $f._key$6 = _key$6; $f._keys = _keys; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.err = err; $f.err$1 = err$1; $f.gt = gt; $f.gt$1 = gt$1; $f.info = info; $f.info$1 = info$1; $f.k = k; $f.m = m; $f.newm = newm; $f.rt = rt; $f.t = t; $f.typ = typ; $f.userType$1 = userType$1; $f.ut = ut; $f.v = v; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- mustGetTypeInfo = function(rt) {
- var $ptr, _r$22, _r$23, _r$24, _tuple, err, rt, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _tuple = $f._tuple; err = $f.err; rt = $f.rt; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$22 = userType(rt); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = getTypeInfo(_r$22); /* */ $s = 2; case 2: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _tuple = _r$23; t = _tuple[0]; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 3:
- _r$24 = err.Error(); /* */ $s = 5; case 5: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- $panic(new $String("getTypeInfo: " + _r$24));
- /* } */ case 4:
- return t;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mustGetTypeInfo }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._tuple = _tuple; $f.err = err; $f.rt = rt; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- RegisterName = function(name, value) {
- var $ptr, _entry, _entry$1, _key$5, _key$6, _r$22, _r$23, _r$24, _tuple, _tuple$1, n, name, ok, ok$1, t, ut, value, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _key$5 = $f._key$5; _key$6 = $f._key$6; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; n = $f.n; name = $f.name; ok = $f.ok; ok$1 = $f.ok$1; t = $f.t; ut = $f.ut; value = $f.value; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- if (name === "") {
- $panic(new $String("attempt to register empty name"));
- }
- registerLock.Lock();
- $deferred.push([$methodVal(registerLock, "Unlock"), []]);
- _r$22 = userType(reflect.TypeOf(value)); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- ut = _r$22;
- _tuple = (_entry = nameToConcreteType[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); t = _tuple[0]; ok = _tuple[1];
- /* */ if (ok && !($interfaceIsEqual(t, ut.user))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (ok && !($interfaceIsEqual(t, ut.user))) { */ case 2:
- _r$23 = fmt.Sprintf("gob: registering duplicate types for %q: %s != %s", new sliceType$3([new $String(name), t, ut.user])); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- $panic(new $String(_r$23));
- /* } */ case 3:
- _tuple$1 = (_entry$1 = concreteTypeToName[reflect.Type.keyFor(ut.base)], _entry$1 !== undefined ? [_entry$1.v, true] : ["", false]); n = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1 && !(n === name)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (ok$1 && !(n === name)) { */ case 5:
- _r$24 = fmt.Sprintf("gob: registering duplicate names for %s: %q != %q", new sliceType$3([ut.user, new $String(n), new $String(name)])); /* */ $s = 7; case 7: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- $panic(new $String(_r$24));
- /* } */ case 6:
- _key$5 = name; (nameToConcreteType || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$5)] = { k: _key$5, v: reflect.TypeOf(value) };
- _key$6 = ut.base; (concreteTypeToName || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$6)] = { k: _key$6, v: name };
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: RegisterName }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._key$5 = _key$5; $f._key$6 = _key$6; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.n = n; $f.name = name; $f.ok = ok; $f.ok$1 = ok$1; $f.t = t; $f.ut = ut; $f.value = value; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- $pkg.RegisterName = RegisterName;
- Register = function(value) {
- var $ptr, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, name, pt, rt, star, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; name = $f.name; pt = $f.pt; rt = $f.rt; star = $f.star; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- rt = reflect.TypeOf(value);
- _r$22 = rt.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- name = _r$22;
- star = "";
- _r$23 = rt.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- /* */ if (_r$23 === "") { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_r$23 === "") { */ case 2:
- pt = rt;
- _r$24 = pt.Kind(); /* */ $s = 7; case 7: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- /* */ if (_r$24 === 22) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_r$24 === 22) { */ case 5:
- star = "*";
- rt = pt;
- /* } */ case 6:
- /* } */ case 3:
- _r$25 = rt.Name(); /* */ $s = 10; case 10: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- /* */ if (!(_r$25 === "")) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!(_r$25 === "")) { */ case 8:
- _r$26 = rt.PkgPath(); /* */ $s = 14; case 14: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- /* */ if (_r$26 === "") { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_r$26 === "") { */ case 11:
- _r$27 = rt.Name(); /* */ $s = 15; case 15: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- name = star + _r$27;
- $s = 13; continue;
- /* } else { */ case 12:
- _r$28 = rt.PkgPath(); /* */ $s = 16; case 16: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _r$29 = rt.Name(); /* */ $s = 17; case 17: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- name = star + _r$28 + "." + _r$29;
- /* } */ case 13:
- /* } */ case 9:
- $r = RegisterName(name, value); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Register }; } $f.$ptr = $ptr; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f.name = name; $f.pt = pt; $f.rt = rt; $f.star = star; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Register = Register;
- registerBasics = function() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = Register(new $Int(0)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Int8(0)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Int16(0)); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Int32(0)); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Int64(0, 0)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Uint(0)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Uint8(0)); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Uint16(0)); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Uint32(0)); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Uint64(0, 0)); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Float32(0)); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Float64(0)); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Complex64(0, 0)); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Complex128(0, 0)); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Uintptr(0)); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $Bool(false)); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(new $String("")); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$1.nil); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$8.nil); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$12.nil); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$9.nil); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$10.nil); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$11.nil); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$14.nil); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$1.nil); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$15.nil); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$16.nil); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$17.nil); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$6.nil); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$7.nil); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$4.nil); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$5.nil); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$18.nil); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$2.nil); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Register(sliceType$13.nil); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: registerBasics }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- };
- ptrType$27.methods = [{prop: "decodeUint", name: "decodeUint", pkg: "encoding/gob", typ: $funcType([], [$Uint64], false)}, {prop: "decodeInt", name: "decodeInt", pkg: "encoding/gob", typ: $funcType([], [$Int64], false)}];
- ptrType$41.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "Drop", name: "Drop", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "ReadByte", name: "ReadByte", pkg: "", typ: $funcType([], [$Uint8, $error], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}];
- ptrType$40.methods = [{prop: "newDecoderState", name: "newDecoderState", pkg: "encoding/gob", typ: $funcType([ptrType$41], [ptrType$27], false)}, {prop: "freeDecoderState", name: "freeDecoderState", pkg: "encoding/gob", typ: $funcType([ptrType$27], [], false)}, {prop: "decodeSingle", name: "decodeSingle", pkg: "encoding/gob", typ: $funcType([ptrType$30, ptrType, reflect.Value], [], false)}, {prop: "decodeStruct", name: "decodeStruct", pkg: "encoding/gob", typ: $funcType([ptrType$30, ptrType, reflect.Value], [], false)}, {prop: "ignoreStruct", name: "ignoreStruct", pkg: "encoding/gob", typ: $funcType([ptrType$30], [], false)}, {prop: "ignoreSingle", name: "ignoreSingle", pkg: "encoding/gob", typ: $funcType([ptrType$30], [], false)}, {prop: "decodeArrayHelper", name: "decodeArrayHelper", pkg: "encoding/gob", typ: $funcType([ptrType$27, reflect.Value, decOp, $Int, $error, decHelper], [], false)}, {prop: "decodeArray", name: "decodeArray", pkg: "encoding/gob", typ: $funcType([reflect.Type, ptrType$27, reflect.Value, decOp, $Int, $error, decHelper], [], false)}, {prop: "decodeMap", name: "decodeMap", pkg: "encoding/gob", typ: $funcType([reflect.Type, ptrType$27, reflect.Value, decOp, decOp, $error], [], false)}, {prop: "ignoreArrayHelper", name: "ignoreArrayHelper", pkg: "encoding/gob", typ: $funcType([ptrType$27, decOp, $Int], [], false)}, {prop: "ignoreArray", name: "ignoreArray", pkg: "encoding/gob", typ: $funcType([ptrType$27, decOp, $Int], [], false)}, {prop: "ignoreMap", name: "ignoreMap", pkg: "encoding/gob", typ: $funcType([ptrType$27, decOp, decOp], [], false)}, {prop: "decodeSlice", name: "decodeSlice", pkg: "encoding/gob", typ: $funcType([ptrType$27, reflect.Value, decOp, $error, decHelper], [], false)}, {prop: "ignoreSlice", name: "ignoreSlice", pkg: "encoding/gob", typ: $funcType([ptrType$27, decOp], [], false)}, {prop: "decodeInterface", name: "decodeInterface", pkg: "encoding/gob", typ: $funcType([reflect.Type, ptrType$27, reflect.Value], [], false)}, {prop: "ignoreInterface", name: "ignoreInterface", pkg: "encoding/gob", typ: $funcType([ptrType$27], [], false)}, {prop: "decodeGobDecoder", name: "decodeGobDecoder", pkg: "encoding/gob", typ: $funcType([ptrType, ptrType$27, reflect.Value], [], false)}, {prop: "ignoreGobDecoder", name: "ignoreGobDecoder", pkg: "encoding/gob", typ: $funcType([ptrType$27], [], false)}, {prop: "decOpFor", name: "decOpFor", pkg: "encoding/gob", typ: $funcType([typeId, reflect.Type, $String, mapType$2], [ptrType$28], false)}, {prop: "decIgnoreOpFor", name: "decIgnoreOpFor", pkg: "encoding/gob", typ: $funcType([typeId], [decOp], false)}, {prop: "gobDecodeOpFor", name: "gobDecodeOpFor", pkg: "encoding/gob", typ: $funcType([ptrType], [ptrType$28], false)}, {prop: "compatibleType", name: "compatibleType", pkg: "encoding/gob", typ: $funcType([reflect.Type, typeId, mapType$3], [$Bool], false)}, {prop: "typeString", name: "typeString", pkg: "encoding/gob", typ: $funcType([typeId], [$String], false)}, {prop: "compileSingle", name: "compileSingle", pkg: "encoding/gob", typ: $funcType([typeId, ptrType], [ptrType$30, $error], false)}, {prop: "compileIgnoreSingle", name: "compileIgnoreSingle", pkg: "encoding/gob", typ: $funcType([typeId], [ptrType$30, $error], false)}, {prop: "compileDec", name: "compileDec", pkg: "encoding/gob", typ: $funcType([typeId, ptrType], [ptrType$30, $error], false)}, {prop: "getDecEnginePtr", name: "getDecEnginePtr", pkg: "encoding/gob", typ: $funcType([typeId, ptrType], [ptrType$31, $error], false)}, {prop: "getIgnoreEnginePtr", name: "getIgnoreEnginePtr", pkg: "encoding/gob", typ: $funcType([typeId], [ptrType$31, $error], false)}, {prop: "decodeValue", name: "decodeValue", pkg: "encoding/gob", typ: $funcType([typeId, reflect.Value], [], false)}, {prop: "decodeIgnoredValue", name: "decodeIgnoredValue", pkg: "encoding/gob", typ: $funcType([typeId], [], false)}, {prop: "recvType", name: "recvType", pkg: "encoding/gob", typ: $funcType([typeId], [], false)}, {prop: "recvMessage", name: "recvMessage", pkg: "encoding/gob", typ: $funcType([], [$Bool], false)}, {prop: "readMessage", name: "readMessage", pkg: "encoding/gob", typ: $funcType([$Int], [], false)}, {prop: "nextInt", name: "nextInt", pkg: "encoding/gob", typ: $funcType([], [$Int64], false)}, {prop: "nextUint", name: "nextUint", pkg: "encoding/gob", typ: $funcType([], [$Uint64], false)}, {prop: "decodeTypeSequence", name: "decodeTypeSequence", pkg: "encoding/gob", typ: $funcType([$Bool], [typeId], false)}, {prop: "Decode", name: "Decode", pkg: "", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "DecodeValue", name: "DecodeValue", pkg: "", typ: $funcType([reflect.Value], [$error], false)}];
- typeId.methods = [{prop: "gobType", name: "gobType", pkg: "encoding/gob", typ: $funcType([], [gobType], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}, {prop: "name", name: "name", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- ptrType$45.methods = [{prop: "id", name: "id", pkg: "encoding/gob", typ: $funcType([], [typeId], false)}, {prop: "setId", name: "setId", pkg: "encoding/gob", typ: $funcType([typeId], [], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}, {prop: "safeString", name: "safeString", pkg: "encoding/gob", typ: $funcType([mapType$7], [$String], false)}, {prop: "name", name: "name", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- ptrType$22.methods = [{prop: "init", name: "init", pkg: "encoding/gob", typ: $funcType([gobType, $Int], [], false)}, {prop: "safeString", name: "safeString", pkg: "encoding/gob", typ: $funcType([mapType$7], [$String], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- ptrType$26.methods = [{prop: "safeString", name: "safeString", pkg: "encoding/gob", typ: $funcType([mapType$7], [$String], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- ptrType$25.methods = [{prop: "init", name: "init", pkg: "encoding/gob", typ: $funcType([gobType, gobType], [], false)}, {prop: "safeString", name: "safeString", pkg: "encoding/gob", typ: $funcType([mapType$7], [$String], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- ptrType$23.methods = [{prop: "init", name: "init", pkg: "encoding/gob", typ: $funcType([gobType], [], false)}, {prop: "safeString", name: "safeString", pkg: "encoding/gob", typ: $funcType([mapType$7], [$String], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- ptrType$24.methods = [{prop: "safeString", name: "safeString", pkg: "encoding/gob", typ: $funcType([mapType$7], [$String], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- ptrType$29.methods = [{prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}];
- decHelper.init([ptrType$27, reflect.Value, $Int, $error], [$Bool], false);
- decoderState.init([{prop: "dec", name: "dec", pkg: "encoding/gob", typ: ptrType$40, tag: ""}, {prop: "b", name: "b", pkg: "encoding/gob", typ: ptrType$41, tag: ""}, {prop: "fieldnum", name: "fieldnum", pkg: "encoding/gob", typ: $Int, tag: ""}, {prop: "buf", name: "buf", pkg: "encoding/gob", typ: sliceType$1, tag: ""}, {prop: "next", name: "next", pkg: "encoding/gob", typ: ptrType$27, tag: ""}]);
- decBuffer.init([{prop: "data", name: "data", pkg: "encoding/gob", typ: sliceType$1, tag: ""}, {prop: "offset", name: "offset", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- decOp.init([ptrType$42, ptrType$27, reflect.Value], [], false);
- decInstr.init([{prop: "op", name: "op", pkg: "encoding/gob", typ: decOp, tag: ""}, {prop: "field", name: "field", pkg: "encoding/gob", typ: $Int, tag: ""}, {prop: "index", name: "index", pkg: "encoding/gob", typ: sliceType$8, tag: ""}, {prop: "ovfl", name: "ovfl", pkg: "encoding/gob", typ: $error, tag: ""}]);
- decEngine.init([{prop: "instr", name: "instr", pkg: "encoding/gob", typ: sliceType$19, tag: ""}, {prop: "numInstr", name: "numInstr", pkg: "encoding/gob", typ: $Int, tag: ""}]);
- emptyStruct.init([]);
- Decoder.init([{prop: "mutex", name: "mutex", pkg: "encoding/gob", typ: nosync.Mutex, tag: ""}, {prop: "r", name: "r", pkg: "encoding/gob", typ: io.Reader, tag: ""}, {prop: "buf", name: "buf", pkg: "encoding/gob", typ: decBuffer, tag: ""}, {prop: "wireType", name: "wireType", pkg: "encoding/gob", typ: mapType$4, tag: ""}, {prop: "decoderCache", name: "decoderCache", pkg: "encoding/gob", typ: mapType$6, tag: ""}, {prop: "ignorerCache", name: "ignorerCache", pkg: "encoding/gob", typ: mapType$5, tag: ""}, {prop: "freeList", name: "freeList", pkg: "encoding/gob", typ: ptrType$27, tag: ""}, {prop: "countBuf", name: "countBuf", pkg: "encoding/gob", typ: sliceType$1, tag: ""}, {prop: "err", name: "err", pkg: "encoding/gob", typ: $error, tag: ""}]);
- gobError.init([{prop: "err", name: "err", pkg: "encoding/gob", typ: $error, tag: ""}]);
- userTypeInfo.init([{prop: "user", name: "user", pkg: "encoding/gob", typ: reflect.Type, tag: ""}, {prop: "base", name: "base", pkg: "encoding/gob", typ: reflect.Type, tag: ""}, {prop: "indir", name: "indir", pkg: "encoding/gob", typ: $Int, tag: ""}, {prop: "externalEnc", name: "externalEnc", pkg: "encoding/gob", typ: $Int, tag: ""}, {prop: "externalDec", name: "externalDec", pkg: "encoding/gob", typ: $Int, tag: ""}, {prop: "encIndir", name: "encIndir", pkg: "encoding/gob", typ: $Int8, tag: ""}, {prop: "decIndir", name: "decIndir", pkg: "encoding/gob", typ: $Int8, tag: ""}]);
- gobType.init([{prop: "id", name: "id", pkg: "encoding/gob", typ: $funcType([], [typeId], false)}, {prop: "name", name: "name", pkg: "encoding/gob", typ: $funcType([], [$String], false)}, {prop: "safeString", name: "safeString", pkg: "encoding/gob", typ: $funcType([mapType$7], [$String], false)}, {prop: "setId", name: "setId", pkg: "encoding/gob", typ: $funcType([typeId], [], false)}, {prop: "string", name: "string", pkg: "encoding/gob", typ: $funcType([], [$String], false)}]);
- CommonType.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Id", name: "Id", pkg: "", typ: typeId, tag: ""}]);
- arrayType.init([{prop: "CommonType", name: "", pkg: "", typ: CommonType, tag: ""}, {prop: "Elem", name: "Elem", pkg: "", typ: typeId, tag: ""}, {prop: "Len", name: "Len", pkg: "", typ: $Int, tag: ""}]);
- gobEncoderType.init([{prop: "CommonType", name: "", pkg: "", typ: CommonType, tag: ""}]);
- mapType.init([{prop: "CommonType", name: "", pkg: "", typ: CommonType, tag: ""}, {prop: "Key", name: "Key", pkg: "", typ: typeId, tag: ""}, {prop: "Elem", name: "Elem", pkg: "", typ: typeId, tag: ""}]);
- sliceType.init([{prop: "CommonType", name: "", pkg: "", typ: CommonType, tag: ""}, {prop: "Elem", name: "Elem", pkg: "", typ: typeId, tag: ""}]);
- fieldType.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Id", name: "Id", pkg: "", typ: typeId, tag: ""}]);
- structType.init([{prop: "CommonType", name: "", pkg: "", typ: CommonType, tag: ""}, {prop: "Field", name: "Field", pkg: "", typ: sliceType$22, tag: ""}]);
- wireType.init([{prop: "ArrayT", name: "ArrayT", pkg: "", typ: ptrType$22, tag: ""}, {prop: "SliceT", name: "SliceT", pkg: "", typ: ptrType$23, tag: ""}, {prop: "StructT", name: "StructT", pkg: "", typ: ptrType$24, tag: ""}, {prop: "MapT", name: "MapT", pkg: "", typ: ptrType$25, tag: ""}, {prop: "GobEncoderT", name: "GobEncoderT", pkg: "", typ: ptrType$26, tag: ""}, {prop: "BinaryMarshalerT", name: "BinaryMarshalerT", pkg: "", typ: ptrType$26, tag: ""}, {prop: "TextMarshalerT", name: "TextMarshalerT", pkg: "", typ: ptrType$26, tag: ""}]);
- typeInfo.init([{prop: "id", name: "id", pkg: "encoding/gob", typ: typeId, tag: ""}, {prop: "encInit", name: "encInit", pkg: "encoding/gob", typ: nosync.Mutex, tag: ""}, {prop: "encoder", name: "encoder", pkg: "encoding/gob", typ: atomic.Value, tag: ""}, {prop: "wire", name: "wire", pkg: "encoding/gob", typ: ptrType$29, tag: ""}]);
- GobEncoder.init([{prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}]);
- GobDecoder.init([{prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType$1], [$error], false)}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bufio.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = encoding.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = nosync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = reflect.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = atomic.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- noValue = new reflect.Value.ptr();
- userTypeLock = new nosync.RWMutex.ptr();
- nextId = 0;
- typeLock = new nosync.Mutex.ptr();
- builtinIdToType = false;
- wireTypeUserInfo = ptrType.nil;
- typeInfoMap = new atomic.Value.ptr();
- registerLock = new nosync.RWMutex.ptr();
- errBadUint = errors.New("gob: encoded unsigned integer out of range");
- errBadType = errors.New("gob: unknown type id or corrupted data");
- errRange = errors.New("gob: bad data: field numbers out of bounds");
- emptyStructType = reflect.TypeOf((x = new emptyStruct.ptr(), new x.constructor.elem(x)));
- errBadCount = errors.New("invalid message length");
- spaceForLength = $makeSlice(sliceType$1, 9);
- decSliceHelper = (_map$2 = new $Map(), _key$2 = 1, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decBoolSlice }, _key$2 = 15, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decComplex64Slice }, _key$2 = 16, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decComplex128Slice }, _key$2 = 13, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decFloat32Slice }, _key$2 = 14, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decFloat64Slice }, _key$2 = 2, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decIntSlice }, _key$2 = 4, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decInt16Slice }, _key$2 = 5, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decInt32Slice }, _key$2 = 6, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decInt64Slice }, _key$2 = 3, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decInt8Slice }, _key$2 = 24, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decStringSlice }, _key$2 = 7, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decUintSlice }, _key$2 = 9, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decUint16Slice }, _key$2 = 10, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decUint32Slice }, _key$2 = 11, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decUint64Slice }, _key$2 = 12, _map$2[reflect.Kind.keyFor(_key$2)] = { k: _key$2, v: decUintptrSlice }, _map$2);
- decArrayHelper = (_map$3 = new $Map(), _key$3 = 1, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decBoolArray }, _key$3 = 15, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decComplex64Array }, _key$3 = 16, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decComplex128Array }, _key$3 = 13, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decFloat32Array }, _key$3 = 14, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decFloat64Array }, _key$3 = 2, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decIntArray }, _key$3 = 4, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decInt16Array }, _key$3 = 5, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decInt32Array }, _key$3 = 6, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decInt64Array }, _key$3 = 3, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decInt8Array }, _key$3 = 24, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decStringArray }, _key$3 = 7, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decUintArray }, _key$3 = 9, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decUint16Array }, _key$3 = 10, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decUint32Array }, _key$3 = 11, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decUint64Array }, _key$3 = 12, _map$3[reflect.Kind.keyFor(_key$3)] = { k: _key$3, v: decUintptrArray }, _map$3);
- decOpTable = $toNativeArray($kindFunc, [$throwNilPointerError, decBool, $throwNilPointerError, decInt8, decInt16, decInt32, decInt64, $throwNilPointerError, decUint8, decUint16, decUint32, decUint64, $throwNilPointerError, decFloat32, decFloat64, decComplex64, decComplex128, $throwNilPointerError, $throwNilPointerError, $throwNilPointerError, $throwNilPointerError, $throwNilPointerError, $throwNilPointerError, $throwNilPointerError, decString]);
- userTypeCache = new $Map();
- _r = reflect.TypeOf(ptrType$1.nil).Elem(); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- gobEncoderInterfaceType = _r;
- _r$1 = reflect.TypeOf(ptrType$2.nil).Elem(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- gobDecoderInterfaceType = _r$1;
- _r$2 = reflect.TypeOf(ptrType$3.nil).Elem(); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- binaryMarshalerInterfaceType = _r$2;
- _r$3 = reflect.TypeOf(ptrType$4.nil).Elem(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- binaryUnmarshalerInterfaceType = _r$3;
- _r$4 = reflect.TypeOf(ptrType$5.nil).Elem(); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- textMarshalerInterfaceType = _r$4;
- _r$5 = reflect.TypeOf(ptrType$6.nil).Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- textUnmarshalerInterfaceType = _r$5;
- types = new $Map();
- idToType = new $Map();
- _r$6 = bootstrapType("bool", ptrType$7.nil, 1); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- tBool = _r$6;
- _r$7 = bootstrapType("int", ptrType$8.nil, 2); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- tInt = _r$7;
- _r$8 = bootstrapType("uint", ptrType$9.nil, 3); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- tUint = _r$8;
- _r$9 = bootstrapType("float", ptrType$10.nil, 4); /* */ $s = 22; case 22: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- tFloat = _r$9;
- _r$10 = bootstrapType("bytes", ptrType$11.nil, 5); /* */ $s = 23; case 23: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- tBytes = _r$10;
- _r$11 = bootstrapType("string", ptrType$12.nil, 6); /* */ $s = 24; case 24: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- tString = _r$11;
- _r$12 = bootstrapType("complex", ptrType$13.nil, 7); /* */ $s = 25; case 25: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- tComplex = _r$12;
- decIgnoreOpMap = (_map$4 = new $Map(), _key$4 = tBool, _map$4[typeId.keyFor(_key$4)] = { k: _key$4, v: ignoreUint }, _key$4 = tInt, _map$4[typeId.keyFor(_key$4)] = { k: _key$4, v: ignoreUint }, _key$4 = tUint, _map$4[typeId.keyFor(_key$4)] = { k: _key$4, v: ignoreUint }, _key$4 = tFloat, _map$4[typeId.keyFor(_key$4)] = { k: _key$4, v: ignoreUint }, _key$4 = tBytes, _map$4[typeId.keyFor(_key$4)] = { k: _key$4, v: ignoreUint8Array }, _key$4 = tString, _map$4[typeId.keyFor(_key$4)] = { k: _key$4, v: ignoreUint8Array }, _key$4 = tComplex, _map$4[typeId.keyFor(_key$4)] = { k: _key$4, v: ignoreTwoUints }, _map$4);
- _r$13 = bootstrapType("interface", ptrType$14.nil, 8); /* */ $s = 26; case 26: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- tInterface = _r$13;
- _r$14 = bootstrapType("_reserved1", ptrType$15.nil, 9); /* */ $s = 27; case 27: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- tReserved7 = _r$14;
- _r$15 = bootstrapType("_reserved1", ptrType$16.nil, 10); /* */ $s = 28; case 28: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- tReserved6 = _r$15;
- _r$16 = bootstrapType("_reserved1", ptrType$17.nil, 11); /* */ $s = 29; case 29: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- tReserved5 = _r$16;
- _r$17 = bootstrapType("_reserved1", ptrType$18.nil, 12); /* */ $s = 30; case 30: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- tReserved4 = _r$17;
- _r$18 = bootstrapType("_reserved1", ptrType$19.nil, 13); /* */ $s = 31; case 31: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- tReserved3 = _r$18;
- _r$19 = bootstrapType("_reserved1", ptrType$20.nil, 14); /* */ $s = 32; case 32: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- tReserved2 = _r$19;
- _r$20 = bootstrapType("_reserved1", ptrType$21.nil, 15); /* */ $s = 33; case 33: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- tReserved1 = _r$20;
- nameToConcreteType = new $Map();
- concreteTypeToName = new $Map();
- _r$21 = mustGetTypeInfo(reflect.TypeOf((x$1 = new wireType.ptr(ptrType$22.nil, ptrType$23.nil, ptrType$24.nil, ptrType$25.nil, ptrType$26.nil, ptrType$26.nil, ptrType$26.nil), new x$1.constructor.elem(x$1)))); /* */ $s = 34; case 34: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- tWireType = _r$21.id;
- $r = init(); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = init$1(); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["encoding/base64"] = (function() {
- var $pkg = {}, $init, bytes, io, strconv, strings, Encoding, encoder, CorruptInputError, sliceType, ptrType, arrayType, arrayType$1, arrayType$2, arrayType$4, ptrType$1, removeNewlinesMapper, NewEncoding, NewEncoder;
- bytes = $packages["bytes"];
- io = $packages["io"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- Encoding = $pkg.Encoding = $newType(0, $kindStruct, "base64.Encoding", "Encoding", "encoding/base64", function(encode_, decodeMap_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.encode = "";
- this.decodeMap = arrayType$4.zero();
- return;
- }
- this.encode = encode_;
- this.decodeMap = decodeMap_;
- });
- encoder = $pkg.encoder = $newType(0, $kindStruct, "base64.encoder", "encoder", "encoding/base64", function(err_, enc_, w_, buf_, nbuf_, out_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.err = $ifaceNil;
- this.enc = ptrType.nil;
- this.w = $ifaceNil;
- this.buf = arrayType.zero();
- this.nbuf = 0;
- this.out = arrayType$1.zero();
- return;
- }
- this.err = err_;
- this.enc = enc_;
- this.w = w_;
- this.buf = buf_;
- this.nbuf = nbuf_;
- this.out = out_;
- });
- CorruptInputError = $pkg.CorruptInputError = $newType(8, $kindInt64, "base64.CorruptInputError", "CorruptInputError", "encoding/base64", null);
- sliceType = $sliceType($Uint8);
- ptrType = $ptrType(Encoding);
- arrayType = $arrayType($Uint8, 3);
- arrayType$1 = $arrayType($Uint8, 1024);
- arrayType$2 = $arrayType($Uint8, 4);
- arrayType$4 = $arrayType($Uint8, 256);
- ptrType$1 = $ptrType(encoder);
- NewEncoding = function(encoder$1) {
- var $ptr, e, encoder$1, i, i$1, x, x$1, x$2;
- e = new Encoding.ptr();
- e.encode = encoder$1;
- i = 0;
- while (true) {
- if (!(i < 256)) { break; }
- (x = e.decodeMap, ((i < 0 || i >= x.length) ? $throwRuntimeError("index out of range") : x[i] = 255));
- i = i + (1) >> 0;
- }
- i$1 = 0;
- while (true) {
- if (!(i$1 < encoder$1.length)) { break; }
- (x$1 = e.decodeMap, x$2 = encoder$1.charCodeAt(i$1), ((x$2 < 0 || x$2 >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[x$2] = (i$1 << 24 >>> 24)));
- i$1 = i$1 + (1) >> 0;
- }
- return e;
- };
- $pkg.NewEncoding = NewEncoding;
- Encoding.ptr.prototype.Encode = function(dst, src) {
- var $ptr, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, b0, b1, b2, b3, dst, enc, src;
- enc = this;
- if (src.$length === 0) {
- return;
- }
- while (true) {
- if (!(src.$length > 0)) { break; }
- _tmp = 0; _tmp$1 = 0; _tmp$2 = 0; _tmp$3 = 0; b0 = _tmp; b1 = _tmp$1; b2 = _tmp$2; b3 = _tmp$3;
- _ref = src.$length;
- if (_ref === 2) {
- b2 = (b2 | ((((((1 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 1]) << 2 << 24 >>> 24)) & 63) >>> 0))) >>> 0;
- b1 = (1 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 1]) >>> 4 << 24 >>> 24;
- b1 = (b1 | ((((((0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]) << 4 << 24 >>> 24)) & 63) >>> 0))) >>> 0;
- b0 = (0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]) >>> 2 << 24 >>> 24;
- } else if (_ref === 1) {
- b1 = (b1 | ((((((0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]) << 4 << 24 >>> 24)) & 63) >>> 0))) >>> 0;
- b0 = (0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]) >>> 2 << 24 >>> 24;
- } else {
- b3 = ((2 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 2]) & 63) >>> 0;
- b2 = (2 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 2]) >>> 6 << 24 >>> 24;
- b2 = (b2 | ((((((1 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 1]) << 2 << 24 >>> 24)) & 63) >>> 0))) >>> 0;
- b1 = (1 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 1]) >>> 4 << 24 >>> 24;
- b1 = (b1 | ((((((0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]) << 4 << 24 >>> 24)) & 63) >>> 0))) >>> 0;
- b0 = (0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]) >>> 2 << 24 >>> 24;
- }
- (0 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 0] = enc.encode.charCodeAt(b0));
- (1 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 1] = enc.encode.charCodeAt(b1));
- (2 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 2] = enc.encode.charCodeAt(b2));
- (3 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 3] = enc.encode.charCodeAt(b3));
- if (src.$length < 3) {
- (3 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 3] = 61);
- if (src.$length < 2) {
- (2 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 2] = 61);
- }
- break;
- }
- src = $subslice(src, 3);
- dst = $subslice(dst, 4);
- }
- };
- Encoding.prototype.Encode = function(dst, src) { return this.$val.Encode(dst, src); };
- Encoding.ptr.prototype.EncodeToString = function(src) {
- var $ptr, buf, enc, src;
- enc = this;
- buf = $makeSlice(sliceType, enc.EncodedLen(src.$length));
- enc.Encode(buf, src);
- return $bytesToString(buf);
- };
- Encoding.prototype.EncodeToString = function(src) { return this.$val.EncodeToString(src); };
- encoder.ptr.prototype.Write = function(p) {
- var $ptr, _q, _r, _r$1, _r$2, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, e, err, i, i$1, n, nn, p, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; e = $f.e; err = $f.err; i = $f.i; i$1 = $f.i$1; n = $f.n; nn = $f.nn; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- e = this;
- if (!($interfaceIsEqual(e.err, $ifaceNil))) {
- _tmp = 0; _tmp$1 = e.err; n = _tmp; err = _tmp$1;
- return [n, err];
- }
- /* */ if (e.nbuf > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (e.nbuf > 0) { */ case 1:
- i = 0;
- i = 0;
- while (true) {
- if (!(i < p.$length && e.nbuf < 3)) { break; }
- (x = e.buf, x$1 = e.nbuf, ((x$1 < 0 || x$1 >= x.length) ? $throwRuntimeError("index out of range") : x[x$1] = ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i])));
- e.nbuf = e.nbuf + (1) >> 0;
- i = i + (1) >> 0;
- }
- n = n + (i) >> 0;
- p = $subslice(p, i);
- if (e.nbuf < 3) {
- return [n, err];
- }
- e.enc.Encode($subslice(new sliceType(e.out), 0), $subslice(new sliceType(e.buf), 0));
- _r = e.w.Write($subslice(new sliceType(e.out), 0, 4)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; e.err = _tuple[1];
- /* */ if (!($interfaceIsEqual(e.err, $ifaceNil))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!($interfaceIsEqual(e.err, $ifaceNil))) { */ case 4:
- _tmp$2 = n; _tmp$3 = e.err; n = _tmp$2; err = _tmp$3;
- return [n, err];
- /* } */ case 5:
- e.nbuf = 0;
- /* } */ case 2:
- /* while (true) { */ case 6:
- /* if (!(p.$length >= 3)) { break; } */ if(!(p.$length >= 3)) { $s = 7; continue; }
- nn = 768;
- if (nn > p.$length) {
- nn = p.$length;
- nn = nn - ((_r$1 = nn % 3, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))) >> 0;
- }
- e.enc.Encode($subslice(new sliceType(e.out), 0), $subslice(p, 0, nn));
- _r$2 = e.w.Write($subslice(new sliceType(e.out), 0, ((_q = nn / 3, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) * 4 >> 0))); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; e.err = _tuple$1[1];
- /* */ if (!($interfaceIsEqual(e.err, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(e.err, $ifaceNil))) { */ case 9:
- _tmp$4 = n; _tmp$5 = e.err; n = _tmp$4; err = _tmp$5;
- return [n, err];
- /* } */ case 10:
- n = n + (nn) >> 0;
- p = $subslice(p, nn);
- /* } */ $s = 6; continue; case 7:
- i$1 = 0;
- while (true) {
- if (!(i$1 < p.$length)) { break; }
- (x$2 = e.buf, ((i$1 < 0 || i$1 >= x$2.length) ? $throwRuntimeError("index out of range") : x$2[i$1] = ((i$1 < 0 || i$1 >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i$1])));
- i$1 = i$1 + (1) >> 0;
- }
- e.nbuf = p.$length;
- n = n + (p.$length) >> 0;
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Write }; } $f.$ptr = $ptr; $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.e = e; $f.err = err; $f.i = i; $f.i$1 = i$1; $f.n = n; $f.nn = nn; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.Write = function(p) { return this.$val.Write(p); };
- encoder.ptr.prototype.Close = function() {
- var $ptr, _r, _tuple, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- /* */ if ($interfaceIsEqual(e.err, $ifaceNil) && e.nbuf > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ($interfaceIsEqual(e.err, $ifaceNil) && e.nbuf > 0) { */ case 1:
- e.enc.Encode($subslice(new sliceType(e.out), 0), $subslice(new sliceType(e.buf), 0, e.nbuf));
- e.nbuf = 0;
- _r = e.w.Write($subslice(new sliceType(e.out), 0, 4)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; e.err = _tuple[1];
- /* } */ case 2:
- return e.err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Close }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- encoder.prototype.Close = function() { return this.$val.Close(); };
- NewEncoder = function(enc, w) {
- var $ptr, enc, w;
- return new encoder.ptr($ifaceNil, enc, w, arrayType.zero(), 0, arrayType$1.zero());
- };
- $pkg.NewEncoder = NewEncoder;
- Encoding.ptr.prototype.EncodedLen = function(n) {
- var $ptr, _q, enc, n;
- enc = this;
- return (_q = ((n + 2 >> 0)) / 3, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) * 4 >> 0;
- };
- Encoding.prototype.EncodedLen = function(n) { return this.$val.EncodedLen(n); };
- CorruptInputError.prototype.Error = function() {
- var $ptr, e;
- e = this;
- return "illegal base64 data at input byte " + strconv.FormatInt(new $Int64(e.$high, e.$low), 10);
- };
- $ptrType(CorruptInputError).prototype.Error = function() { return this.$get().Error(); };
- Encoding.ptr.prototype.decode = function(dst, src) {
- var $ptr, _i, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dbuf, dlen, dst, enc, end, err, in$1, j, n, olen, src, x;
- n = 0;
- end = false;
- err = $ifaceNil;
- enc = this;
- olen = src.$length;
- while (true) {
- if (!(src.$length > 0 && !end)) { break; }
- dbuf = $clone(arrayType$2.zero(), arrayType$2);
- dlen = 4;
- _ref = dbuf;
- _i = 0;
- while (true) {
- if (!(_i < 4)) { break; }
- j = _i;
- if (src.$length === 0) {
- _tmp = n; _tmp$1 = false; _tmp$2 = new CorruptInputError(0, ((olen - src.$length >> 0) - j >> 0)); n = _tmp; end = _tmp$1; err = _tmp$2;
- return [n, end, err];
- }
- in$1 = (0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]);
- src = $subslice(src, 1);
- if (in$1 === 61) {
- _ref$1 = j;
- if (_ref$1 === 0 || _ref$1 === 1) {
- _tmp$3 = n; _tmp$4 = false; _tmp$5 = new CorruptInputError(0, ((olen - src.$length >> 0) - 1 >> 0)); n = _tmp$3; end = _tmp$4; err = _tmp$5;
- return [n, end, err];
- } else if (_ref$1 === 2) {
- if (src.$length === 0) {
- _tmp$6 = n; _tmp$7 = false; _tmp$8 = new CorruptInputError(0, olen); n = _tmp$6; end = _tmp$7; err = _tmp$8;
- return [n, end, err];
- }
- if (!(((0 >= src.$length ? $throwRuntimeError("index out of range") : src.$array[src.$offset + 0]) === 61))) {
- _tmp$9 = n; _tmp$10 = false; _tmp$11 = new CorruptInputError(0, ((olen - src.$length >> 0) - 1 >> 0)); n = _tmp$9; end = _tmp$10; err = _tmp$11;
- return [n, end, err];
- }
- src = $subslice(src, 1);
- }
- if (src.$length > 0) {
- err = new CorruptInputError(0, (olen - src.$length >> 0));
- }
- _tmp$12 = j; _tmp$13 = true; dlen = _tmp$12; end = _tmp$13;
- break;
- }
- ((j < 0 || j >= dbuf.length) ? $throwRuntimeError("index out of range") : dbuf[j] = (x = enc.decodeMap, ((in$1 < 0 || in$1 >= x.length) ? $throwRuntimeError("index out of range") : x[in$1])));
- if (((j < 0 || j >= dbuf.length) ? $throwRuntimeError("index out of range") : dbuf[j]) === 255) {
- _tmp$14 = n; _tmp$15 = false; _tmp$16 = new CorruptInputError(0, ((olen - src.$length >> 0) - 1 >> 0)); n = _tmp$14; end = _tmp$15; err = _tmp$16;
- return [n, end, err];
- }
- _i++;
- }
- _ref$2 = dlen;
- if (_ref$2 === 4) {
- (2 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 2] = ((dbuf[2] << 6 << 24 >>> 24) | dbuf[3]) >>> 0);
- (1 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 1] = ((dbuf[1] << 4 << 24 >>> 24) | (dbuf[2] >>> 2 << 24 >>> 24)) >>> 0);
- (0 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 0] = ((dbuf[0] << 2 << 24 >>> 24) | (dbuf[1] >>> 4 << 24 >>> 24)) >>> 0);
- } else if (_ref$2 === 3) {
- (1 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 1] = ((dbuf[1] << 4 << 24 >>> 24) | (dbuf[2] >>> 2 << 24 >>> 24)) >>> 0);
- (0 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 0] = ((dbuf[0] << 2 << 24 >>> 24) | (dbuf[1] >>> 4 << 24 >>> 24)) >>> 0);
- } else if (_ref$2 === 2) {
- (0 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 0] = ((dbuf[0] << 2 << 24 >>> 24) | (dbuf[1] >>> 4 << 24 >>> 24)) >>> 0);
- }
- dst = $subslice(dst, 3);
- n = n + ((dlen - 1 >> 0)) >> 0;
- }
- _tmp$17 = n; _tmp$18 = end; _tmp$19 = err; n = _tmp$17; end = _tmp$18; err = _tmp$19;
- return [n, end, err];
- };
- Encoding.prototype.decode = function(dst, src) { return this.$val.decode(dst, src); };
- Encoding.ptr.prototype.Decode = function(dst, src) {
- var $ptr, _r, _tuple, dst, enc, err, n, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; dst = $f.dst; enc = $f.enc; err = $f.err; n = $f.n; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- enc = this;
- _r = bytes.Map(removeNewlinesMapper, src); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- src = _r;
- _tuple = enc.decode(dst, src); n = _tuple[0]; err = _tuple[2];
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Encoding.ptr.prototype.Decode }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.dst = dst; $f.enc = enc; $f.err = err; $f.n = n; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- Encoding.prototype.Decode = function(dst, src) { return this.$val.Decode(dst, src); };
- Encoding.ptr.prototype.DecodeString = function(s) {
- var $ptr, _r, _tuple, dbuf, enc, err, n, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; dbuf = $f.dbuf; enc = $f.enc; err = $f.err; n = $f.n; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- enc = this;
- _r = strings.Map(removeNewlinesMapper, s); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- s = _r;
- dbuf = $makeSlice(sliceType, enc.DecodedLen(s.length));
- _tuple = enc.decode(dbuf, new sliceType($stringToBytes(s))); n = _tuple[0]; err = _tuple[2];
- return [$subslice(dbuf, 0, n), err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Encoding.ptr.prototype.DecodeString }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.dbuf = dbuf; $f.enc = enc; $f.err = err; $f.n = n; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Encoding.prototype.DecodeString = function(s) { return this.$val.DecodeString(s); };
- Encoding.ptr.prototype.DecodedLen = function(n) {
- var $ptr, _q, enc, n;
- enc = this;
- return (_q = n / 4, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) * 3 >> 0;
- };
- Encoding.prototype.DecodedLen = function(n) { return this.$val.DecodedLen(n); };
- ptrType.methods = [{prop: "Encode", name: "Encode", pkg: "", typ: $funcType([sliceType, sliceType], [], false)}, {prop: "EncodeToString", name: "EncodeToString", pkg: "", typ: $funcType([sliceType], [$String], false)}, {prop: "EncodedLen", name: "EncodedLen", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "decode", name: "decode", pkg: "encoding/base64", typ: $funcType([sliceType, sliceType], [$Int, $Bool, $error], false)}, {prop: "Decode", name: "Decode", pkg: "", typ: $funcType([sliceType, sliceType], [$Int, $error], false)}, {prop: "DecodeString", name: "DecodeString", pkg: "", typ: $funcType([$String], [sliceType, $error], false)}, {prop: "DecodedLen", name: "DecodedLen", pkg: "", typ: $funcType([$Int], [$Int], false)}];
- ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}];
- CorruptInputError.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- Encoding.init([{prop: "encode", name: "encode", pkg: "encoding/base64", typ: $String, tag: ""}, {prop: "decodeMap", name: "decodeMap", pkg: "encoding/base64", typ: arrayType$4, tag: ""}]);
- encoder.init([{prop: "err", name: "err", pkg: "encoding/base64", typ: $error, tag: ""}, {prop: "enc", name: "enc", pkg: "encoding/base64", typ: ptrType, tag: ""}, {prop: "w", name: "w", pkg: "encoding/base64", typ: io.Writer, tag: ""}, {prop: "buf", name: "buf", pkg: "encoding/base64", typ: arrayType, tag: ""}, {prop: "nbuf", name: "nbuf", pkg: "encoding/base64", typ: $Int, tag: ""}, {prop: "out", name: "out", pkg: "encoding/base64", typ: arrayType$1, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.StdEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
- $pkg.URLEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
- removeNewlinesMapper = (function(r) {
- var $ptr, r;
- if ((r === 13) || (r === 10)) {
- return -1;
- }
- return r;
- });
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["sort"] = (function() {
- var $pkg = {}, $init, StringSlice, sliceType$2, Search, SearchStrings, min, insertionSort, siftDown, heapSort, medianOfThree, swapRange, doPivot, quickSort, Sort, IsSorted, Strings;
- StringSlice = $pkg.StringSlice = $newType(12, $kindSlice, "sort.StringSlice", "StringSlice", "sort", null);
- sliceType$2 = $sliceType($String);
- Search = function(n, f) {
- var $ptr, _q, _r, _tmp, _tmp$1, f, h, i, j, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; f = $f.f; h = $f.h; i = $f.i; j = $f.j; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tmp = 0; _tmp$1 = n; i = _tmp; j = _tmp$1;
- /* while (true) { */ case 1:
- /* if (!(i < j)) { break; } */ if(!(i < j)) { $s = 2; continue; }
- h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- _r = f(h); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!_r) { */ case 3:
- i = h + 1 >> 0;
- $s = 5; continue;
- /* } else { */ case 4:
- j = h;
- /* } */ case 5:
- /* } */ $s = 1; continue; case 2:
- return i;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Search }; } $f.$ptr = $ptr; $f._q = _q; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.f = f; $f.h = h; $f.i = i; $f.j = j; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Search = Search;
- SearchStrings = function(a, x) {
- var $ptr, _r, a, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; a = $f.a; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = [a];
- x = [x];
- _r = Search(a[0].$length, (function(a, x) { return function(i) {
- var $ptr, i;
- return ((i < 0 || i >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + i]) >= x[0];
- }; })(a, x)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SearchStrings }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.SearchStrings = SearchStrings;
- StringSlice.prototype.Search = function(x) {
- var $ptr, _r, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = SearchStrings($subslice(new sliceType$2(p.$array), p.$offset, p.$offset + p.$length), x); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StringSlice.prototype.Search }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(StringSlice).prototype.Search = function(x) { return this.$get().Search(x); };
- min = function(a, b) {
- var $ptr, a, b;
- if (a < b) {
- return a;
- }
- return b;
- };
- insertionSort = function(data, a, b) {
- var $ptr, _r, _v, a, b, data, i, j, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _v = $f._v; a = $f.a; b = $f.b; data = $f.data; i = $f.i; j = $f.j; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = a + 1 >> 0;
- /* while (true) { */ case 1:
- /* if (!(i < b)) { break; } */ if(!(i < b)) { $s = 2; continue; }
- j = i;
- /* while (true) { */ case 3:
- if (!(j > a)) { _v = false; $s = 5; continue s; }
- _r = data.Less(j, j - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 5:
- /* if (!(_v)) { break; } */ if(!(_v)) { $s = 4; continue; }
- $r = data.Swap(j, j - 1 >> 0); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- j = j - (1) >> 0;
- /* } */ $s = 3; continue; case 4:
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: insertionSort }; } $f.$ptr = $ptr; $f._r = _r; $f._v = _v; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.j = j; $f.$s = $s; $f.$r = $r; return $f;
- };
- siftDown = function(data, lo, hi, first) {
- var $ptr, _r, _r$1, _v, child, data, first, hi, lo, root, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; child = $f.child; data = $f.data; first = $f.first; hi = $f.hi; lo = $f.lo; root = $f.root; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- root = lo;
- /* while (true) { */ case 1:
- child = (2 * root >> 0) + 1 >> 0;
- if (child >= hi) {
- /* break; */ $s = 2; continue;
- }
- if (!((child + 1 >> 0) < hi)) { _v = false; $s = 5; continue s; }
- _r = data.Less(first + child >> 0, (first + child >> 0) + 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 5:
- /* */ if (_v) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_v) { */ case 3:
- child = child + (1) >> 0;
- /* } */ case 4:
- _r$1 = data.Less(first + root >> 0, first + child >> 0); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!_r$1) { */ case 7:
- return;
- /* } */ case 8:
- $r = data.Swap(first + root >> 0, first + child >> 0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- root = child;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: siftDown }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.child = child; $f.data = data; $f.first = first; $f.hi = hi; $f.lo = lo; $f.root = root; $f.$s = $s; $f.$r = $r; return $f;
- };
- heapSort = function(data, a, b) {
- var $ptr, _q, a, b, data, first, hi, i, i$1, lo, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; a = $f.a; b = $f.b; data = $f.data; first = $f.first; hi = $f.hi; i = $f.i; i$1 = $f.i$1; lo = $f.lo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- first = a;
- lo = 0;
- hi = b - a >> 0;
- i = (_q = ((hi - 1 >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- /* while (true) { */ case 1:
- /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 2; continue; }
- $r = siftDown(data, i, hi, first); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i - (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- i$1 = hi - 1 >> 0;
- /* while (true) { */ case 4:
- /* if (!(i$1 >= 0)) { break; } */ if(!(i$1 >= 0)) { $s = 5; continue; }
- $r = data.Swap(first, first + i$1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = siftDown(data, lo, i$1, first); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$1 = i$1 - (1) >> 0;
- /* } */ $s = 4; continue; case 5:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: heapSort }; } $f.$ptr = $ptr; $f._q = _q; $f.a = a; $f.b = b; $f.data = data; $f.first = first; $f.hi = hi; $f.i = i; $f.i$1 = i$1; $f.lo = lo; $f.$s = $s; $f.$r = $r; return $f;
- };
- medianOfThree = function(data, a, b, c) {
- var $ptr, _r, _r$1, _r$2, a, b, c, data, m0, m1, m2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; a = $f.a; b = $f.b; c = $f.c; data = $f.data; m0 = $f.m0; m1 = $f.m1; m2 = $f.m2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m0 = b;
- m1 = a;
- m2 = c;
- _r = data.Less(m1, m0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r) { */ case 1:
- $r = data.Swap(m1, m0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- _r$1 = data.Less(m2, m1); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_r$1) { */ case 5:
- $r = data.Swap(m2, m1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- _r$2 = data.Less(m1, m0); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_r$2) { */ case 9:
- $r = data.Swap(m1, m0); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: medianOfThree }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.a = a; $f.b = b; $f.c = c; $f.data = data; $f.m0 = m0; $f.m1 = m1; $f.m2 = m2; $f.$s = $s; $f.$r = $r; return $f;
- };
- swapRange = function(data, a, b, n) {
- var $ptr, a, b, data, i, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; a = $f.a; b = $f.b; data = $f.data; i = $f.i; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; }
- $r = data.Swap(a + i >> 0, b + i >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: swapRange }; } $f.$ptr = $ptr; $f.a = a; $f.b = b; $f.data = data; $f.i = i; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- doPivot = function(data, lo, hi) {
- var $ptr, _q, _q$1, _r, _r$1, _r$2, _r$3, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, a, b, c, d, data, hi, lo, m, midhi, midlo, n, pivot, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _q$1 = $f._q$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; a = $f.a; b = $f.b; c = $f.c; d = $f.d; data = $f.data; hi = $f.hi; lo = $f.lo; m = $f.m; midhi = $f.midhi; midlo = $f.midlo; n = $f.n; pivot = $f.pivot; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- midlo = 0;
- midhi = 0;
- m = lo + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- /* */ if ((hi - lo >> 0) > 40) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((hi - lo >> 0) > 40) { */ case 1:
- s = (_q$1 = ((hi - lo >> 0)) / 8, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"));
- $r = medianOfThree(data, lo, lo + s >> 0, lo + (2 * s >> 0) >> 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = medianOfThree(data, m, m - s >> 0, m + s >> 0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = medianOfThree(data, hi - 1 >> 0, (hi - 1 >> 0) - s >> 0, (hi - 1 >> 0) - (2 * s >> 0) >> 0); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- $r = medianOfThree(data, lo, m, hi - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- pivot = lo;
- _tmp = lo + 1 >> 0; _tmp$1 = lo + 1 >> 0; _tmp$2 = hi; _tmp$3 = hi; a = _tmp; b = _tmp$1; c = _tmp$2; d = _tmp$3;
- /* while (true) { */ case 7:
- /* while (true) { */ case 9:
- /* if (!(b < c)) { break; } */ if(!(b < c)) { $s = 10; continue; }
- _r = data.Less(b, pivot); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 11; continue; }
- _r$1 = data.Less(pivot, b); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (_r) { */ case 11:
- b = b + (1) >> 0;
- $s = 14; continue;
- /* } else if (!_r$1) { */ case 12:
- $r = data.Swap(a, b); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- a = a + (1) >> 0;
- b = b + (1) >> 0;
- $s = 14; continue;
- /* } else { */ case 13:
- /* break; */ $s = 10; continue;
- /* } */ case 14:
- /* } */ $s = 9; continue; case 10:
- /* while (true) { */ case 18:
- /* if (!(b < c)) { break; } */ if(!(b < c)) { $s = 19; continue; }
- _r$2 = data.Less(pivot, c - 1 >> 0); /* */ $s = 24; case 24: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 20; continue; }
- _r$3 = data.Less(c - 1 >> 0, pivot); /* */ $s = 25; case 25: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!_r$3) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (_r$2) { */ case 20:
- c = c - (1) >> 0;
- $s = 23; continue;
- /* } else if (!_r$3) { */ case 21:
- $r = data.Swap(c - 1 >> 0, d - 1 >> 0); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- c = c - (1) >> 0;
- d = d - (1) >> 0;
- $s = 23; continue;
- /* } else { */ case 22:
- /* break; */ $s = 19; continue;
- /* } */ case 23:
- /* } */ $s = 18; continue; case 19:
- if (b >= c) {
- /* break; */ $s = 8; continue;
- }
- $r = data.Swap(b, c - 1 >> 0); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- b = b + (1) >> 0;
- c = c - (1) >> 0;
- /* } */ $s = 7; continue; case 8:
- n = min(b - a >> 0, a - lo >> 0);
- $r = swapRange(data, lo, b - n >> 0, n); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = min(hi - d >> 0, d - c >> 0);
- $r = swapRange(data, c, hi - n >> 0, n); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tmp$4 = (lo + b >> 0) - a >> 0; _tmp$5 = hi - ((d - c >> 0)) >> 0; midlo = _tmp$4; midhi = _tmp$5;
- return [midlo, midhi];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: doPivot }; } $f.$ptr = $ptr; $f._q = _q; $f._q$1 = _q$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f.a = a; $f.b = b; $f.c = c; $f.d = d; $f.data = data; $f.hi = hi; $f.lo = lo; $f.m = m; $f.midhi = midhi; $f.midlo = midlo; $f.n = n; $f.pivot = pivot; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- quickSort = function(data, a, b, maxDepth) {
- var $ptr, _r, _tuple, a, b, data, maxDepth, mhi, mlo, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; a = $f.a; b = $f.b; data = $f.data; maxDepth = $f.maxDepth; mhi = $f.mhi; mlo = $f.mlo; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* while (true) { */ case 1:
- /* if (!((b - a >> 0) > 7)) { break; } */ if(!((b - a >> 0) > 7)) { $s = 2; continue; }
- /* */ if (maxDepth === 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (maxDepth === 0) { */ case 3:
- $r = heapSort(data, a, b); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 4:
- maxDepth = maxDepth - (1) >> 0;
- _r = doPivot(data, a, b); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; mlo = _tuple[0]; mhi = _tuple[1];
- /* */ if ((mlo - a >> 0) < (b - mhi >> 0)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if ((mlo - a >> 0) < (b - mhi >> 0)) { */ case 7:
- $r = quickSort(data, a, mlo, maxDepth); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- a = mhi;
- $s = 9; continue;
- /* } else { */ case 8:
- $r = quickSort(data, mhi, b, maxDepth); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- b = mlo;
- /* } */ case 9:
- /* } */ $s = 1; continue; case 2:
- /* */ if ((b - a >> 0) > 1) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ((b - a >> 0) > 1) { */ case 12:
- $r = insertionSort(data, a, b); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 13:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: quickSort }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.a = a; $f.b = b; $f.data = data; $f.maxDepth = maxDepth; $f.mhi = mhi; $f.mlo = mlo; $f.$s = $s; $f.$r = $r; return $f;
- };
- Sort = function(data) {
- var $ptr, _r, data, i, maxDepth, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; data = $f.data; i = $f.i; maxDepth = $f.maxDepth; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = data.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n = _r;
- maxDepth = 0;
- i = n;
- while (true) {
- if (!(i > 0)) { break; }
- maxDepth = maxDepth + (1) >> 0;
- i = (i >> $min((1), 31)) >> 0;
- }
- maxDepth = maxDepth * (2) >> 0;
- $r = quickSort(data, 0, n, maxDepth); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Sort }; } $f.$ptr = $ptr; $f._r = _r; $f.data = data; $f.i = i; $f.maxDepth = maxDepth; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Sort = Sort;
- IsSorted = function(data) {
- var $ptr, _r, _r$1, data, i, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; data = $f.data; i = $f.i; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = data.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n = _r;
- i = n - 1 >> 0;
- /* while (true) { */ case 2:
- /* if (!(i > 0)) { break; } */ if(!(i > 0)) { $s = 3; continue; }
- _r$1 = data.Less(i, i - 1 >> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_r$1) { */ case 4:
- return false;
- /* } */ case 5:
- i = i - (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: IsSorted }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.data = data; $f.i = i; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.IsSorted = IsSorted;
- StringSlice.prototype.Len = function() {
- var $ptr, p;
- p = this;
- return p.$length;
- };
- $ptrType(StringSlice).prototype.Len = function() { return this.$get().Len(); };
- StringSlice.prototype.Less = function(i, j) {
- var $ptr, i, j, p;
- p = this;
- return ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j]);
- };
- $ptrType(StringSlice).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- StringSlice.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, i, j, p;
- p = this;
- _tmp = ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j]); _tmp$1 = ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i]); ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i] = _tmp); ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j] = _tmp$1);
- };
- $ptrType(StringSlice).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- StringSlice.prototype.Sort = function() {
- var $ptr, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = Sort(p); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StringSlice.prototype.Sort }; } $f.$ptr = $ptr; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(StringSlice).prototype.Sort = function() { return this.$get().Sort(); };
- Strings = function(a) {
- var $ptr, a, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; a = $f.a; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = Sort($subslice(new StringSlice(a.$array), a.$offset, a.$offset + a.$length)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Strings }; } $f.$ptr = $ptr; $f.a = a; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Strings = Strings;
- StringSlice.methods = [{prop: "Search", name: "Search", pkg: "", typ: $funcType([$String], [$Int], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Sort", name: "Sort", pkg: "", typ: $funcType([], [], false)}];
- StringSlice.init($String);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["unicode/utf16"] = (function() {
- var $pkg = {}, $init, IsSurrogate, DecodeRune;
- IsSurrogate = function(r) {
- var $ptr, r;
- return 55296 <= r && r < 57344;
- };
- $pkg.IsSurrogate = IsSurrogate;
- DecodeRune = function(r1, r2) {
- var $ptr, r1, r2;
- if (55296 <= r1 && r1 < 56320 && 56320 <= r2 && r2 < 57344) {
- return ((((r1 - 55296 >> 0)) << 10 >> 0) | ((r2 - 56320 >> 0))) + 65536 >> 0;
- }
- return 65533;
- };
- $pkg.DecodeRune = DecodeRune;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["encoding/json"] = (function() {
- var $pkg = {}, $init, bytes, encoding, base64, errors, fmt, nosync, io, math, reflect, runtime, sort, strconv, strings, unicode, utf16, utf8, Unmarshaler, UnmarshalTypeError, InvalidUnmarshalError, Number, decodeState, unquotedValue, Marshaler, UnsupportedTypeError, UnsupportedValueError, MarshalerError, encodeState, encoderFunc, floatEncoder, structEncoder, mapEncoder, sliceEncoder, arrayEncoder, ptrEncoder, condAddrEncoder, stringValues, field, byName, byIndex, SyntaxError, scanner, Decoder, Encoder, tagOptions, mapType, structType, sliceType, mapType$1, structType$1, sliceType$1, ptrType, ptrType$1, ptrType$2, mapType$2, ptrType$3, sliceType$2, arrayType, ptrType$4, sliceType$3, sliceType$4, ptrType$6, ptrType$8, ptrType$9, ptrType$10, ptrType$11, ptrType$13, ptrType$14, ptrType$15, ptrType$16, ptrType$17, ptrType$18, ptrType$19, funcType, ptrType$20, ptrType$21, funcType$1, ptrType$22, ptrType$23, errPhase, nullLiteral, numberType, hex, encodeStatePool, byteSliceType, encoderCache, marshalerType, textMarshalerType, float32Encoder, float64Encoder, fieldCache, _r, _r$1, getu4, unquote, unquoteBytes, Marshal, newEncodeState, isEmptyValue, valueEncoder, typeEncoder, newTypeEncoder, invalidValueEncoder, marshalerEncoder, addrMarshalerEncoder, textMarshalerEncoder, addrTextMarshalerEncoder, boolEncoder, intEncoder, uintEncoder, stringEncoder, interfaceEncoder, unsupportedTypeEncoder, newStructEncoder, newMapEncoder, encodeByteSlice, newSliceEncoder, newArrayEncoder, newPtrEncoder, newCondAddrEncoder, isValidTag, fieldByIndex, typeByIndex, fillField, typeFields, dominantField, cachedTypeFields, foldFunc, equalFoldRight, asciiEqualFold, simpleLetterEqualFold, compact, nextValue, isSpace, stateBeginValueOrEmpty, stateBeginValue, stateBeginStringOrEmpty, stateBeginString, stateEndValue, stateEndTop, stateInString, stateInStringEsc, stateInStringEscU, stateInStringEscU1, stateInStringEscU12, stateInStringEscU123, stateNeg, state1, state0, stateDot, stateDot0, stateE, stateESign, stateE0, stateT, stateTr, stateTru, stateF, stateFa, stateFal, stateFals, stateN, stateNu, stateNul, stateError, quoteChar, stateRedo, NewDecoder, nonSpace, NewEncoder, parseTag;
- bytes = $packages["bytes"];
- encoding = $packages["encoding"];
- base64 = $packages["encoding/base64"];
- errors = $packages["errors"];
- fmt = $packages["fmt"];
- nosync = $packages["github.com/gopherjs/gopherjs/nosync"];
- io = $packages["io"];
- math = $packages["math"];
- reflect = $packages["reflect"];
- runtime = $packages["runtime"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- unicode = $packages["unicode"];
- utf16 = $packages["unicode/utf16"];
- utf8 = $packages["unicode/utf8"];
- Unmarshaler = $pkg.Unmarshaler = $newType(8, $kindInterface, "json.Unmarshaler", "Unmarshaler", "encoding/json", null);
- UnmarshalTypeError = $pkg.UnmarshalTypeError = $newType(0, $kindStruct, "json.UnmarshalTypeError", "UnmarshalTypeError", "encoding/json", function(Value_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Value = "";
- this.Type = $ifaceNil;
- return;
- }
- this.Value = Value_;
- this.Type = Type_;
- });
- InvalidUnmarshalError = $pkg.InvalidUnmarshalError = $newType(0, $kindStruct, "json.InvalidUnmarshalError", "InvalidUnmarshalError", "encoding/json", function(Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Type = $ifaceNil;
- return;
- }
- this.Type = Type_;
- });
- Number = $pkg.Number = $newType(8, $kindString, "json.Number", "Number", "encoding/json", null);
- decodeState = $pkg.decodeState = $newType(0, $kindStruct, "json.decodeState", "decodeState", "encoding/json", function(data_, off_, scan_, nextscan_, savedError_, useNumber_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.data = sliceType$1.nil;
- this.off = 0;
- this.scan = new scanner.ptr();
- this.nextscan = new scanner.ptr();
- this.savedError = $ifaceNil;
- this.useNumber = false;
- return;
- }
- this.data = data_;
- this.off = off_;
- this.scan = scan_;
- this.nextscan = nextscan_;
- this.savedError = savedError_;
- this.useNumber = useNumber_;
- });
- unquotedValue = $pkg.unquotedValue = $newType(0, $kindStruct, "json.unquotedValue", "unquotedValue", "encoding/json", function() {
- this.$val = this;
- if (arguments.length === 0) {
- return;
- }
- });
- Marshaler = $pkg.Marshaler = $newType(8, $kindInterface, "json.Marshaler", "Marshaler", "encoding/json", null);
- UnsupportedTypeError = $pkg.UnsupportedTypeError = $newType(0, $kindStruct, "json.UnsupportedTypeError", "UnsupportedTypeError", "encoding/json", function(Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Type = $ifaceNil;
- return;
- }
- this.Type = Type_;
- });
- UnsupportedValueError = $pkg.UnsupportedValueError = $newType(0, $kindStruct, "json.UnsupportedValueError", "UnsupportedValueError", "encoding/json", function(Value_, Str_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Value = new reflect.Value.ptr();
- this.Str = "";
- return;
- }
- this.Value = Value_;
- this.Str = Str_;
- });
- MarshalerError = $pkg.MarshalerError = $newType(0, $kindStruct, "json.MarshalerError", "MarshalerError", "encoding/json", function(Type_, Err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Type = $ifaceNil;
- this.Err = $ifaceNil;
- return;
- }
- this.Type = Type_;
- this.Err = Err_;
- });
- encodeState = $pkg.encodeState = $newType(0, $kindStruct, "json.encodeState", "encodeState", "encoding/json", function(Buffer_, scratch_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Buffer = new bytes.Buffer.ptr();
- this.scratch = arrayType.zero();
- return;
- }
- this.Buffer = Buffer_;
- this.scratch = scratch_;
- });
- encoderFunc = $pkg.encoderFunc = $newType(4, $kindFunc, "json.encoderFunc", "encoderFunc", "encoding/json", null);
- floatEncoder = $pkg.floatEncoder = $newType(4, $kindInt, "json.floatEncoder", "floatEncoder", "encoding/json", null);
- structEncoder = $pkg.structEncoder = $newType(0, $kindStruct, "json.structEncoder", "structEncoder", "encoding/json", function(fields_, fieldEncs_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.fields = sliceType.nil;
- this.fieldEncs = sliceType$3.nil;
- return;
- }
- this.fields = fields_;
- this.fieldEncs = fieldEncs_;
- });
- mapEncoder = $pkg.mapEncoder = $newType(0, $kindStruct, "json.mapEncoder", "mapEncoder", "encoding/json", function(elemEnc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.elemEnc = $throwNilPointerError;
- return;
- }
- this.elemEnc = elemEnc_;
- });
- sliceEncoder = $pkg.sliceEncoder = $newType(0, $kindStruct, "json.sliceEncoder", "sliceEncoder", "encoding/json", function(arrayEnc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.arrayEnc = $throwNilPointerError;
- return;
- }
- this.arrayEnc = arrayEnc_;
- });
- arrayEncoder = $pkg.arrayEncoder = $newType(0, $kindStruct, "json.arrayEncoder", "arrayEncoder", "encoding/json", function(elemEnc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.elemEnc = $throwNilPointerError;
- return;
- }
- this.elemEnc = elemEnc_;
- });
- ptrEncoder = $pkg.ptrEncoder = $newType(0, $kindStruct, "json.ptrEncoder", "ptrEncoder", "encoding/json", function(elemEnc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.elemEnc = $throwNilPointerError;
- return;
- }
- this.elemEnc = elemEnc_;
- });
- condAddrEncoder = $pkg.condAddrEncoder = $newType(0, $kindStruct, "json.condAddrEncoder", "condAddrEncoder", "encoding/json", function(canAddrEnc_, elseEnc_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.canAddrEnc = $throwNilPointerError;
- this.elseEnc = $throwNilPointerError;
- return;
- }
- this.canAddrEnc = canAddrEnc_;
- this.elseEnc = elseEnc_;
- });
- stringValues = $pkg.stringValues = $newType(12, $kindSlice, "json.stringValues", "stringValues", "encoding/json", null);
- field = $pkg.field = $newType(0, $kindStruct, "json.field", "field", "encoding/json", function(name_, nameBytes_, equalFold_, tag_, index_, typ_, omitEmpty_, quoted_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = "";
- this.nameBytes = sliceType$1.nil;
- this.equalFold = $throwNilPointerError;
- this.tag = false;
- this.index = sliceType$4.nil;
- this.typ = $ifaceNil;
- this.omitEmpty = false;
- this.quoted = false;
- return;
- }
- this.name = name_;
- this.nameBytes = nameBytes_;
- this.equalFold = equalFold_;
- this.tag = tag_;
- this.index = index_;
- this.typ = typ_;
- this.omitEmpty = omitEmpty_;
- this.quoted = quoted_;
- });
- byName = $pkg.byName = $newType(12, $kindSlice, "json.byName", "byName", "encoding/json", null);
- byIndex = $pkg.byIndex = $newType(12, $kindSlice, "json.byIndex", "byIndex", "encoding/json", null);
- SyntaxError = $pkg.SyntaxError = $newType(0, $kindStruct, "json.SyntaxError", "SyntaxError", "encoding/json", function(msg_, Offset_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.msg = "";
- this.Offset = new $Int64(0, 0);
- return;
- }
- this.msg = msg_;
- this.Offset = Offset_;
- });
- scanner = $pkg.scanner = $newType(0, $kindStruct, "json.scanner", "scanner", "encoding/json", function(step_, endTop_, parseState_, err_, redo_, redoCode_, redoState_, bytes_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.step = $throwNilPointerError;
- this.endTop = false;
- this.parseState = sliceType$4.nil;
- this.err = $ifaceNil;
- this.redo = false;
- this.redoCode = 0;
- this.redoState = $throwNilPointerError;
- this.bytes = new $Int64(0, 0);
- return;
- }
- this.step = step_;
- this.endTop = endTop_;
- this.parseState = parseState_;
- this.err = err_;
- this.redo = redo_;
- this.redoCode = redoCode_;
- this.redoState = redoState_;
- this.bytes = bytes_;
- });
- Decoder = $pkg.Decoder = $newType(0, $kindStruct, "json.Decoder", "Decoder", "encoding/json", function(r_, buf_, d_, scan_, err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.r = $ifaceNil;
- this.buf = sliceType$1.nil;
- this.d = new decodeState.ptr();
- this.scan = new scanner.ptr();
- this.err = $ifaceNil;
- return;
- }
- this.r = r_;
- this.buf = buf_;
- this.d = d_;
- this.scan = scan_;
- this.err = err_;
- });
- Encoder = $pkg.Encoder = $newType(0, $kindStruct, "json.Encoder", "Encoder", "encoding/json", function(w_, err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.w = $ifaceNil;
- this.err = $ifaceNil;
- return;
- }
- this.w = w_;
- this.err = err_;
- });
- tagOptions = $pkg.tagOptions = $newType(8, $kindString, "json.tagOptions", "tagOptions", "encoding/json", null);
- mapType = $mapType(reflect.Type, encoderFunc);
- structType = $structType([{prop: "RWMutex", name: "", pkg: "", typ: nosync.RWMutex, tag: ""}, {prop: "m", name: "m", pkg: "encoding/json", typ: mapType, tag: ""}]);
- sliceType = $sliceType(field);
- mapType$1 = $mapType(reflect.Type, sliceType);
- structType$1 = $structType([{prop: "RWMutex", name: "", pkg: "", typ: nosync.RWMutex, tag: ""}, {prop: "m", name: "m", pkg: "encoding/json", typ: mapType$1, tag: ""}]);
- sliceType$1 = $sliceType($Uint8);
- ptrType = $ptrType(Marshaler);
- ptrType$1 = $ptrType(encoding.TextMarshaler);
- ptrType$2 = $ptrType(reflect.rtype);
- mapType$2 = $mapType($String, $emptyInterface);
- ptrType$3 = $ptrType(field);
- sliceType$2 = $sliceType($emptyInterface);
- arrayType = $arrayType($Uint8, 64);
- ptrType$4 = $ptrType(encodeState);
- sliceType$3 = $sliceType(encoderFunc);
- sliceType$4 = $sliceType($Int);
- ptrType$6 = $ptrType(UnmarshalTypeError);
- ptrType$8 = $ptrType(InvalidUnmarshalError);
- ptrType$9 = $ptrType(decodeState);
- ptrType$10 = $ptrType(UnsupportedTypeError);
- ptrType$11 = $ptrType(UnsupportedValueError);
- ptrType$13 = $ptrType(MarshalerError);
- ptrType$14 = $ptrType(structEncoder);
- ptrType$15 = $ptrType(mapEncoder);
- ptrType$16 = $ptrType(sliceEncoder);
- ptrType$17 = $ptrType(arrayEncoder);
- ptrType$18 = $ptrType(ptrEncoder);
- ptrType$19 = $ptrType(condAddrEncoder);
- funcType = $funcType([sliceType$1, sliceType$1], [$Bool], false);
- ptrType$20 = $ptrType(SyntaxError);
- ptrType$21 = $ptrType(scanner);
- funcType$1 = $funcType([ptrType$21, $Int], [$Int], false);
- ptrType$22 = $ptrType(Decoder);
- ptrType$23 = $ptrType(Encoder);
- UnmarshalTypeError.ptr.prototype.Error = function() {
- var $ptr, _r$2, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- _r$2 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return "json: cannot unmarshal " + e.Value + " into Go value of type " + _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: UnmarshalTypeError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- UnmarshalTypeError.prototype.Error = function() { return this.$val.Error(); };
- InvalidUnmarshalError.ptr.prototype.Error = function() {
- var $ptr, _r$2, _r$3, _r$4, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- if ($interfaceIsEqual(e.Type, $ifaceNil)) {
- return "json: Unmarshal(nil)";
- }
- _r$2 = e.Type.Kind(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!((_r$2 === 22))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r$2 === 22))) { */ case 1:
- _r$3 = e.Type.String(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return "json: Unmarshal(non-pointer " + _r$3 + ")";
- /* } */ case 2:
- _r$4 = e.Type.String(); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return "json: Unmarshal(nil " + _r$4 + ")";
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: InvalidUnmarshalError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- InvalidUnmarshalError.prototype.Error = function() { return this.$val.Error(); };
- decodeState.ptr.prototype.unmarshal = function(v) {
- var $ptr, _r$2, d, err, rv, v, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; d = $f.d; err = $f.err; rv = $f.rv; v = $f.v; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- err[0] = $ifaceNil;
- d = this;
- $deferred.push([(function(err) { return function() {
- var $ptr, _tuple, ok, r;
- r = $recover();
- if (!($interfaceIsEqual(r, $ifaceNil))) {
- _tuple = $assertType(r, runtime.Error, true); ok = _tuple[1];
- if (ok) {
- $panic(r);
- }
- err[0] = $assertType(r, $error);
- }
- }; })(err), []]);
- _r$2 = reflect.ValueOf(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- rv = _r$2;
- if (!((rv.Kind() === 22)) || rv.IsNil()) {
- err[0] = new InvalidUnmarshalError.ptr(reflect.TypeOf(v));
- return err[0];
- }
- d.scan.reset();
- $r = d.value(rv); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- err[0] = d.savedError;
- return err[0];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err[0]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.unmarshal }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.d = d; $f.err = err; $f.rv = rv; $f.v = v; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- decodeState.prototype.unmarshal = function(v) { return this.$val.unmarshal(v); };
- Number.prototype.String = function() {
- var $ptr, n;
- n = this.$val;
- return n;
- };
- $ptrType(Number).prototype.String = function() { return new Number(this.$get()).String(); };
- Number.prototype.Float64 = function() {
- var $ptr, n;
- n = this.$val;
- return strconv.ParseFloat(n, 64);
- };
- $ptrType(Number).prototype.Float64 = function() { return new Number(this.$get()).Float64(); };
- Number.prototype.Int64 = function() {
- var $ptr, n;
- n = this.$val;
- return strconv.ParseInt(n, 10, 64);
- };
- $ptrType(Number).prototype.Int64 = function() { return new Number(this.$get()).Int64(); };
- decodeState.ptr.prototype.init = function(data) {
- var $ptr, d, data;
- d = this;
- d.data = data;
- d.off = 0;
- d.savedError = $ifaceNil;
- return d;
- };
- decodeState.prototype.init = function(data) { return this.$val.init(data); };
- decodeState.ptr.prototype.error = function(err) {
- var $ptr, d, err;
- d = this;
- $panic(err);
- };
- decodeState.prototype.error = function(err) { return this.$val.error(err); };
- decodeState.ptr.prototype.saveError = function(err) {
- var $ptr, d, err;
- d = this;
- if ($interfaceIsEqual(d.savedError, $ifaceNil)) {
- d.savedError = err;
- }
- };
- decodeState.prototype.saveError = function(err) { return this.$val.saveError(err); };
- decodeState.ptr.prototype.next = function() {
- var $ptr, _r$2, _r$3, _r$4, _tuple, c, d, err, item, rest, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; c = $f.c; d = $f.d; err = $f.err; item = $f.item; rest = $f.rest; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- c = (x = d.data, x$1 = d.off, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- _r$2 = nextValue($subslice(d.data, d.off), d.nextscan); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; item = _tuple[0]; rest = _tuple[1]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- d.error(err);
- }
- d.off = d.data.$length - rest.$length >> 0;
- /* */ if (c === 123) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (c === 123) { */ case 2:
- _r$3 = d.scan.step(d.scan, 125); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- $s = 4; continue;
- /* } else { */ case 3:
- _r$4 = d.scan.step(d.scan, 93); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- /* } */ case 4:
- return item;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.next }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.c = c; $f.d = d; $f.err = err; $f.item = item; $f.rest = rest; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.next = function() { return this.$val.next(); };
- decodeState.ptr.prototype.scanWhile = function(op) {
- var $ptr, _r$2, _r$3, c, d, newOp, op, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; c = $f.c; d = $f.d; newOp = $f.newOp; op = $f.op; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- newOp = 0;
- /* while (true) { */ case 1:
- /* */ if (d.off >= d.data.$length) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (d.off >= d.data.$length) { */ case 3:
- _r$2 = d.scan.eof(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- newOp = _r$2;
- d.off = d.data.$length + 1 >> 0;
- $s = 5; continue;
- /* } else { */ case 4:
- c = ((x = d.data, x$1 = d.off, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])) >> 0);
- d.off = d.off + (1) >> 0;
- _r$3 = d.scan.step(d.scan, c); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- newOp = _r$3;
- /* } */ case 5:
- if (!((newOp === op))) {
- /* break; */ $s = 2; continue;
- }
- /* } */ $s = 1; continue; case 2:
- return newOp;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.scanWhile }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.c = c; $f.d = d; $f.newOp = newOp; $f.op = op; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.scanWhile = function(op) { return this.$val.scanWhile(op); };
- decodeState.ptr.prototype.value = function(v) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, d, err, n, op, rest, v, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; d = $f.d; err = $f.err; n = $f.n; op = $f.op; rest = $f.rest; v = $f.v; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- v = v;
- /* */ if (!v.IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!v.IsValid()) { */ case 1:
- _r$2 = nextValue($subslice(d.data, d.off), d.nextscan); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; rest = _tuple[1]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- d.error(err);
- }
- d.off = d.data.$length - rest.$length >> 0;
- if (d.scan.redo) {
- d.scan.redo = false;
- d.scan.step = stateBeginValue;
- }
- _r$3 = d.scan.step(d.scan, 34); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- _r$4 = d.scan.step(d.scan, 34); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- n = d.scan.parseState.$length;
- /* */ if (n > 0 && ((x = d.scan.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])) === 0)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (n > 0 && ((x = d.scan.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])) === 0)) { */ case 6:
- _r$5 = d.scan.step(d.scan, 58); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$5;
- _r$6 = d.scan.step(d.scan, 34); /* */ $s = 9; case 9: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- _r$7 = d.scan.step(d.scan, 34); /* */ $s = 10; case 10: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$7;
- _r$8 = d.scan.step(d.scan, 125); /* */ $s = 11; case 11: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$8;
- /* } */ case 7:
- return;
- /* } */ case 2:
- _r$9 = d.scanWhile(9); /* */ $s = 12; case 12: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- op = _r$9;
- _ref = op;
- /* */ if (_ref === 6) { $s = 13; continue; }
- /* */ if (_ref === 2) { $s = 14; continue; }
- /* */ if (_ref === 1) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_ref === 6) { */ case 13:
- $r = d.array(v); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 17; continue;
- /* } else if (_ref === 2) { */ case 14:
- $r = d.object(v); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 17; continue;
- /* } else if (_ref === 1) { */ case 15:
- $r = d.literal(v); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 17; continue;
- /* } else { */ case 16:
- d.error(errPhase);
- /* } */ case 17:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.value }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f.d = d; $f.err = err; $f.n = n; $f.op = op; $f.rest = rest; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.value = function(v) { return this.$val.value(v); };
- decodeState.ptr.prototype.valueQuoted = function() {
- var $ptr, _r$2, _r$3, _ref, _ref$1, d, op, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; d = $f.d; op = $f.op; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- _r$2 = d.scanWhile(9); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- op = _r$2;
- _ref = op;
- /* */ if (_ref === 6) { $s = 2; continue; }
- /* */ if (_ref === 2) { $s = 3; continue; }
- /* */ if (_ref === 1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref === 6) { */ case 2:
- $r = d.array(new reflect.Value.ptr(ptrType$2.nil, 0, 0)); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if (_ref === 2) { */ case 3:
- $r = d.object(new reflect.Value.ptr(ptrType$2.nil, 0, 0)); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if (_ref === 1) { */ case 4:
- _r$3 = d.literalInterface(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _ref$1 = _r$3;
- /* */ if (_ref$1 === $ifaceNil || $assertType(_ref$1, $String, true)[1]) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_ref$1 === $ifaceNil || $assertType(_ref$1, $String, true)[1]) { */ case 10:
- v = _ref$1;
- return v;
- /* } */ case 11:
- $s = 6; continue;
- /* } else { */ case 5:
- d.error(errPhase);
- /* } */ case 6:
- return (x = new unquotedValue.ptr(), new x.constructor.elem(x));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.valueQuoted }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.d = d; $f.op = op; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.valueQuoted = function() { return this.$val.valueQuoted(); };
- decodeState.ptr.prototype.indirect = function(v, decodingNull) {
- var $ptr, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, _v, _v$1, _v$2, d, decodingNull, e, ok, ok$1, u, u$1, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; d = $f.d; decodingNull = $f.decodingNull; e = $f.e; ok = $f.ok; ok$1 = $f.ok$1; u = $f.u; u$1 = $f.u$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- v = v;
- if (!(!((v.Kind() === 22)))) { _v = false; $s = 3; continue s; }
- _r$2 = v.Type().Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = !(_r$2 === ""); case 3:
- /* */ if (_v && v.CanAddr()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v && v.CanAddr()) { */ case 1:
- v = v.Addr();
- /* } */ case 2:
- /* while (true) { */ case 5:
- /* */ if ((v.Kind() === 20) && !v.IsNil()) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if ((v.Kind() === 20) && !v.IsNil()) { */ case 7:
- _r$3 = v.Elem(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- e = _r$3;
- if (!((e.Kind() === 22) && !e.IsNil())) { _v$1 = false; $s = 12; continue s; }
- if (!decodingNull) { _v$2 = true; $s = 13; continue s; }
- _r$4 = e.Elem(); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = _r$4.Kind(); /* */ $s = 15; case 15: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _v$2 = _r$5 === 22; case 13:
- _v$1 = _v$2; case 12:
- /* */ if (_v$1) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_v$1) { */ case 10:
- v = e;
- /* continue; */ $s = 5; continue;
- /* } */ case 11:
- /* } */ case 8:
- if (!((v.Kind() === 22))) {
- /* break; */ $s = 6; continue;
- }
- _r$6 = v.Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = _r$6.Kind(); /* */ $s = 19; case 19: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (!((_r$7 === 22)) && decodingNull && v.CanSet()) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (!((_r$7 === 22)) && decodingNull && v.CanSet()) { */ case 16:
- /* break; */ $s = 6; continue;
- /* } */ case 17:
- /* */ if (v.IsNil()) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (v.IsNil()) { */ case 20:
- _r$8 = v.Type().Elem(); /* */ $s = 22; case 22: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = reflect.New(_r$8); /* */ $s = 23; case 23: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- $r = v.Set(_r$9); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 21:
- _r$10 = v.Type().NumMethod(); /* */ $s = 27; case 27: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- /* */ if (_r$10 > 0) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if (_r$10 > 0) { */ case 25:
- _r$11 = v.Interface(); /* */ $s = 28; case 28: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$11, Unmarshaler, true); u = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (ok) { */ case 29:
- return [u, $ifaceNil, new reflect.Value.ptr(ptrType$2.nil, 0, 0)];
- /* } */ case 30:
- _r$12 = v.Interface(); /* */ $s = 31; case 31: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r$12, encoding.TextUnmarshaler, true); u$1 = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (ok$1) { */ case 32:
- return [$ifaceNil, u$1, new reflect.Value.ptr(ptrType$2.nil, 0, 0)];
- /* } */ case 33:
- /* } */ case 26:
- _r$13 = v.Elem(); /* */ $s = 34; case 34: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- v = _r$13;
- /* } */ $s = 5; continue; case 6:
- return [$ifaceNil, $ifaceNil, v];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.indirect }; } $f.$ptr = $ptr; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.d = d; $f.decodingNull = decodingNull; $f.e = e; $f.ok = ok; $f.ok$1 = ok$1; $f.u = u; $f.u$1 = u$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.indirect = function(v, decodingNull) { return this.$val.indirect(v, decodingNull); };
- decodeState.ptr.prototype.array = function(v) {
- var $ptr, _q, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, d, err, i, newcap, newv, op, pv, u, ut, v, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; d = $f.d; err = $f.err; i = $f.i; newcap = $f.newcap; newv = $f.newv; op = $f.op; pv = $f.pv; u = $f.u; ut = $f.ut; v = $f.v; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- v = v;
- _r$2 = d.indirect(v, false); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; u = _tuple[0]; ut = _tuple[1]; pv = _tuple[2];
- /* */ if (!($interfaceIsEqual(u, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(u, $ifaceNil))) { */ case 2:
- d.off = d.off - (1) >> 0;
- _r$3 = d.next(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = u.UnmarshalJSON(_r$3); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- err = _r$4;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- d.error(err);
- }
- return;
- /* } */ case 3:
- /* */ if (!($interfaceIsEqual(ut, $ifaceNil))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!($interfaceIsEqual(ut, $ifaceNil))) { */ case 6:
- d.saveError(new UnmarshalTypeError.ptr("array", v.Type()));
- d.off = d.off - (1) >> 0;
- _r$5 = d.next(); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$5;
- return;
- /* } */ case 7:
- v = pv;
- _ref = v.Kind();
- /* */ if (_ref === 20) { $s = 9; continue; }
- /* */ if (_ref === 17) { $s = 10; continue; }
- /* */ if (_ref === 23) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* switch (0) { default: if (_ref === 20) { */ case 9:
- /* */ if (v.NumMethod() === 0) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (v.NumMethod() === 0) { */ case 14:
- _r$6 = d.arrayInterface(); /* */ $s = 16; case 16: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = reflect.ValueOf(_r$6); /* */ $s = 17; case 17: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $r = v.Set(_r$7); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 15:
- d.saveError(new UnmarshalTypeError.ptr("array", v.Type()));
- d.off = d.off - (1) >> 0;
- _r$8 = d.next(); /* */ $s = 19; case 19: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$8;
- return;
- $s = 13; continue;
- /* } else if (_ref === 17) { */ case 10:
- $s = 13; continue;
- /* } else if (_ref === 23) { */ case 11:
- /* break; */ $s = 13; continue;
- $s = 13; continue;
- /* } else { */ case 12:
- d.saveError(new UnmarshalTypeError.ptr("array", v.Type()));
- d.off = d.off - (1) >> 0;
- _r$9 = d.next(); /* */ $s = 20; case 20: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$9;
- return;
- /* } } */ case 13:
- i = 0;
- /* while (true) { */ case 21:
- _r$10 = d.scanWhile(9); /* */ $s = 23; case 23: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- op = _r$10;
- if (op === 8) {
- /* break; */ $s = 22; continue;
- }
- d.off = d.off - (1) >> 0;
- d.scan.undo(op);
- /* */ if (v.Kind() === 23) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (v.Kind() === 23) { */ case 24:
- /* */ if (i >= v.Cap()) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (i >= v.Cap()) { */ case 26:
- newcap = v.Cap() + (_q = v.Cap() / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- if (newcap < 4) {
- newcap = 4;
- }
- _r$11 = reflect.MakeSlice(v.Type(), v.Len(), newcap); /* */ $s = 28; case 28: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- newv = _r$11;
- _r$12 = reflect.Copy(newv, v); /* */ $s = 29; case 29: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _r$12;
- $r = v.Set(newv); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 27:
- if (i >= v.Len()) {
- v.SetLen(i + 1 >> 0);
- }
- /* } */ case 25:
- /* */ if (i < v.Len()) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (i < v.Len()) { */ case 31:
- _r$13 = v.Index(i); /* */ $s = 34; case 34: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- $r = d.value(_r$13); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 33; continue;
- /* } else { */ case 32:
- $r = d.value(new reflect.Value.ptr(ptrType$2.nil, 0, 0)); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 33:
- i = i + (1) >> 0;
- _r$14 = d.scanWhile(9); /* */ $s = 37; case 37: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- op = _r$14;
- if (op === 8) {
- /* break; */ $s = 22; continue;
- }
- if (!((op === 7))) {
- d.error(errPhase);
- }
- /* } */ $s = 21; continue; case 22:
- /* */ if (i < v.Len()) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (i < v.Len()) { */ case 38:
- /* */ if (v.Kind() === 17) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if (v.Kind() === 17) { */ case 40:
- _r$15 = v.Type().Elem(); /* */ $s = 43; case 43: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _r$16 = reflect.Zero(_r$15); /* */ $s = 44; case 44: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- z = _r$16;
- /* while (true) { */ case 45:
- /* if (!(i < v.Len())) { break; } */ if(!(i < v.Len())) { $s = 46; continue; }
- _r$17 = v.Index(i); /* */ $s = 47; case 47: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- $r = _r$17.Set(z); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 45; continue; case 46:
- $s = 42; continue;
- /* } else { */ case 41:
- v.SetLen(i);
- /* } */ case 42:
- /* } */ case 39:
- /* */ if ((i === 0) && (v.Kind() === 23)) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if ((i === 0) && (v.Kind() === 23)) { */ case 49:
- _r$18 = reflect.MakeSlice(v.Type(), 0, 0); /* */ $s = 51; case 51: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- $r = v.Set(_r$18); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 50:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.array }; } $f.$ptr = $ptr; $f._q = _q; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f.d = d; $f.err = err; $f.i = i; $f.newcap = newcap; $f.newv = newv; $f.op = op; $f.pv = pv; $f.u = u; $f.ut = ut; $f.v = v; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.array = function(v) { return this.$val.array(v); };
- decodeState.ptr.prototype.object = function(v) {
- var $ptr, _i, _i$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _tuple, _tuple$1, _v, d, destring, elemType, err, f, ff, fields, i, i$1, item, key, kv, mapElem, ok, op, pv, qv, qv$1, qv$2, start, subv, t, u, ut, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; d = $f.d; destring = $f.destring; elemType = $f.elemType; err = $f.err; f = $f.f; ff = $f.ff; fields = $f.fields; i = $f.i; i$1 = $f.i$1; item = $f.item; key = $f.key; kv = $f.kv; mapElem = $f.mapElem; ok = $f.ok; op = $f.op; pv = $f.pv; qv = $f.qv; qv$1 = $f.qv$1; qv$2 = $f.qv$2; start = $f.start; subv = $f.subv; t = $f.t; u = $f.u; ut = $f.ut; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- v = v;
- _r$2 = d.indirect(v, false); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; u = _tuple[0]; ut = _tuple[1]; pv = _tuple[2];
- /* */ if (!($interfaceIsEqual(u, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(u, $ifaceNil))) { */ case 2:
- d.off = d.off - (1) >> 0;
- _r$3 = d.next(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = u.UnmarshalJSON(_r$3); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- err = _r$4;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- d.error(err);
- }
- return;
- /* } */ case 3:
- /* */ if (!($interfaceIsEqual(ut, $ifaceNil))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!($interfaceIsEqual(ut, $ifaceNil))) { */ case 6:
- d.saveError(new UnmarshalTypeError.ptr("object", v.Type()));
- d.off = d.off - (1) >> 0;
- _r$5 = d.next(); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$5;
- return;
- /* } */ case 7:
- v = pv;
- /* */ if ((v.Kind() === 20) && (v.NumMethod() === 0)) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if ((v.Kind() === 20) && (v.NumMethod() === 0)) { */ case 9:
- _r$6 = d.objectInterface(); /* */ $s = 11; case 11: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = reflect.ValueOf(new mapType$2(_r$6)); /* */ $s = 12; case 12: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $r = v.Set(_r$7); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 10:
- _ref = v.Kind();
- /* */ if (_ref === 21) { $s = 14; continue; }
- /* */ if (_ref === 25) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_ref === 21) { */ case 14:
- t = v.Type();
- _r$8 = t.Key(); /* */ $s = 20; case 20: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = _r$8.Kind(); /* */ $s = 21; case 21: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- /* */ if (!((_r$9 === 24))) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!((_r$9 === 24))) { */ case 18:
- d.saveError(new UnmarshalTypeError.ptr("object", v.Type()));
- d.off = d.off - (1) >> 0;
- _r$10 = d.next(); /* */ $s = 22; case 22: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$10;
- return;
- /* } */ case 19:
- /* */ if (v.IsNil()) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (v.IsNil()) { */ case 23:
- _r$11 = reflect.MakeMap(t); /* */ $s = 25; case 25: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- $r = v.Set(_r$11); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 24:
- $s = 17; continue;
- /* } else if (_ref === 25) { */ case 15:
- $s = 17; continue;
- /* } else { */ case 16:
- d.saveError(new UnmarshalTypeError.ptr("object", v.Type()));
- d.off = d.off - (1) >> 0;
- _r$12 = d.next(); /* */ $s = 27; case 27: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _r$12;
- return;
- /* } */ case 17:
- mapElem = new reflect.Value.ptr();
- /* while (true) { */ case 28:
- _r$13 = d.scanWhile(9); /* */ $s = 30; case 30: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- op = _r$13;
- if (op === 5) {
- /* break; */ $s = 29; continue;
- }
- if (!((op === 1))) {
- d.error(errPhase);
- }
- start = d.off - 1 >> 0;
- _r$14 = d.scanWhile(0); /* */ $s = 31; case 31: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- op = _r$14;
- item = $subslice(d.data, start, (d.off - 1 >> 0));
- _tuple$1 = unquoteBytes(item); key = _tuple$1[0]; ok = _tuple$1[1];
- if (!ok) {
- d.error(errPhase);
- }
- subv = new reflect.Value.ptr();
- destring = false;
- /* */ if (v.Kind() === 21) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (v.Kind() === 21) { */ case 32:
- _r$15 = v.Type().Elem(); /* */ $s = 35; case 35: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- elemType = _r$15;
- /* */ if (!mapElem.IsValid()) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (!mapElem.IsValid()) { */ case 36:
- _r$16 = reflect.New(elemType); /* */ $s = 39; case 39: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _r$17 = _r$16.Elem(); /* */ $s = 40; case 40: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- mapElem = _r$17;
- $s = 38; continue;
- /* } else { */ case 37:
- _r$18 = reflect.Zero(elemType); /* */ $s = 41; case 41: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- $r = mapElem.Set(_r$18); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 38:
- subv = mapElem;
- $s = 34; continue;
- /* } else { */ case 33:
- f = ptrType$3.nil;
- _r$19 = cachedTypeFields(v.Type()); /* */ $s = 43; case 43: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- fields = _r$19;
- _ref$1 = fields;
- _i = 0;
- /* while (true) { */ case 44:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 45; continue; }
- i = _i;
- ff = ((i < 0 || i >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + i]);
- if (bytes.Equal(ff.nameBytes, key)) {
- f = ff;
- /* break; */ $s = 45; continue;
- }
- if (!(f === ptrType$3.nil)) { _v = false; $s = 48; continue s; }
- _r$20 = ff.equalFold(ff.nameBytes, key); /* */ $s = 49; case 49: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- _v = _r$20; case 48:
- /* */ if (_v) { $s = 46; continue; }
- /* */ $s = 47; continue;
- /* if (_v) { */ case 46:
- f = ff;
- /* } */ case 47:
- _i++;
- /* } */ $s = 44; continue; case 45:
- /* */ if (!(f === ptrType$3.nil)) { $s = 50; continue; }
- /* */ $s = 51; continue;
- /* if (!(f === ptrType$3.nil)) { */ case 50:
- subv = v;
- destring = f.quoted;
- _ref$2 = f.index;
- _i$1 = 0;
- /* while (true) { */ case 52:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 53; continue; }
- i$1 = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- /* */ if (subv.Kind() === 22) { $s = 54; continue; }
- /* */ $s = 55; continue;
- /* if (subv.Kind() === 22) { */ case 54:
- /* */ if (subv.IsNil()) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if (subv.IsNil()) { */ case 56:
- _r$21 = subv.Type().Elem(); /* */ $s = 58; case 58: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- _r$22 = reflect.New(_r$21); /* */ $s = 59; case 59: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- $r = subv.Set(_r$22); /* */ $s = 60; case 60: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 57:
- _r$23 = subv.Elem(); /* */ $s = 61; case 61: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- subv = _r$23;
- /* } */ case 55:
- _r$24 = subv.Field(i$1); /* */ $s = 62; case 62: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- subv = _r$24;
- _i$1++;
- /* } */ $s = 52; continue; case 53:
- /* } */ case 51:
- /* } */ case 34:
- /* */ if (op === 9) { $s = 63; continue; }
- /* */ $s = 64; continue;
- /* if (op === 9) { */ case 63:
- _r$25 = d.scanWhile(9); /* */ $s = 65; case 65: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- op = _r$25;
- /* } */ case 64:
- if (!((op === 3))) {
- d.error(errPhase);
- }
- /* */ if (destring) { $s = 66; continue; }
- /* */ $s = 67; continue;
- /* if (destring) { */ case 66:
- _r$26 = d.valueQuoted(); /* */ $s = 69; case 69: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _ref$3 = _r$26;
- /* */ if (_ref$3 === $ifaceNil) { $s = 70; continue; }
- /* */ if ($assertType(_ref$3, $String, true)[1]) { $s = 71; continue; }
- /* */ $s = 72; continue;
- /* if (_ref$3 === $ifaceNil) { */ case 70:
- qv = _ref$3;
- $r = d.literalStore(nullLiteral, subv, false); /* */ $s = 74; case 74: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 73; continue;
- /* } else if ($assertType(_ref$3, $String, true)[1]) { */ case 71:
- qv$1 = _ref$3.$val;
- $r = d.literalStore(new sliceType$1($stringToBytes(qv$1)), subv, true); /* */ $s = 75; case 75: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 73; continue;
- /* } else { */ case 72:
- qv$2 = _ref$3;
- _r$27 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", new sliceType$2([item, v.Type()])); /* */ $s = 76; case 76: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- $r = d.saveError(_r$27); /* */ $s = 77; case 77: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 73:
- $s = 68; continue;
- /* } else { */ case 67:
- $r = d.value(subv); /* */ $s = 78; case 78: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 68:
- /* */ if (v.Kind() === 21) { $s = 79; continue; }
- /* */ $s = 80; continue;
- /* if (v.Kind() === 21) { */ case 79:
- _r$28 = reflect.ValueOf(key); /* */ $s = 81; case 81: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _r$29 = v.Type().Key(); /* */ $s = 82; case 82: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _r$30 = _r$28.Convert(_r$29); /* */ $s = 83; case 83: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- kv = _r$30;
- $r = v.SetMapIndex(kv, subv); /* */ $s = 84; case 84: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 80:
- _r$31 = d.scanWhile(9); /* */ $s = 85; case 85: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- op = _r$31;
- if (op === 5) {
- /* break; */ $s = 29; continue;
- }
- if (!((op === 4))) {
- d.error(errPhase);
- }
- /* } */ $s = 28; continue; case 29:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.object }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f.d = d; $f.destring = destring; $f.elemType = elemType; $f.err = err; $f.f = f; $f.ff = ff; $f.fields = fields; $f.i = i; $f.i$1 = i$1; $f.item = item; $f.key = key; $f.kv = kv; $f.mapElem = mapElem; $f.ok = ok; $f.op = op; $f.pv = pv; $f.qv = qv; $f.qv$1 = qv$1; $f.qv$2 = qv$2; $f.start = start; $f.subv = subv; $f.t = t; $f.u = u; $f.ut = ut; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.object = function(v) { return this.$val.object(v); };
- decodeState.ptr.prototype.literal = function(v) {
- var $ptr, _r$2, d, op, start, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; d = $f.d; op = $f.op; start = $f.start; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- v = v;
- start = d.off - 1 >> 0;
- _r$2 = d.scanWhile(0); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- op = _r$2;
- d.off = d.off - (1) >> 0;
- d.scan.undo(op);
- $r = d.literalStore($subslice(d.data, start, d.off), v, false); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.literal }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.d = d; $f.op = op; $f.start = start; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.literal = function(v) { return this.$val.literal(v); };
- decodeState.ptr.prototype.convertNumber = function(s) {
- var $ptr, _tuple, d, err, f, s;
- d = this;
- if (d.useNumber) {
- return [new Number(s), $ifaceNil];
- }
- _tuple = strconv.ParseFloat(s, 64); f = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [$ifaceNil, new UnmarshalTypeError.ptr("number " + s, reflect.TypeOf(new $Float64(0)))];
- }
- return [new $Float64(f), $ifaceNil];
- };
- decodeState.prototype.convertNumber = function(s) { return this.$val.convertNumber(s); };
- decodeState.ptr.prototype.literalStore = function(item, v, fromQuoted) {
- var $ptr, _arg, _arg$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, b, c, d, err, err$1, err$2, err$3, err$4, err$5, err$6, fromQuoted, item, n, n$1, n$2, n$3, n$4, ok, ok$1, pv, s, s$1, s$2, u, ut, v, value, wantptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; b = $f.b; c = $f.c; d = $f.d; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; err$3 = $f.err$3; err$4 = $f.err$4; err$5 = $f.err$5; err$6 = $f.err$6; fromQuoted = $f.fromQuoted; item = $f.item; n = $f.n; n$1 = $f.n$1; n$2 = $f.n$2; n$3 = $f.n$3; n$4 = $f.n$4; ok = $f.ok; ok$1 = $f.ok$1; pv = $f.pv; s = $f.s; s$1 = $f.s$1; s$2 = $f.s$2; u = $f.u; ut = $f.ut; v = $f.v; value = $f.value; wantptr = $f.wantptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- v = v;
- /* */ if (item.$length === 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (item.$length === 0) { */ case 1:
- _r$2 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", new sliceType$2([item, v.Type()])); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = d.saveError(_r$2); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- wantptr = (0 >= item.$length ? $throwRuntimeError("index out of range") : item.$array[item.$offset + 0]) === 110;
- _r$3 = d.indirect(v, wantptr); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; u = _tuple[0]; ut = _tuple[1]; pv = _tuple[2];
- /* */ if (!($interfaceIsEqual(u, $ifaceNil))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!($interfaceIsEqual(u, $ifaceNil))) { */ case 6:
- _r$4 = u.UnmarshalJSON(item); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- err = _r$4;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- d.error(err);
- }
- return;
- /* } */ case 7:
- /* */ if (!($interfaceIsEqual(ut, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(ut, $ifaceNil))) { */ case 9:
- /* */ if (!(((0 >= item.$length ? $throwRuntimeError("index out of range") : item.$array[item.$offset + 0]) === 34))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!(((0 >= item.$length ? $throwRuntimeError("index out of range") : item.$array[item.$offset + 0]) === 34))) { */ case 11:
- /* */ if (fromQuoted) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (fromQuoted) { */ case 13:
- _r$5 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", new sliceType$2([item, v.Type()])); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = d.saveError(_r$5); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 15; continue;
- /* } else { */ case 14:
- d.saveError(new UnmarshalTypeError.ptr("string", v.Type()));
- /* } */ case 15:
- /* } */ case 12:
- _tuple$1 = unquoteBytes(item); s = _tuple$1[0]; ok = _tuple$1[1];
- /* */ if (!ok) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!ok) { */ case 18:
- /* */ if (fromQuoted) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (fromQuoted) { */ case 20:
- _r$6 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", new sliceType$2([item, v.Type()])); /* */ $s = 23; case 23: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = d.error(_r$6); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 22; continue;
- /* } else { */ case 21:
- d.error(errPhase);
- /* } */ case 22:
- /* } */ case 19:
- _r$7 = ut.UnmarshalText(s); /* */ $s = 25; case 25: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- err$1 = _r$7;
- if (!($interfaceIsEqual(err$1, $ifaceNil))) {
- d.error(err$1);
- }
- return;
- /* } */ case 10:
- v = pv;
- c = (0 >= item.$length ? $throwRuntimeError("index out of range") : item.$array[item.$offset + 0]);
- _ref = c;
- /* */ if (_ref === 110) { $s = 26; continue; }
- /* */ if (_ref === 116 || _ref === 102) { $s = 27; continue; }
- /* */ if (_ref === 34) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (_ref === 110) { */ case 26:
- _ref$1 = v.Kind();
- /* */ if (_ref$1 === 20 || _ref$1 === 22 || _ref$1 === 21 || _ref$1 === 23) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (_ref$1 === 20 || _ref$1 === 22 || _ref$1 === 21 || _ref$1 === 23) { */ case 31:
- _r$8 = reflect.Zero(v.Type()); /* */ $s = 33; case 33: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- $r = v.Set(_r$8); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 32:
- $s = 30; continue;
- /* } else if (_ref === 116 || _ref === 102) { */ case 27:
- value = c === 116;
- _ref$2 = v.Kind();
- /* */ if (_ref$2 === 1) { $s = 35; continue; }
- /* */ if (_ref$2 === 20) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (_ref$2 === 1) { */ case 35:
- v.SetBool(value);
- $s = 38; continue;
- /* } else if (_ref$2 === 20) { */ case 36:
- /* */ if (v.NumMethod() === 0) { $s = 39; continue; }
- /* */ $s = 40; continue;
- /* if (v.NumMethod() === 0) { */ case 39:
- _r$9 = reflect.ValueOf(new $Bool(value)); /* */ $s = 42; case 42: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- $r = v.Set(_r$9); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 41; continue;
- /* } else { */ case 40:
- d.saveError(new UnmarshalTypeError.ptr("bool", v.Type()));
- /* } */ case 41:
- $s = 38; continue;
- /* } else { */ case 37:
- /* */ if (fromQuoted) { $s = 44; continue; }
- /* */ $s = 45; continue;
- /* if (fromQuoted) { */ case 44:
- _r$10 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", new sliceType$2([item, v.Type()])); /* */ $s = 47; case 47: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- $r = d.saveError(_r$10); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 46; continue;
- /* } else { */ case 45:
- d.saveError(new UnmarshalTypeError.ptr("bool", v.Type()));
- /* } */ case 46:
- /* } */ case 38:
- $s = 30; continue;
- /* } else if (_ref === 34) { */ case 28:
- _tuple$2 = unquoteBytes(item); s$1 = _tuple$2[0]; ok$1 = _tuple$2[1];
- /* */ if (!ok$1) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (!ok$1) { */ case 49:
- /* */ if (fromQuoted) { $s = 51; continue; }
- /* */ $s = 52; continue;
- /* if (fromQuoted) { */ case 51:
- _r$11 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", new sliceType$2([item, v.Type()])); /* */ $s = 54; case 54: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- $r = d.error(_r$11); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 53; continue;
- /* } else { */ case 52:
- d.error(errPhase);
- /* } */ case 53:
- /* } */ case 50:
- _ref$3 = v.Kind();
- /* */ if (_ref$3 === 23) { $s = 56; continue; }
- /* */ if (_ref$3 === 24) { $s = 57; continue; }
- /* */ if (_ref$3 === 20) { $s = 58; continue; }
- /* */ $s = 59; continue;
- /* switch (0) { default: if (_ref$3 === 23) { */ case 56:
- if (!($interfaceIsEqual(v.Type(), byteSliceType))) {
- d.saveError(new UnmarshalTypeError.ptr("string", v.Type()));
- /* break; */ $s = 60; continue;
- }
- b = $makeSlice(sliceType$1, base64.StdEncoding.DecodedLen(s$1.$length));
- _r$12 = base64.StdEncoding.Decode(b, s$1); /* */ $s = 61; case 61: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _tuple$3 = _r$12; n = _tuple$3[0]; err$2 = _tuple$3[1];
- if (!($interfaceIsEqual(err$2, $ifaceNil))) {
- d.saveError(err$2);
- /* break; */ $s = 60; continue;
- }
- _r$13 = reflect.ValueOf($subslice(b, 0, n)); /* */ $s = 62; case 62: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- $r = v.Set(_r$13); /* */ $s = 63; case 63: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 60; continue;
- /* } else if (_ref$3 === 24) { */ case 57:
- v.SetString($bytesToString(s$1));
- $s = 60; continue;
- /* } else if (_ref$3 === 20) { */ case 58:
- /* */ if (v.NumMethod() === 0) { $s = 64; continue; }
- /* */ $s = 65; continue;
- /* if (v.NumMethod() === 0) { */ case 64:
- _r$14 = reflect.ValueOf(new $String($bytesToString(s$1))); /* */ $s = 67; case 67: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- $r = v.Set(_r$14); /* */ $s = 68; case 68: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 66; continue;
- /* } else { */ case 65:
- d.saveError(new UnmarshalTypeError.ptr("string", v.Type()));
- /* } */ case 66:
- $s = 60; continue;
- /* } else { */ case 59:
- d.saveError(new UnmarshalTypeError.ptr("string", v.Type()));
- /* } } */ case 60:
- $s = 30; continue;
- /* } else { */ case 29:
- /* */ if (!((c === 45)) && (c < 48 || c > 57)) { $s = 69; continue; }
- /* */ $s = 70; continue;
- /* if (!((c === 45)) && (c < 48 || c > 57)) { */ case 69:
- /* */ if (fromQuoted) { $s = 71; continue; }
- /* */ $s = 72; continue;
- /* if (fromQuoted) { */ case 71:
- _r$15 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", new sliceType$2([item, v.Type()])); /* */ $s = 74; case 74: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- $r = d.error(_r$15); /* */ $s = 75; case 75: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 73; continue;
- /* } else { */ case 72:
- d.error(errPhase);
- /* } */ case 73:
- /* } */ case 70:
- s$2 = $bytesToString(item);
- _ref$4 = v.Kind();
- /* */ if (_ref$4 === 20) { $s = 76; continue; }
- /* */ if (_ref$4 === 2 || _ref$4 === 3 || _ref$4 === 4 || _ref$4 === 5 || _ref$4 === 6) { $s = 77; continue; }
- /* */ if (_ref$4 === 7 || _ref$4 === 8 || _ref$4 === 9 || _ref$4 === 10 || _ref$4 === 11 || _ref$4 === 12) { $s = 78; continue; }
- /* */ if (_ref$4 === 13 || _ref$4 === 14) { $s = 79; continue; }
- /* */ $s = 80; continue;
- /* switch (0) { default: if (_ref$4 === 20) { */ case 76:
- _tuple$4 = d.convertNumber(s$2); n$1 = _tuple$4[0]; err$3 = _tuple$4[1];
- if (!($interfaceIsEqual(err$3, $ifaceNil))) {
- d.saveError(err$3);
- /* break; */ $s = 81; continue;
- }
- if (!((v.NumMethod() === 0))) {
- d.saveError(new UnmarshalTypeError.ptr("number", v.Type()));
- /* break; */ $s = 81; continue;
- }
- _r$16 = reflect.ValueOf(n$1); /* */ $s = 82; case 82: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- $r = v.Set(_r$16); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 81; continue;
- /* } else if (_ref$4 === 2 || _ref$4 === 3 || _ref$4 === 4 || _ref$4 === 5 || _ref$4 === 6) { */ case 77:
- _tuple$5 = strconv.ParseInt(s$2, 10, 64); n$2 = _tuple$5[0]; err$4 = _tuple$5[1];
- if (!($interfaceIsEqual(err$4, $ifaceNil)) || v.OverflowInt(n$2)) {
- d.saveError(new UnmarshalTypeError.ptr("number " + s$2, v.Type()));
- /* break; */ $s = 81; continue;
- }
- v.SetInt(n$2);
- $s = 81; continue;
- /* } else if (_ref$4 === 7 || _ref$4 === 8 || _ref$4 === 9 || _ref$4 === 10 || _ref$4 === 11 || _ref$4 === 12) { */ case 78:
- _tuple$6 = strconv.ParseUint(s$2, 10, 64); n$3 = _tuple$6[0]; err$5 = _tuple$6[1];
- if (!($interfaceIsEqual(err$5, $ifaceNil)) || v.OverflowUint(n$3)) {
- d.saveError(new UnmarshalTypeError.ptr("number " + s$2, v.Type()));
- /* break; */ $s = 81; continue;
- }
- v.SetUint(n$3);
- $s = 81; continue;
- /* } else if (_ref$4 === 13 || _ref$4 === 14) { */ case 79:
- _arg = s$2;
- _r$17 = v.Type().Bits(); /* */ $s = 84; case 84: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _arg$1 = _r$17;
- _r$18 = strconv.ParseFloat(_arg, _arg$1); /* */ $s = 85; case 85: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _tuple$7 = _r$18; n$4 = _tuple$7[0]; err$6 = _tuple$7[1];
- if (!($interfaceIsEqual(err$6, $ifaceNil)) || v.OverflowFloat(n$4)) {
- d.saveError(new UnmarshalTypeError.ptr("number " + s$2, v.Type()));
- /* break; */ $s = 81; continue;
- }
- v.SetFloat(n$4);
- $s = 81; continue;
- /* } else { */ case 80:
- if ((v.Kind() === 24) && $interfaceIsEqual(v.Type(), numberType)) {
- v.SetString(s$2);
- /* break; */ $s = 81; continue;
- }
- /* */ if (fromQuoted) { $s = 86; continue; }
- /* */ $s = 87; continue;
- /* if (fromQuoted) { */ case 86:
- _r$19 = fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", new sliceType$2([item, v.Type()])); /* */ $s = 89; case 89: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- $r = d.error(_r$19); /* */ $s = 90; case 90: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 88; continue;
- /* } else { */ case 87:
- d.error(new UnmarshalTypeError.ptr("number", v.Type()));
- /* } */ case 88:
- /* } } */ case 81:
- /* } */ case 30:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.literalStore }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.b = b; $f.c = c; $f.d = d; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.err$3 = err$3; $f.err$4 = err$4; $f.err$5 = err$5; $f.err$6 = err$6; $f.fromQuoted = fromQuoted; $f.item = item; $f.n = n; $f.n$1 = n$1; $f.n$2 = n$2; $f.n$3 = n$3; $f.n$4 = n$4; $f.ok = ok; $f.ok$1 = ok$1; $f.pv = pv; $f.s = s; $f.s$1 = s$1; $f.s$2 = s$2; $f.u = u; $f.ut = ut; $f.v = v; $f.value = value; $f.wantptr = wantptr; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.literalStore = function(item, v, fromQuoted) { return this.$val.literalStore(item, v, fromQuoted); };
- decodeState.ptr.prototype.valueInterface = function() {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _ref, d, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; d = $f.d; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- _r$2 = d.scanWhile(9); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _ref = _r$2;
- /* */ if (_ref === 6) { $s = 2; continue; }
- /* */ if (_ref === 2) { $s = 3; continue; }
- /* */ if (_ref === 1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref === 6) { */ case 2:
- _r$3 = d.arrayInterface(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 6; continue;
- /* } else if (_ref === 2) { */ case 3:
- _r$4 = d.objectInterface(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return new mapType$2(_r$4);
- $s = 6; continue;
- /* } else if (_ref === 1) { */ case 4:
- _r$5 = d.literalInterface(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- $s = 6; continue;
- /* } else { */ case 5:
- d.error(errPhase);
- $panic(new $String("unreachable"));
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.valueInterface }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.d = d; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.valueInterface = function() { return this.$val.valueInterface(); };
- decodeState.ptr.prototype.arrayInterface = function() {
- var $ptr, _r$2, _r$3, _r$4, d, op, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; d = $f.d; op = $f.op; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- v = $makeSlice(sliceType$2, 0);
- /* while (true) { */ case 1:
- _r$2 = d.scanWhile(9); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- op = _r$2;
- if (op === 8) {
- /* break; */ $s = 2; continue;
- }
- d.off = d.off - (1) >> 0;
- d.scan.undo(op);
- _r$3 = d.valueInterface(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- v = $append(v, _r$3);
- _r$4 = d.scanWhile(9); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- op = _r$4;
- if (op === 8) {
- /* break; */ $s = 2; continue;
- }
- if (!((op === 7))) {
- d.error(errPhase);
- }
- /* } */ $s = 1; continue; case 2:
- return v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.arrayInterface }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.d = d; $f.op = op; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.arrayInterface = function() { return this.$val.arrayInterface(); };
- decodeState.ptr.prototype.objectInterface = function() {
- var $ptr, _key, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, d, item, key, m, ok, op, start, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key = $f._key; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; d = $f.d; item = $f.item; key = $f.key; m = $f.m; ok = $f.ok; op = $f.op; start = $f.start; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- m = new $Map();
- /* while (true) { */ case 1:
- _r$2 = d.scanWhile(9); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- op = _r$2;
- if (op === 5) {
- /* break; */ $s = 2; continue;
- }
- if (!((op === 1))) {
- d.error(errPhase);
- }
- start = d.off - 1 >> 0;
- _r$3 = d.scanWhile(0); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- op = _r$3;
- item = $subslice(d.data, start, (d.off - 1 >> 0));
- _tuple = unquote(item); key = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- d.error(errPhase);
- }
- /* */ if (op === 9) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (op === 9) { */ case 5:
- _r$4 = d.scanWhile(9); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- op = _r$4;
- /* } */ case 6:
- if (!((op === 3))) {
- d.error(errPhase);
- }
- _r$5 = d.valueInterface(); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _key = key; (m || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: _r$5 };
- _r$6 = d.scanWhile(9); /* */ $s = 9; case 9: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- op = _r$6;
- if (op === 5) {
- /* break; */ $s = 2; continue;
- }
- if (!((op === 4))) {
- d.error(errPhase);
- }
- /* } */ $s = 1; continue; case 2:
- return m;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.objectInterface }; } $f.$ptr = $ptr; $f._key = _key; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f.d = d; $f.item = item; $f.key = key; $f.m = m; $f.ok = ok; $f.op = op; $f.start = start; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.objectInterface = function() { return this.$val.objectInterface(); };
- decodeState.ptr.prototype.literalInterface = function() {
- var $ptr, _r$2, _ref, _tuple, _tuple$1, c, d, err, item, n, ok, op, s, start, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; c = $f.c; d = $f.d; err = $f.err; item = $f.item; n = $f.n; ok = $f.ok; op = $f.op; s = $f.s; start = $f.start; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- start = d.off - 1 >> 0;
- _r$2 = d.scanWhile(0); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- op = _r$2;
- d.off = d.off - (1) >> 0;
- d.scan.undo(op);
- item = $subslice(d.data, start, d.off);
- c = (0 >= item.$length ? $throwRuntimeError("index out of range") : item.$array[item.$offset + 0]);
- _ref = c;
- if (_ref === 110) {
- return $ifaceNil;
- } else if (_ref === 116 || _ref === 102) {
- return new $Bool((c === 116));
- } else if (_ref === 34) {
- _tuple = unquote(item); s = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- d.error(errPhase);
- }
- return new $String(s);
- } else {
- if (!((c === 45)) && (c < 48 || c > 57)) {
- d.error(errPhase);
- }
- _tuple$1 = d.convertNumber($bytesToString(item)); n = _tuple$1[0]; err = _tuple$1[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- d.saveError(err);
- }
- return n;
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: decodeState.ptr.prototype.literalInterface }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.c = c; $f.d = d; $f.err = err; $f.item = item; $f.n = n; $f.ok = ok; $f.op = op; $f.s = s; $f.start = start; $f.$s = $s; $f.$r = $r; return $f;
- };
- decodeState.prototype.literalInterface = function() { return this.$val.literalInterface(); };
- getu4 = function(s) {
- var $ptr, _tuple, err, r, s;
- if (s.$length < 6 || !(((0 >= s.$length ? $throwRuntimeError("index out of range") : s.$array[s.$offset + 0]) === 92)) || !(((1 >= s.$length ? $throwRuntimeError("index out of range") : s.$array[s.$offset + 1]) === 117))) {
- return -1;
- }
- _tuple = strconv.ParseUint($bytesToString($subslice(s, 2, 6)), 16, 64); r = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return -1;
- }
- return (r.$low >> 0);
- };
- unquote = function(s) {
- var $ptr, _tuple, ok, s, t;
- t = "";
- ok = false;
- _tuple = unquoteBytes(s); s = _tuple[0]; ok = _tuple[1];
- t = $bytesToString(s);
- return [t, ok];
- };
- unquoteBytes = function(s) {
- var $ptr, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, b, c, c$1, dec, nb, ok, r, rr, rr$1, rr$2, rr1, s, size, size$1, t, w, x;
- t = sliceType$1.nil;
- ok = false;
- if (s.$length < 2 || !(((0 >= s.$length ? $throwRuntimeError("index out of range") : s.$array[s.$offset + 0]) === 34)) || !(((x = s.$length - 1 >> 0, ((x < 0 || x >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + x])) === 34))) {
- return [t, ok];
- }
- s = $subslice(s, 1, (s.$length - 1 >> 0));
- r = 0;
- while (true) {
- if (!(r < s.$length)) { break; }
- c = ((r < 0 || r >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + r]);
- if ((c === 92) || (c === 34) || c < 32) {
- break;
- }
- if (c < 128) {
- r = r + (1) >> 0;
- continue;
- }
- _tuple = utf8.DecodeRune($subslice(s, r)); rr = _tuple[0]; size = _tuple[1];
- if ((rr === 65533) && (size === 1)) {
- break;
- }
- r = r + (size) >> 0;
- }
- if (r === s.$length) {
- _tmp = s; _tmp$1 = true; t = _tmp; ok = _tmp$1;
- return [t, ok];
- }
- b = $makeSlice(sliceType$1, (s.$length + 8 >> 0));
- w = $copySlice(b, $subslice(s, 0, r));
- while (true) {
- if (!(r < s.$length)) { break; }
- if (w >= (b.$length - 8 >> 0)) {
- nb = $makeSlice(sliceType$1, (((b.$length + 4 >> 0)) * 2 >> 0));
- $copySlice(nb, $subslice(b, 0, w));
- b = nb;
- }
- c$1 = ((r < 0 || r >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + r]);
- if (c$1 === 92) {
- r = r + (1) >> 0;
- if (r >= s.$length) {
- return [t, ok];
- }
- _ref = ((r < 0 || r >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + r]);
- switch (0) { default: if (_ref === 34 || _ref === 92 || _ref === 47 || _ref === 39) {
- ((w < 0 || w >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + w] = ((r < 0 || r >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + r]));
- r = r + (1) >> 0;
- w = w + (1) >> 0;
- } else if (_ref === 98) {
- ((w < 0 || w >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + w] = 8);
- r = r + (1) >> 0;
- w = w + (1) >> 0;
- } else if (_ref === 102) {
- ((w < 0 || w >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + w] = 12);
- r = r + (1) >> 0;
- w = w + (1) >> 0;
- } else if (_ref === 110) {
- ((w < 0 || w >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + w] = 10);
- r = r + (1) >> 0;
- w = w + (1) >> 0;
- } else if (_ref === 114) {
- ((w < 0 || w >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + w] = 13);
- r = r + (1) >> 0;
- w = w + (1) >> 0;
- } else if (_ref === 116) {
- ((w < 0 || w >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + w] = 9);
- r = r + (1) >> 0;
- w = w + (1) >> 0;
- } else if (_ref === 117) {
- r = r - (1) >> 0;
- rr$1 = getu4($subslice(s, r));
- if (rr$1 < 0) {
- return [t, ok];
- }
- r = r + (6) >> 0;
- if (utf16.IsSurrogate(rr$1)) {
- rr1 = getu4($subslice(s, r));
- dec = utf16.DecodeRune(rr$1, rr1);
- if (!((dec === 65533))) {
- r = r + (6) >> 0;
- w = w + (utf8.EncodeRune($subslice(b, w), dec)) >> 0;
- break;
- }
- rr$1 = 65533;
- }
- w = w + (utf8.EncodeRune($subslice(b, w), rr$1)) >> 0;
- } else {
- return [t, ok];
- } }
- } else if (c$1 === 34 || c$1 < 32) {
- return [t, ok];
- } else if (c$1 < 128) {
- ((w < 0 || w >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + w] = c$1);
- r = r + (1) >> 0;
- w = w + (1) >> 0;
- } else {
- _tuple$1 = utf8.DecodeRune($subslice(s, r)); rr$2 = _tuple$1[0]; size$1 = _tuple$1[1];
- r = r + (size$1) >> 0;
- w = w + (utf8.EncodeRune($subslice(b, w), rr$2)) >> 0;
- }
- }
- _tmp$2 = $subslice(b, 0, w); _tmp$3 = true; t = _tmp$2; ok = _tmp$3;
- return [t, ok];
- };
- Marshal = function(v) {
- var $ptr, _r$2, e, err, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; err = $f.err; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = new encodeState.ptr(new bytes.Buffer.ptr(), arrayType.zero());
- _r$2 = e.marshal(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- err = _r$2;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [sliceType$1.nil, err];
- }
- return [e.Buffer.Bytes(), $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Marshal }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.err = err; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Marshal = Marshal;
- UnsupportedTypeError.ptr.prototype.Error = function() {
- var $ptr, _r$2, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- _r$2 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return "json: unsupported type: " + _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: UnsupportedTypeError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- UnsupportedTypeError.prototype.Error = function() { return this.$val.Error(); };
- UnsupportedValueError.ptr.prototype.Error = function() {
- var $ptr, e;
- e = this;
- return "json: unsupported value: " + e.Str;
- };
- UnsupportedValueError.prototype.Error = function() { return this.$val.Error(); };
- MarshalerError.ptr.prototype.Error = function() {
- var $ptr, _r$2, _r$3, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- _r$2 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = e.Err.Error(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return "json: error calling MarshalJSON for type " + _r$2 + ": " + _r$3;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: MarshalerError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- MarshalerError.prototype.Error = function() { return this.$val.Error(); };
- newEncodeState = function() {
- var $ptr, _r$2, e, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = encodeStatePool.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- /* */ if (!($interfaceIsEqual(v, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(v, $ifaceNil))) { */ case 2:
- e = $assertType(v, ptrType$4);
- e.Buffer.Reset();
- return e;
- /* } */ case 3:
- return new encodeState.ptr();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newEncodeState }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- encodeState.ptr.prototype.marshal = function(v) {
- var $ptr, _r$2, e, err, v, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; err = $f.err; v = $f.v; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- err[0] = $ifaceNil;
- e = this;
- $deferred.push([(function(err) { return function() {
- var $ptr, _tuple, _tuple$1, ok, ok$1, r, s;
- r = $recover();
- if (!($interfaceIsEqual(r, $ifaceNil))) {
- _tuple = $assertType(r, runtime.Error, true); ok = _tuple[1];
- if (ok) {
- $panic(r);
- }
- _tuple$1 = $assertType(r, $String, true); s = _tuple$1[0]; ok$1 = _tuple$1[1];
- if (ok$1) {
- $panic(new $String(s));
- }
- err[0] = $assertType(r, $error);
- }
- }; })(err), []]);
- _r$2 = reflect.ValueOf(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = e.reflectValue(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- err[0] = $ifaceNil;
- return err[0];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err[0]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: encodeState.ptr.prototype.marshal }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.err = err; $f.v = v; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- encodeState.prototype.marshal = function(v) { return this.$val.marshal(v); };
- encodeState.ptr.prototype.error = function(err) {
- var $ptr, e, err;
- e = this;
- $panic(err);
- };
- encodeState.prototype.error = function(err) { return this.$val.error(err); };
- isEmptyValue = function(v) {
- var $ptr, _ref, v, x, x$1;
- v = v;
- _ref = v.Kind();
- if (_ref === 17 || _ref === 21 || _ref === 23 || _ref === 24) {
- return v.Len() === 0;
- } else if (_ref === 1) {
- return !v.Bool();
- } else if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) {
- return (x = v.Int(), (x.$high === 0 && x.$low === 0));
- } else if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) {
- return (x$1 = v.Uint(), (x$1.$high === 0 && x$1.$low === 0));
- } else if (_ref === 13 || _ref === 14) {
- return v.Float() === 0;
- } else if (_ref === 20 || _ref === 22) {
- return v.IsNil();
- }
- return false;
- };
- encodeState.ptr.prototype.reflectValue = function(v) {
- var $ptr, _r$2, e, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = this;
- v = v;
- _r$2 = valueEncoder(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = _r$2(e, v, false); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encodeState.ptr.prototype.reflectValue }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- encodeState.prototype.reflectValue = function(v) { return this.$val.reflectValue(v); };
- valueEncoder = function(v) {
- var $ptr, _r$2, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (!v.IsValid()) {
- return invalidValueEncoder;
- }
- _r$2 = typeEncoder(v.Type()); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: valueEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- typeEncoder = function(t) {
- var $ptr, _entry, _key, _key$1, _r$2, f, t, wg, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _key$1 = $f._key$1; _r$2 = $f._r$2; f = $f.f; t = $f.t; wg = $f.wg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = [f];
- wg = [wg];
- encoderCache.RWMutex.RLock();
- f[0] = (_entry = encoderCache.m[reflect.Type.keyFor(t)], _entry !== undefined ? _entry.v : $throwNilPointerError);
- encoderCache.RWMutex.RUnlock();
- if (!(f[0] === $throwNilPointerError)) {
- return f[0];
- }
- encoderCache.RWMutex.Lock();
- if (encoderCache.m === false) {
- encoderCache.m = new $Map();
- }
- wg[0] = $clone(new nosync.WaitGroup.ptr(), nosync.WaitGroup);
- wg[0].Add(1);
- _key = t; (encoderCache.m || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key)] = { k: _key, v: (function(f, wg) { return function $b(e, v, quoted) {
- var $ptr, e, quoted, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- wg[0].Wait();
- $r = f[0](e, v, quoted); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.e = e; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- }; })(f, wg) };
- encoderCache.RWMutex.Unlock();
- _r$2 = newTypeEncoder(t, true); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- f[0] = _r$2;
- wg[0].Done();
- encoderCache.RWMutex.Lock();
- _key$1 = t; (encoderCache.m || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$1)] = { k: _key$1, v: f[0] };
- encoderCache.RWMutex.Unlock();
- return f[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: typeEncoder }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._key$1 = _key$1; $f._r$2 = _r$2; $f.f = f; $f.t = t; $f.wg = wg; $f.$s = $s; $f.$r = $r; return $f;
- };
- newTypeEncoder = function(t, allowAddr) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, allowAddr, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; allowAddr = $f.allowAddr; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = t.Implements(marshalerType); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r$2) { */ case 1:
- return marshalerEncoder;
- /* } */ case 2:
- _r$3 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!((_r$3 === 22)) && allowAddr) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!((_r$3 === 22)) && allowAddr) { */ case 4:
- _r$4 = reflect.PtrTo(t).Implements(marshalerType); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (_r$4) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_r$4) { */ case 7:
- _arg = addrMarshalerEncoder;
- _r$5 = newTypeEncoder(t, false); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$1 = _r$5;
- _r$6 = newCondAddrEncoder(_arg, _arg$1); /* */ $s = 11; case 11: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- /* } */ case 8:
- /* } */ case 5:
- _r$7 = t.Implements(textMarshalerType); /* */ $s = 14; case 14: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (_r$7) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (_r$7) { */ case 12:
- return textMarshalerEncoder;
- /* } */ case 13:
- _r$8 = t.Kind(); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- /* */ if (!((_r$8 === 22)) && allowAddr) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!((_r$8 === 22)) && allowAddr) { */ case 15:
- _r$9 = reflect.PtrTo(t).Implements(textMarshalerType); /* */ $s = 20; case 20: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- /* */ if (_r$9) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (_r$9) { */ case 18:
- _arg$2 = addrTextMarshalerEncoder;
- _r$10 = newTypeEncoder(t, false); /* */ $s = 21; case 21: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _arg$3 = _r$10;
- _r$11 = newCondAddrEncoder(_arg$2, _arg$3); /* */ $s = 22; case 22: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- /* } */ case 19:
- /* } */ case 16:
- _r$12 = t.Kind(); /* */ $s = 23; case 23: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _ref = _r$12;
- /* */ if (_ref === 1) { $s = 24; continue; }
- /* */ if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { $s = 25; continue; }
- /* */ if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { $s = 26; continue; }
- /* */ if (_ref === 13) { $s = 27; continue; }
- /* */ if (_ref === 14) { $s = 28; continue; }
- /* */ if (_ref === 24) { $s = 29; continue; }
- /* */ if (_ref === 20) { $s = 30; continue; }
- /* */ if (_ref === 25) { $s = 31; continue; }
- /* */ if (_ref === 21) { $s = 32; continue; }
- /* */ if (_ref === 23) { $s = 33; continue; }
- /* */ if (_ref === 17) { $s = 34; continue; }
- /* */ if (_ref === 22) { $s = 35; continue; }
- /* */ $s = 36; continue;
- /* if (_ref === 1) { */ case 24:
- return boolEncoder;
- $s = 37; continue;
- /* } else if (_ref === 2 || _ref === 3 || _ref === 4 || _ref === 5 || _ref === 6) { */ case 25:
- return intEncoder;
- $s = 37; continue;
- /* } else if (_ref === 7 || _ref === 8 || _ref === 9 || _ref === 10 || _ref === 11 || _ref === 12) { */ case 26:
- return uintEncoder;
- $s = 37; continue;
- /* } else if (_ref === 13) { */ case 27:
- return float32Encoder;
- $s = 37; continue;
- /* } else if (_ref === 14) { */ case 28:
- return float64Encoder;
- $s = 37; continue;
- /* } else if (_ref === 24) { */ case 29:
- return stringEncoder;
- $s = 37; continue;
- /* } else if (_ref === 20) { */ case 30:
- return interfaceEncoder;
- $s = 37; continue;
- /* } else if (_ref === 25) { */ case 31:
- _r$13 = newStructEncoder(t); /* */ $s = 38; case 38: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- return _r$13;
- $s = 37; continue;
- /* } else if (_ref === 21) { */ case 32:
- _r$14 = newMapEncoder(t); /* */ $s = 39; case 39: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- return _r$14;
- $s = 37; continue;
- /* } else if (_ref === 23) { */ case 33:
- _r$15 = newSliceEncoder(t); /* */ $s = 40; case 40: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- return _r$15;
- $s = 37; continue;
- /* } else if (_ref === 17) { */ case 34:
- _r$16 = newArrayEncoder(t); /* */ $s = 41; case 41: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- return _r$16;
- $s = 37; continue;
- /* } else if (_ref === 22) { */ case 35:
- _r$17 = newPtrEncoder(t); /* */ $s = 42; case 42: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- return _r$17;
- $s = 37; continue;
- /* } else { */ case 36:
- return unsupportedTypeEncoder;
- /* } */ case 37:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newTypeEncoder }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f.allowAddr = allowAddr; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- invalidValueEncoder = function(e, v, quoted) {
- var $ptr, e, quoted, v;
- v = v;
- e.Buffer.WriteString("null");
- };
- marshalerEncoder = function(e, v, quoted) {
- var $ptr, _r$2, _r$3, _r$4, _tuple, b, e, err, m, quoted, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if ((v.Kind() === 22) && v.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- _r$2 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- m = $assertType(_r$2, Marshaler);
- _r$3 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; b = _tuple[0]; err = _tuple[1];
- /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3:
- _r$4 = compact(e.Buffer, b, true); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- err = _r$4;
- /* } */ case 4:
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- e.error(new MarshalerError.ptr(v.Type(), err));
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: marshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- addrMarshalerEncoder = function(e, v, quoted) {
- var $ptr, _r$2, _r$3, _r$4, _tuple, b, e, err, m, quoted, v, va, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; quoted = $f.quoted; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- va = v.Addr();
- if (va.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- _r$2 = va.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- m = $assertType(_r$2, Marshaler);
- _r$3 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; b = _tuple[0]; err = _tuple[1];
- /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3:
- _r$4 = compact(e.Buffer, b, true); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- err = _r$4;
- /* } */ case 4:
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- e.error(new MarshalerError.ptr(v.Type(), err));
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: addrMarshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.quoted = quoted; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f;
- };
- textMarshalerEncoder = function(e, v, quoted) {
- var $ptr, _r$2, _r$3, _tuple, _tuple$1, b, e, err, m, quoted, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; e = $f.e; err = $f.err; m = $f.m; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if ((v.Kind() === 22) && v.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- _r$2 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- m = $assertType(_r$2, encoding.TextMarshaler);
- _r$3 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; b = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- _tuple$1 = e.stringBytes(b); err = _tuple$1[1];
- }
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- e.error(new MarshalerError.ptr(v.Type(), err));
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: textMarshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- addrTextMarshalerEncoder = function(e, v, quoted) {
- var $ptr, _r$2, _r$3, _tuple, _tuple$1, b, e, err, m, quoted, v, va, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; b = $f.b; e = $f.e; err = $f.err; m = $f.m; quoted = $f.quoted; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- va = v.Addr();
- if (va.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- _r$2 = va.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- m = $assertType(_r$2, encoding.TextMarshaler);
- _r$3 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; b = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- _tuple$1 = e.stringBytes(b); err = _tuple$1[1];
- }
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- e.error(new MarshalerError.ptr(v.Type(), err));
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: addrTextMarshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.quoted = quoted; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f;
- };
- boolEncoder = function(e, v, quoted) {
- var $ptr, e, quoted, v;
- v = v;
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- if (v.Bool()) {
- e.Buffer.WriteString("true");
- } else {
- e.Buffer.WriteString("false");
- }
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- };
- intEncoder = function(e, v, quoted) {
- var $ptr, b, e, quoted, v;
- v = v;
- b = strconv.AppendInt($subslice(new sliceType$1(e.scratch), 0, 0), v.Int(), 10);
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- e.Buffer.Write(b);
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- };
- uintEncoder = function(e, v, quoted) {
- var $ptr, b, e, quoted, v;
- v = v;
- b = strconv.AppendUint($subslice(new sliceType$1(e.scratch), 0, 0), v.Uint(), 10);
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- e.Buffer.Write(b);
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- };
- floatEncoder.prototype.encode = function(e, v, quoted) {
- var $ptr, b, bits, e, f, quoted, v;
- bits = this.$val;
- v = v;
- f = v.Float();
- if (math.IsInf(f, 0) || math.IsNaN(f)) {
- e.error(new UnsupportedValueError.ptr($clone(v, reflect.Value), strconv.FormatFloat(f, 103, -1, (bits >> 0))));
- }
- b = strconv.AppendFloat($subslice(new sliceType$1(e.scratch), 0, 0), f, 103, -1, (bits >> 0));
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- e.Buffer.Write(b);
- if (quoted) {
- e.Buffer.WriteByte(34);
- }
- };
- $ptrType(floatEncoder).prototype.encode = function(e, v, quoted) { return new floatEncoder(this.$get()).encode(e, v, quoted); };
- stringEncoder = function(e, v, quoted) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, e, err, numStr, quoted, sb, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; e = $f.e; err = $f.err; numStr = $f.numStr; quoted = $f.quoted; sb = $f.sb; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- /* */ if ($interfaceIsEqual(v.Type(), numberType)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ($interfaceIsEqual(v.Type(), numberType)) { */ case 1:
- _r$2 = v.String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- numStr = _r$2;
- if (numStr === "") {
- numStr = "0";
- }
- e.Buffer.WriteString(numStr);
- return;
- /* } */ case 2:
- /* */ if (quoted) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (quoted) { */ case 4:
- _r$3 = v.String(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = Marshal(new $String(_r$3)); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; sb = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- e.error(err);
- }
- e.string($bytesToString(sb));
- $s = 6; continue;
- /* } else { */ case 5:
- _r$5 = v.String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = e.string(_r$5); /* */ $s = 10; case 10: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: stringEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f.e = e; $f.err = err; $f.numStr = numStr; $f.quoted = quoted; $f.sb = sb; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- interfaceEncoder = function(e, v, quoted) {
- var $ptr, _r$2, e, quoted, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (v.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- _r$2 = v.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = e.reflectValue(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: interfaceEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- unsupportedTypeEncoder = function(e, v, quoted) {
- var $ptr, e, quoted, v;
- v = v;
- e.error(new UnsupportedTypeError.ptr(v.Type()));
- };
- structEncoder.ptr.prototype.encode = function(e, v, quoted) {
- var $ptr, _i, _r$2, _ref, e, f, first, fv, i, quoted, se, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _ref = $f._ref; e = $f.e; f = $f.f; first = $f.first; fv = $f.fv; i = $f.i; quoted = $f.quoted; se = $f.se; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- se = this;
- v = v;
- e.Buffer.WriteByte(123);
- first = true;
- _ref = se.fields;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), field);
- _r$2 = fieldByIndex(v, f.index); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- fv = _r$2;
- /* */ if (!fv.IsValid() || f.omitEmpty && isEmptyValue(fv)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!fv.IsValid() || f.omitEmpty && isEmptyValue(fv)) { */ case 4:
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 5:
- if (first) {
- first = false;
- } else {
- e.Buffer.WriteByte(44);
- }
- e.string(f.name);
- e.Buffer.WriteByte(58);
- $r = (x = se.fieldEncs, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]))(e, fv, f.quoted); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- e.Buffer.WriteByte(125);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._ref = _ref; $f.e = e; $f.f = f; $f.first = first; $f.fv = fv; $f.i = i; $f.quoted = quoted; $f.se = se; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- structEncoder.prototype.encode = function(e, v, quoted) { return this.$val.encode(e, v, quoted); };
- newStructEncoder = function(t) {
- var $ptr, _i, _r$2, _r$3, _r$4, _ref, f, fields, i, se, t, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; f = $f.f; fields = $f.fields; i = $f.i; se = $f.se; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = cachedTypeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- fields = _r$2;
- se = new structEncoder.ptr(fields, $makeSlice(sliceType$3, fields.$length));
- _ref = fields;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- i = _i;
- f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), field);
- _r$3 = typeByIndex(t, f.index); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = typeEncoder(_r$3); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- (x = se.fieldEncs, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = _r$4));
- _i++;
- /* } */ $s = 2; continue; case 3:
- return $methodVal(se, "encode");
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newStructEncoder }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.f = f; $f.fields = fields; $f.i = i; $f.se = se; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- mapEncoder.ptr.prototype.encode = function(e, v, param) {
- var $ptr, _arg, _arg$1, _i, _r$2, _r$3, _r$4, _r$5, _ref, e, i, k, me, param, sv, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; e = $f.e; i = $f.i; k = $f.k; me = $f.me; param = $f.param; sv = $f.sv; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- me = this;
- v = v;
- if (v.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- e.Buffer.WriteByte(123);
- _r$2 = v.MapKeys(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- sv = (x = _r$2, $subslice(new stringValues(x.$array), x.$offset, x.$offset + x.$length));
- $r = sort.Sort(sv); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = sv;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- i = _i;
- k = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (i > 0) {
- e.Buffer.WriteByte(44);
- }
- _r$3 = k.String(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = e.string(_r$3); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- e.Buffer.WriteByte(58);
- _arg = e;
- _r$5 = v.MapIndex(k); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$1 = _r$5;
- $r = me.elemEnc(_arg, _arg$1, false); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 3; continue; case 4:
- e.Buffer.WriteByte(125);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mapEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.e = e; $f.i = i; $f.k = k; $f.me = me; $f.param = param; $f.sv = sv; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- mapEncoder.prototype.encode = function(e, v, param) { return this.$val.encode(e, v, param); };
- newMapEncoder = function(t) {
- var $ptr, _r$2, _r$3, _r$4, _r$5, me, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; me = $f.me; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = t.Key(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = _r$2.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!((_r$3 === 24))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r$3 === 24))) { */ case 1:
- return unsupportedTypeEncoder;
- /* } */ case 2:
- _r$4 = t.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = typeEncoder(_r$4); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- me = new mapEncoder.ptr(_r$5);
- return $methodVal(me, "encode");
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newMapEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.me = me; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- encodeByteSlice = function(e, v, param) {
- var $ptr, _r$2, _r$3, _r$4, dst, e, enc, param, s, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; dst = $f.dst; e = $f.e; enc = $f.enc; param = $f.param; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- if (v.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- _r$2 = v.Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- s = _r$2;
- e.Buffer.WriteByte(34);
- /* */ if (s.$length < 1024) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (s.$length < 1024) { */ case 2:
- dst = $makeSlice(sliceType$1, base64.StdEncoding.EncodedLen(s.$length));
- base64.StdEncoding.Encode(dst, s);
- e.Buffer.Write(dst);
- $s = 4; continue;
- /* } else { */ case 3:
- enc = base64.NewEncoder(base64.StdEncoding, e);
- _r$3 = enc.Write(s); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- _r$4 = enc.Close(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- /* } */ case 4:
- e.Buffer.WriteByte(34);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encodeByteSlice }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.dst = dst; $f.e = e; $f.enc = enc; $f.param = param; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- sliceEncoder.ptr.prototype.encode = function(e, v, param) {
- var $ptr, e, param, se, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; param = $f.param; se = $f.se; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- se = this;
- v = v;
- if (v.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- $r = se.arrayEnc(e, v, false); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sliceEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f.e = e; $f.param = param; $f.se = se; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- sliceEncoder.prototype.encode = function(e, v, param) { return this.$val.encode(e, v, param); };
- newSliceEncoder = function(t) {
- var $ptr, _r$2, _r$3, _r$4, enc, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = t.Elem(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = _r$2.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3 === 8) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r$3 === 8) { */ case 1:
- return encodeByteSlice;
- /* } */ case 2:
- _r$4 = newArrayEncoder(t); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- enc = new sliceEncoder.ptr(_r$4);
- return $methodVal(enc, "encode");
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newSliceEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- arrayEncoder.ptr.prototype.encode = function(e, v, param) {
- var $ptr, _arg, _arg$1, _r$2, ae, e, i, n, param, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r$2 = $f._r$2; ae = $f.ae; e = $f.e; i = $f.i; n = $f.n; param = $f.param; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- ae = this;
- v = v;
- e.Buffer.WriteByte(91);
- n = v.Len();
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; }
- if (i > 0) {
- e.Buffer.WriteByte(44);
- }
- _arg = e;
- _r$2 = v.Index(i); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = _r$2;
- $r = ae.elemEnc(_arg, _arg$1, false); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- e.Buffer.WriteByte(93);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: arrayEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$2 = _r$2; $f.ae = ae; $f.e = e; $f.i = i; $f.n = n; $f.param = param; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- arrayEncoder.prototype.encode = function(e, v, param) { return this.$val.encode(e, v, param); };
- newArrayEncoder = function(t) {
- var $ptr, _r$2, _r$3, enc, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = typeEncoder(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- enc = new arrayEncoder.ptr(_r$3);
- return $methodVal(enc, "encode");
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newArrayEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- ptrEncoder.ptr.prototype.encode = function(e, v, quoted) {
- var $ptr, _arg, _arg$1, _arg$2, _r$2, e, pe, quoted, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$2 = $f._r$2; e = $f.e; pe = $f.pe; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pe = this;
- v = v;
- if (v.IsNil()) {
- e.Buffer.WriteString("null");
- return;
- }
- _arg = e;
- _r$2 = v.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = _r$2;
- _arg$2 = quoted;
- $r = pe.elemEnc(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ptrEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$2 = _r$2; $f.e = e; $f.pe = pe; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- ptrEncoder.prototype.encode = function(e, v, quoted) { return this.$val.encode(e, v, quoted); };
- newPtrEncoder = function(t) {
- var $ptr, _r$2, _r$3, enc, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = typeEncoder(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- enc = new ptrEncoder.ptr(_r$3);
- return $methodVal(enc, "encode");
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newPtrEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- condAddrEncoder.ptr.prototype.encode = function(e, v, quoted) {
- var $ptr, ce, e, quoted, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ce = $f.ce; e = $f.e; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- ce = this;
- v = v;
- /* */ if (v.CanAddr()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (v.CanAddr()) { */ case 1:
- $r = ce.canAddrEnc(e, v, quoted); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 3; continue;
- /* } else { */ case 2:
- $r = ce.elseEnc(e, v, quoted); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: condAddrEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f.ce = ce; $f.e = e; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- condAddrEncoder.prototype.encode = function(e, v, quoted) { return this.$val.encode(e, v, quoted); };
- newCondAddrEncoder = function(canAddrEnc, elseEnc) {
- var $ptr, canAddrEnc, elseEnc, enc;
- enc = new condAddrEncoder.ptr(canAddrEnc, elseEnc);
- return $methodVal(enc, "encode");
- };
- isValidTag = function(s) {
- var $ptr, _i, _ref, _rune, c, s;
- if (s === "") {
- return false;
- }
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- c = _rune[0];
- if (strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c)) {
- } else {
- if (!unicode.IsLetter(c) && !unicode.IsDigit(c)) {
- return false;
- }
- }
- _i += _rune[1];
- }
- return true;
- };
- fieldByIndex = function(v, index) {
- var $ptr, _i, _r$2, _r$3, _ref, i, index, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; i = $f.i; index = $f.index; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = v;
- _ref = index;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (v.Kind() === 22) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (v.Kind() === 22) { */ case 3:
- if (v.IsNil()) {
- return new reflect.Value.ptr(ptrType$2.nil, 0, 0);
- }
- _r$2 = v.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- /* } */ case 4:
- _r$3 = v.Field(i); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- v = _r$3;
- _i++;
- /* } */ $s = 1; continue; case 2:
- return v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: fieldByIndex }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f.i = i; $f.index = index; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- typeByIndex = function(t, index) {
- var $ptr, _i, _r$2, _r$3, _r$4, _ref, i, index, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; i = $f.i; index = $f.index; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = index;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$2 = t.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2 === 22) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_r$2 === 22) { */ case 3:
- _r$3 = t.Elem(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- t = _r$3;
- /* } */ case 4:
- _r$4 = t.Field(i); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- t = _r$4.Type;
- _i++;
- /* } */ $s = 1; continue; case 2:
- return t;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: typeByIndex }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.i = i; $f.index = index; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- stringValues.prototype.Len = function() {
- var $ptr, sv;
- sv = this;
- return sv.$length;
- };
- $ptrType(stringValues).prototype.Len = function() { return this.$get().Len(); };
- stringValues.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, i, j, sv;
- sv = this;
- _tmp = ((j < 0 || j >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + j]); _tmp$1 = ((i < 0 || i >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + i]); ((i < 0 || i >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + i] = _tmp); ((j < 0 || j >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + j] = _tmp$1);
- };
- $ptrType(stringValues).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- stringValues.prototype.Less = function(i, j) {
- var $ptr, _r$2, _r$3, i, j, sv, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; j = $f.j; sv = $f.sv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- sv = this;
- _r$2 = sv.get(i); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = sv.get(j); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$2 < _r$3;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: stringValues.prototype.Less }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.j = j; $f.sv = sv; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(stringValues).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- stringValues.prototype.get = function(i) {
- var $ptr, _r$2, i, sv, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; i = $f.i; sv = $f.sv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- sv = this;
- _r$2 = ((i < 0 || i >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + i]).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: stringValues.prototype.get }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.i = i; $f.sv = sv; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(stringValues).prototype.get = function(i) { return this.$get().get(i); };
- encodeState.ptr.prototype.string = function(s) {
- var $ptr, _ref, _tuple, b, c, e, i, len0, s, size, start;
- e = this;
- len0 = e.Buffer.Len();
- e.Buffer.WriteByte(34);
- start = 0;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- b = s.charCodeAt(i);
- if (b < 128) {
- if (32 <= b && !((b === 92)) && !((b === 34)) && !((b === 60)) && !((b === 62)) && !((b === 38))) {
- i = i + (1) >> 0;
- continue;
- }
- if (start < i) {
- e.Buffer.WriteString(s.substring(start, i));
- }
- _ref = b;
- if (_ref === 92 || _ref === 34) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(b);
- } else if (_ref === 10) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(110);
- } else if (_ref === 13) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(114);
- } else if (_ref === 9) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(116);
- } else {
- e.Buffer.WriteString("\\u00");
- e.Buffer.WriteByte(hex.charCodeAt((b >>> 4 << 24 >>> 24)));
- e.Buffer.WriteByte(hex.charCodeAt(((b & 15) >>> 0)));
- }
- i = i + (1) >> 0;
- start = i;
- continue;
- }
- _tuple = utf8.DecodeRuneInString(s.substring(i)); c = _tuple[0]; size = _tuple[1];
- if ((c === 65533) && (size === 1)) {
- if (start < i) {
- e.Buffer.WriteString(s.substring(start, i));
- }
- e.Buffer.WriteString("\\ufffd");
- i = i + (size) >> 0;
- start = i;
- continue;
- }
- if ((c === 8232) || (c === 8233)) {
- if (start < i) {
- e.Buffer.WriteString(s.substring(start, i));
- }
- e.Buffer.WriteString("\\u202");
- e.Buffer.WriteByte(hex.charCodeAt((c & 15)));
- i = i + (size) >> 0;
- start = i;
- continue;
- }
- i = i + (size) >> 0;
- }
- if (start < s.length) {
- e.Buffer.WriteString(s.substring(start));
- }
- e.Buffer.WriteByte(34);
- return [e.Buffer.Len() - len0 >> 0, $ifaceNil];
- };
- encodeState.prototype.string = function(s) { return this.$val.string(s); };
- encodeState.ptr.prototype.stringBytes = function(s) {
- var $ptr, _ref, _tuple, b, c, e, i, len0, s, size, start;
- e = this;
- len0 = e.Buffer.Len();
- e.Buffer.WriteByte(34);
- start = 0;
- i = 0;
- while (true) {
- if (!(i < s.$length)) { break; }
- b = ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i]);
- if (b < 128) {
- if (32 <= b && !((b === 92)) && !((b === 34)) && !((b === 60)) && !((b === 62)) && !((b === 38))) {
- i = i + (1) >> 0;
- continue;
- }
- if (start < i) {
- e.Buffer.Write($subslice(s, start, i));
- }
- _ref = b;
- if (_ref === 92 || _ref === 34) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(b);
- } else if (_ref === 10) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(110);
- } else if (_ref === 13) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(114);
- } else if (_ref === 9) {
- e.Buffer.WriteByte(92);
- e.Buffer.WriteByte(116);
- } else {
- e.Buffer.WriteString("\\u00");
- e.Buffer.WriteByte(hex.charCodeAt((b >>> 4 << 24 >>> 24)));
- e.Buffer.WriteByte(hex.charCodeAt(((b & 15) >>> 0)));
- }
- i = i + (1) >> 0;
- start = i;
- continue;
- }
- _tuple = utf8.DecodeRune($subslice(s, i)); c = _tuple[0]; size = _tuple[1];
- if ((c === 65533) && (size === 1)) {
- if (start < i) {
- e.Buffer.Write($subslice(s, start, i));
- }
- e.Buffer.WriteString("\\ufffd");
- i = i + (size) >> 0;
- start = i;
- continue;
- }
- if ((c === 8232) || (c === 8233)) {
- if (start < i) {
- e.Buffer.Write($subslice(s, start, i));
- }
- e.Buffer.WriteString("\\u202");
- e.Buffer.WriteByte(hex.charCodeAt((c & 15)));
- i = i + (size) >> 0;
- start = i;
- continue;
- }
- i = i + (size) >> 0;
- }
- if (start < s.$length) {
- e.Buffer.Write($subslice(s, start));
- }
- e.Buffer.WriteByte(34);
- return [e.Buffer.Len() - len0 >> 0, $ifaceNil];
- };
- encodeState.prototype.stringBytes = function(s) { return this.$val.stringBytes(s); };
- fillField = function(f) {
- var $ptr, f;
- f = $clone(f, field);
- f.nameBytes = new sliceType$1($stringToBytes(f.name));
- f.equalFold = foldFunc(f.nameBytes);
- return f;
- };
- byName.prototype.Len = function() {
- var $ptr, x;
- x = this;
- return x.$length;
- };
- $ptrType(byName).prototype.Len = function() { return this.$get().Len(); };
- byName.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, i, j, x;
- x = this;
- _tmp = $clone(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]), field); _tmp$1 = $clone(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), field); $copy(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), _tmp, field); $copy(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]), _tmp$1, field);
- };
- $ptrType(byName).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- byName.prototype.Less = function(i, j) {
- var $ptr, i, j, x;
- x = this;
- if (!(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).name === ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).name)) {
- return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).name < ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).name;
- }
- if (!((((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).index.$length === ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length))) {
- return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).index.$length < ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length;
- }
- if (!(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).tag === ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).tag)) {
- return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).tag;
- }
- return $subslice(new byIndex(x.$array), x.$offset, x.$offset + x.$length).Less(i, j);
- };
- $ptrType(byName).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- byIndex.prototype.Len = function() {
- var $ptr, x;
- x = this;
- return x.$length;
- };
- $ptrType(byIndex).prototype.Len = function() { return this.$get().Len(); };
- byIndex.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, i, j, x;
- x = this;
- _tmp = $clone(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]), field); _tmp$1 = $clone(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), field); $copy(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), _tmp, field); $copy(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]), _tmp$1, field);
- };
- $ptrType(byIndex).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- byIndex.prototype.Less = function(i, j) {
- var $ptr, _i, _ref, i, j, k, x, x$1, x$2, xik;
- x = this;
- _ref = ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).index;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- k = _i;
- xik = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (k >= ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length) {
- return false;
- }
- if (!((xik === (x$1 = ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + k]))))) {
- return xik < (x$2 = ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + k]));
- }
- _i++;
- }
- return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).index.$length < ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length;
- };
- $ptrType(byIndex).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- typeFields = function(t) {
- var $ptr, _entry, _entry$1, _entry$2, _entry$3, _i, _key, _key$1, _key$2, _key$3, _key$4, _key$5, _map, _map$1, _map$2, _map$3, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, _tuple$1, _v, _v$1, advance, count, current, dominant, f, fi, fields, fj, ft, i, i$1, index, name, name$1, next, nextCount, ok, opts, out, sf, t, tag, tagged, visited, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _key$4 = $f._key$4; _key$5 = $f._key$5; _map = $f._map; _map$1 = $f._map$1; _map$2 = $f._map$2; _map$3 = $f._map$3; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; _v$1 = $f._v$1; advance = $f.advance; count = $f.count; current = $f.current; dominant = $f.dominant; f = $f.f; fi = $f.fi; fields = $f.fields; fj = $f.fj; ft = $f.ft; i = $f.i; i$1 = $f.i$1; index = $f.index; name = $f.name; name$1 = $f.name$1; next = $f.next; nextCount = $f.nextCount; ok = $f.ok; opts = $f.opts; out = $f.out; sf = $f.sf; t = $f.t; tag = $f.tag; tagged = $f.tagged; visited = $f.visited; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- current = new sliceType([]);
- next = new sliceType([new field.ptr("", sliceType$1.nil, $throwNilPointerError, false, sliceType$4.nil, t, false, false)]);
- count = (_map = new $Map(), _map);
- nextCount = (_map$1 = new $Map(), _map$1);
- visited = (_map$2 = new $Map(), _map$2);
- fields = sliceType.nil;
- /* while (true) { */ case 1:
- /* if (!(next.$length > 0)) { break; } */ if(!(next.$length > 0)) { $s = 2; continue; }
- _tmp = next; _tmp$1 = $subslice(current, 0, 0); current = _tmp; next = _tmp$1;
- _tmp$2 = nextCount; _tmp$3 = (_map$3 = new $Map(), _map$3); count = _tmp$2; nextCount = _tmp$3;
- _ref = current;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), field);
- /* */ if ((_entry = visited[reflect.Type.keyFor(f.typ)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ((_entry = visited[reflect.Type.keyFor(f.typ)], _entry !== undefined ? _entry.v : false)) { */ case 5:
- _i++;
- /* continue; */ $s = 3; continue;
- /* } */ case 6:
- _key$4 = f.typ; (visited || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$4)] = { k: _key$4, v: true };
- i = 0;
- /* while (true) { */ case 7:
- _r$2 = f.typ.NumField(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* if (!(i < _r$2)) { break; } */ if(!(i < _r$2)) { $s = 8; continue; }
- _r$3 = f.typ.Field(i); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- sf = $clone(_r$3, reflect.StructField);
- /* */ if (!(sf.PkgPath === "")) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!(sf.PkgPath === "")) { */ case 11:
- i = i + (1) >> 0;
- /* continue; */ $s = 7; continue;
- /* } */ case 12:
- tag = new reflect.StructTag(sf.Tag).Get("json");
- /* */ if (tag === "-") { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (tag === "-") { */ case 13:
- i = i + (1) >> 0;
- /* continue; */ $s = 7; continue;
- /* } */ case 14:
- _tuple = parseTag(tag); name = _tuple[0]; opts = _tuple[1];
- if (!isValidTag(name)) {
- name = "";
- }
- index = $makeSlice(sliceType$4, (f.index.$length + 1 >> 0));
- $copySlice(index, f.index);
- (x = f.index.$length, ((x < 0 || x >= index.$length) ? $throwRuntimeError("index out of range") : index.$array[index.$offset + x] = i));
- ft = sf.Type;
- _r$4 = ft.Name(); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- if (!(_r$4 === "")) { _v = false; $s = 17; continue s; }
- _r$5 = ft.Kind(); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _v = _r$5 === 22; case 17:
- /* */ if (_v) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_v) { */ case 15:
- _r$6 = ft.Elem(); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- ft = _r$6;
- /* } */ case 16:
- if (!(name === "") || !sf.Anonymous) { _v$1 = true; $s = 23; continue s; }
- _r$7 = ft.Kind(); /* */ $s = 24; case 24: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _v$1 = !((_r$7 === 25)); case 23:
- /* */ if (_v$1) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (_v$1) { */ case 21:
- tagged = !(name === "");
- if (name === "") {
- name = sf.Name;
- }
- fields = $append(fields, fillField(new field.ptr(name, sliceType$1.nil, $throwNilPointerError, tagged, index, ft, new tagOptions(opts).Contains("omitempty"), new tagOptions(opts).Contains("string"))));
- if ((_entry$1 = count[reflect.Type.keyFor(f.typ)], _entry$1 !== undefined ? _entry$1.v : 0) > 1) {
- fields = $append(fields, (x$1 = fields.$length - 1 >> 0, ((x$1 < 0 || x$1 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + x$1])));
- }
- i = i + (1) >> 0;
- /* continue; */ $s = 7; continue;
- /* } */ case 22:
- _key$5 = ft; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$5)] = { k: _key$5, v: (_entry$2 = nextCount[reflect.Type.keyFor(ft)], _entry$2 !== undefined ? _entry$2.v : 0) + (1) >> 0 };
- /* */ if ((_entry$3 = nextCount[reflect.Type.keyFor(ft)], _entry$3 !== undefined ? _entry$3.v : 0) === 1) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if ((_entry$3 = nextCount[reflect.Type.keyFor(ft)], _entry$3 !== undefined ? _entry$3.v : 0) === 1) { */ case 25:
- _r$8 = ft.Name(); /* */ $s = 27; case 27: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = fillField(new field.ptr(_r$8, sliceType$1.nil, $throwNilPointerError, false, index, ft, false, false)); /* */ $s = 28; case 28: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- next = $append(next, _r$9);
- /* } */ case 26:
- i = i + (1) >> 0;
- /* } */ $s = 7; continue; case 8:
- _i++;
- /* } */ $s = 3; continue; case 4:
- /* } */ $s = 1; continue; case 2:
- $r = sort.Sort($subslice(new byName(fields.$array), fields.$offset, fields.$offset + fields.$length)); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- out = $subslice(fields, 0, 0);
- _tmp$4 = 0; _tmp$5 = 0; advance = _tmp$4; i$1 = _tmp$5;
- /* while (true) { */ case 30:
- /* if (!(i$1 < fields.$length)) { break; } */ if(!(i$1 < fields.$length)) { $s = 31; continue; }
- fi = $clone(((i$1 < 0 || i$1 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + i$1]), field);
- name$1 = fi.name;
- advance = 1;
- while (true) {
- if (!((i$1 + advance >> 0) < fields.$length)) { break; }
- fj = $clone((x$2 = i$1 + advance >> 0, ((x$2 < 0 || x$2 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + x$2])), field);
- if (!(fj.name === name$1)) {
- break;
- }
- advance = advance + (1) >> 0;
- }
- if (advance === 1) {
- out = $append(out, fi);
- i$1 = i$1 + (advance) >> 0;
- /* continue; */ $s = 30; continue;
- }
- _tuple$1 = dominantField($subslice(fields, i$1, (i$1 + advance >> 0))); dominant = $clone(_tuple$1[0], field); ok = _tuple$1[1];
- if (ok) {
- out = $append(out, dominant);
- }
- i$1 = i$1 + (advance) >> 0;
- /* } */ $s = 30; continue; case 31:
- fields = out;
- $r = sort.Sort($subslice(new byIndex(fields.$array), fields.$offset, fields.$offset + fields.$length)); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return fields;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: typeFields }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._key$4 = _key$4; $f._key$5 = _key$5; $f._map = _map; $f._map$1 = _map$1; $f._map$2 = _map$2; $f._map$3 = _map$3; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f._v$1 = _v$1; $f.advance = advance; $f.count = count; $f.current = current; $f.dominant = dominant; $f.f = f; $f.fi = fi; $f.fields = fields; $f.fj = fj; $f.ft = ft; $f.i = i; $f.i$1 = i$1; $f.index = index; $f.name = name; $f.name$1 = name$1; $f.next = next; $f.nextCount = nextCount; $f.ok = ok; $f.opts = opts; $f.out = out; $f.sf = sf; $f.t = t; $f.tag = tag; $f.tagged = tagged; $f.visited = visited; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- dominantField = function(fields) {
- var $ptr, _i, _ref, f, fields, i, length, tagged;
- length = (0 >= fields.$length ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + 0]).index.$length;
- tagged = -1;
- _ref = fields;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), field);
- if (f.index.$length > length) {
- fields = $subslice(fields, 0, i);
- break;
- }
- if (f.tag) {
- if (tagged >= 0) {
- return [new field.ptr("", sliceType$1.nil, $throwNilPointerError, false, sliceType$4.nil, $ifaceNil, false, false), false];
- }
- tagged = i;
- }
- _i++;
- }
- if (tagged >= 0) {
- return [((tagged < 0 || tagged >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + tagged]), true];
- }
- if (fields.$length > 1) {
- return [new field.ptr("", sliceType$1.nil, $throwNilPointerError, false, sliceType$4.nil, $ifaceNil, false, false), false];
- }
- return [(0 >= fields.$length ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + 0]), true];
- };
- cachedTypeFields = function(t) {
- var $ptr, _entry, _key, _key$1, _map, _r$2, f, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _key$1 = $f._key$1; _map = $f._map; _r$2 = $f._r$2; f = $f.f; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- fieldCache.RWMutex.RLock();
- f = (_entry = fieldCache.m[reflect.Type.keyFor(t)], _entry !== undefined ? _entry.v : sliceType.nil);
- fieldCache.RWMutex.RUnlock();
- if (!(f === sliceType.nil)) {
- return f;
- }
- _r$2 = typeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- f = _r$2;
- if (f === sliceType.nil) {
- f = new sliceType([]);
- }
- fieldCache.RWMutex.Lock();
- if (fieldCache.m === false) {
- fieldCache.m = (_map = new $Map(), _map);
- }
- _key$1 = t; (fieldCache.m || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$1)] = { k: _key$1, v: f };
- fieldCache.RWMutex.Unlock();
- return f;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: cachedTypeFields }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._key$1 = _key$1; $f._map = _map; $f._r$2 = _r$2; $f.f = f; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- foldFunc = function(s) {
- var $ptr, _i, _ref, b, nonLetter, s, special, upper;
- nonLetter = false;
- special = false;
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (b >= 128) {
- return bytes.EqualFold;
- }
- upper = (b & 223) >>> 0;
- if (upper < 65 || upper > 90) {
- nonLetter = true;
- } else if ((upper === 75) || (upper === 83)) {
- special = true;
- }
- _i++;
- }
- if (special) {
- return equalFoldRight;
- }
- if (nonLetter) {
- return asciiEqualFold;
- }
- return simpleLetterEqualFold;
- };
- equalFoldRight = function(s, t) {
- var $ptr, _i, _ref, _ref$1, _tuple, s, sb, sbUpper, size, t, tb, tr;
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- sb = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (t.$length === 0) {
- return false;
- }
- tb = (0 >= t.$length ? $throwRuntimeError("index out of range") : t.$array[t.$offset + 0]);
- if (tb < 128) {
- if (!((sb === tb))) {
- sbUpper = (sb & 223) >>> 0;
- if (65 <= sbUpper && sbUpper <= 90) {
- if (!((sbUpper === ((tb & 223) >>> 0)))) {
- return false;
- }
- } else {
- return false;
- }
- }
- t = $subslice(t, 1);
- _i++;
- continue;
- }
- _tuple = utf8.DecodeRune(t); tr = _tuple[0]; size = _tuple[1];
- _ref$1 = sb;
- if (_ref$1 === 115 || _ref$1 === 83) {
- if (!((tr === 383))) {
- return false;
- }
- } else if (_ref$1 === 107 || _ref$1 === 75) {
- if (!((tr === 8490))) {
- return false;
- }
- } else {
- return false;
- }
- t = $subslice(t, size);
- _i++;
- }
- if (t.$length > 0) {
- return false;
- }
- return true;
- };
- asciiEqualFold = function(s, t) {
- var $ptr, _i, _ref, i, s, sb, t, tb;
- if (!((s.$length === t.$length))) {
- return false;
- }
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- sb = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- tb = ((i < 0 || i >= t.$length) ? $throwRuntimeError("index out of range") : t.$array[t.$offset + i]);
- if (sb === tb) {
- _i++;
- continue;
- }
- if ((97 <= sb && sb <= 122) || (65 <= sb && sb <= 90)) {
- if (!((((sb & 223) >>> 0) === ((tb & 223) >>> 0)))) {
- return false;
- }
- } else {
- return false;
- }
- _i++;
- }
- return true;
- };
- simpleLetterEqualFold = function(s, t) {
- var $ptr, _i, _ref, b, i, s, t;
- if (!((s.$length === t.$length))) {
- return false;
- }
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!((((b & 223) >>> 0) === ((((i < 0 || i >= t.$length) ? $throwRuntimeError("index out of range") : t.$array[t.$offset + i]) & 223) >>> 0)))) {
- return false;
- }
- _i++;
- }
- return true;
- };
- compact = function(dst, src, escape) {
- var $ptr, _i, _r$2, _r$3, _ref, c, dst, escape, i, origLen, scan, src, start, v, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; c = $f.c; dst = $f.dst; escape = $f.escape; i = $f.i; origLen = $f.origLen; scan = $f.scan; src = $f.src; start = $f.start; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- scan = [scan];
- origLen = dst.Len();
- scan[0] = $clone(new scanner.ptr(), scanner);
- scan[0].reset();
- start = 0;
- _ref = src;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (escape && ((c === 60) || (c === 62) || (c === 38))) {
- if (start < i) {
- dst.Write($subslice(src, start, i));
- }
- dst.WriteString("\\u00");
- dst.WriteByte(hex.charCodeAt((c >>> 4 << 24 >>> 24)));
- dst.WriteByte(hex.charCodeAt(((c & 15) >>> 0)));
- start = i + 1 >> 0;
- }
- if ((c === 226) && (i + 2 >> 0) < src.$length && ((x = i + 1 >> 0, ((x < 0 || x >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + x])) === 128) && ((((x$1 = i + 2 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + x$1])) & ~1) << 24 >>> 24) === 168)) {
- if (start < i) {
- dst.Write($subslice(src, start, i));
- }
- dst.WriteString("\\u202");
- dst.WriteByte(hex.charCodeAt((((x$2 = i + 2 >> 0, ((x$2 < 0 || x$2 >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + x$2])) & 15) >>> 0)));
- start = i + 3 >> 0;
- }
- _r$2 = scan[0].step(scan[0], (c >> 0)); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- if (v >= 9) {
- if (v === 11) {
- /* break; */ $s = 2; continue;
- }
- if (start < i) {
- dst.Write($subslice(src, start, i));
- }
- start = i + 1 >> 0;
- }
- _i++;
- /* } */ $s = 1; continue; case 2:
- _r$3 = scan[0].eof(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3 === 11) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_r$3 === 11) { */ case 4:
- dst.Truncate(origLen);
- return scan[0].err;
- /* } */ case 5:
- if (start < src.$length) {
- dst.Write($subslice(src, start));
- }
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: compact }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f.c = c; $f.dst = dst; $f.escape = escape; $f.i = i; $f.origLen = origLen; $f.scan = scan; $f.src = src; $f.start = start; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- nextValue = function(data, scan) {
- var $ptr, _i, _r$2, _r$3, _ref, _ref$1, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, c, data, err, i, rest, scan, v, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; c = $f.c; data = $f.data; err = $f.err; i = $f.i; rest = $f.rest; scan = $f.scan; v = $f.v; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- value = sliceType$1.nil;
- rest = sliceType$1.nil;
- err = $ifaceNil;
- scan.reset();
- _ref = data;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$2 = scan.step(scan, (c >> 0)); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- if (v >= 10) {
- _ref$1 = v;
- if (_ref$1 === 11) {
- _tmp = sliceType$1.nil; _tmp$1 = sliceType$1.nil; _tmp$2 = scan.err; value = _tmp; rest = _tmp$1; err = _tmp$2;
- return [value, rest, err];
- } else if (_ref$1 === 10) {
- _tmp$3 = $subslice(data, 0, i); _tmp$4 = $subslice(data, i); _tmp$5 = $ifaceNil; value = _tmp$3; rest = _tmp$4; err = _tmp$5;
- return [value, rest, err];
- }
- }
- _i++;
- /* } */ $s = 1; continue; case 2:
- _r$3 = scan.eof(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3 === 11) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_r$3 === 11) { */ case 4:
- _tmp$6 = sliceType$1.nil; _tmp$7 = sliceType$1.nil; _tmp$8 = scan.err; value = _tmp$6; rest = _tmp$7; err = _tmp$8;
- return [value, rest, err];
- /* } */ case 5:
- _tmp$9 = data; _tmp$10 = sliceType$1.nil; _tmp$11 = $ifaceNil; value = _tmp$9; rest = _tmp$10; err = _tmp$11;
- return [value, rest, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: nextValue }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f.c = c; $f.data = data; $f.err = err; $f.i = i; $f.rest = rest; $f.scan = scan; $f.v = v; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- SyntaxError.ptr.prototype.Error = function() {
- var $ptr, e;
- e = this;
- return e.msg;
- };
- SyntaxError.prototype.Error = function() { return this.$val.Error(); };
- scanner.ptr.prototype.reset = function() {
- var $ptr, s;
- s = this;
- s.step = stateBeginValue;
- s.parseState = $subslice(s.parseState, 0, 0);
- s.err = $ifaceNil;
- s.redo = false;
- s.endTop = false;
- };
- scanner.prototype.reset = function() { return this.$val.reset(); };
- scanner.ptr.prototype.eof = function() {
- var $ptr, _r$2, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- if (!($interfaceIsEqual(s.err, $ifaceNil))) {
- return 11;
- }
- if (s.endTop) {
- return 10;
- }
- _r$2 = s.step(s, 32); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- if (s.endTop) {
- return 10;
- }
- if ($interfaceIsEqual(s.err, $ifaceNil)) {
- s.err = new SyntaxError.ptr("unexpected end of JSON input", s.bytes);
- }
- return 11;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: scanner.ptr.prototype.eof }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- scanner.prototype.eof = function() { return this.$val.eof(); };
- scanner.ptr.prototype.pushParseState = function(p) {
- var $ptr, p, s;
- s = this;
- s.parseState = $append(s.parseState, p);
- };
- scanner.prototype.pushParseState = function(p) { return this.$val.pushParseState(p); };
- scanner.ptr.prototype.popParseState = function() {
- var $ptr, n, s;
- s = this;
- n = s.parseState.$length - 1 >> 0;
- s.parseState = $subslice(s.parseState, 0, n);
- s.redo = false;
- if (n === 0) {
- s.step = stateEndTop;
- s.endTop = true;
- } else {
- s.step = stateEndValue;
- }
- };
- scanner.prototype.popParseState = function() { return this.$val.popParseState(); };
- isSpace = function(c) {
- var $ptr, c;
- return (c === 32) || (c === 9) || (c === 13) || (c === 10);
- };
- stateBeginValueOrEmpty = function(s, c) {
- var $ptr, c, s;
- if (c <= 32 && isSpace((c >> 0))) {
- return 9;
- }
- if (c === 93) {
- return stateEndValue(s, c);
- }
- return stateBeginValue(s, c);
- };
- stateBeginValue = function(s, c) {
- var $ptr, _ref, c, s;
- if (c <= 32 && isSpace((c >> 0))) {
- return 9;
- }
- _ref = c;
- if (_ref === 123) {
- s.step = stateBeginStringOrEmpty;
- s.pushParseState(0);
- return 2;
- } else if (_ref === 91) {
- s.step = stateBeginValueOrEmpty;
- s.pushParseState(2);
- return 6;
- } else if (_ref === 34) {
- s.step = stateInString;
- return 1;
- } else if (_ref === 45) {
- s.step = stateNeg;
- return 1;
- } else if (_ref === 48) {
- s.step = state0;
- return 1;
- } else if (_ref === 116) {
- s.step = stateT;
- return 1;
- } else if (_ref === 102) {
- s.step = stateF;
- return 1;
- } else if (_ref === 110) {
- s.step = stateN;
- return 1;
- }
- if (49 <= c && c <= 57) {
- s.step = state1;
- return 1;
- }
- return s.error(c, "looking for beginning of value");
- };
- stateBeginStringOrEmpty = function(s, c) {
- var $ptr, c, n, s, x, x$1;
- if (c <= 32 && isSpace((c >> 0))) {
- return 9;
- }
- if (c === 125) {
- n = s.parseState.$length;
- (x = s.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1] = 1));
- return stateEndValue(s, c);
- }
- return stateBeginString(s, c);
- };
- stateBeginString = function(s, c) {
- var $ptr, c, s;
- if (c <= 32 && isSpace((c >> 0))) {
- return 9;
- }
- if (c === 34) {
- s.step = stateInString;
- return 1;
- }
- return s.error(c, "looking for beginning of object key string");
- };
- stateEndValue = function(s, c) {
- var $ptr, _ref, c, n, ps, s, x, x$1, x$2, x$3, x$4, x$5;
- n = s.parseState.$length;
- if (n === 0) {
- s.step = stateEndTop;
- s.endTop = true;
- return stateEndTop(s, c);
- }
- if (c <= 32 && isSpace((c >> 0))) {
- s.step = stateEndValue;
- return 9;
- }
- ps = (x = s.parseState, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- _ref = ps;
- if (_ref === 0) {
- if (c === 58) {
- (x$2 = s.parseState, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3] = 1));
- s.step = stateBeginValue;
- return 3;
- }
- return s.error(c, "after object key");
- } else if (_ref === 1) {
- if (c === 44) {
- (x$4 = s.parseState, x$5 = n - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + x$5] = 0));
- s.step = stateBeginString;
- return 4;
- }
- if (c === 125) {
- s.popParseState();
- return 5;
- }
- return s.error(c, "after object key:value pair");
- } else if (_ref === 2) {
- if (c === 44) {
- s.step = stateBeginValue;
- return 7;
- }
- if (c === 93) {
- s.popParseState();
- return 8;
- }
- return s.error(c, "after array element");
- }
- return s.error(c, "");
- };
- stateEndTop = function(s, c) {
- var $ptr, c, s;
- if (!((c === 32)) && !((c === 9)) && !((c === 13)) && !((c === 10))) {
- s.error(c, "after top-level value");
- }
- return 10;
- };
- stateInString = function(s, c) {
- var $ptr, c, s;
- if (c === 34) {
- s.step = stateEndValue;
- return 0;
- }
- if (c === 92) {
- s.step = stateInStringEsc;
- return 0;
- }
- if (c < 32) {
- return s.error(c, "in string literal");
- }
- return 0;
- };
- stateInStringEsc = function(s, c) {
- var $ptr, _ref, c, s;
- _ref = c;
- if (_ref === 98 || _ref === 102 || _ref === 110 || _ref === 114 || _ref === 116 || _ref === 92 || _ref === 47 || _ref === 34) {
- s.step = stateInString;
- return 0;
- }
- if (c === 117) {
- s.step = stateInStringEscU;
- return 0;
- }
- return s.error(c, "in string escape code");
- };
- stateInStringEscU = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) {
- s.step = stateInStringEscU1;
- return 0;
- }
- return s.error(c, "in \\u hexadecimal character escape");
- };
- stateInStringEscU1 = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) {
- s.step = stateInStringEscU12;
- return 0;
- }
- return s.error(c, "in \\u hexadecimal character escape");
- };
- stateInStringEscU12 = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) {
- s.step = stateInStringEscU123;
- return 0;
- }
- return s.error(c, "in \\u hexadecimal character escape");
- };
- stateInStringEscU123 = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57 || 97 <= c && c <= 102 || 65 <= c && c <= 70) {
- s.step = stateInString;
- return 0;
- }
- return s.error(c, "in \\u hexadecimal character escape");
- };
- stateNeg = function(s, c) {
- var $ptr, c, s;
- if (c === 48) {
- s.step = state0;
- return 0;
- }
- if (49 <= c && c <= 57) {
- s.step = state1;
- return 0;
- }
- return s.error(c, "in numeric literal");
- };
- state1 = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57) {
- s.step = state1;
- return 0;
- }
- return state0(s, c);
- };
- state0 = function(s, c) {
- var $ptr, c, s;
- if (c === 46) {
- s.step = stateDot;
- return 0;
- }
- if ((c === 101) || (c === 69)) {
- s.step = stateE;
- return 0;
- }
- return stateEndValue(s, c);
- };
- stateDot = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57) {
- s.step = stateDot0;
- return 0;
- }
- return s.error(c, "after decimal point in numeric literal");
- };
- stateDot0 = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57) {
- s.step = stateDot0;
- return 0;
- }
- if ((c === 101) || (c === 69)) {
- s.step = stateE;
- return 0;
- }
- return stateEndValue(s, c);
- };
- stateE = function(s, c) {
- var $ptr, c, s;
- if (c === 43) {
- s.step = stateESign;
- return 0;
- }
- if (c === 45) {
- s.step = stateESign;
- return 0;
- }
- return stateESign(s, c);
- };
- stateESign = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57) {
- s.step = stateE0;
- return 0;
- }
- return s.error(c, "in exponent of numeric literal");
- };
- stateE0 = function(s, c) {
- var $ptr, c, s;
- if (48 <= c && c <= 57) {
- s.step = stateE0;
- return 0;
- }
- return stateEndValue(s, c);
- };
- stateT = function(s, c) {
- var $ptr, c, s;
- if (c === 114) {
- s.step = stateTr;
- return 0;
- }
- return s.error(c, "in literal true (expecting 'r')");
- };
- stateTr = function(s, c) {
- var $ptr, c, s;
- if (c === 117) {
- s.step = stateTru;
- return 0;
- }
- return s.error(c, "in literal true (expecting 'u')");
- };
- stateTru = function(s, c) {
- var $ptr, c, s;
- if (c === 101) {
- s.step = stateEndValue;
- return 0;
- }
- return s.error(c, "in literal true (expecting 'e')");
- };
- stateF = function(s, c) {
- var $ptr, c, s;
- if (c === 97) {
- s.step = stateFa;
- return 0;
- }
- return s.error(c, "in literal false (expecting 'a')");
- };
- stateFa = function(s, c) {
- var $ptr, c, s;
- if (c === 108) {
- s.step = stateFal;
- return 0;
- }
- return s.error(c, "in literal false (expecting 'l')");
- };
- stateFal = function(s, c) {
- var $ptr, c, s;
- if (c === 115) {
- s.step = stateFals;
- return 0;
- }
- return s.error(c, "in literal false (expecting 's')");
- };
- stateFals = function(s, c) {
- var $ptr, c, s;
- if (c === 101) {
- s.step = stateEndValue;
- return 0;
- }
- return s.error(c, "in literal false (expecting 'e')");
- };
- stateN = function(s, c) {
- var $ptr, c, s;
- if (c === 117) {
- s.step = stateNu;
- return 0;
- }
- return s.error(c, "in literal null (expecting 'u')");
- };
- stateNu = function(s, c) {
- var $ptr, c, s;
- if (c === 108) {
- s.step = stateNul;
- return 0;
- }
- return s.error(c, "in literal null (expecting 'l')");
- };
- stateNul = function(s, c) {
- var $ptr, c, s;
- if (c === 108) {
- s.step = stateEndValue;
- return 0;
- }
- return s.error(c, "in literal null (expecting 'l')");
- };
- stateError = function(s, c) {
- var $ptr, c, s;
- return 11;
- };
- scanner.ptr.prototype.error = function(c, context) {
- var $ptr, c, context, s;
- s = this;
- s.step = stateError;
- s.err = new SyntaxError.ptr("invalid character " + quoteChar(c) + " " + context, s.bytes);
- return 11;
- };
- scanner.prototype.error = function(c, context) { return this.$val.error(c, context); };
- quoteChar = function(c) {
- var $ptr, c, s;
- if (c === 39) {
- return "'\\''";
- }
- if (c === 34) {
- return "'\"'";
- }
- s = strconv.Quote($encodeRune(c));
- return "'" + s.substring(1, (s.length - 1 >> 0)) + "'";
- };
- scanner.ptr.prototype.undo = function(scanCode) {
- var $ptr, s, scanCode;
- s = this;
- if (s.redo) {
- $panic(new $String("json: invalid use of scanner"));
- }
- s.redoCode = scanCode;
- s.redoState = s.step;
- s.step = stateRedo;
- s.redo = true;
- };
- scanner.prototype.undo = function(scanCode) { return this.$val.undo(scanCode); };
- stateRedo = function(s, c) {
- var $ptr, c, s;
- s.redo = false;
- s.step = s.redoState;
- return s.redoCode;
- };
- NewDecoder = function(r) {
- var $ptr, r;
- return new Decoder.ptr(r, sliceType$1.nil, new decodeState.ptr(), new scanner.ptr(), $ifaceNil);
- };
- $pkg.NewDecoder = NewDecoder;
- Decoder.ptr.prototype.UseNumber = function() {
- var $ptr, dec;
- dec = this;
- dec.d.useNumber = true;
- };
- Decoder.prototype.UseNumber = function() { return this.$val.UseNumber(); };
- Decoder.ptr.prototype.Decode = function(v) {
- var $ptr, _r$2, _r$3, _tuple, dec, err, n, rest, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; dec = $f.dec; err = $f.err; n = $f.n; rest = $f.rest; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- if (!($interfaceIsEqual(dec.err, $ifaceNil))) {
- return dec.err;
- }
- _r$2 = dec.readValue(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; n = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return err;
- }
- dec.d.init($subslice(dec.buf, 0, n));
- _r$3 = dec.d.unmarshal(v); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- err = _r$3;
- rest = $copySlice(dec.buf, $subslice(dec.buf, n));
- dec.buf = $subslice(dec.buf, 0, rest);
- return err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.Decode }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.dec = dec; $f.err = err; $f.n = n; $f.rest = rest; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.Decode = function(v) { return this.$val.Decode(v); };
- Decoder.ptr.prototype.Buffered = function() {
- var $ptr, dec;
- dec = this;
- return bytes.NewReader(dec.buf);
- };
- Decoder.prototype.Buffered = function() { return this.$val.Buffered(); };
- Decoder.ptr.prototype.readValue = function() {
- var $ptr, _i, _r$2, _r$3, _r$4, _r$5, _ref, _tuple, _v, c, dec, err, i, n, newBuf, scanp, v, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _tuple = $f._tuple; _v = $f._v; c = $f.c; dec = $f.dec; err = $f.err; i = $f.i; n = $f.n; newBuf = $f.newBuf; scanp = $f.scanp; v = $f.v; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- dec = this;
- dec.scan.reset();
- scanp = 0;
- err = $ifaceNil;
- /* while (true) { */ case 1:
- _ref = $subslice(dec.buf, scanp);
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- i = _i;
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- dec.scan.bytes = (x = dec.scan.bytes, x$1 = new $Int64(0, 1), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low));
- _r$2 = dec.scan.step(dec.scan, (c >> 0)); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- if (v === 10) {
- scanp = scanp + (i) >> 0;
- /* break Input; */ $s = 2; continue s;
- }
- if (!((v === 5) || (v === 8))) { _v = false; $s = 8; continue s; }
- _r$3 = dec.scan.step(dec.scan, 32); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v = _r$3 === 10; case 8:
- /* */ if (_v) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_v) { */ case 6:
- scanp = scanp + ((i + 1 >> 0)) >> 0;
- /* break Input; */ $s = 2; continue s;
- /* } */ case 7:
- if (v === 11) {
- dec.err = dec.scan.err;
- return [0, dec.scan.err];
- }
- _i++;
- /* } */ $s = 3; continue; case 4:
- scanp = dec.buf.$length;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 10:
- /* */ if ($interfaceIsEqual(err, io.EOF)) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ($interfaceIsEqual(err, io.EOF)) { */ case 12:
- _r$4 = dec.scan.step(dec.scan, 32); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (_r$4 === 10) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (_r$4 === 10) { */ case 14:
- /* break Input; */ $s = 2; continue s;
- /* } */ case 15:
- if (nonSpace(dec.buf)) {
- err = io.ErrUnexpectedEOF;
- }
- /* } */ case 13:
- dec.err = err;
- return [0, err];
- /* } */ case 11:
- if ((dec.buf.$capacity - dec.buf.$length >> 0) < 512) {
- newBuf = $makeSlice(sliceType$1, dec.buf.$length, ((2 * dec.buf.$capacity >> 0) + 512 >> 0));
- $copySlice(newBuf, dec.buf);
- dec.buf = newBuf;
- }
- n = 0;
- _r$5 = dec.r.Read($subslice(dec.buf, dec.buf.$length, dec.buf.$capacity)); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _tuple = _r$5; n = _tuple[0]; err = _tuple[1];
- dec.buf = $subslice(dec.buf, 0, (dec.buf.$length + n >> 0));
- /* } */ $s = 1; continue; case 2:
- return [scanp, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Decoder.ptr.prototype.readValue }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._tuple = _tuple; $f._v = _v; $f.c = c; $f.dec = dec; $f.err = err; $f.i = i; $f.n = n; $f.newBuf = newBuf; $f.scanp = scanp; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Decoder.prototype.readValue = function() { return this.$val.readValue(); };
- nonSpace = function(b) {
- var $ptr, _i, _ref, b, c;
- _ref = b;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!isSpace((c >> 0))) {
- return true;
- }
- _i++;
- }
- return false;
- };
- NewEncoder = function(w) {
- var $ptr, w;
- return new Encoder.ptr(w, $ifaceNil);
- };
- $pkg.NewEncoder = NewEncoder;
- Encoder.ptr.prototype.Encode = function(v) {
- var $ptr, _r$2, _r$3, _r$4, _tuple, e, enc, err, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; e = $f.e; enc = $f.enc; err = $f.err; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- enc = this;
- if (!($interfaceIsEqual(enc.err, $ifaceNil))) {
- return enc.err;
- }
- _r$2 = newEncodeState(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- e = _r$2;
- _r$3 = e.marshal(v); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- err = _r$3;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return err;
- }
- e.Buffer.WriteByte(10);
- _r$4 = enc.w.Write(e.Buffer.Bytes()); /* */ $s = 3; case 3: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 4:
- enc.err = err;
- /* } */ case 5:
- encodeStatePool.Put(e);
- return err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Encoder.ptr.prototype.Encode }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.e = e; $f.enc = enc; $f.err = err; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Encoder.prototype.Encode = function(v) { return this.$val.Encode(v); };
- parseTag = function(tag) {
- var $ptr, idx, tag;
- idx = strings.Index(tag, ",");
- if (!((idx === -1))) {
- return [tag.substring(0, idx), tag.substring((idx + 1 >> 0))];
- }
- return [tag, ""];
- };
- tagOptions.prototype.Contains = function(optionName) {
- var $ptr, _tmp, _tmp$1, i, next, o, optionName, s;
- o = this.$val;
- if (o.length === 0) {
- return false;
- }
- s = o;
- while (true) {
- if (!(!(s === ""))) { break; }
- next = "";
- i = strings.Index(s, ",");
- if (i >= 0) {
- _tmp = s.substring(0, i); _tmp$1 = s.substring((i + 1 >> 0)); s = _tmp; next = _tmp$1;
- }
- if (s === optionName) {
- return true;
- }
- s = next;
- }
- return false;
- };
- $ptrType(tagOptions).prototype.Contains = function(optionName) { return new tagOptions(this.$get()).Contains(optionName); };
- ptrType$6.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$8.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- Number.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, $error], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64, $error], false)}];
- ptrType$9.methods = [{prop: "unmarshal", name: "unmarshal", pkg: "encoding/json", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "init", name: "init", pkg: "encoding/json", typ: $funcType([sliceType$1], [ptrType$9], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$error], [], false)}, {prop: "saveError", name: "saveError", pkg: "encoding/json", typ: $funcType([$error], [], false)}, {prop: "next", name: "next", pkg: "encoding/json", typ: $funcType([], [sliceType$1], false)}, {prop: "scanWhile", name: "scanWhile", pkg: "encoding/json", typ: $funcType([$Int], [$Int], false)}, {prop: "value", name: "value", pkg: "encoding/json", typ: $funcType([reflect.Value], [], false)}, {prop: "valueQuoted", name: "valueQuoted", pkg: "encoding/json", typ: $funcType([], [$emptyInterface], false)}, {prop: "indirect", name: "indirect", pkg: "encoding/json", typ: $funcType([reflect.Value, $Bool], [Unmarshaler, encoding.TextUnmarshaler, reflect.Value], false)}, {prop: "array", name: "array", pkg: "encoding/json", typ: $funcType([reflect.Value], [], false)}, {prop: "object", name: "object", pkg: "encoding/json", typ: $funcType([reflect.Value], [], false)}, {prop: "literal", name: "literal", pkg: "encoding/json", typ: $funcType([reflect.Value], [], false)}, {prop: "convertNumber", name: "convertNumber", pkg: "encoding/json", typ: $funcType([$String], [$emptyInterface, $error], false)}, {prop: "literalStore", name: "literalStore", pkg: "encoding/json", typ: $funcType([sliceType$1, reflect.Value, $Bool], [], false)}, {prop: "valueInterface", name: "valueInterface", pkg: "encoding/json", typ: $funcType([], [$emptyInterface], false)}, {prop: "arrayInterface", name: "arrayInterface", pkg: "encoding/json", typ: $funcType([], [sliceType$2], false)}, {prop: "objectInterface", name: "objectInterface", pkg: "encoding/json", typ: $funcType([], [mapType$2], false)}, {prop: "literalInterface", name: "literalInterface", pkg: "encoding/json", typ: $funcType([], [$emptyInterface], false)}];
- ptrType$10.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$11.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$13.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$4.methods = [{prop: "marshal", name: "marshal", pkg: "encoding/json", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$error], [], false)}, {prop: "reflectValue", name: "reflectValue", pkg: "encoding/json", typ: $funcType([reflect.Value], [], false)}, {prop: "string", name: "string", pkg: "encoding/json", typ: $funcType([$String], [$Int, $error], false)}, {prop: "stringBytes", name: "stringBytes", pkg: "encoding/json", typ: $funcType([sliceType$1], [$Int, $error], false)}];
- floatEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}];
- ptrType$14.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}];
- ptrType$15.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}];
- ptrType$16.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}];
- ptrType$17.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}];
- ptrType$18.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}];
- ptrType$19.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}];
- stringValues.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "get", name: "get", pkg: "encoding/json", typ: $funcType([$Int], [$String], false)}];
- byName.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}];
- byIndex.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}];
- ptrType$20.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$21.methods = [{prop: "reset", name: "reset", pkg: "encoding/json", typ: $funcType([], [], false)}, {prop: "eof", name: "eof", pkg: "encoding/json", typ: $funcType([], [$Int], false)}, {prop: "pushParseState", name: "pushParseState", pkg: "encoding/json", typ: $funcType([$Int], [], false)}, {prop: "popParseState", name: "popParseState", pkg: "encoding/json", typ: $funcType([], [], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$Int, $String], [$Int], false)}, {prop: "undo", name: "undo", pkg: "encoding/json", typ: $funcType([$Int], [], false)}];
- ptrType$22.methods = [{prop: "UseNumber", name: "UseNumber", pkg: "", typ: $funcType([], [], false)}, {prop: "Decode", name: "Decode", pkg: "", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "Buffered", name: "Buffered", pkg: "", typ: $funcType([], [io.Reader], false)}, {prop: "readValue", name: "readValue", pkg: "encoding/json", typ: $funcType([], [$Int, $error], false)}];
- ptrType$23.methods = [{prop: "Encode", name: "Encode", pkg: "", typ: $funcType([$emptyInterface], [$error], false)}];
- tagOptions.methods = [{prop: "Contains", name: "Contains", pkg: "", typ: $funcType([$String], [$Bool], false)}];
- Unmarshaler.init([{prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType$1], [$error], false)}]);
- UnmarshalTypeError.init([{prop: "Value", name: "Value", pkg: "", typ: $String, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: reflect.Type, tag: ""}]);
- InvalidUnmarshalError.init([{prop: "Type", name: "Type", pkg: "", typ: reflect.Type, tag: ""}]);
- decodeState.init([{prop: "data", name: "data", pkg: "encoding/json", typ: sliceType$1, tag: ""}, {prop: "off", name: "off", pkg: "encoding/json", typ: $Int, tag: ""}, {prop: "scan", name: "scan", pkg: "encoding/json", typ: scanner, tag: ""}, {prop: "nextscan", name: "nextscan", pkg: "encoding/json", typ: scanner, tag: ""}, {prop: "savedError", name: "savedError", pkg: "encoding/json", typ: $error, tag: ""}, {prop: "useNumber", name: "useNumber", pkg: "encoding/json", typ: $Bool, tag: ""}]);
- unquotedValue.init([]);
- Marshaler.init([{prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$1, $error], false)}]);
- UnsupportedTypeError.init([{prop: "Type", name: "Type", pkg: "", typ: reflect.Type, tag: ""}]);
- UnsupportedValueError.init([{prop: "Value", name: "Value", pkg: "", typ: reflect.Value, tag: ""}, {prop: "Str", name: "Str", pkg: "", typ: $String, tag: ""}]);
- MarshalerError.init([{prop: "Type", name: "Type", pkg: "", typ: reflect.Type, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]);
- encodeState.init([{prop: "Buffer", name: "", pkg: "", typ: bytes.Buffer, tag: ""}, {prop: "scratch", name: "scratch", pkg: "encoding/json", typ: arrayType, tag: ""}]);
- encoderFunc.init([ptrType$4, reflect.Value, $Bool], [], false);
- structEncoder.init([{prop: "fields", name: "fields", pkg: "encoding/json", typ: sliceType, tag: ""}, {prop: "fieldEncs", name: "fieldEncs", pkg: "encoding/json", typ: sliceType$3, tag: ""}]);
- mapEncoder.init([{prop: "elemEnc", name: "elemEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]);
- sliceEncoder.init([{prop: "arrayEnc", name: "arrayEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]);
- arrayEncoder.init([{prop: "elemEnc", name: "elemEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]);
- ptrEncoder.init([{prop: "elemEnc", name: "elemEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]);
- condAddrEncoder.init([{prop: "canAddrEnc", name: "canAddrEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}, {prop: "elseEnc", name: "elseEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]);
- stringValues.init(reflect.Value);
- field.init([{prop: "name", name: "name", pkg: "encoding/json", typ: $String, tag: ""}, {prop: "nameBytes", name: "nameBytes", pkg: "encoding/json", typ: sliceType$1, tag: ""}, {prop: "equalFold", name: "equalFold", pkg: "encoding/json", typ: funcType, tag: ""}, {prop: "tag", name: "tag", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "index", name: "index", pkg: "encoding/json", typ: sliceType$4, tag: ""}, {prop: "typ", name: "typ", pkg: "encoding/json", typ: reflect.Type, tag: ""}, {prop: "omitEmpty", name: "omitEmpty", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "quoted", name: "quoted", pkg: "encoding/json", typ: $Bool, tag: ""}]);
- byName.init(field);
- byIndex.init(field);
- SyntaxError.init([{prop: "msg", name: "msg", pkg: "encoding/json", typ: $String, tag: ""}, {prop: "Offset", name: "Offset", pkg: "", typ: $Int64, tag: ""}]);
- scanner.init([{prop: "step", name: "step", pkg: "encoding/json", typ: funcType$1, tag: ""}, {prop: "endTop", name: "endTop", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "parseState", name: "parseState", pkg: "encoding/json", typ: sliceType$4, tag: ""}, {prop: "err", name: "err", pkg: "encoding/json", typ: $error, tag: ""}, {prop: "redo", name: "redo", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "redoCode", name: "redoCode", pkg: "encoding/json", typ: $Int, tag: ""}, {prop: "redoState", name: "redoState", pkg: "encoding/json", typ: funcType$1, tag: ""}, {prop: "bytes", name: "bytes", pkg: "encoding/json", typ: $Int64, tag: ""}]);
- Decoder.init([{prop: "r", name: "r", pkg: "encoding/json", typ: io.Reader, tag: ""}, {prop: "buf", name: "buf", pkg: "encoding/json", typ: sliceType$1, tag: ""}, {prop: "d", name: "d", pkg: "encoding/json", typ: decodeState, tag: ""}, {prop: "scan", name: "scan", pkg: "encoding/json", typ: scanner, tag: ""}, {prop: "err", name: "err", pkg: "encoding/json", typ: $error, tag: ""}]);
- Encoder.init([{prop: "w", name: "w", pkg: "encoding/json", typ: io.Writer, tag: ""}, {prop: "err", name: "err", pkg: "encoding/json", typ: $error, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = encoding.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = base64.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = nosync.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = reflect.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = runtime.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf16.$init(); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- encodeStatePool = new nosync.Pool.ptr();
- encoderCache = new structType.ptr();
- fieldCache = new structType$1.ptr();
- errPhase = errors.New("JSON decoder out of sync - data changing underfoot?");
- nullLiteral = new sliceType$1($stringToBytes("null"));
- numberType = reflect.TypeOf(new Number(""));
- hex = "0123456789abcdef";
- byteSliceType = reflect.TypeOf(sliceType$1.nil);
- _r = reflect.TypeOf($newDataPointer($ifaceNil, ptrType)).Elem(); /* */ $s = 17; case 17: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- marshalerType = _r;
- _r$1 = reflect.TypeOf($newDataPointer($ifaceNil, ptrType$1)).Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- textMarshalerType = _r$1;
- float32Encoder = $methodVal(new floatEncoder(32), "encode");
- float64Encoder = $methodVal(new floatEncoder(64), "encode");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["flag"] = (function() {
- var $pkg = {}, $init, errors, fmt, io, os, sort, strconv, time, boolValue, boolFlag, intValue, int64Value, uintValue, uint64Value, stringValue, float64Value, durationValue, Value, ErrorHandling, FlagSet, Flag, sliceType, ptrType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, sliceType$1, ptrType$10, ptrType$11, ptrType$12, ptrType$13, ptrType$14, ptrType$15, ptrType$16, sliceType$2, funcType, ptrType$17, funcType$1, mapType, x, newBoolValue, newIntValue, newInt64Value, newUintValue, newUint64Value, newStringValue, newFloat64Value, newDurationValue, sortFlags, PrintDefaults, defaultUsage, Bool, Int, String, Duration, NewFlagSet;
- errors = $packages["errors"];
- fmt = $packages["fmt"];
- io = $packages["io"];
- os = $packages["os"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- time = $packages["time"];
- boolValue = $pkg.boolValue = $newType(1, $kindBool, "flag.boolValue", "boolValue", "flag", null);
- boolFlag = $pkg.boolFlag = $newType(8, $kindInterface, "flag.boolFlag", "boolFlag", "flag", null);
- intValue = $pkg.intValue = $newType(4, $kindInt, "flag.intValue", "intValue", "flag", null);
- int64Value = $pkg.int64Value = $newType(8, $kindInt64, "flag.int64Value", "int64Value", "flag", null);
- uintValue = $pkg.uintValue = $newType(4, $kindUint, "flag.uintValue", "uintValue", "flag", null);
- uint64Value = $pkg.uint64Value = $newType(8, $kindUint64, "flag.uint64Value", "uint64Value", "flag", null);
- stringValue = $pkg.stringValue = $newType(8, $kindString, "flag.stringValue", "stringValue", "flag", null);
- float64Value = $pkg.float64Value = $newType(8, $kindFloat64, "flag.float64Value", "float64Value", "flag", null);
- durationValue = $pkg.durationValue = $newType(8, $kindInt64, "flag.durationValue", "durationValue", "flag", null);
- Value = $pkg.Value = $newType(8, $kindInterface, "flag.Value", "Value", "flag", null);
- ErrorHandling = $pkg.ErrorHandling = $newType(4, $kindInt, "flag.ErrorHandling", "ErrorHandling", "flag", null);
- FlagSet = $pkg.FlagSet = $newType(0, $kindStruct, "flag.FlagSet", "FlagSet", "flag", function(Usage_, name_, parsed_, actual_, formal_, args_, errorHandling_, output_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Usage = $throwNilPointerError;
- this.name = "";
- this.parsed = false;
- this.actual = false;
- this.formal = false;
- this.args = sliceType$2.nil;
- this.errorHandling = 0;
- this.output = $ifaceNil;
- return;
- }
- this.Usage = Usage_;
- this.name = name_;
- this.parsed = parsed_;
- this.actual = actual_;
- this.formal = formal_;
- this.args = args_;
- this.errorHandling = errorHandling_;
- this.output = output_;
- });
- Flag = $pkg.Flag = $newType(0, $kindStruct, "flag.Flag", "Flag", "flag", function(Name_, Usage_, Value_, DefValue_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Name = "";
- this.Usage = "";
- this.Value = $ifaceNil;
- this.DefValue = "";
- return;
- }
- this.Name = Name_;
- this.Usage = Usage_;
- this.Value = Value_;
- this.DefValue = DefValue_;
- });
- sliceType = $sliceType($emptyInterface);
- ptrType = $ptrType(boolValue);
- ptrType$1 = $ptrType(intValue);
- ptrType$2 = $ptrType(int64Value);
- ptrType$3 = $ptrType(uintValue);
- ptrType$4 = $ptrType(uint64Value);
- ptrType$5 = $ptrType(stringValue);
- ptrType$6 = $ptrType(float64Value);
- ptrType$7 = $ptrType(durationValue);
- ptrType$8 = $ptrType(time.Duration);
- ptrType$9 = $ptrType(Flag);
- sliceType$1 = $sliceType(ptrType$9);
- ptrType$10 = $ptrType($Bool);
- ptrType$11 = $ptrType($Int);
- ptrType$12 = $ptrType($Int64);
- ptrType$13 = $ptrType($Uint);
- ptrType$14 = $ptrType($Uint64);
- ptrType$15 = $ptrType($String);
- ptrType$16 = $ptrType($Float64);
- sliceType$2 = $sliceType($String);
- funcType = $funcType([ptrType$9], [], false);
- ptrType$17 = $ptrType(FlagSet);
- funcType$1 = $funcType([], [], false);
- mapType = $mapType($String, ptrType$9);
- newBoolValue = function(val, p) {
- var $ptr, _ptr, p, val;
- p.$set(val);
- return (_ptr = p, new ptrType(function() { return _ptr.$get(); }, function($v) { _ptr.$set($v); }, _ptr.$target));
- };
- $ptrType(boolValue).prototype.Set = function(s) {
- var $ptr, _tuple, b, err, s, v;
- b = this;
- _tuple = strconv.ParseBool(s); v = _tuple[0]; err = _tuple[1];
- b.$set(v);
- return err;
- };
- $ptrType(boolValue).prototype.Get = function() {
- var $ptr, b;
- b = this;
- return new $Bool(b.$get());
- };
- $ptrType(boolValue).prototype.String = function() {
- var $ptr, _r, b, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; b = $f.b; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- b = this;
- _r = fmt.Sprintf("%v", new sliceType([new boolValue(b.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(boolValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.b = b; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(boolValue).prototype.IsBoolFlag = function() {
- var $ptr, b;
- b = this;
- return true;
- };
- newIntValue = function(val, p) {
- var $ptr, _ptr, p, val;
- p.$set(val);
- return (_ptr = p, new ptrType$1(function() { return (_ptr.$get() >> 0); }, function($v) { _ptr.$set(($v >> 0)); }, _ptr.$target));
- };
- $ptrType(intValue).prototype.Set = function(s) {
- var $ptr, _tuple, err, i, s, v;
- i = this;
- _tuple = strconv.ParseInt(s, 0, 64); v = _tuple[0]; err = _tuple[1];
- i.$set(((v.$low + ((v.$high >> 31) * 4294967296)) >> 0));
- return err;
- };
- $ptrType(intValue).prototype.Get = function() {
- var $ptr, i;
- i = this;
- return new $Int((i.$get() >> 0));
- };
- $ptrType(intValue).prototype.String = function() {
- var $ptr, _r, i, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = this;
- _r = fmt.Sprintf("%v", new sliceType([new intValue(i.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(intValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f;
- };
- newInt64Value = function(val, p) {
- var $ptr, _ptr, p, val, x$1;
- p.$set(val);
- return (_ptr = p, new ptrType$2(function() { return (x$1 = _ptr.$get(), new int64Value(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new $Int64($v.$high, $v.$low)); }, _ptr.$target));
- };
- $ptrType(int64Value).prototype.Set = function(s) {
- var $ptr, _tuple, err, i, s, v;
- i = this;
- _tuple = strconv.ParseInt(s, 0, 64); v = _tuple[0]; err = _tuple[1];
- i.$set(new int64Value(v.$high, v.$low));
- return err;
- };
- $ptrType(int64Value).prototype.Get = function() {
- var $ptr, i, x$1;
- i = this;
- return (x$1 = i.$get(), new $Int64(x$1.$high, x$1.$low));
- };
- $ptrType(int64Value).prototype.String = function() {
- var $ptr, _r, i, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = this;
- _r = fmt.Sprintf("%v", new sliceType([i.$get()])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(int64Value).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f;
- };
- newUintValue = function(val, p) {
- var $ptr, _ptr, p, val;
- p.$set(val);
- return (_ptr = p, new ptrType$3(function() { return (_ptr.$get() >>> 0); }, function($v) { _ptr.$set(($v >>> 0)); }, _ptr.$target));
- };
- $ptrType(uintValue).prototype.Set = function(s) {
- var $ptr, _tuple, err, i, s, v;
- i = this;
- _tuple = strconv.ParseUint(s, 0, 64); v = _tuple[0]; err = _tuple[1];
- i.$set((v.$low >>> 0));
- return err;
- };
- $ptrType(uintValue).prototype.Get = function() {
- var $ptr, i;
- i = this;
- return new $Uint((i.$get() >>> 0));
- };
- $ptrType(uintValue).prototype.String = function() {
- var $ptr, _r, i, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = this;
- _r = fmt.Sprintf("%v", new sliceType([new uintValue(i.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(uintValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f;
- };
- newUint64Value = function(val, p) {
- var $ptr, _ptr, p, val, x$1;
- p.$set(val);
- return (_ptr = p, new ptrType$4(function() { return (x$1 = _ptr.$get(), new uint64Value(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new $Uint64($v.$high, $v.$low)); }, _ptr.$target));
- };
- $ptrType(uint64Value).prototype.Set = function(s) {
- var $ptr, _tuple, err, i, s, v;
- i = this;
- _tuple = strconv.ParseUint(s, 0, 64); v = _tuple[0]; err = _tuple[1];
- i.$set(new uint64Value(v.$high, v.$low));
- return err;
- };
- $ptrType(uint64Value).prototype.Get = function() {
- var $ptr, i, x$1;
- i = this;
- return (x$1 = i.$get(), new $Uint64(x$1.$high, x$1.$low));
- };
- $ptrType(uint64Value).prototype.String = function() {
- var $ptr, _r, i, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = this;
- _r = fmt.Sprintf("%v", new sliceType([i.$get()])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(uint64Value).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f;
- };
- newStringValue = function(val, p) {
- var $ptr, _ptr, p, val;
- p.$set(val);
- return (_ptr = p, new ptrType$5(function() { return _ptr.$get(); }, function($v) { _ptr.$set($v); }, _ptr.$target));
- };
- $ptrType(stringValue).prototype.Set = function(val) {
- var $ptr, s, val;
- s = this;
- s.$set(val);
- return $ifaceNil;
- };
- $ptrType(stringValue).prototype.Get = function() {
- var $ptr, s;
- s = this;
- return new $String(s.$get());
- };
- $ptrType(stringValue).prototype.String = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = fmt.Sprintf("%s", new sliceType([new stringValue(s.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(stringValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- newFloat64Value = function(val, p) {
- var $ptr, _ptr, p, val;
- p.$set(val);
- return (_ptr = p, new ptrType$6(function() { return _ptr.$get(); }, function($v) { _ptr.$set($v); }, _ptr.$target));
- };
- $ptrType(float64Value).prototype.Set = function(s) {
- var $ptr, _tuple, err, f, s, v;
- f = this;
- _tuple = strconv.ParseFloat(s, 64); v = _tuple[0]; err = _tuple[1];
- f.$set(v);
- return err;
- };
- $ptrType(float64Value).prototype.Get = function() {
- var $ptr, f;
- f = this;
- return new $Float64(f.$get());
- };
- $ptrType(float64Value).prototype.String = function() {
- var $ptr, _r, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- _r = fmt.Sprintf("%v", new sliceType([new float64Value(f.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(float64Value).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- newDurationValue = function(val, p) {
- var $ptr, _ptr, p, val, x$1;
- p.$set(val);
- return (_ptr = p, new ptrType$7(function() { return (x$1 = _ptr.$get(), new durationValue(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new time.Duration($v.$high, $v.$low)); }, _ptr.$target));
- };
- $ptrType(durationValue).prototype.Set = function(s) {
- var $ptr, _tuple, d, err, s, v;
- d = this;
- _tuple = time.ParseDuration(s); v = _tuple[0]; err = _tuple[1];
- d.$set(new durationValue(v.$high, v.$low));
- return err;
- };
- $ptrType(durationValue).prototype.Get = function() {
- var $ptr, d, x$1;
- d = this;
- return (x$1 = d.$get(), new time.Duration(x$1.$high, x$1.$low));
- };
- $ptrType(durationValue).prototype.String = function() {
- var $ptr, _ptr, d, x$1;
- d = this;
- return (_ptr = d, new ptrType$8(function() { return (x$1 = _ptr.$get(), new time.Duration(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new durationValue($v.$high, $v.$low)); }, _ptr.$target)).String();
- };
- sortFlags = function(flags) {
- var $ptr, _entry, _entry$1, _i, _i$1, _keys, _ref, _ref$1, f, flags, i, i$1, list, name, result, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _i$1 = $f._i$1; _keys = $f._keys; _ref = $f._ref; _ref$1 = $f._ref$1; f = $f.f; flags = $f.flags; i = $f.i; i$1 = $f.i$1; list = $f.list; name = $f.name; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- list = $makeSlice(sort.StringSlice, $keys(flags).length);
- i = 0;
- _ref = flags;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- f = _entry.v;
- ((i < 0 || i >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + i] = f.Name);
- i = i + (1) >> 0;
- _i++;
- }
- $r = list.Sort(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- result = $makeSlice(sliceType$1, list.$length);
- _ref$1 = list;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- i$1 = _i$1;
- name = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- ((i$1 < 0 || i$1 >= result.$length) ? $throwRuntimeError("index out of range") : result.$array[result.$offset + i$1] = (_entry$1 = flags[$String.keyFor(name)], _entry$1 !== undefined ? _entry$1.v : ptrType$9.nil));
- _i$1++;
- }
- return result;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sortFlags }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._i$1 = _i$1; $f._keys = _keys; $f._ref = _ref; $f._ref$1 = _ref$1; $f.f = f; $f.flags = flags; $f.i = i; $f.i$1 = i$1; $f.list = list; $f.name = name; $f.result = result; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.ptr.prototype.out = function() {
- var $ptr, f;
- f = this;
- if ($interfaceIsEqual(f.output, $ifaceNil)) {
- return os.Stderr;
- }
- return f.output;
- };
- FlagSet.prototype.out = function() { return this.$val.out(); };
- FlagSet.ptr.prototype.SetOutput = function(output) {
- var $ptr, f, output;
- f = this;
- f.output = output;
- };
- FlagSet.prototype.SetOutput = function(output) { return this.$val.SetOutput(output); };
- FlagSet.ptr.prototype.VisitAll = function(fn) {
- var $ptr, _i, _r, _ref, f, flag, fn, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; f = $f.f; flag = $f.flag; fn = $f.fn; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- _r = sortFlags(f.formal); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- flag = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = fn(flag); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 2; continue; case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.VisitAll }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.f = f; $f.flag = flag; $f.fn = fn; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.VisitAll = function(fn) { return this.$val.VisitAll(fn); };
- FlagSet.ptr.prototype.Visit = function(fn) {
- var $ptr, _i, _r, _ref, f, flag, fn, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; f = $f.f; flag = $f.flag; fn = $f.fn; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- _r = sortFlags(f.actual); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- flag = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = fn(flag); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 2; continue; case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Visit }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.f = f; $f.flag = flag; $f.fn = fn; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Visit = function(fn) { return this.$val.Visit(fn); };
- FlagSet.ptr.prototype.Lookup = function(name) {
- var $ptr, _entry, f, name;
- f = this;
- return (_entry = f.formal[$String.keyFor(name)], _entry !== undefined ? _entry.v : ptrType$9.nil);
- };
- FlagSet.prototype.Lookup = function(name) { return this.$val.Lookup(name); };
- FlagSet.ptr.prototype.Set = function(name, value) {
- var $ptr, _entry, _key, _r, _r$1, _tuple, err, f, flag, name, ok, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; f = $f.f; flag = $f.flag; name = $f.name; ok = $f.ok; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- _tuple = (_entry = f.formal[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [ptrType$9.nil, false]); flag = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!ok) { */ case 1:
- _r = fmt.Errorf("no such flag -%v", new sliceType([new $String(name)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- _r$1 = flag.Value.Set(value); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- err = _r$1;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return err;
- }
- if (f.actual === false) {
- f.actual = new $Map();
- }
- _key = name; (f.actual || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: flag };
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Set }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.flag = flag; $f.name = name; $f.ok = ok; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Set = function(name, value) { return this.$val.Set(name, value); };
- FlagSet.ptr.prototype.PrintDefaults = function() {
- var $ptr, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = [f];
- f[0] = this;
- $r = f[0].VisitAll((function(f) { return function $b(flag) {
- var $ptr, _r, _tuple, flag, format, ok, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; flag = $f.flag; format = $f.format; ok = $f.ok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- format = " -%s=%s: %s\n";
- _tuple = $assertType(flag.Value, ptrType$5, true); ok = _tuple[1];
- if (ok) {
- format = " -%s=%q: %s\n";
- }
- _r = fmt.Fprintf(f[0].out(), format, new sliceType([new $String(flag.Name), new $String(flag.DefValue), new $String(flag.Usage)])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.flag = flag; $f.format = format; $f.ok = ok; $f.$s = $s; $f.$r = $r; return $f;
- }; })(f)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.PrintDefaults }; } $f.$ptr = $ptr; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.PrintDefaults = function() { return this.$val.PrintDefaults(); };
- PrintDefaults = function() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = $pkg.CommandLine.PrintDefaults(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: PrintDefaults }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.PrintDefaults = PrintDefaults;
- defaultUsage = function(f) {
- var $ptr, _r, _r$1, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (f.name === "") { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (f.name === "") { */ case 1:
- _r = fmt.Fprintf(f.out(), "Usage:\n", new sliceType([])); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- $s = 3; continue;
- /* } else { */ case 2:
- _r$1 = fmt.Fprintf(f.out(), "Usage of %s:\n", new sliceType([new $String(f.name)])); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- /* } */ case 3:
- $r = f.PrintDefaults(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: defaultUsage }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.ptr.prototype.NFlag = function() {
- var $ptr, f;
- f = this;
- return $keys(f.actual).length;
- };
- FlagSet.prototype.NFlag = function() { return this.$val.NFlag(); };
- FlagSet.ptr.prototype.Arg = function(i) {
- var $ptr, f, i, x$1;
- f = this;
- if (i < 0 || i >= f.args.$length) {
- return "";
- }
- return (x$1 = f.args, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i]));
- };
- FlagSet.prototype.Arg = function(i) { return this.$val.Arg(i); };
- FlagSet.ptr.prototype.NArg = function() {
- var $ptr, f;
- f = this;
- return f.args.$length;
- };
- FlagSet.prototype.NArg = function() { return this.$val.NArg(); };
- FlagSet.ptr.prototype.Args = function() {
- var $ptr, f;
- f = this;
- return f.args;
- };
- FlagSet.prototype.Args = function() { return this.$val.Args(); };
- FlagSet.ptr.prototype.BoolVar = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newBoolValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.BoolVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.BoolVar = function(p, name, value, usage) { return this.$val.BoolVar(p, name, value, usage); };
- FlagSet.ptr.prototype.Bool = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer(false, ptrType$10);
- $r = f.BoolVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Bool }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Bool = function(name, value, usage) { return this.$val.Bool(name, value, usage); };
- Bool = function(name, value, usage) {
- var $ptr, _r, name, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = $pkg.CommandLine.Bool(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Bool }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Bool = Bool;
- FlagSet.ptr.prototype.IntVar = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newIntValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.IntVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.IntVar = function(p, name, value, usage) { return this.$val.IntVar(p, name, value, usage); };
- FlagSet.ptr.prototype.Int = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer(0, ptrType$11);
- $r = f.IntVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Int }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Int = function(name, value, usage) { return this.$val.Int(name, value, usage); };
- Int = function(name, value, usage) {
- var $ptr, _r, name, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = $pkg.CommandLine.Int(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Int = Int;
- FlagSet.ptr.prototype.Int64Var = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newInt64Value(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Int64Var }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Int64Var = function(p, name, value, usage) { return this.$val.Int64Var(p, name, value, usage); };
- FlagSet.ptr.prototype.Int64 = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer(new $Int64(0, 0), ptrType$12);
- $r = f.Int64Var(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Int64 }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Int64 = function(name, value, usage) { return this.$val.Int64(name, value, usage); };
- FlagSet.ptr.prototype.UintVar = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newUintValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.UintVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.UintVar = function(p, name, value, usage) { return this.$val.UintVar(p, name, value, usage); };
- FlagSet.ptr.prototype.Uint = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer(0, ptrType$13);
- $r = f.UintVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Uint }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Uint = function(name, value, usage) { return this.$val.Uint(name, value, usage); };
- FlagSet.ptr.prototype.Uint64Var = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newUint64Value(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Uint64Var }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Uint64Var = function(p, name, value, usage) { return this.$val.Uint64Var(p, name, value, usage); };
- FlagSet.ptr.prototype.Uint64 = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer(new $Uint64(0, 0), ptrType$14);
- $r = f.Uint64Var(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Uint64 }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Uint64 = function(name, value, usage) { return this.$val.Uint64(name, value, usage); };
- FlagSet.ptr.prototype.StringVar = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newStringValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.StringVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.StringVar = function(p, name, value, usage) { return this.$val.StringVar(p, name, value, usage); };
- FlagSet.ptr.prototype.String = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer("", ptrType$15);
- $r = f.StringVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.String }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.String = function(name, value, usage) { return this.$val.String(name, value, usage); };
- String = function(name, value, usage) {
- var $ptr, _r, name, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = $pkg.CommandLine.String(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: String }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.String = String;
- FlagSet.ptr.prototype.Float64Var = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newFloat64Value(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Float64Var }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Float64Var = function(p, name, value, usage) { return this.$val.Float64Var(p, name, value, usage); };
- FlagSet.ptr.prototype.Float64 = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer(0, ptrType$16);
- $r = f.Float64Var(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Float64 }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Float64 = function(name, value, usage) { return this.$val.Float64(name, value, usage); };
- FlagSet.ptr.prototype.DurationVar = function(p, name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- $r = f.Var(newDurationValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.DurationVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.DurationVar = function(p, name, value, usage) { return this.$val.DurationVar(p, name, value, usage); };
- FlagSet.ptr.prototype.Duration = function(name, value, usage) {
- var $ptr, f, name, p, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- p = $newDataPointer(new time.Duration(0, 0), ptrType$8);
- $r = f.DurationVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Duration }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Duration = function(name, value, usage) { return this.$val.Duration(name, value, usage); };
- Duration = function(name, value, usage) {
- var $ptr, _r, name, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = $pkg.CommandLine.Duration(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Duration }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Duration = Duration;
- FlagSet.ptr.prototype.Var = function(value, name, usage) {
- var $ptr, _entry, _key, _r, _r$1, _r$2, _r$3, _tuple, alreadythere, f, flag, msg, name, usage, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; alreadythere = $f.alreadythere; f = $f.f; flag = $f.flag; msg = $f.msg; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- _r = value.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- flag = new Flag.ptr(name, usage, value, _r);
- _tuple = (_entry = f.formal[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [ptrType$9.nil, false]); alreadythere = _tuple[1];
- /* */ if (alreadythere) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (alreadythere) { */ case 2:
- msg = "";
- /* */ if (f.name === "") { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (f.name === "") { */ case 4:
- _r$1 = fmt.Sprintf("flag redefined: %s", new sliceType([new $String(name)])); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- msg = _r$1;
- $s = 6; continue;
- /* } else { */ case 5:
- _r$2 = fmt.Sprintf("%s flag redefined: %s", new sliceType([new $String(f.name), new $String(name)])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- msg = _r$2;
- /* } */ case 6:
- _r$3 = fmt.Fprintln(f.out(), new sliceType([new $String(msg)])); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- $panic(new $String(msg));
- /* } */ case 3:
- if (f.formal === false) {
- f.formal = new $Map();
- }
- _key = name; (f.formal || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: flag };
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Var }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.alreadythere = alreadythere; $f.f = f; $f.flag = flag; $f.msg = msg; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Var = function(value, name, usage) { return this.$val.Var(value, name, usage); };
- FlagSet.ptr.prototype.failf = function(format, a) {
- var $ptr, _r, _r$1, a, err, f, format, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; a = $f.a; err = $f.err; f = $f.f; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- _r = fmt.Errorf(format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- _r$1 = fmt.Fprintln(f.out(), new sliceType([err])); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- $r = f.usage(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.failf }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.err = err; $f.f = f; $f.format = format; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.failf = function(format, a) { return this.$val.failf(format, a); };
- FlagSet.ptr.prototype.usage = function() {
- var $ptr, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- /* */ if (f.Usage === $throwNilPointerError) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (f.Usage === $throwNilPointerError) { */ case 1:
- /* */ if (f === $pkg.CommandLine) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (f === $pkg.CommandLine) { */ case 4:
- $r = $pkg.Usage(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else { */ case 5:
- $r = defaultUsage(f); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- $s = 3; continue;
- /* } else { */ case 2:
- $r = f.Usage(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.usage }; } $f.$ptr = $ptr; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.usage = function() { return this.$val.usage(); };
- FlagSet.ptr.prototype.parseOne = function() {
- var $ptr, _entry, _key, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _tmp, _tmp$1, _tuple, _tuple$1, _v, alreadythere, err, err$1, f, flag, fv, has_value, i, m, name, num_minuses, ok, s, value, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; alreadythere = $f.alreadythere; err = $f.err; err$1 = $f.err$1; f = $f.f; flag = $f.flag; fv = $f.fv; has_value = $f.has_value; i = $f.i; m = $f.m; name = $f.name; num_minuses = $f.num_minuses; ok = $f.ok; s = $f.s; value = $f.value; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- if (f.args.$length === 0) {
- return [false, $ifaceNil];
- }
- s = (x$1 = f.args, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0]));
- if ((s.length === 0) || !((s.charCodeAt(0) === 45)) || (s.length === 1)) {
- return [false, $ifaceNil];
- }
- num_minuses = 1;
- if (s.charCodeAt(1) === 45) {
- num_minuses = num_minuses + (1) >> 0;
- if (s.length === 2) {
- f.args = $subslice(f.args, 1);
- return [false, $ifaceNil];
- }
- }
- name = s.substring(num_minuses);
- /* */ if ((name.length === 0) || (name.charCodeAt(0) === 45) || (name.charCodeAt(0) === 61)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((name.length === 0) || (name.charCodeAt(0) === 45) || (name.charCodeAt(0) === 61)) { */ case 1:
- _r = f.failf("bad flag syntax: %s", new sliceType([new $String(s)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return [false, _r];
- /* } */ case 2:
- f.args = $subslice(f.args, 1);
- has_value = false;
- value = "";
- i = 1;
- while (true) {
- if (!(i < name.length)) { break; }
- if (name.charCodeAt(i) === 61) {
- value = name.substring((i + 1 >> 0));
- has_value = true;
- name = name.substring(0, i);
- break;
- }
- i = i + (1) >> 0;
- }
- m = f.formal;
- _tuple = (_entry = m[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [ptrType$9.nil, false]); flag = _tuple[0]; alreadythere = _tuple[1];
- /* */ if (!alreadythere) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!alreadythere) { */ case 4:
- /* */ if (name === "help" || name === "h") { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (name === "help" || name === "h") { */ case 6:
- $r = f.usage(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [false, $pkg.ErrHelp];
- /* } */ case 7:
- _r$1 = f.failf("flag provided but not defined: -%s", new sliceType([new $String(name)])); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return [false, _r$1];
- /* } */ case 5:
- _tuple$1 = $assertType(flag.Value, boolFlag, true); fv = _tuple$1[0]; ok = _tuple$1[1];
- if (!(ok)) { _v = false; $s = 13; continue s; }
- _r$2 = fv.IsBoolFlag(); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2; case 13:
- /* */ if (_v) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_v) { */ case 10:
- /* */ if (has_value) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (has_value) { */ case 15:
- _r$3 = fv.Set(value); /* */ $s = 18; case 18: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- err = _r$3;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 19:
- _r$4 = f.failf("invalid boolean value %q for -%s: %v", new sliceType([new $String(value), new $String(name), err])); /* */ $s = 21; case 21: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return [false, _r$4];
- /* } */ case 20:
- $s = 17; continue;
- /* } else { */ case 16:
- _r$5 = fv.Set("true"); /* */ $s = 22; case 22: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$5;
- /* } */ case 17:
- $s = 12; continue;
- /* } else { */ case 11:
- if (!has_value && f.args.$length > 0) {
- has_value = true;
- _tmp = (x$2 = f.args, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])); _tmp$1 = $subslice(f.args, 1); value = _tmp; f.args = _tmp$1;
- }
- /* */ if (!has_value) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (!has_value) { */ case 23:
- _r$6 = f.failf("flag needs an argument: -%s", new sliceType([new $String(name)])); /* */ $s = 25; case 25: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return [false, _r$6];
- /* } */ case 24:
- _r$7 = flag.Value.Set(value); /* */ $s = 26; case 26: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- err$1 = _r$7;
- /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 27:
- _r$8 = f.failf("invalid value %q for flag -%s: %v", new sliceType([new $String(value), new $String(name), err$1])); /* */ $s = 29; case 29: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- return [false, _r$8];
- /* } */ case 28:
- /* } */ case 12:
- if (f.actual === false) {
- f.actual = new $Map();
- }
- _key = name; (f.actual || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: flag };
- return [true, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.parseOne }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f.alreadythere = alreadythere; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.flag = flag; $f.fv = fv; $f.has_value = has_value; $f.i = i; $f.m = m; $f.name = name; $f.num_minuses = num_minuses; $f.ok = ok; $f.s = s; $f.value = value; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.parseOne = function() { return this.$val.parseOne(); };
- FlagSet.ptr.prototype.Parse = function(arguments$1) {
- var $ptr, _r, _ref, _tuple, arguments$1, err, f, seen, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; arguments$1 = $f.arguments$1; err = $f.err; f = $f.f; seen = $f.seen; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- f.parsed = true;
- f.args = arguments$1;
- /* while (true) { */ case 1:
- _r = f.parseOne(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; seen = _tuple[0]; err = _tuple[1];
- if (seen) {
- /* continue; */ $s = 1; continue;
- }
- if ($interfaceIsEqual(err, $ifaceNil)) {
- /* break; */ $s = 2; continue;
- }
- _ref = f.errorHandling;
- if (_ref === 0) {
- return err;
- } else if (_ref === 1) {
- os.Exit(2);
- } else if (_ref === 2) {
- $panic(err);
- }
- /* } */ $s = 1; continue; case 2:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Parse }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.arguments$1 = arguments$1; $f.err = err; $f.f = f; $f.seen = seen; $f.$s = $s; $f.$r = $r; return $f;
- };
- FlagSet.prototype.Parse = function(arguments$1) { return this.$val.Parse(arguments$1); };
- FlagSet.ptr.prototype.Parsed = function() {
- var $ptr, f;
- f = this;
- return f.parsed;
- };
- FlagSet.prototype.Parsed = function() { return this.$val.Parsed(); };
- NewFlagSet = function(name, errorHandling) {
- var $ptr, errorHandling, f, name;
- f = new FlagSet.ptr($throwNilPointerError, name, false, false, false, sliceType$2.nil, errorHandling, $ifaceNil);
- return f;
- };
- $pkg.NewFlagSet = NewFlagSet;
- FlagSet.ptr.prototype.Init = function(name, errorHandling) {
- var $ptr, errorHandling, f, name;
- f = this;
- f.name = name;
- f.errorHandling = errorHandling;
- };
- FlagSet.prototype.Init = function(name, errorHandling) { return this.$val.Init(name, errorHandling); };
- ptrType.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsBoolFlag", name: "IsBoolFlag", pkg: "", typ: $funcType([], [$Bool], false)}];
- ptrType$1.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$2.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$3.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$4.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$5.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$6.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$7.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$17.methods = [{prop: "out", name: "out", pkg: "flag", typ: $funcType([], [io.Writer], false)}, {prop: "SetOutput", name: "SetOutput", pkg: "", typ: $funcType([io.Writer], [], false)}, {prop: "VisitAll", name: "VisitAll", pkg: "", typ: $funcType([funcType], [], false)}, {prop: "Visit", name: "Visit", pkg: "", typ: $funcType([funcType], [], false)}, {prop: "Lookup", name: "Lookup", pkg: "", typ: $funcType([$String], [ptrType$9], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String, $String], [$error], false)}, {prop: "PrintDefaults", name: "PrintDefaults", pkg: "", typ: $funcType([], [], false)}, {prop: "NFlag", name: "NFlag", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Arg", name: "Arg", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "NArg", name: "NArg", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Args", name: "Args", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "BoolVar", name: "BoolVar", pkg: "", typ: $funcType([ptrType$10, $String, $Bool, $String], [], false)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([$String, $Bool, $String], [ptrType$10], false)}, {prop: "IntVar", name: "IntVar", pkg: "", typ: $funcType([ptrType$11, $String, $Int, $String], [], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([$String, $Int, $String], [ptrType$11], false)}, {prop: "Int64Var", name: "Int64Var", pkg: "", typ: $funcType([ptrType$12, $String, $Int64, $String], [], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([$String, $Int64, $String], [ptrType$12], false)}, {prop: "UintVar", name: "UintVar", pkg: "", typ: $funcType([ptrType$13, $String, $Uint, $String], [], false)}, {prop: "Uint", name: "Uint", pkg: "", typ: $funcType([$String, $Uint, $String], [ptrType$13], false)}, {prop: "Uint64Var", name: "Uint64Var", pkg: "", typ: $funcType([ptrType$14, $String, $Uint64, $String], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([$String, $Uint64, $String], [ptrType$14], false)}, {prop: "StringVar", name: "StringVar", pkg: "", typ: $funcType([ptrType$15, $String, $String, $String], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([$String, $String, $String], [ptrType$15], false)}, {prop: "Float64Var", name: "Float64Var", pkg: "", typ: $funcType([ptrType$16, $String, $Float64, $String], [], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([$String, $Float64, $String], [ptrType$16], false)}, {prop: "DurationVar", name: "DurationVar", pkg: "", typ: $funcType([ptrType$8, $String, time.Duration, $String], [], false)}, {prop: "Duration", name: "Duration", pkg: "", typ: $funcType([$String, time.Duration, $String], [ptrType$8], false)}, {prop: "Var", name: "Var", pkg: "", typ: $funcType([Value, $String, $String], [], false)}, {prop: "failf", name: "failf", pkg: "flag", typ: $funcType([$String, sliceType], [$error], true)}, {prop: "usage", name: "usage", pkg: "flag", typ: $funcType([], [], false)}, {prop: "parseOne", name: "parseOne", pkg: "flag", typ: $funcType([], [$Bool, $error], false)}, {prop: "Parse", name: "Parse", pkg: "", typ: $funcType([sliceType$2], [$error], false)}, {prop: "Parsed", name: "Parsed", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Init", name: "Init", pkg: "", typ: $funcType([$String, ErrorHandling], [], false)}];
- boolFlag.init([{prop: "IsBoolFlag", name: "IsBoolFlag", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]);
- Value.init([{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]);
- FlagSet.init([{prop: "Usage", name: "Usage", pkg: "", typ: funcType$1, tag: ""}, {prop: "name", name: "name", pkg: "flag", typ: $String, tag: ""}, {prop: "parsed", name: "parsed", pkg: "flag", typ: $Bool, tag: ""}, {prop: "actual", name: "actual", pkg: "flag", typ: mapType, tag: ""}, {prop: "formal", name: "formal", pkg: "flag", typ: mapType, tag: ""}, {prop: "args", name: "args", pkg: "flag", typ: sliceType$2, tag: ""}, {prop: "errorHandling", name: "errorHandling", pkg: "flag", typ: ErrorHandling, tag: ""}, {prop: "output", name: "output", pkg: "flag", typ: io.Writer, tag: ""}]);
- Flag.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Usage", name: "Usage", pkg: "", typ: $String, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: Value, tag: ""}, {prop: "DefValue", name: "DefValue", pkg: "", typ: $String, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = time.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.ErrHelp = errors.New("flag: help requested");
- $pkg.CommandLine = NewFlagSet((x = os.Args, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])), 1);
- $pkg.Usage = (function $b() {
- var $ptr, _r, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = fmt.Fprintf(os.Stderr, "Usage of %s:\n", new sliceType([new $String((x$1 = os.Args, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])))])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- $r = PrintDefaults(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- });
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["runtime/pprof"] = (function() {
- var $pkg = {}, $init, io, sync;
- io = $packages["io"];
- sync = $packages["sync"];
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = io.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["testing"] = (function() {
- var $pkg = {}, $init, bytes, flag, fmt, nosync, io, os, runtime, pprof, strconv, strings, atomic, time, matchBenchmarks, benchTime, benchmarkMemory, short$1, outputDir, chatty, coverProfile, match, memProfile, memProfileRate, cpuProfile, blockProfile, blockProfileRate, timeout, cpuListStr, parallel, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15;
- bytes = $packages["bytes"];
- flag = $packages["flag"];
- fmt = $packages["fmt"];
- nosync = $packages["github.com/gopherjs/gopherjs/nosync"];
- io = $packages["io"];
- os = $packages["os"];
- runtime = $packages["runtime"];
- pprof = $packages["runtime/pprof"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- atomic = $packages["sync/atomic"];
- time = $packages["time"];
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = flag.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = nosync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = runtime.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = pprof.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = atomic.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = time.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = flag.String("test.bench", "", "regular expression to select benchmarks to run"); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- matchBenchmarks = _r;
- _r$1 = flag.Duration("test.benchtime", new time.Duration(0, 1000000000), "approximate run time for each benchmark"); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- benchTime = _r$1;
- _r$2 = flag.Bool("test.benchmem", false, "print memory allocations for benchmarks"); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- benchmarkMemory = _r$2;
- _r$3 = flag.Bool("test.short", false, "run smaller test suite to save time"); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- short$1 = _r$3;
- _r$4 = flag.String("test.outputdir", "", "directory in which to write profiles"); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- outputDir = _r$4;
- _r$5 = flag.Bool("test.v", false, "verbose: print additional output"); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- chatty = _r$5;
- _r$6 = flag.String("test.coverprofile", "", "write a coverage profile to the named file after execution"); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- coverProfile = _r$6;
- _r$7 = flag.String("test.run", "", "regular expression to select tests and examples to run"); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- match = _r$7;
- _r$8 = flag.String("test.memprofile", "", "write a memory profile to the named file after execution"); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- memProfile = _r$8;
- _r$9 = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate"); /* */ $s = 22; case 22: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- memProfileRate = _r$9;
- _r$10 = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution"); /* */ $s = 23; case 23: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- cpuProfile = _r$10;
- _r$11 = flag.String("test.blockprofile", "", "write a goroutine blocking profile to the named file after execution"); /* */ $s = 24; case 24: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- blockProfile = _r$11;
- _r$12 = flag.Int("test.blockprofilerate", 1, "if >= 0, calls runtime.SetBlockProfileRate()"); /* */ $s = 25; case 25: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- blockProfileRate = _r$12;
- _r$13 = flag.Duration("test.timeout", new time.Duration(0, 0), "if positive, sets an aggregate time limit for all tests"); /* */ $s = 26; case 26: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- timeout = _r$13;
- _r$14 = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test"); /* */ $s = 27; case 27: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- cpuListStr = _r$14;
- _r$15 = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism"); /* */ $s = 28; case 28: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- parallel = _r$15;
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["go/token"] = (function() {
- var $pkg = {}, $init, fmt, nosync, sort, strconv, testing, Position, Pos, File, lineInfo, FileSet, serializedFile, serializedFileSet, Token, sliceType, sliceType$1, ptrType, sliceType$2, sliceType$3, sliceType$4, ptrType$1, ptrType$2, sliceType$5, funcType, funcType$1, tokens, keywords, searchLineInfos, NewFileSet, searchFiles, searchInts, init, Lookup;
- fmt = $packages["fmt"];
- nosync = $packages["github.com/gopherjs/gopherjs/nosync"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- testing = $packages["testing"];
- Position = $pkg.Position = $newType(0, $kindStruct, "token.Position", "Position", "go/token", function(Filename_, Offset_, Line_, Column_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Filename = "";
- this.Offset = 0;
- this.Line = 0;
- this.Column = 0;
- return;
- }
- this.Filename = Filename_;
- this.Offset = Offset_;
- this.Line = Line_;
- this.Column = Column_;
- });
- Pos = $pkg.Pos = $newType(4, $kindInt, "token.Pos", "Pos", "go/token", null);
- File = $pkg.File = $newType(0, $kindStruct, "token.File", "File", "go/token", function(set_, name_, base_, size_, lines_, infos_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.set = ptrType$2.nil;
- this.name = "";
- this.base = 0;
- this.size = 0;
- this.lines = sliceType$1.nil;
- this.infos = sliceType$3.nil;
- return;
- }
- this.set = set_;
- this.name = name_;
- this.base = base_;
- this.size = size_;
- this.lines = lines_;
- this.infos = infos_;
- });
- lineInfo = $pkg.lineInfo = $newType(0, $kindStruct, "token.lineInfo", "lineInfo", "go/token", function(Offset_, Filename_, Line_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Offset = 0;
- this.Filename = "";
- this.Line = 0;
- return;
- }
- this.Offset = Offset_;
- this.Filename = Filename_;
- this.Line = Line_;
- });
- FileSet = $pkg.FileSet = $newType(0, $kindStruct, "token.FileSet", "FileSet", "go/token", function(mutex_, base_, files_, last_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.mutex = new nosync.RWMutex.ptr();
- this.base = 0;
- this.files = sliceType$2.nil;
- this.last = ptrType.nil;
- return;
- }
- this.mutex = mutex_;
- this.base = base_;
- this.files = files_;
- this.last = last_;
- });
- serializedFile = $pkg.serializedFile = $newType(0, $kindStruct, "token.serializedFile", "serializedFile", "go/token", function(Name_, Base_, Size_, Lines_, Infos_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Name = "";
- this.Base = 0;
- this.Size = 0;
- this.Lines = sliceType$1.nil;
- this.Infos = sliceType$3.nil;
- return;
- }
- this.Name = Name_;
- this.Base = Base_;
- this.Size = Size_;
- this.Lines = Lines_;
- this.Infos = Infos_;
- });
- serializedFileSet = $pkg.serializedFileSet = $newType(0, $kindStruct, "token.serializedFileSet", "serializedFileSet", "go/token", function(Base_, Files_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Base = 0;
- this.Files = sliceType$4.nil;
- return;
- }
- this.Base = Base_;
- this.Files = Files_;
- });
- Token = $pkg.Token = $newType(4, $kindInt, "token.Token", "Token", "go/token", null);
- sliceType = $sliceType($emptyInterface);
- sliceType$1 = $sliceType($Int);
- ptrType = $ptrType(File);
- sliceType$2 = $sliceType(ptrType);
- sliceType$3 = $sliceType(lineInfo);
- sliceType$4 = $sliceType(serializedFile);
- ptrType$1 = $ptrType(Position);
- ptrType$2 = $ptrType(FileSet);
- sliceType$5 = $sliceType($Uint8);
- funcType = $funcType([ptrType], [$Bool], false);
- funcType$1 = $funcType([$emptyInterface], [$error], false);
- Position.ptr.prototype.IsValid = function() {
- var $ptr, pos;
- pos = this;
- return pos.Line > 0;
- };
- Position.prototype.IsValid = function() { return this.$val.IsValid(); };
- Position.ptr.prototype.String = function() {
- var $ptr, _r, pos, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; pos = $f.pos; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = $clone(this, Position);
- s = pos.Filename;
- /* */ if (pos.IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (pos.IsValid()) { */ case 1:
- if (!(s === "")) {
- s = s + (":");
- }
- _r = fmt.Sprintf("%d:%d", new sliceType([new $Int(pos.Line), new $Int(pos.Column)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- s = s + (_r);
- /* } */ case 2:
- if (s === "") {
- s = "-";
- }
- return s;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Position.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.pos = pos; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Position.prototype.String = function() { return this.$val.String(); };
- Pos.prototype.IsValid = function() {
- var $ptr, p;
- p = this.$val;
- return !((p === 0));
- };
- $ptrType(Pos).prototype.IsValid = function() { return new Pos(this.$get()).IsValid(); };
- File.ptr.prototype.Name = function() {
- var $ptr, f;
- f = this;
- return f.name;
- };
- File.prototype.Name = function() { return this.$val.Name(); };
- File.ptr.prototype.Base = function() {
- var $ptr, f;
- f = this;
- return f.base;
- };
- File.prototype.Base = function() { return this.$val.Base(); };
- File.ptr.prototype.Size = function() {
- var $ptr, f;
- f = this;
- return f.size;
- };
- File.prototype.Size = function() { return this.$val.Size(); };
- File.ptr.prototype.LineCount = function() {
- var $ptr, f, n;
- f = this;
- f.set.mutex.RLock();
- n = f.lines.$length;
- f.set.mutex.RUnlock();
- return n;
- };
- File.prototype.LineCount = function() { return this.$val.LineCount(); };
- File.ptr.prototype.AddLine = function(offset) {
- var $ptr, f, i, offset, x, x$1;
- f = this;
- f.set.mutex.Lock();
- i = f.lines.$length;
- if (((i === 0) || (x = f.lines, x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])) < offset) && offset < f.size) {
- f.lines = $append(f.lines, offset);
- }
- f.set.mutex.Unlock();
- };
- File.prototype.AddLine = function(offset) { return this.$val.AddLine(offset); };
- File.ptr.prototype.MergeLine = function(line) {
- var $ptr, f, line, $deferred;
- /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- f = this;
- if (line <= 0) {
- $panic(new $String("illegal line number (line numbering starts at 1)"));
- }
- f.set.mutex.Lock();
- $deferred.push([$methodVal(f.set.mutex, "Unlock"), []]);
- if (line >= f.lines.$length) {
- $panic(new $String("illegal line number"));
- }
- $copySlice($subslice(f.lines, line), $subslice(f.lines, (line + 1 >> 0)));
- f.lines = $subslice(f.lines, 0, (f.lines.$length - 1 >> 0));
- /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); }
- };
- File.prototype.MergeLine = function(line) { return this.$val.MergeLine(line); };
- File.ptr.prototype.SetLines = function(lines) {
- var $ptr, _i, _ref, f, i, lines, offset, size, x;
- f = this;
- size = f.size;
- _ref = lines;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- offset = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (i > 0 && offset <= (x = i - 1 >> 0, ((x < 0 || x >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + x])) || size <= offset) {
- return false;
- }
- _i++;
- }
- f.set.mutex.Lock();
- f.lines = lines;
- f.set.mutex.Unlock();
- return true;
- };
- File.prototype.SetLines = function(lines) { return this.$val.SetLines(lines); };
- File.ptr.prototype.SetLinesForContent = function(content) {
- var $ptr, _i, _ref, b, content, f, line, lines, offset;
- f = this;
- lines = sliceType$1.nil;
- line = 0;
- _ref = content;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- offset = _i;
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (line >= 0) {
- lines = $append(lines, line);
- }
- line = -1;
- if (b === 10) {
- line = offset + 1 >> 0;
- }
- _i++;
- }
- f.set.mutex.Lock();
- f.lines = lines;
- f.set.mutex.Unlock();
- };
- File.prototype.SetLinesForContent = function(content) { return this.$val.SetLinesForContent(content); };
- File.ptr.prototype.AddLineInfo = function(offset, filename, line) {
- var $ptr, f, filename, i, line, offset, x, x$1;
- f = this;
- f.set.mutex.Lock();
- i = f.infos.$length;
- if ((i === 0) || (x = f.infos, x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).Offset < offset && offset < f.size) {
- f.infos = $append(f.infos, new lineInfo.ptr(offset, filename, line));
- }
- f.set.mutex.Unlock();
- };
- File.prototype.AddLineInfo = function(offset, filename, line) { return this.$val.AddLineInfo(offset, filename, line); };
- File.ptr.prototype.Pos = function(offset) {
- var $ptr, f, offset;
- f = this;
- if (offset > f.size) {
- $panic(new $String("illegal file offset"));
- }
- return ((f.base + offset >> 0) >> 0);
- };
- File.prototype.Pos = function(offset) { return this.$val.Pos(offset); };
- File.ptr.prototype.Offset = function(p) {
- var $ptr, f, p;
- f = this;
- if ((p >> 0) < f.base || (p >> 0) > (f.base + f.size >> 0)) {
- $panic(new $String("illegal Pos value"));
- }
- return (p >> 0) - f.base >> 0;
- };
- File.prototype.Offset = function(p) { return this.$val.Offset(p); };
- File.ptr.prototype.Line = function(p) {
- var $ptr, _r, f, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- _r = f.Position(p); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r.Line;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Line }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.Line = function(p) { return this.$val.Line(p); };
- searchLineInfos = function(a, x) {
- var $ptr, _r, a, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; a = $f.a; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = [a];
- x = [x];
- _r = sort.Search(a[0].$length, (function(a, x) { return function(i) {
- var $ptr, i;
- return ((i < 0 || i >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + i]).Offset > x[0];
- }; })(a, x)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r - 1 >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: searchLineInfos }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.ptr.prototype.unpack = function(offset, adjusted) {
- var $ptr, _r, _tmp, _tmp$1, adjusted, alt, column, f, filename, i, i$1, i$2, line, offset, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; adjusted = $f.adjusted; alt = $f.alt; column = $f.column; f = $f.f; filename = $f.filename; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; line = $f.line; offset = $f.offset; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- filename = "";
- line = 0;
- column = 0;
- f = this;
- filename = f.name;
- i = searchInts(f.lines, offset);
- if (i >= 0) {
- _tmp = i + 1 >> 0; _tmp$1 = (offset - (x = f.lines, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])) >> 0) + 1 >> 0; line = _tmp; column = _tmp$1;
- }
- /* */ if (adjusted && f.infos.$length > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (adjusted && f.infos.$length > 0) { */ case 1:
- _r = searchLineInfos(f.infos, offset); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- i$1 = _r;
- /* */ if (i$1 >= 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (i$1 >= 0) { */ case 4:
- alt = (x$1 = f.infos, ((i$1 < 0 || i$1 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i$1]));
- filename = alt.Filename;
- i$2 = searchInts(f.lines, alt.Offset);
- if (i$2 >= 0) {
- line = line + (((alt.Line - i$2 >> 0) - 1 >> 0)) >> 0;
- }
- /* } */ case 5:
- /* } */ case 2:
- return [filename, line, column];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.unpack }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.adjusted = adjusted; $f.alt = alt; $f.column = column; $f.f = f; $f.filename = filename; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.line = line; $f.offset = offset; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.unpack = function(offset, adjusted) { return this.$val.unpack(offset, adjusted); };
- File.ptr.prototype.position = function(p, adjusted) {
- var $ptr, _r, _tuple, adjusted, f, offset, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; adjusted = $f.adjusted; f = $f.f; offset = $f.offset; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = new Position.ptr();
- f = this;
- offset = (p >> 0) - f.base >> 0;
- pos.Offset = offset;
- _r = f.unpack(offset, adjusted); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; pos.Filename = _tuple[0]; pos.Line = _tuple[1]; pos.Column = _tuple[2];
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.position }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.adjusted = adjusted; $f.f = f; $f.offset = offset; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.position = function(p, adjusted) { return this.$val.position(p, adjusted); };
- File.ptr.prototype.PositionFor = function(p, adjusted) {
- var $ptr, _r, adjusted, f, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; adjusted = $f.adjusted; f = $f.f; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = new Position.ptr();
- f = this;
- /* */ if (!((p === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((p === 0))) { */ case 1:
- if ((p >> 0) < f.base || (p >> 0) > (f.base + f.size >> 0)) {
- $panic(new $String("illegal Pos value"));
- }
- _r = f.position(p, adjusted); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $copy(pos, _r, Position);
- /* } */ case 2:
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.PositionFor }; } $f.$ptr = $ptr; $f._r = _r; $f.adjusted = adjusted; $f.f = f; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.PositionFor = function(p, adjusted) { return this.$val.PositionFor(p, adjusted); };
- File.ptr.prototype.Position = function(p) {
- var $ptr, _r, f, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = new Position.ptr();
- f = this;
- _r = f.PositionFor(p, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $copy(pos, _r, Position);
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Position }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.Position = function(p) { return this.$val.Position(p); };
- NewFileSet = function() {
- var $ptr;
- return new FileSet.ptr(new nosync.RWMutex.ptr(), 1, sliceType$2.nil, ptrType.nil);
- };
- $pkg.NewFileSet = NewFileSet;
- FileSet.ptr.prototype.Base = function() {
- var $ptr, b, s;
- s = this;
- s.mutex.RLock();
- b = s.base;
- s.mutex.RUnlock();
- return b;
- };
- FileSet.prototype.Base = function() { return this.$val.Base(); };
- FileSet.ptr.prototype.AddFile = function(filename, base, size) {
- var $ptr, base, f, filename, s, size, $deferred;
- /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- s = this;
- s.mutex.Lock();
- $deferred.push([$methodVal(s.mutex, "Unlock"), []]);
- if (base < 0) {
- base = s.base;
- }
- if (base < s.base || size < 0) {
- $panic(new $String("illegal base or size"));
- }
- f = new File.ptr(s, filename, base, size, new sliceType$1([0]), sliceType$3.nil);
- base = base + ((size + 1 >> 0)) >> 0;
- if (base < 0) {
- $panic(new $String("token.Pos offset overflow (> 2G of source code in file set)"));
- }
- s.base = base;
- s.files = $append(s.files, f);
- s.last = f;
- return f;
- /* */ } catch(err) { $err = err; return ptrType.nil; } finally { $callDeferred($deferred, $err); }
- };
- FileSet.prototype.AddFile = function(filename, base, size) { return this.$val.AddFile(filename, base, size); };
- FileSet.ptr.prototype.Iterate = function(f) {
- var $ptr, _r, _v, f, file, i, s, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _v = $f._v; f = $f.f; file = $f.file; i = $f.i; s = $f.s; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- i = 0;
- /* while (true) { */ case 1:
- file = ptrType.nil;
- s.mutex.RLock();
- if (i < s.files.$length) {
- file = (x = s.files, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- }
- s.mutex.RUnlock();
- if (file === ptrType.nil) { _v = true; $s = 5; continue s; }
- _r = f(file); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = !_r; case 5:
- /* */ if (_v) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_v) { */ case 3:
- /* break; */ $s = 2; continue;
- /* } */ case 4:
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FileSet.ptr.prototype.Iterate }; } $f.$ptr = $ptr; $f._r = _r; $f._v = _v; $f.f = f; $f.file = file; $f.i = i; $f.s = s; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.prototype.Iterate = function(f) { return this.$val.Iterate(f); };
- searchFiles = function(a, x) {
- var $ptr, _r, a, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; a = $f.a; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = [a];
- x = [x];
- _r = sort.Search(a[0].$length, (function(a, x) { return function(i) {
- var $ptr, i;
- return ((i < 0 || i >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + i]).base > x[0];
- }; })(a, x)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r - 1 >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: searchFiles }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.ptr.prototype.file = function(p) {
- var $ptr, _r, f, f$1, i, p, s, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; f$1 = $f.f$1; i = $f.i; p = $f.p; s = $f.s; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- s.mutex.RLock();
- f = s.last;
- if (!(f === ptrType.nil) && f.base <= (p >> 0) && (p >> 0) <= (f.base + f.size >> 0)) {
- s.mutex.RUnlock();
- return f;
- }
- _r = searchFiles(s.files, (p >> 0)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- i = _r;
- /* */ if (i >= 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (i >= 0) { */ case 2:
- f$1 = (x = s.files, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- if ((p >> 0) <= (f$1.base + f$1.size >> 0)) {
- s.mutex.RUnlock();
- s.mutex.Lock();
- s.last = f$1;
- s.mutex.Unlock();
- return f$1;
- }
- /* } */ case 3:
- s.mutex.RUnlock();
- return ptrType.nil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FileSet.ptr.prototype.file }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.f$1 = f$1; $f.i = i; $f.p = p; $f.s = s; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.prototype.file = function(p) { return this.$val.file(p); };
- FileSet.ptr.prototype.File = function(p) {
- var $ptr, _r, f, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = ptrType.nil;
- s = this;
- /* */ if (!((p === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((p === 0))) { */ case 1:
- _r = s.file(p); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- f = _r;
- /* } */ case 2:
- return f;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FileSet.ptr.prototype.File }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.prototype.File = function(p) { return this.$val.File(p); };
- FileSet.ptr.prototype.PositionFor = function(p, adjusted) {
- var $ptr, _r, _r$1, adjusted, f, p, pos, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; adjusted = $f.adjusted; f = $f.f; p = $f.p; pos = $f.pos; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = new Position.ptr();
- s = this;
- /* */ if (!((p === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((p === 0))) { */ case 1:
- _r = s.file(p); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- f = _r;
- /* */ if (!(f === ptrType.nil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(f === ptrType.nil)) { */ case 4:
- _r$1 = f.position(p, adjusted); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $copy(pos, _r$1, Position);
- /* } */ case 5:
- /* } */ case 2:
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FileSet.ptr.prototype.PositionFor }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.adjusted = adjusted; $f.f = f; $f.p = p; $f.pos = pos; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.prototype.PositionFor = function(p, adjusted) { return this.$val.PositionFor(p, adjusted); };
- FileSet.ptr.prototype.Position = function(p) {
- var $ptr, _r, p, pos, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; p = $f.p; pos = $f.pos; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = new Position.ptr();
- s = this;
- _r = s.PositionFor(p, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $copy(pos, _r, Position);
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FileSet.ptr.prototype.Position }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.pos = pos; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.prototype.Position = function(p) { return this.$val.Position(p); };
- searchInts = function(a, x) {
- var $ptr, _q, _tmp, _tmp$1, a, h, i, j, x;
- _tmp = 0; _tmp$1 = a.$length; i = _tmp; j = _tmp$1;
- while (true) {
- if (!(i < j)) { break; }
- h = i + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0;
- if (((h < 0 || h >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + h]) <= x) {
- i = h + 1 >> 0;
- } else {
- j = h;
- }
- }
- return i - 1 >> 0;
- };
- FileSet.ptr.prototype.Read = function(decode) {
- var $ptr, _r, decode, err, f, files, i, s, ss, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; decode = $f.decode; err = $f.err; f = $f.f; files = $f.files; i = $f.i; s = $f.s; ss = $f.ss; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- ss = [ss];
- s = this;
- ss[0] = $clone(new serializedFileSet.ptr(), serializedFileSet);
- _r = decode(ss[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- return err;
- /* } */ case 3:
- s.mutex.Lock();
- s.base = ss[0].Base;
- files = $makeSlice(sliceType$2, ss[0].Files.$length);
- i = 0;
- while (true) {
- if (!(i < ss[0].Files.$length)) { break; }
- f = (x = ss[0].Files, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- ((i < 0 || i >= files.$length) ? $throwRuntimeError("index out of range") : files.$array[files.$offset + i] = new File.ptr(s, f.Name, f.Base, f.Size, f.Lines, f.Infos));
- i = i + (1) >> 0;
- }
- s.files = files;
- s.last = ptrType.nil;
- s.mutex.Unlock();
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FileSet.ptr.prototype.Read }; } $f.$ptr = $ptr; $f._r = _r; $f.decode = decode; $f.err = err; $f.f = f; $f.files = files; $f.i = i; $f.s = s; $f.ss = ss; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.prototype.Read = function(decode) { return this.$val.Read(decode); };
- FileSet.ptr.prototype.Write = function(encode) {
- var $ptr, _i, _r, _ref, encode, f, files, i, s, ss, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; encode = $f.encode; f = $f.f; files = $f.files; i = $f.i; s = $f.s; ss = $f.ss; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- ss = $clone(new serializedFileSet.ptr(), serializedFileSet);
- s.mutex.Lock();
- ss.Base = s.base;
- files = $makeSlice(sliceType$4, s.files.$length);
- _ref = s.files;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $copy(((i < 0 || i >= files.$length) ? $throwRuntimeError("index out of range") : files.$array[files.$offset + i]), new serializedFile.ptr(f.name, f.base, f.size, f.lines, f.infos), serializedFile);
- _i++;
- }
- ss.Files = files;
- s.mutex.Unlock();
- _r = encode(new ss.constructor.elem(ss)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FileSet.ptr.prototype.Write }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.encode = encode; $f.f = f; $f.files = files; $f.i = i; $f.s = s; $f.ss = ss; $f.$s = $s; $f.$r = $r; return $f;
- };
- FileSet.prototype.Write = function(encode) { return this.$val.Write(encode); };
- Token.prototype.String = function() {
- var $ptr, s, tok;
- tok = this.$val;
- s = "";
- if (0 <= tok && tok < 86) {
- s = ((tok < 0 || tok >= tokens.length) ? $throwRuntimeError("index out of range") : tokens[tok]);
- }
- if (s === "") {
- s = "token(" + strconv.Itoa((tok >> 0)) + ")";
- }
- return s;
- };
- $ptrType(Token).prototype.String = function() { return new Token(this.$get()).String(); };
- Token.prototype.Precedence = function() {
- var $ptr, _ref, op;
- op = this.$val;
- _ref = op;
- if (_ref === 35) {
- return 1;
- } else if (_ref === 34) {
- return 2;
- } else if (_ref === 39 || _ref === 44 || _ref === 40 || _ref === 45 || _ref === 41 || _ref === 46) {
- return 3;
- } else if (_ref === 12 || _ref === 13 || _ref === 18 || _ref === 19) {
- return 4;
- } else if (_ref === 14 || _ref === 15 || _ref === 16 || _ref === 20 || _ref === 21 || _ref === 17 || _ref === 22) {
- return 5;
- }
- return 0;
- };
- $ptrType(Token).prototype.Precedence = function() { return new Token(this.$get()).Precedence(); };
- init = function() {
- var $ptr, _key, i;
- keywords = new $Map();
- i = 61;
- while (true) {
- if (!(i < 86)) { break; }
- _key = ((i < 0 || i >= tokens.length) ? $throwRuntimeError("index out of range") : tokens[i]); (keywords || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: i };
- i = i + (1) >> 0;
- }
- };
- Lookup = function(ident) {
- var $ptr, _entry, _tuple, ident, is_keyword, tok;
- _tuple = (_entry = keywords[$String.keyFor(ident)], _entry !== undefined ? [_entry.v, true] : [0, false]); tok = _tuple[0]; is_keyword = _tuple[1];
- if (is_keyword) {
- return tok;
- }
- return 4;
- };
- $pkg.Lookup = Lookup;
- Token.prototype.IsLiteral = function() {
- var $ptr, tok;
- tok = this.$val;
- return 3 < tok && tok < 10;
- };
- $ptrType(Token).prototype.IsLiteral = function() { return new Token(this.$get()).IsLiteral(); };
- Token.prototype.IsOperator = function() {
- var $ptr, tok;
- tok = this.$val;
- return 11 < tok && tok < 59;
- };
- $ptrType(Token).prototype.IsOperator = function() { return new Token(this.$get()).IsOperator(); };
- Token.prototype.IsKeyword = function() {
- var $ptr, tok;
- tok = this.$val;
- return 60 < tok && tok < 86;
- };
- $ptrType(Token).prototype.IsKeyword = function() { return new Token(this.$get()).IsKeyword(); };
- Position.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$1.methods = [{prop: "IsValid", name: "IsValid", pkg: "", typ: $funcType([], [$Bool], false)}];
- Pos.methods = [{prop: "IsValid", name: "IsValid", pkg: "", typ: $funcType([], [$Bool], false)}];
- ptrType.methods = [{prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Base", name: "Base", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Size", name: "Size", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "LineCount", name: "LineCount", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "AddLine", name: "AddLine", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "MergeLine", name: "MergeLine", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "SetLines", name: "SetLines", pkg: "", typ: $funcType([sliceType$1], [$Bool], false)}, {prop: "SetLinesForContent", name: "SetLinesForContent", pkg: "", typ: $funcType([sliceType$5], [], false)}, {prop: "AddLineInfo", name: "AddLineInfo", pkg: "", typ: $funcType([$Int, $String, $Int], [], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([$Int], [Pos], false)}, {prop: "Offset", name: "Offset", pkg: "", typ: $funcType([Pos], [$Int], false)}, {prop: "Line", name: "Line", pkg: "", typ: $funcType([Pos], [$Int], false)}, {prop: "unpack", name: "unpack", pkg: "go/token", typ: $funcType([$Int, $Bool], [$String, $Int, $Int], false)}, {prop: "position", name: "position", pkg: "go/token", typ: $funcType([Pos, $Bool], [Position], false)}, {prop: "PositionFor", name: "PositionFor", pkg: "", typ: $funcType([Pos, $Bool], [Position], false)}, {prop: "Position", name: "Position", pkg: "", typ: $funcType([Pos], [Position], false)}];
- ptrType$2.methods = [{prop: "Base", name: "Base", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "AddFile", name: "AddFile", pkg: "", typ: $funcType([$String, $Int, $Int], [ptrType], false)}, {prop: "Iterate", name: "Iterate", pkg: "", typ: $funcType([funcType], [], false)}, {prop: "file", name: "file", pkg: "go/token", typ: $funcType([Pos], [ptrType], false)}, {prop: "File", name: "File", pkg: "", typ: $funcType([Pos], [ptrType], false)}, {prop: "PositionFor", name: "PositionFor", pkg: "", typ: $funcType([Pos, $Bool], [Position], false)}, {prop: "Position", name: "Position", pkg: "", typ: $funcType([Pos], [Position], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([funcType$1], [$error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([funcType$1], [$error], false)}];
- Token.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Precedence", name: "Precedence", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "IsLiteral", name: "IsLiteral", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsOperator", name: "IsOperator", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsKeyword", name: "IsKeyword", pkg: "", typ: $funcType([], [$Bool], false)}];
- Position.init([{prop: "Filename", name: "Filename", pkg: "", typ: $String, tag: ""}, {prop: "Offset", name: "Offset", pkg: "", typ: $Int, tag: ""}, {prop: "Line", name: "Line", pkg: "", typ: $Int, tag: ""}, {prop: "Column", name: "Column", pkg: "", typ: $Int, tag: ""}]);
- File.init([{prop: "set", name: "set", pkg: "go/token", typ: ptrType$2, tag: ""}, {prop: "name", name: "name", pkg: "go/token", typ: $String, tag: ""}, {prop: "base", name: "base", pkg: "go/token", typ: $Int, tag: ""}, {prop: "size", name: "size", pkg: "go/token", typ: $Int, tag: ""}, {prop: "lines", name: "lines", pkg: "go/token", typ: sliceType$1, tag: ""}, {prop: "infos", name: "infos", pkg: "go/token", typ: sliceType$3, tag: ""}]);
- lineInfo.init([{prop: "Offset", name: "Offset", pkg: "", typ: $Int, tag: ""}, {prop: "Filename", name: "Filename", pkg: "", typ: $String, tag: ""}, {prop: "Line", name: "Line", pkg: "", typ: $Int, tag: ""}]);
- FileSet.init([{prop: "mutex", name: "mutex", pkg: "go/token", typ: nosync.RWMutex, tag: ""}, {prop: "base", name: "base", pkg: "go/token", typ: $Int, tag: ""}, {prop: "files", name: "files", pkg: "go/token", typ: sliceType$2, tag: ""}, {prop: "last", name: "last", pkg: "go/token", typ: ptrType, tag: ""}]);
- serializedFile.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Base", name: "Base", pkg: "", typ: $Int, tag: ""}, {prop: "Size", name: "Size", pkg: "", typ: $Int, tag: ""}, {prop: "Lines", name: "Lines", pkg: "", typ: sliceType$1, tag: ""}, {prop: "Infos", name: "Infos", pkg: "", typ: sliceType$3, tag: ""}]);
- serializedFileSet.init([{prop: "Base", name: "Base", pkg: "", typ: $Int, tag: ""}, {prop: "Files", name: "Files", pkg: "", typ: sliceType$4, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = fmt.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = nosync.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = testing.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- keywords = false;
- tokens = $toNativeArray($kindString, ["ILLEGAL", "EOF", "COMMENT", "", "IDENT", "INT", "FLOAT", "IMAG", "CHAR", "STRING", "", "", "+", "-", "*", "/", "%", "&", "|", "^", "<<", ">>", "&^", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=", "&^=", "&&", "||", "<-", "++", "--", "==", "<", ">", "=", "!", "!=", "<=", ">=", ":=", "...", "(", "[", "{", ",", ".", ")", "]", "}", ";", ":", "", "", "break", "case", "chan", "const", "continue", "default", "defer", "else", "fallthrough", "for", "func", "go", "goto", "if", "import", "interface", "map", "package", "range", "return", "select", "struct", "switch", "type", "var"]);
- init();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["path/filepath"] = (function() {
- var $pkg = {}, $init, bytes, errors, os, runtime, sort, strings, utf8, lazybuf, sliceType$1, ptrType, Clean, FromSlash, Split, Join, VolumeName, IsAbs, volumeNameLen;
- bytes = $packages["bytes"];
- errors = $packages["errors"];
- os = $packages["os"];
- runtime = $packages["runtime"];
- sort = $packages["sort"];
- strings = $packages["strings"];
- utf8 = $packages["unicode/utf8"];
- lazybuf = $pkg.lazybuf = $newType(0, $kindStruct, "filepath.lazybuf", "lazybuf", "path/filepath", function(path_, buf_, w_, volAndPath_, volLen_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.path = "";
- this.buf = sliceType$1.nil;
- this.w = 0;
- this.volAndPath = "";
- this.volLen = 0;
- return;
- }
- this.path = path_;
- this.buf = buf_;
- this.w = w_;
- this.volAndPath = volAndPath_;
- this.volLen = volLen_;
- });
- sliceType$1 = $sliceType($Uint8);
- ptrType = $ptrType(lazybuf);
- lazybuf.ptr.prototype.index = function(i) {
- var $ptr, b, i, x;
- b = this;
- if (!(b.buf === sliceType$1.nil)) {
- return (x = b.buf, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- }
- return b.path.charCodeAt(i);
- };
- lazybuf.prototype.index = function(i) { return this.$val.index(i); };
- lazybuf.ptr.prototype.append = function(c) {
- var $ptr, b, c, x, x$1;
- b = this;
- if (b.buf === sliceType$1.nil) {
- if (b.w < b.path.length && (b.path.charCodeAt(b.w) === c)) {
- b.w = b.w + (1) >> 0;
- return;
- }
- b.buf = $makeSlice(sliceType$1, b.path.length);
- $copyString(b.buf, b.path.substring(0, b.w));
- }
- (x = b.buf, x$1 = b.w, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1] = c));
- b.w = b.w + (1) >> 0;
- };
- lazybuf.prototype.append = function(c) { return this.$val.append(c); };
- lazybuf.ptr.prototype.string = function() {
- var $ptr, b;
- b = this;
- if (b.buf === sliceType$1.nil) {
- return b.volAndPath.substring(0, (b.volLen + b.w >> 0));
- }
- return b.volAndPath.substring(0, b.volLen) + $bytesToString($subslice(b.buf, 0, b.w));
- };
- lazybuf.prototype.string = function() { return this.$val.string(); };
- Clean = function(path) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, dotdot, n, originalPath, out, path, r, rooted, volLen;
- originalPath = path;
- volLen = volumeNameLen(path);
- path = path.substring(volLen);
- if (path === "") {
- if (volLen > 1 && !((originalPath.charCodeAt(1) === 58))) {
- return FromSlash(originalPath);
- }
- return originalPath + ".";
- }
- rooted = os.IsPathSeparator(path.charCodeAt(0));
- n = path.length;
- out = new lazybuf.ptr(path, sliceType$1.nil, 0, originalPath, volLen);
- _tmp = 0; _tmp$1 = 0; r = _tmp; dotdot = _tmp$1;
- if (rooted) {
- out.append(47);
- _tmp$2 = 1; _tmp$3 = 1; r = _tmp$2; dotdot = _tmp$3;
- }
- while (true) {
- if (!(r < n)) { break; }
- if (os.IsPathSeparator(path.charCodeAt(r))) {
- r = r + (1) >> 0;
- } else if ((path.charCodeAt(r) === 46) && (((r + 1 >> 0) === n) || os.IsPathSeparator(path.charCodeAt((r + 1 >> 0))))) {
- r = r + (1) >> 0;
- } else if ((path.charCodeAt(r) === 46) && (path.charCodeAt((r + 1 >> 0)) === 46) && (((r + 2 >> 0) === n) || os.IsPathSeparator(path.charCodeAt((r + 2 >> 0))))) {
- r = r + (2) >> 0;
- if (out.w > dotdot) {
- out.w = out.w - (1) >> 0;
- while (true) {
- if (!(out.w > dotdot && !os.IsPathSeparator(out.index(out.w)))) { break; }
- out.w = out.w - (1) >> 0;
- }
- } else if (!rooted) {
- if (out.w > 0) {
- out.append(47);
- }
- out.append(46);
- out.append(46);
- dotdot = out.w;
- }
- } else {
- if (rooted && !((out.w === 1)) || !rooted && !((out.w === 0))) {
- out.append(47);
- }
- while (true) {
- if (!(r < n && !os.IsPathSeparator(path.charCodeAt(r)))) { break; }
- out.append(path.charCodeAt(r));
- r = r + (1) >> 0;
- }
- }
- }
- if (out.w === 0) {
- out.append(46);
- }
- return FromSlash(out.string());
- };
- $pkg.Clean = Clean;
- FromSlash = function(path) {
- var $ptr, path;
- return path;
- return strings.Replace(path, "/", "/", -1);
- };
- $pkg.FromSlash = FromSlash;
- Split = function(path) {
- var $ptr, _tmp, _tmp$1, dir, file, i, path, vol;
- dir = "";
- file = "";
- vol = VolumeName(path);
- i = path.length - 1 >> 0;
- while (true) {
- if (!(i >= vol.length && !os.IsPathSeparator(path.charCodeAt(i)))) { break; }
- i = i - (1) >> 0;
- }
- _tmp = path.substring(0, (i + 1 >> 0)); _tmp$1 = path.substring((i + 1 >> 0)); dir = _tmp; file = _tmp$1;
- return [dir, file];
- };
- $pkg.Split = Split;
- Join = function(elem) {
- var $ptr, _i, _ref, e, elem, i;
- _ref = elem;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- e = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!(e === "")) {
- return Clean(strings.Join($subslice(elem, i), "/"));
- }
- _i++;
- }
- return "";
- };
- $pkg.Join = Join;
- VolumeName = function(path) {
- var $ptr, path, v;
- v = "";
- v = path.substring(0, volumeNameLen(path));
- return v;
- };
- $pkg.VolumeName = VolumeName;
- IsAbs = function(path) {
- var $ptr, path;
- return strings.HasPrefix(path, "/");
- };
- $pkg.IsAbs = IsAbs;
- volumeNameLen = function(path) {
- var $ptr, path;
- return 0;
- };
- ptrType.methods = [{prop: "index", name: "index", pkg: "path/filepath", typ: $funcType([$Int], [$Uint8], false)}, {prop: "append", name: "append", pkg: "path/filepath", typ: $funcType([$Uint8], [], false)}, {prop: "string", name: "string", pkg: "path/filepath", typ: $funcType([], [$String], false)}];
- lazybuf.init([{prop: "path", name: "path", pkg: "path/filepath", typ: $String, tag: ""}, {prop: "buf", name: "buf", pkg: "path/filepath", typ: sliceType$1, tag: ""}, {prop: "w", name: "w", pkg: "path/filepath", typ: $Int, tag: ""}, {prop: "volAndPath", name: "volAndPath", pkg: "path/filepath", typ: $String, tag: ""}, {prop: "volLen", name: "volLen", pkg: "path/filepath", typ: $Int, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = runtime.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.ErrBadPattern = errors.New("syntax error in pattern");
- $pkg.SkipDir = errors.New("skip this directory");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["go/scanner"] = (function() {
- var $pkg = {}, $init, bytes, fmt, token, io, filepath, sort, strconv, unicode, utf8, Error, ErrorList, ErrorHandler, Scanner, Mode, sliceType, sliceType$1, sliceType$2, ptrType, ptrType$1, ptrType$2, ptrType$3, prefix, isLetter, isDigit, digitVal, stripCR;
- bytes = $packages["bytes"];
- fmt = $packages["fmt"];
- token = $packages["go/token"];
- io = $packages["io"];
- filepath = $packages["path/filepath"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- unicode = $packages["unicode"];
- utf8 = $packages["unicode/utf8"];
- Error = $pkg.Error = $newType(0, $kindStruct, "scanner.Error", "Error", "go/scanner", function(Pos_, Msg_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Pos = new token.Position.ptr();
- this.Msg = "";
- return;
- }
- this.Pos = Pos_;
- this.Msg = Msg_;
- });
- ErrorList = $pkg.ErrorList = $newType(12, $kindSlice, "scanner.ErrorList", "ErrorList", "go/scanner", null);
- ErrorHandler = $pkg.ErrorHandler = $newType(4, $kindFunc, "scanner.ErrorHandler", "ErrorHandler", "go/scanner", null);
- Scanner = $pkg.Scanner = $newType(0, $kindStruct, "scanner.Scanner", "Scanner", "go/scanner", function(file_, dir_, src_, err_, mode_, ch_, offset_, rdOffset_, lineOffset_, insertSemi_, ErrorCount_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.file = ptrType$2.nil;
- this.dir = "";
- this.src = sliceType.nil;
- this.err = $throwNilPointerError;
- this.mode = 0;
- this.ch = 0;
- this.offset = 0;
- this.rdOffset = 0;
- this.lineOffset = 0;
- this.insertSemi = false;
- this.ErrorCount = 0;
- return;
- }
- this.file = file_;
- this.dir = dir_;
- this.src = src_;
- this.err = err_;
- this.mode = mode_;
- this.ch = ch_;
- this.offset = offset_;
- this.rdOffset = rdOffset_;
- this.lineOffset = lineOffset_;
- this.insertSemi = insertSemi_;
- this.ErrorCount = ErrorCount_;
- });
- Mode = $pkg.Mode = $newType(4, $kindUint, "scanner.Mode", "Mode", "go/scanner", null);
- sliceType = $sliceType($Uint8);
- sliceType$1 = $sliceType($emptyInterface);
- sliceType$2 = $sliceType($String);
- ptrType = $ptrType(ErrorList);
- ptrType$1 = $ptrType(Error);
- ptrType$2 = $ptrType(token.File);
- ptrType$3 = $ptrType(Scanner);
- Error.ptr.prototype.Error = function() {
- var $ptr, _r, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = $clone(this, Error);
- /* */ if (!(e.Pos.Filename === "") || e.Pos.IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(e.Pos.Filename === "") || e.Pos.IsValid()) { */ case 1:
- _r = e.Pos.String(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r + ": " + e.Msg;
- /* } */ case 2:
- return e.Msg;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Error.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- Error.prototype.Error = function() { return this.$val.Error(); };
- $ptrType(ErrorList).prototype.Add = function(pos, msg) {
- var $ptr, msg, p, pos;
- p = this;
- pos = $clone(pos, token.Position);
- p.$set($append(p.$get(), new Error.ptr($clone(pos, token.Position), msg)));
- };
- $ptrType(ErrorList).prototype.Reset = function() {
- var $ptr, p;
- p = this;
- p.$set($subslice((p.$get()), 0, 0));
- };
- ErrorList.prototype.Len = function() {
- var $ptr, p;
- p = this;
- return p.$length;
- };
- $ptrType(ErrorList).prototype.Len = function() { return this.$get().Len(); };
- ErrorList.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, i, j, p;
- p = this;
- _tmp = ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j]); _tmp$1 = ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i]); ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i] = _tmp); ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j] = _tmp$1);
- };
- $ptrType(ErrorList).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- ErrorList.prototype.Less = function(i, j) {
- var $ptr, e, f, i, j, p;
- p = this;
- e = ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i]).Pos;
- f = ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j]).Pos;
- if (e.Filename < f.Filename) {
- return true;
- }
- if (e.Filename === f.Filename) {
- if (e.Line < f.Line) {
- return true;
- }
- if (e.Line === f.Line) {
- return e.Column < f.Column;
- }
- }
- return false;
- };
- $ptrType(ErrorList).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- ErrorList.prototype.Sort = function() {
- var $ptr, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = sort.Sort(p); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ErrorList.prototype.Sort }; } $f.$ptr = $ptr; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(ErrorList).prototype.Sort = function() { return this.$get().Sort(); };
- $ptrType(ErrorList).prototype.RemoveMultiples = function() {
- var $ptr, _i, _ref, e, i, last, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; e = $f.e; i = $f.i; last = $f.last; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = sort.Sort(p); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- last = $clone(new token.Position.ptr(), token.Position);
- i = 0;
- _ref = p.$get();
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- e = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!(e.Pos.Filename === last.Filename) || !((e.Pos.Line === last.Line))) {
- $copy(last, e.Pos, token.Position);
- (x = p.$get(), ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = e));
- i = i + (1) >> 0;
- }
- _i++;
- }
- p.$set($subslice((p.$get()), 0, i));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(ErrorList).prototype.RemoveMultiples }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.e = e; $f.i = i; $f.last = last; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- ErrorList.prototype.Error = function() {
- var $ptr, _r, _r$1, _ref, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = p.$length;
- /* */ if (_ref === 0) { $s = 1; continue; }
- /* */ if (_ref === 1) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_ref === 0) { */ case 1:
- return "no errors";
- $s = 3; continue;
- /* } else if (_ref === 1) { */ case 2:
- _r = (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0]).Error(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 3:
- _r$1 = fmt.Sprintf("%s (and %d more errors)", new sliceType$1([(0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0]), new $Int((p.$length - 1 >> 0))])); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ErrorList.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(ErrorList).prototype.Error = function() { return this.$get().Error(); };
- ErrorList.prototype.Err = function() {
- var $ptr, p;
- p = this;
- if (p.$length === 0) {
- return $ifaceNil;
- }
- return p;
- };
- $ptrType(ErrorList).prototype.Err = function() { return this.$get().Err(); };
- Scanner.ptr.prototype.next = function() {
- var $ptr, _tmp, _tmp$1, _tuple, r, s, w, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; r = $f.r; s = $f.s; w = $f.w; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (s.rdOffset < s.src.$length) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (s.rdOffset < s.src.$length) { */ case 1:
- s.offset = s.rdOffset;
- if (s.ch === 10) {
- s.lineOffset = s.offset;
- s.file.AddLine(s.offset);
- }
- _tmp = ((x = s.src, x$1 = s.rdOffset, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])) >> 0); _tmp$1 = 1; r = _tmp; w = _tmp$1;
- /* */ if (r === 0) { $s = 4; continue; }
- /* */ if (r >= 128) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (r === 0) { */ case 4:
- $r = s.error(s.offset, "illegal character NUL"); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if (r >= 128) { */ case 5:
- _tuple = utf8.DecodeRune($subslice(s.src, s.rdOffset)); r = _tuple[0]; w = _tuple[1];
- /* */ if ((r === 65533) && (w === 1)) { $s = 8; continue; }
- /* */ if ((r === 65279) && s.offset > 0) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if ((r === 65533) && (w === 1)) { */ case 8:
- $r = s.error(s.offset, "illegal UTF-8 encoding"); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 10; continue;
- /* } else if ((r === 65279) && s.offset > 0) { */ case 9:
- $r = s.error(s.offset, "illegal byte order mark"); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- /* } */ case 6:
- s.rdOffset = s.rdOffset + (w) >> 0;
- s.ch = r;
- $s = 3; continue;
- /* } else { */ case 2:
- s.offset = s.src.$length;
- if (s.ch === 10) {
- s.lineOffset = s.offset;
- s.file.AddLine(s.offset);
- }
- s.ch = -1;
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.next }; } $f.$ptr = $ptr; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.r = r; $f.s = s; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.next = function() { return this.$val.next(); };
- Scanner.ptr.prototype.Init = function(file, src, err, mode) {
- var $ptr, _r, _tuple, err, file, mode, s, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; err = $f.err; file = $f.file; mode = $f.mode; s = $f.s; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (!((file.Size() === src.$length))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((file.Size() === src.$length))) { */ case 1:
- _r = fmt.Sprintf("file size (%d) does not match src len (%d)", new sliceType$1([new $Int(file.Size()), new $Int(src.$length)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* } */ case 2:
- s.file = file;
- _tuple = filepath.Split(file.Name()); s.dir = _tuple[0];
- s.src = src;
- s.err = err;
- s.mode = mode;
- s.ch = 32;
- s.offset = 0;
- s.rdOffset = 0;
- s.lineOffset = 0;
- s.insertSemi = false;
- s.ErrorCount = 0;
- $r = s.next(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (s.ch === 65279) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (s.ch === 65279) { */ case 5:
- $r = s.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.Init }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.file = file; $f.mode = mode; $f.s = s; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.Init = function(file, src, err, mode) { return this.$val.Init(file, src, err, mode); };
- Scanner.ptr.prototype.error = function(offs, msg) {
- var $ptr, _r, msg, offs, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; msg = $f.msg; offs = $f.offs; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (!(s.err === $throwNilPointerError)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(s.err === $throwNilPointerError)) { */ case 1:
- _r = s.file.Position(s.file.Pos(offs)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = s.err(_r, msg); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- s.ErrorCount = s.ErrorCount + (1) >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.error }; } $f.$ptr = $ptr; $f._r = _r; $f.msg = msg; $f.offs = offs; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.error = function(offs, msg) { return this.$val.error(offs, msg); };
- Scanner.ptr.prototype.interpretLineComment = function(text) {
- var $ptr, _r, _tuple, err, filename, i, line, s, text, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; err = $f.err; filename = $f.filename; i = $f.i; line = $f.line; s = $f.s; text = $f.text; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (bytes.HasPrefix(text, prefix)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (bytes.HasPrefix(text, prefix)) { */ case 1:
- i = bytes.LastIndex(text, new sliceType([58]));
- /* */ if (i > 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (i > 0) { */ case 3:
- _tuple = strconv.Atoi($bytesToString($subslice(text, (i + 1 >> 0)))); line = _tuple[0]; err = _tuple[1];
- /* */ if ($interfaceIsEqual(err, $ifaceNil) && line > 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ($interfaceIsEqual(err, $ifaceNil) && line > 0) { */ case 5:
- _r = bytes.TrimSpace($subslice(text, prefix.$length, i)); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- filename = $bytesToString(_r);
- if (!(filename === "")) {
- filename = filepath.Clean(filename);
- if (!filepath.IsAbs(filename)) {
- filename = filepath.Join(new sliceType$2([s.dir, filename]));
- }
- }
- s.file.AddLineInfo((s.lineOffset + text.$length >> 0) + 1 >> 0, filename, line);
- /* } */ case 6:
- /* } */ case 4:
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.interpretLineComment }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.filename = filename; $f.i = i; $f.line = line; $f.s = s; $f.text = text; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.interpretLineComment = function(text) { return this.$val.interpretLineComment(text); };
- Scanner.ptr.prototype.scanComment = function() {
- var $ptr, ch, hasCR, lit, offs, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ch = $f.ch; hasCR = $f.hasCR; lit = $f.lit; offs = $f.offs; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offs = s.offset - 1 >> 0;
- hasCR = false;
- /* */ if (s.ch === 47) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (s.ch === 47) { */ case 1:
- $r = s.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* while (true) { */ case 4:
- /* if (!(!((s.ch === 10)) && s.ch >= 0)) { break; } */ if(!(!((s.ch === 10)) && s.ch >= 0)) { $s = 5; continue; }
- if (s.ch === 13) {
- hasCR = true;
- }
- $r = s.next(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 4; continue; case 5:
- /* */ if (offs === s.lineOffset) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (offs === s.lineOffset) { */ case 7:
- $r = s.interpretLineComment($subslice(s.src, offs, s.offset)); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* goto exit */ $s = 10; continue;
- /* } */ case 2:
- $r = s.next(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* while (true) { */ case 12:
- /* if (!(s.ch >= 0)) { break; } */ if(!(s.ch >= 0)) { $s = 13; continue; }
- ch = s.ch;
- if (ch === 13) {
- hasCR = true;
- }
- $r = s.next(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((ch === 42) && (s.ch === 47)) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if ((ch === 42) && (s.ch === 47)) { */ case 15:
- $r = s.next(); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto exit */ $s = 10; continue;
- /* } */ case 16:
- /* } */ $s = 12; continue; case 13:
- $r = s.error(offs, "comment not terminated"); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* exit: */ case 10:
- lit = $subslice(s.src, offs, s.offset);
- if (hasCR) {
- lit = stripCR(lit);
- }
- return $bytesToString(lit);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanComment }; } $f.$ptr = $ptr; $f.ch = ch; $f.hasCR = hasCR; $f.lit = lit; $f.offs = offs; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanComment = function() { return this.$val.scanComment(); };
- Scanner.ptr.prototype.findLineEnd = function() {
- var $ptr, ch, s, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ch = $f.ch; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- s = [s];
- s[0] = this;
- $deferred.push([(function(s) { return function $b(offs) {
- var $ptr, offs, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; offs = $f.offs; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s[0].ch = 47;
- s[0].offset = offs;
- s[0].rdOffset = offs + 1 >> 0;
- $r = s[0].next(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.offs = offs; $f.$s = $s; $f.$r = $r; return $f;
- }; })(s), [s[0].offset - 1 >> 0]]);
- /* while (true) { */ case 1:
- /* if (!((s[0].ch === 47) || (s[0].ch === 42))) { break; } */ if(!((s[0].ch === 47) || (s[0].ch === 42))) { $s = 2; continue; }
- if (s[0].ch === 47) {
- return true;
- }
- $r = s[0].next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* while (true) { */ case 4:
- /* if (!(s[0].ch >= 0)) { break; } */ if(!(s[0].ch >= 0)) { $s = 5; continue; }
- ch = s[0].ch;
- if (ch === 10) {
- return true;
- }
- $r = s[0].next(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((ch === 42) && (s[0].ch === 47)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if ((ch === 42) && (s[0].ch === 47)) { */ case 7:
- $r = s[0].next(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* break; */ $s = 5; continue;
- /* } */ case 8:
- /* } */ $s = 4; continue; case 5:
- $r = s[0].skipWhitespace(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (s[0].ch < 0 || (s[0].ch === 10)) {
- return true;
- }
- if (!((s[0].ch === 47))) {
- return false;
- }
- $r = s[0].next(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- return false;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return false; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.findLineEnd }; } $f.$ptr = $ptr; $f.ch = ch; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Scanner.prototype.findLineEnd = function() { return this.$val.findLineEnd(); };
- isLetter = function(ch) {
- var $ptr, ch;
- return 97 <= ch && ch <= 122 || 65 <= ch && ch <= 90 || (ch === 95) || ch >= 128 && unicode.IsLetter(ch);
- };
- isDigit = function(ch) {
- var $ptr, ch;
- return 48 <= ch && ch <= 57 || ch >= 128 && unicode.IsDigit(ch);
- };
- Scanner.ptr.prototype.scanIdentifier = function() {
- var $ptr, offs, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; offs = $f.offs; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offs = s.offset;
- /* while (true) { */ case 1:
- /* if (!(isLetter(s.ch) || isDigit(s.ch))) { break; } */ if(!(isLetter(s.ch) || isDigit(s.ch))) { $s = 2; continue; }
- $r = s.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- return $bytesToString($subslice(s.src, offs, s.offset));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanIdentifier }; } $f.$ptr = $ptr; $f.offs = offs; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanIdentifier = function() { return this.$val.scanIdentifier(); };
- digitVal = function(ch) {
- var $ptr, ch;
- if (48 <= ch && ch <= 57) {
- return ((ch - 48 >> 0) >> 0);
- } else if (97 <= ch && ch <= 102) {
- return (((ch - 97 >> 0) + 10 >> 0) >> 0);
- } else if (65 <= ch && ch <= 70) {
- return (((ch - 65 >> 0) + 10 >> 0) >> 0);
- }
- return 16;
- };
- Scanner.ptr.prototype.scanMantissa = function(base) {
- var $ptr, base, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; base = $f.base; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* while (true) { */ case 1:
- /* if (!(digitVal(s.ch) < base)) { break; } */ if(!(digitVal(s.ch) < base)) { $s = 2; continue; }
- $r = s.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanMantissa }; } $f.$ptr = $ptr; $f.base = base; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanMantissa = function(base) { return this.$val.scanMantissa(base); };
- Scanner.ptr.prototype.scanNumber = function(seenDecimalPoint) {
- var $ptr, offs, offs$1, s, seenDecimalDigit, seenDecimalPoint, tok, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; offs = $f.offs; offs$1 = $f.offs$1; s = $f.s; seenDecimalDigit = $f.seenDecimalDigit; seenDecimalPoint = $f.seenDecimalPoint; tok = $f.tok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offs = s.offset;
- tok = 5;
- /* */ if (seenDecimalPoint) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (seenDecimalPoint) { */ case 1:
- offs = offs - (1) >> 0;
- tok = 6;
- $r = s.scanMantissa(10); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto exponent */ $s = 4; continue;
- /* } */ case 2:
- /* */ if (s.ch === 48) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (s.ch === 48) { */ case 5:
- offs$1 = s.offset;
- $r = s.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((s.ch === 120) || (s.ch === 88)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ((s.ch === 120) || (s.ch === 88)) { */ case 8:
- $r = s.next(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = s.scanMantissa(16); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((s.offset - offs$1 >> 0) <= 2) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if ((s.offset - offs$1 >> 0) <= 2) { */ case 13:
- $r = s.error(offs$1, "illegal hexadecimal number"); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- $s = 10; continue;
- /* } else { */ case 9:
- seenDecimalDigit = false;
- $r = s.scanMantissa(8); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((s.ch === 56) || (s.ch === 57)) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if ((s.ch === 56) || (s.ch === 57)) { */ case 17:
- seenDecimalDigit = true;
- $r = s.scanMantissa(10); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- /* */ if ((s.ch === 46) || (s.ch === 101) || (s.ch === 69) || (s.ch === 105)) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if ((s.ch === 46) || (s.ch === 101) || (s.ch === 69) || (s.ch === 105)) { */ case 20:
- /* goto fraction */ $s = 22; continue;
- /* } */ case 21:
- /* */ if (seenDecimalDigit) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (seenDecimalDigit) { */ case 23:
- $r = s.error(offs$1, "illegal octal number"); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 24:
- /* } */ case 10:
- /* goto exit */ $s = 26; continue;
- /* } */ case 6:
- $r = s.scanMantissa(10); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* fraction: */ case 22:
- /* */ if (s.ch === 46) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (s.ch === 46) { */ case 28:
- tok = 6;
- $r = s.next(); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = s.scanMantissa(10); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 29:
- /* exponent: */ case 4:
- /* */ if ((s.ch === 101) || (s.ch === 69)) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if ((s.ch === 101) || (s.ch === 69)) { */ case 32:
- tok = 6;
- $r = s.next(); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((s.ch === 45) || (s.ch === 43)) { $s = 35; continue; }
- /* */ $s = 36; continue;
- /* if ((s.ch === 45) || (s.ch === 43)) { */ case 35:
- $r = s.next(); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 36:
- $r = s.scanMantissa(10); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 33:
- /* */ if (s.ch === 105) { $s = 39; continue; }
- /* */ $s = 40; continue;
- /* if (s.ch === 105) { */ case 39:
- tok = 7;
- $r = s.next(); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 40:
- /* exit: */ case 26:
- return [tok, $bytesToString($subslice(s.src, offs, s.offset))];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanNumber }; } $f.$ptr = $ptr; $f.offs = offs; $f.offs$1 = offs$1; $f.s = s; $f.seenDecimalDigit = seenDecimalDigit; $f.seenDecimalPoint = seenDecimalPoint; $f.tok = tok; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanNumber = function(seenDecimalPoint) { return this.$val.scanNumber(seenDecimalPoint); };
- Scanner.ptr.prototype.scanEscape = function(quote) {
- var $ptr, _r, _ref, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, base, d, max, msg, msg$1, n, offs, quote, s, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; base = $f.base; d = $f.d; max = $f.max; msg = $f.msg; msg$1 = $f.msg$1; n = $f.n; offs = $f.offs; quote = $f.quote; s = $f.s; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offs = s.offset;
- n = 0;
- _tmp = 0; _tmp$1 = 0; base = _tmp; max = _tmp$1;
- _ref = s.ch;
- /* */ if (_ref === 97 || _ref === 98 || _ref === 102 || _ref === 110 || _ref === 114 || _ref === 116 || _ref === 118 || _ref === 92 || _ref === quote) { $s = 1; continue; }
- /* */ if (_ref === 48 || _ref === 49 || _ref === 50 || _ref === 51 || _ref === 52 || _ref === 53 || _ref === 54 || _ref === 55) { $s = 2; continue; }
- /* */ if (_ref === 120) { $s = 3; continue; }
- /* */ if (_ref === 117) { $s = 4; continue; }
- /* */ if (_ref === 85) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref === 97 || _ref === 98 || _ref === 102 || _ref === 110 || _ref === 114 || _ref === 116 || _ref === 118 || _ref === 92 || _ref === quote) { */ case 1:
- $r = s.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return true;
- $s = 7; continue;
- /* } else if (_ref === 48 || _ref === 49 || _ref === 50 || _ref === 51 || _ref === 52 || _ref === 53 || _ref === 54 || _ref === 55) { */ case 2:
- _tmp$2 = 3; _tmp$3 = 8; _tmp$4 = 255; n = _tmp$2; base = _tmp$3; max = _tmp$4;
- $s = 7; continue;
- /* } else if (_ref === 120) { */ case 3:
- $r = s.next(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tmp$5 = 2; _tmp$6 = 16; _tmp$7 = 255; n = _tmp$5; base = _tmp$6; max = _tmp$7;
- $s = 7; continue;
- /* } else if (_ref === 117) { */ case 4:
- $r = s.next(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tmp$8 = 4; _tmp$9 = 16; _tmp$10 = 1114111; n = _tmp$8; base = _tmp$9; max = _tmp$10;
- $s = 7; continue;
- /* } else if (_ref === 85) { */ case 5:
- $r = s.next(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tmp$11 = 8; _tmp$12 = 16; _tmp$13 = 1114111; n = _tmp$11; base = _tmp$12; max = _tmp$13;
- $s = 7; continue;
- /* } else { */ case 6:
- msg = "unknown escape sequence";
- if (s.ch < 0) {
- msg = "escape sequence not terminated";
- }
- $r = s.error(offs, msg); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return false;
- /* } */ case 7:
- x = 0;
- /* while (true) { */ case 13:
- /* if (!(n > 0)) { break; } */ if(!(n > 0)) { $s = 14; continue; }
- d = (digitVal(s.ch) >>> 0);
- /* */ if (d >= base) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (d >= base) { */ case 15:
- _r = fmt.Sprintf("illegal character %#U in escape sequence", new sliceType$1([new $Int32(s.ch)])); /* */ $s = 17; case 17: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- msg$1 = _r;
- if (s.ch < 0) {
- msg$1 = "escape sequence not terminated";
- }
- $r = s.error(s.offset, msg$1); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return false;
- /* } */ case 16:
- x = ((((x >>> 16 << 16) * base >>> 0) + (x << 16 >>> 16) * base) >>> 0) + d >>> 0;
- $r = s.next(); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = n - (1) >> 0;
- /* } */ $s = 13; continue; case 14:
- /* */ if (x > max || 55296 <= x && x < 57344) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (x > max || 55296 <= x && x < 57344) { */ case 20:
- $r = s.error(offs, "escape sequence is invalid Unicode code point"); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return false;
- /* } */ case 21:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanEscape }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f.base = base; $f.d = d; $f.max = max; $f.msg = msg; $f.msg$1 = msg$1; $f.n = n; $f.offs = offs; $f.quote = quote; $f.s = s; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanEscape = function(quote) { return this.$val.scanEscape(quote); };
- Scanner.ptr.prototype.scanRune = function() {
- var $ptr, _r, ch, n, offs, s, valid, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; ch = $f.ch; n = $f.n; offs = $f.offs; s = $f.s; valid = $f.valid; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offs = s.offset - 1 >> 0;
- valid = true;
- n = 0;
- /* while (true) { */ case 1:
- ch = s.ch;
- /* */ if ((ch === 10) || ch < 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ((ch === 10) || ch < 0) { */ case 3:
- /* */ if (valid) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (valid) { */ case 5:
- $r = s.error(offs, "rune literal not terminated"); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- valid = false;
- /* } */ case 6:
- /* break; */ $s = 2; continue;
- /* } */ case 4:
- $r = s.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (ch === 39) {
- /* break; */ $s = 2; continue;
- }
- n = n + (1) >> 0;
- /* */ if (ch === 92) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (ch === 92) { */ case 9:
- _r = s.scanEscape(39); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!_r) { */ case 11:
- valid = false;
- /* } */ case 12:
- /* } */ case 10:
- /* } */ $s = 1; continue; case 2:
- /* */ if (valid && !((n === 1))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (valid && !((n === 1))) { */ case 14:
- $r = s.error(offs, "illegal rune literal"); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- return $bytesToString($subslice(s.src, offs, s.offset));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanRune }; } $f.$ptr = $ptr; $f._r = _r; $f.ch = ch; $f.n = n; $f.offs = offs; $f.s = s; $f.valid = valid; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanRune = function() { return this.$val.scanRune(); };
- Scanner.ptr.prototype.scanString = function() {
- var $ptr, _r, ch, offs, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; ch = $f.ch; offs = $f.offs; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offs = s.offset - 1 >> 0;
- /* while (true) { */ case 1:
- ch = s.ch;
- /* */ if ((ch === 10) || ch < 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ((ch === 10) || ch < 0) { */ case 3:
- $r = s.error(offs, "string literal not terminated"); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* break; */ $s = 2; continue;
- /* } */ case 4:
- $r = s.next(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (ch === 34) {
- /* break; */ $s = 2; continue;
- }
- /* */ if (ch === 92) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (ch === 92) { */ case 7:
- _r = s.scanEscape(34); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- /* } */ case 8:
- /* } */ $s = 1; continue; case 2:
- return $bytesToString($subslice(s.src, offs, s.offset));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanString }; } $f.$ptr = $ptr; $f._r = _r; $f.ch = ch; $f.offs = offs; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanString = function() { return this.$val.scanString(); };
- stripCR = function(b) {
- var $ptr, _i, _ref, b, c, ch, i;
- c = $makeSlice(sliceType, b.$length);
- i = 0;
- _ref = b;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- ch = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!((ch === 13))) {
- ((i < 0 || i >= c.$length) ? $throwRuntimeError("index out of range") : c.$array[c.$offset + i] = ch);
- i = i + (1) >> 0;
- }
- _i++;
- }
- return $subslice(c, 0, i);
- };
- Scanner.ptr.prototype.scanRawString = function() {
- var $ptr, ch, hasCR, lit, offs, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ch = $f.ch; hasCR = $f.hasCR; lit = $f.lit; offs = $f.offs; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offs = s.offset - 1 >> 0;
- hasCR = false;
- /* while (true) { */ case 1:
- ch = s.ch;
- /* */ if (ch < 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (ch < 0) { */ case 3:
- $r = s.error(offs, "raw string literal not terminated"); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* break; */ $s = 2; continue;
- /* } */ case 4:
- $r = s.next(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (ch === 96) {
- /* break; */ $s = 2; continue;
- }
- if (ch === 13) {
- hasCR = true;
- }
- /* } */ $s = 1; continue; case 2:
- lit = $subslice(s.src, offs, s.offset);
- if (hasCR) {
- lit = stripCR(lit);
- }
- return $bytesToString(lit);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.scanRawString }; } $f.$ptr = $ptr; $f.ch = ch; $f.hasCR = hasCR; $f.lit = lit; $f.offs = offs; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.scanRawString = function() { return this.$val.scanRawString(); };
- Scanner.ptr.prototype.skipWhitespace = function() {
- var $ptr, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* while (true) { */ case 1:
- /* if (!((s.ch === 32) || (s.ch === 9) || (s.ch === 10) && !s.insertSemi || (s.ch === 13))) { break; } */ if(!((s.ch === 32) || (s.ch === 9) || (s.ch === 10) && !s.insertSemi || (s.ch === 13))) { $s = 2; continue; }
- $r = s.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.skipWhitespace }; } $f.$ptr = $ptr; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.skipWhitespace = function() { return this.$val.skipWhitespace(); };
- Scanner.ptr.prototype.switch2 = function(tok0, tok1) {
- var $ptr, s, tok0, tok1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; s = $f.s; tok0 = $f.tok0; tok1 = $f.tok1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (s.ch === 61) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (s.ch === 61) { */ case 1:
- $r = s.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return tok1;
- /* } */ case 2:
- return tok0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.switch2 }; } $f.$ptr = $ptr; $f.s = s; $f.tok0 = tok0; $f.tok1 = tok1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.switch2 = function(tok0, tok1) { return this.$val.switch2(tok0, tok1); };
- Scanner.ptr.prototype.switch3 = function(tok0, tok1, ch2, tok2) {
- var $ptr, ch2, s, tok0, tok1, tok2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ch2 = $f.ch2; s = $f.s; tok0 = $f.tok0; tok1 = $f.tok1; tok2 = $f.tok2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (s.ch === 61) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (s.ch === 61) { */ case 1:
- $r = s.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return tok1;
- /* } */ case 2:
- /* */ if (s.ch === ch2) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (s.ch === ch2) { */ case 4:
- $r = s.next(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return tok2;
- /* } */ case 5:
- return tok0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.switch3 }; } $f.$ptr = $ptr; $f.ch2 = ch2; $f.s = s; $f.tok0 = tok0; $f.tok1 = tok1; $f.tok2 = tok2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.switch3 = function(tok0, tok1, ch2, tok2) { return this.$val.switch3(tok0, tok1, ch2, tok2); };
- Scanner.ptr.prototype.switch4 = function(tok0, tok1, ch2, tok2, tok3) {
- var $ptr, ch2, s, tok0, tok1, tok2, tok3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ch2 = $f.ch2; s = $f.s; tok0 = $f.tok0; tok1 = $f.tok1; tok2 = $f.tok2; tok3 = $f.tok3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (s.ch === 61) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (s.ch === 61) { */ case 1:
- $r = s.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return tok1;
- /* } */ case 2:
- /* */ if (s.ch === ch2) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (s.ch === ch2) { */ case 4:
- $r = s.next(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (s.ch === 61) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (s.ch === 61) { */ case 7:
- $r = s.next(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return tok3;
- /* } */ case 8:
- return tok2;
- /* } */ case 5:
- return tok0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.switch4 }; } $f.$ptr = $ptr; $f.ch2 = ch2; $f.s = s; $f.tok0 = tok0; $f.tok1 = tok1; $f.tok2 = tok2; $f.tok3 = tok3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.switch4 = function(tok0, tok1, ch2, tok2, tok3) { return this.$val.switch4(tok0, tok1, ch2, tok2, tok3); };
- Scanner.ptr.prototype.Scan = function() {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tuple, _tuple$1, _v, ch, insertSemi, lit, pos, s, tok, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; ch = $f.ch; insertSemi = $f.insertSemi; lit = $f.lit; pos = $f.pos; s = $f.s; tok = $f.tok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = 0;
- tok = 0;
- lit = "";
- s = this;
- /* scanAgain: */ case 1:
- $r = s.skipWhitespace(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- pos = s.file.Pos(s.offset);
- insertSemi = false;
- ch = s.ch;
- /* */ if (isLetter(ch)) { $s = 3; continue; }
- /* */ if (48 <= ch && ch <= 57) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (isLetter(ch)) { */ case 3:
- _r = s.scanIdentifier(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- lit = _r;
- if (lit.length > 1) {
- tok = token.Lookup(lit);
- _ref = tok;
- if (_ref === 4 || _ref === 61 || _ref === 65 || _ref === 69 || _ref === 80) {
- insertSemi = true;
- }
- } else {
- insertSemi = true;
- tok = 4;
- }
- $s = 6; continue;
- /* } else if (48 <= ch && ch <= 57) { */ case 4:
- insertSemi = true;
- _r$1 = s.scanNumber(false); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; tok = _tuple[0]; lit = _tuple[1];
- $s = 6; continue;
- /* } else { */ case 5:
- $r = s.next(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$1 = ch;
- /* */ if (_ref$1 === -1) { $s = 10; continue; }
- /* */ if (_ref$1 === 10) { $s = 11; continue; }
- /* */ if (_ref$1 === 34) { $s = 12; continue; }
- /* */ if (_ref$1 === 39) { $s = 13; continue; }
- /* */ if (_ref$1 === 96) { $s = 14; continue; }
- /* */ if (_ref$1 === 58) { $s = 15; continue; }
- /* */ if (_ref$1 === 46) { $s = 16; continue; }
- /* */ if (_ref$1 === 44) { $s = 17; continue; }
- /* */ if (_ref$1 === 59) { $s = 18; continue; }
- /* */ if (_ref$1 === 40) { $s = 19; continue; }
- /* */ if (_ref$1 === 41) { $s = 20; continue; }
- /* */ if (_ref$1 === 91) { $s = 21; continue; }
- /* */ if (_ref$1 === 93) { $s = 22; continue; }
- /* */ if (_ref$1 === 123) { $s = 23; continue; }
- /* */ if (_ref$1 === 125) { $s = 24; continue; }
- /* */ if (_ref$1 === 43) { $s = 25; continue; }
- /* */ if (_ref$1 === 45) { $s = 26; continue; }
- /* */ if (_ref$1 === 42) { $s = 27; continue; }
- /* */ if (_ref$1 === 47) { $s = 28; continue; }
- /* */ if (_ref$1 === 37) { $s = 29; continue; }
- /* */ if (_ref$1 === 94) { $s = 30; continue; }
- /* */ if (_ref$1 === 60) { $s = 31; continue; }
- /* */ if (_ref$1 === 62) { $s = 32; continue; }
- /* */ if (_ref$1 === 61) { $s = 33; continue; }
- /* */ if (_ref$1 === 33) { $s = 34; continue; }
- /* */ if (_ref$1 === 38) { $s = 35; continue; }
- /* */ if (_ref$1 === 124) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (_ref$1 === -1) { */ case 10:
- if (s.insertSemi) {
- s.insertSemi = false;
- _tmp = pos; _tmp$1 = 57; _tmp$2 = "\n"; pos = _tmp; tok = _tmp$1; lit = _tmp$2;
- return [pos, tok, lit];
- }
- tok = 1;
- $s = 38; continue;
- /* } else if (_ref$1 === 10) { */ case 11:
- s.insertSemi = false;
- _tmp$3 = pos; _tmp$4 = 57; _tmp$5 = "\n"; pos = _tmp$3; tok = _tmp$4; lit = _tmp$5;
- return [pos, tok, lit];
- $s = 38; continue;
- /* } else if (_ref$1 === 34) { */ case 12:
- insertSemi = true;
- tok = 9;
- _r$2 = s.scanString(); /* */ $s = 39; case 39: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- lit = _r$2;
- $s = 38; continue;
- /* } else if (_ref$1 === 39) { */ case 13:
- insertSemi = true;
- tok = 8;
- _r$3 = s.scanRune(); /* */ $s = 40; case 40: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- lit = _r$3;
- $s = 38; continue;
- /* } else if (_ref$1 === 96) { */ case 14:
- insertSemi = true;
- tok = 9;
- _r$4 = s.scanRawString(); /* */ $s = 41; case 41: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- lit = _r$4;
- $s = 38; continue;
- /* } else if (_ref$1 === 58) { */ case 15:
- _r$5 = s.switch2(58, 47); /* */ $s = 42; case 42: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- tok = _r$5;
- $s = 38; continue;
- /* } else if (_ref$1 === 46) { */ case 16:
- /* */ if (48 <= s.ch && s.ch <= 57) { $s = 43; continue; }
- /* */ if (s.ch === 46) { $s = 44; continue; }
- /* */ $s = 45; continue;
- /* if (48 <= s.ch && s.ch <= 57) { */ case 43:
- insertSemi = true;
- _r$6 = s.scanNumber(true); /* */ $s = 47; case 47: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$1 = _r$6; tok = _tuple$1[0]; lit = _tuple$1[1];
- $s = 46; continue;
- /* } else if (s.ch === 46) { */ case 44:
- $r = s.next(); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (s.ch === 46) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (s.ch === 46) { */ case 49:
- $r = s.next(); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- tok = 48;
- /* } */ case 50:
- $s = 46; continue;
- /* } else { */ case 45:
- tok = 53;
- /* } */ case 46:
- $s = 38; continue;
- /* } else if (_ref$1 === 44) { */ case 17:
- tok = 52;
- $s = 38; continue;
- /* } else if (_ref$1 === 59) { */ case 18:
- tok = 57;
- lit = ";";
- $s = 38; continue;
- /* } else if (_ref$1 === 40) { */ case 19:
- tok = 49;
- $s = 38; continue;
- /* } else if (_ref$1 === 41) { */ case 20:
- insertSemi = true;
- tok = 54;
- $s = 38; continue;
- /* } else if (_ref$1 === 91) { */ case 21:
- tok = 50;
- $s = 38; continue;
- /* } else if (_ref$1 === 93) { */ case 22:
- insertSemi = true;
- tok = 55;
- $s = 38; continue;
- /* } else if (_ref$1 === 123) { */ case 23:
- tok = 51;
- $s = 38; continue;
- /* } else if (_ref$1 === 125) { */ case 24:
- insertSemi = true;
- tok = 56;
- $s = 38; continue;
- /* } else if (_ref$1 === 43) { */ case 25:
- _r$7 = s.switch3(12, 23, 43, 37); /* */ $s = 52; case 52: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- tok = _r$7;
- if (tok === 37) {
- insertSemi = true;
- }
- $s = 38; continue;
- /* } else if (_ref$1 === 45) { */ case 26:
- _r$8 = s.switch3(13, 24, 45, 38); /* */ $s = 53; case 53: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- tok = _r$8;
- if (tok === 38) {
- insertSemi = true;
- }
- $s = 38; continue;
- /* } else if (_ref$1 === 42) { */ case 27:
- _r$9 = s.switch2(14, 25); /* */ $s = 54; case 54: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- tok = _r$9;
- $s = 38; continue;
- /* } else if (_ref$1 === 47) { */ case 28:
- /* */ if ((s.ch === 47) || (s.ch === 42)) { $s = 55; continue; }
- /* */ $s = 56; continue;
- /* if ((s.ch === 47) || (s.ch === 42)) { */ case 55:
- if (!(s.insertSemi)) { _v = false; $s = 60; continue s; }
- _r$10 = s.findLineEnd(); /* */ $s = 61; case 61: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _v = _r$10; case 60:
- /* */ if (_v) { $s = 58; continue; }
- /* */ $s = 59; continue;
- /* if (_v) { */ case 58:
- s.ch = 47;
- s.offset = s.file.Offset(pos);
- s.rdOffset = s.offset + 1 >> 0;
- s.insertSemi = false;
- _tmp$6 = pos; _tmp$7 = 57; _tmp$8 = "\n"; pos = _tmp$6; tok = _tmp$7; lit = _tmp$8;
- return [pos, tok, lit];
- /* } */ case 59:
- _r$11 = s.scanComment(); /* */ $s = 62; case 62: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- lit = _r$11;
- /* */ if (((s.mode & 1) >>> 0) === 0) { $s = 63; continue; }
- /* */ $s = 64; continue;
- /* if (((s.mode & 1) >>> 0) === 0) { */ case 63:
- s.insertSemi = false;
- /* goto scanAgain */ $s = 1; continue;
- /* } */ case 64:
- tok = 2;
- $s = 57; continue;
- /* } else { */ case 56:
- _r$12 = s.switch2(15, 26); /* */ $s = 65; case 65: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- tok = _r$12;
- /* } */ case 57:
- $s = 38; continue;
- /* } else if (_ref$1 === 37) { */ case 29:
- _r$13 = s.switch2(16, 27); /* */ $s = 66; case 66: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- tok = _r$13;
- $s = 38; continue;
- /* } else if (_ref$1 === 94) { */ case 30:
- _r$14 = s.switch2(19, 30); /* */ $s = 67; case 67: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- tok = _r$14;
- $s = 38; continue;
- /* } else if (_ref$1 === 60) { */ case 31:
- /* */ if (s.ch === 45) { $s = 68; continue; }
- /* */ $s = 69; continue;
- /* if (s.ch === 45) { */ case 68:
- $r = s.next(); /* */ $s = 71; case 71: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- tok = 36;
- $s = 70; continue;
- /* } else { */ case 69:
- _r$15 = s.switch4(40, 45, 60, 20, 31); /* */ $s = 72; case 72: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- tok = _r$15;
- /* } */ case 70:
- $s = 38; continue;
- /* } else if (_ref$1 === 62) { */ case 32:
- _r$16 = s.switch4(41, 46, 62, 21, 32); /* */ $s = 73; case 73: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- tok = _r$16;
- $s = 38; continue;
- /* } else if (_ref$1 === 61) { */ case 33:
- _r$17 = s.switch2(42, 39); /* */ $s = 74; case 74: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- tok = _r$17;
- $s = 38; continue;
- /* } else if (_ref$1 === 33) { */ case 34:
- _r$18 = s.switch2(43, 44); /* */ $s = 75; case 75: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- tok = _r$18;
- $s = 38; continue;
- /* } else if (_ref$1 === 38) { */ case 35:
- /* */ if (s.ch === 94) { $s = 76; continue; }
- /* */ $s = 77; continue;
- /* if (s.ch === 94) { */ case 76:
- $r = s.next(); /* */ $s = 79; case 79: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$19 = s.switch2(22, 33); /* */ $s = 80; case 80: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- tok = _r$19;
- $s = 78; continue;
- /* } else { */ case 77:
- _r$20 = s.switch3(17, 28, 38, 34); /* */ $s = 81; case 81: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- tok = _r$20;
- /* } */ case 78:
- $s = 38; continue;
- /* } else if (_ref$1 === 124) { */ case 36:
- _r$21 = s.switch3(18, 29, 124, 35); /* */ $s = 82; case 82: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- tok = _r$21;
- $s = 38; continue;
- /* } else { */ case 37:
- /* */ if (!((ch === 65279))) { $s = 83; continue; }
- /* */ $s = 84; continue;
- /* if (!((ch === 65279))) { */ case 83:
- _arg = s.file.Offset(pos);
- _r$22 = fmt.Sprintf("illegal character %#U", new sliceType$1([new $Int32(ch)])); /* */ $s = 85; case 85: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$1 = _r$22;
- $r = s.error(_arg, _arg$1); /* */ $s = 86; case 86: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 84:
- insertSemi = s.insertSemi;
- tok = 0;
- lit = $encodeRune(ch);
- /* } */ case 38:
- /* } */ case 6:
- if (((s.mode & 2) >>> 0) === 0) {
- s.insertSemi = insertSemi;
- }
- return [pos, tok, lit];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scanner.ptr.prototype.Scan }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f.ch = ch; $f.insertSemi = insertSemi; $f.lit = lit; $f.pos = pos; $f.s = s; $f.tok = tok; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scanner.prototype.Scan = function() { return this.$val.Scan(); };
- Error.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ErrorList.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Sort", name: "Sort", pkg: "", typ: $funcType([], [], false)}, {prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Err", name: "Err", pkg: "", typ: $funcType([], [$error], false)}];
- ptrType.methods = [{prop: "Add", name: "Add", pkg: "", typ: $funcType([token.Position, $String], [], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "RemoveMultiples", name: "RemoveMultiples", pkg: "", typ: $funcType([], [], false)}];
- ptrType$3.methods = [{prop: "next", name: "next", pkg: "go/scanner", typ: $funcType([], [], false)}, {prop: "Init", name: "Init", pkg: "", typ: $funcType([ptrType$2, sliceType, ErrorHandler, Mode], [], false)}, {prop: "error", name: "error", pkg: "go/scanner", typ: $funcType([$Int, $String], [], false)}, {prop: "interpretLineComment", name: "interpretLineComment", pkg: "go/scanner", typ: $funcType([sliceType], [], false)}, {prop: "scanComment", name: "scanComment", pkg: "go/scanner", typ: $funcType([], [$String], false)}, {prop: "findLineEnd", name: "findLineEnd", pkg: "go/scanner", typ: $funcType([], [$Bool], false)}, {prop: "scanIdentifier", name: "scanIdentifier", pkg: "go/scanner", typ: $funcType([], [$String], false)}, {prop: "scanMantissa", name: "scanMantissa", pkg: "go/scanner", typ: $funcType([$Int], [], false)}, {prop: "scanNumber", name: "scanNumber", pkg: "go/scanner", typ: $funcType([$Bool], [token.Token, $String], false)}, {prop: "scanEscape", name: "scanEscape", pkg: "go/scanner", typ: $funcType([$Int32], [$Bool], false)}, {prop: "scanRune", name: "scanRune", pkg: "go/scanner", typ: $funcType([], [$String], false)}, {prop: "scanString", name: "scanString", pkg: "go/scanner", typ: $funcType([], [$String], false)}, {prop: "scanRawString", name: "scanRawString", pkg: "go/scanner", typ: $funcType([], [$String], false)}, {prop: "skipWhitespace", name: "skipWhitespace", pkg: "go/scanner", typ: $funcType([], [], false)}, {prop: "switch2", name: "switch2", pkg: "go/scanner", typ: $funcType([token.Token, token.Token], [token.Token], false)}, {prop: "switch3", name: "switch3", pkg: "go/scanner", typ: $funcType([token.Token, token.Token, $Int32, token.Token], [token.Token], false)}, {prop: "switch4", name: "switch4", pkg: "go/scanner", typ: $funcType([token.Token, token.Token, $Int32, token.Token, token.Token], [token.Token], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([], [token.Pos, token.Token, $String], false)}];
- Error.init([{prop: "Pos", name: "Pos", pkg: "", typ: token.Position, tag: ""}, {prop: "Msg", name: "Msg", pkg: "", typ: $String, tag: ""}]);
- ErrorList.init(ptrType$1);
- ErrorHandler.init([token.Position, $String], [], false);
- Scanner.init([{prop: "file", name: "file", pkg: "go/scanner", typ: ptrType$2, tag: ""}, {prop: "dir", name: "dir", pkg: "go/scanner", typ: $String, tag: ""}, {prop: "src", name: "src", pkg: "go/scanner", typ: sliceType, tag: ""}, {prop: "err", name: "err", pkg: "go/scanner", typ: ErrorHandler, tag: ""}, {prop: "mode", name: "mode", pkg: "go/scanner", typ: Mode, tag: ""}, {prop: "ch", name: "ch", pkg: "go/scanner", typ: $Int32, tag: ""}, {prop: "offset", name: "offset", pkg: "go/scanner", typ: $Int, tag: ""}, {prop: "rdOffset", name: "rdOffset", pkg: "go/scanner", typ: $Int, tag: ""}, {prop: "lineOffset", name: "lineOffset", pkg: "go/scanner", typ: $Int, tag: ""}, {prop: "insertSemi", name: "insertSemi", pkg: "go/scanner", typ: $Bool, tag: ""}, {prop: "ErrorCount", name: "ErrorCount", pkg: "", typ: $Int, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = filepath.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- prefix = new sliceType($stringToBytes("//line "));
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["go/ast"] = (function() {
- var $pkg = {}, $init, bytes, fmt, scanner, token, io, os, reflect, sort, strconv, strings, unicode, utf8, Node, Expr, Stmt, Decl, Comment, CommentGroup, Field, FieldList, BadExpr, Ident, Ellipsis, BasicLit, FuncLit, CompositeLit, ParenExpr, SelectorExpr, IndexExpr, SliceExpr, TypeAssertExpr, CallExpr, StarExpr, UnaryExpr, BinaryExpr, KeyValueExpr, ChanDir, ArrayType, StructType, FuncType, InterfaceType, MapType, ChanType, BadStmt, DeclStmt, EmptyStmt, LabeledStmt, ExprStmt, SendStmt, IncDecStmt, AssignStmt, GoStmt, DeferStmt, ReturnStmt, BranchStmt, BlockStmt, IfStmt, CaseClause, SwitchStmt, TypeSwitchStmt, CommClause, SelectStmt, ForStmt, RangeStmt, Spec, ImportSpec, ValueSpec, TypeSpec, BadDecl, GenDecl, FuncDecl, File, Package, byPos, CommentMap, commentListReader, nodeStack, posSpan, byImportSpec, byCommentPos, Scope, Object, ObjKind, Visitor, inspector, ptrType, sliceType$1, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, sliceType$2, sliceType$3, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, sliceType$4, ptrType$11, ptrType$12, ptrType$13, ptrType$14, ptrType$15, ptrType$16, ptrType$17, ptrType$18, ptrType$19, ptrType$20, ptrType$21, ptrType$22, ptrType$23, sliceType$5, sliceType$6, ptrType$24, sliceType$7, sliceType$8, sliceType$9, ptrType$26, ptrType$27, ptrType$28, ptrType$29, ptrType$30, ptrType$31, ptrType$32, ptrType$33, ptrType$34, ptrType$35, ptrType$36, ptrType$37, ptrType$38, ptrType$39, ptrType$40, ptrType$41, ptrType$42, ptrType$43, ptrType$44, ptrType$45, ptrType$46, ptrType$47, ptrType$48, ptrType$49, ptrType$50, ptrType$51, ptrType$52, ptrType$53, ptrType$54, ptrType$55, ptrType$56, ptrType$57, ptrType$58, ptrType$59, sliceType$10, sliceType$11, sliceType$12, sliceType$13, mapType, mapType$1, ptrType$60, objKindStrings, isWhitespace, stripTrailingWhitespace, NewIdent, IsExported, sortComments, nodeList, NewCommentMap, summary, SortImports, importPath, importName, importComment, collapse, sortSpecs, NewScope, NewObj, walkIdentList, walkExprList, walkStmtList, walkDeclList, Walk, Inspect;
- bytes = $packages["bytes"];
- fmt = $packages["fmt"];
- scanner = $packages["go/scanner"];
- token = $packages["go/token"];
- io = $packages["io"];
- os = $packages["os"];
- reflect = $packages["reflect"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- unicode = $packages["unicode"];
- utf8 = $packages["unicode/utf8"];
- Node = $pkg.Node = $newType(8, $kindInterface, "ast.Node", "Node", "go/ast", null);
- Expr = $pkg.Expr = $newType(8, $kindInterface, "ast.Expr", "Expr", "go/ast", null);
- Stmt = $pkg.Stmt = $newType(8, $kindInterface, "ast.Stmt", "Stmt", "go/ast", null);
- Decl = $pkg.Decl = $newType(8, $kindInterface, "ast.Decl", "Decl", "go/ast", null);
- Comment = $pkg.Comment = $newType(0, $kindStruct, "ast.Comment", "Comment", "go/ast", function(Slash_, Text_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Slash = 0;
- this.Text = "";
- return;
- }
- this.Slash = Slash_;
- this.Text = Text_;
- });
- CommentGroup = $pkg.CommentGroup = $newType(0, $kindStruct, "ast.CommentGroup", "CommentGroup", "go/ast", function(List_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.List = sliceType$5.nil;
- return;
- }
- this.List = List_;
- });
- Field = $pkg.Field = $newType(0, $kindStruct, "ast.Field", "Field", "go/ast", function(Doc_, Names_, Type_, Tag_, Comment_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Doc = ptrType.nil;
- this.Names = sliceType$8.nil;
- this.Type = $ifaceNil;
- this.Tag = ptrType$1.nil;
- this.Comment = ptrType.nil;
- return;
- }
- this.Doc = Doc_;
- this.Names = Names_;
- this.Type = Type_;
- this.Tag = Tag_;
- this.Comment = Comment_;
- });
- FieldList = $pkg.FieldList = $newType(0, $kindStruct, "ast.FieldList", "FieldList", "go/ast", function(Opening_, List_, Closing_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Opening = 0;
- this.List = sliceType$10.nil;
- this.Closing = 0;
- return;
- }
- this.Opening = Opening_;
- this.List = List_;
- this.Closing = Closing_;
- });
- BadExpr = $pkg.BadExpr = $newType(0, $kindStruct, "ast.BadExpr", "BadExpr", "go/ast", function(From_, To_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.From = 0;
- this.To = 0;
- return;
- }
- this.From = From_;
- this.To = To_;
- });
- Ident = $pkg.Ident = $newType(0, $kindStruct, "ast.Ident", "Ident", "go/ast", function(NamePos_, Name_, Obj_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.NamePos = 0;
- this.Name = "";
- this.Obj = ptrType$3.nil;
- return;
- }
- this.NamePos = NamePos_;
- this.Name = Name_;
- this.Obj = Obj_;
- });
- Ellipsis = $pkg.Ellipsis = $newType(0, $kindStruct, "ast.Ellipsis", "Ellipsis", "go/ast", function(Ellipsis_, Elt_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Ellipsis = 0;
- this.Elt = $ifaceNil;
- return;
- }
- this.Ellipsis = Ellipsis_;
- this.Elt = Elt_;
- });
- BasicLit = $pkg.BasicLit = $newType(0, $kindStruct, "ast.BasicLit", "BasicLit", "go/ast", function(ValuePos_, Kind_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.ValuePos = 0;
- this.Kind = 0;
- this.Value = "";
- return;
- }
- this.ValuePos = ValuePos_;
- this.Kind = Kind_;
- this.Value = Value_;
- });
- FuncLit = $pkg.FuncLit = $newType(0, $kindStruct, "ast.FuncLit", "FuncLit", "go/ast", function(Type_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Type = ptrType$16.nil;
- this.Body = ptrType$5.nil;
- return;
- }
- this.Type = Type_;
- this.Body = Body_;
- });
- CompositeLit = $pkg.CompositeLit = $newType(0, $kindStruct, "ast.CompositeLit", "CompositeLit", "go/ast", function(Type_, Lbrace_, Elts_, Rbrace_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Type = $ifaceNil;
- this.Lbrace = 0;
- this.Elts = sliceType$11.nil;
- this.Rbrace = 0;
- return;
- }
- this.Type = Type_;
- this.Lbrace = Lbrace_;
- this.Elts = Elts_;
- this.Rbrace = Rbrace_;
- });
- ParenExpr = $pkg.ParenExpr = $newType(0, $kindStruct, "ast.ParenExpr", "ParenExpr", "go/ast", function(Lparen_, X_, Rparen_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lparen = 0;
- this.X = $ifaceNil;
- this.Rparen = 0;
- return;
- }
- this.Lparen = Lparen_;
- this.X = X_;
- this.Rparen = Rparen_;
- });
- SelectorExpr = $pkg.SelectorExpr = $newType(0, $kindStruct, "ast.SelectorExpr", "SelectorExpr", "go/ast", function(X_, Sel_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.X = $ifaceNil;
- this.Sel = ptrType$4.nil;
- return;
- }
- this.X = X_;
- this.Sel = Sel_;
- });
- IndexExpr = $pkg.IndexExpr = $newType(0, $kindStruct, "ast.IndexExpr", "IndexExpr", "go/ast", function(X_, Lbrack_, Index_, Rbrack_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.X = $ifaceNil;
- this.Lbrack = 0;
- this.Index = $ifaceNil;
- this.Rbrack = 0;
- return;
- }
- this.X = X_;
- this.Lbrack = Lbrack_;
- this.Index = Index_;
- this.Rbrack = Rbrack_;
- });
- SliceExpr = $pkg.SliceExpr = $newType(0, $kindStruct, "ast.SliceExpr", "SliceExpr", "go/ast", function(X_, Lbrack_, Low_, High_, Max_, Slice3_, Rbrack_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.X = $ifaceNil;
- this.Lbrack = 0;
- this.Low = $ifaceNil;
- this.High = $ifaceNil;
- this.Max = $ifaceNil;
- this.Slice3 = false;
- this.Rbrack = 0;
- return;
- }
- this.X = X_;
- this.Lbrack = Lbrack_;
- this.Low = Low_;
- this.High = High_;
- this.Max = Max_;
- this.Slice3 = Slice3_;
- this.Rbrack = Rbrack_;
- });
- TypeAssertExpr = $pkg.TypeAssertExpr = $newType(0, $kindStruct, "ast.TypeAssertExpr", "TypeAssertExpr", "go/ast", function(X_, Lparen_, Type_, Rparen_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.X = $ifaceNil;
- this.Lparen = 0;
- this.Type = $ifaceNil;
- this.Rparen = 0;
- return;
- }
- this.X = X_;
- this.Lparen = Lparen_;
- this.Type = Type_;
- this.Rparen = Rparen_;
- });
- CallExpr = $pkg.CallExpr = $newType(0, $kindStruct, "ast.CallExpr", "CallExpr", "go/ast", function(Fun_, Lparen_, Args_, Ellipsis_, Rparen_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Fun = $ifaceNil;
- this.Lparen = 0;
- this.Args = sliceType$11.nil;
- this.Ellipsis = 0;
- this.Rparen = 0;
- return;
- }
- this.Fun = Fun_;
- this.Lparen = Lparen_;
- this.Args = Args_;
- this.Ellipsis = Ellipsis_;
- this.Rparen = Rparen_;
- });
- StarExpr = $pkg.StarExpr = $newType(0, $kindStruct, "ast.StarExpr", "StarExpr", "go/ast", function(Star_, X_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Star = 0;
- this.X = $ifaceNil;
- return;
- }
- this.Star = Star_;
- this.X = X_;
- });
- UnaryExpr = $pkg.UnaryExpr = $newType(0, $kindStruct, "ast.UnaryExpr", "UnaryExpr", "go/ast", function(OpPos_, Op_, X_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.OpPos = 0;
- this.Op = 0;
- this.X = $ifaceNil;
- return;
- }
- this.OpPos = OpPos_;
- this.Op = Op_;
- this.X = X_;
- });
- BinaryExpr = $pkg.BinaryExpr = $newType(0, $kindStruct, "ast.BinaryExpr", "BinaryExpr", "go/ast", function(X_, OpPos_, Op_, Y_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.X = $ifaceNil;
- this.OpPos = 0;
- this.Op = 0;
- this.Y = $ifaceNil;
- return;
- }
- this.X = X_;
- this.OpPos = OpPos_;
- this.Op = Op_;
- this.Y = Y_;
- });
- KeyValueExpr = $pkg.KeyValueExpr = $newType(0, $kindStruct, "ast.KeyValueExpr", "KeyValueExpr", "go/ast", function(Key_, Colon_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Key = $ifaceNil;
- this.Colon = 0;
- this.Value = $ifaceNil;
- return;
- }
- this.Key = Key_;
- this.Colon = Colon_;
- this.Value = Value_;
- });
- ChanDir = $pkg.ChanDir = $newType(4, $kindInt, "ast.ChanDir", "ChanDir", "go/ast", null);
- ArrayType = $pkg.ArrayType = $newType(0, $kindStruct, "ast.ArrayType", "ArrayType", "go/ast", function(Lbrack_, Len_, Elt_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lbrack = 0;
- this.Len = $ifaceNil;
- this.Elt = $ifaceNil;
- return;
- }
- this.Lbrack = Lbrack_;
- this.Len = Len_;
- this.Elt = Elt_;
- });
- StructType = $pkg.StructType = $newType(0, $kindStruct, "ast.StructType", "StructType", "go/ast", function(Struct_, Fields_, Incomplete_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Struct = 0;
- this.Fields = ptrType$2.nil;
- this.Incomplete = false;
- return;
- }
- this.Struct = Struct_;
- this.Fields = Fields_;
- this.Incomplete = Incomplete_;
- });
- FuncType = $pkg.FuncType = $newType(0, $kindStruct, "ast.FuncType", "FuncType", "go/ast", function(Func_, Params_, Results_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Func = 0;
- this.Params = ptrType$2.nil;
- this.Results = ptrType$2.nil;
- return;
- }
- this.Func = Func_;
- this.Params = Params_;
- this.Results = Results_;
- });
- InterfaceType = $pkg.InterfaceType = $newType(0, $kindStruct, "ast.InterfaceType", "InterfaceType", "go/ast", function(Interface_, Methods_, Incomplete_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Interface = 0;
- this.Methods = ptrType$2.nil;
- this.Incomplete = false;
- return;
- }
- this.Interface = Interface_;
- this.Methods = Methods_;
- this.Incomplete = Incomplete_;
- });
- MapType = $pkg.MapType = $newType(0, $kindStruct, "ast.MapType", "MapType", "go/ast", function(Map_, Key_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Map = 0;
- this.Key = $ifaceNil;
- this.Value = $ifaceNil;
- return;
- }
- this.Map = Map_;
- this.Key = Key_;
- this.Value = Value_;
- });
- ChanType = $pkg.ChanType = $newType(0, $kindStruct, "ast.ChanType", "ChanType", "go/ast", function(Begin_, Arrow_, Dir_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Begin = 0;
- this.Arrow = 0;
- this.Dir = 0;
- this.Value = $ifaceNil;
- return;
- }
- this.Begin = Begin_;
- this.Arrow = Arrow_;
- this.Dir = Dir_;
- this.Value = Value_;
- });
- BadStmt = $pkg.BadStmt = $newType(0, $kindStruct, "ast.BadStmt", "BadStmt", "go/ast", function(From_, To_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.From = 0;
- this.To = 0;
- return;
- }
- this.From = From_;
- this.To = To_;
- });
- DeclStmt = $pkg.DeclStmt = $newType(0, $kindStruct, "ast.DeclStmt", "DeclStmt", "go/ast", function(Decl_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Decl = $ifaceNil;
- return;
- }
- this.Decl = Decl_;
- });
- EmptyStmt = $pkg.EmptyStmt = $newType(0, $kindStruct, "ast.EmptyStmt", "EmptyStmt", "go/ast", function(Semicolon_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Semicolon = 0;
- return;
- }
- this.Semicolon = Semicolon_;
- });
- LabeledStmt = $pkg.LabeledStmt = $newType(0, $kindStruct, "ast.LabeledStmt", "LabeledStmt", "go/ast", function(Label_, Colon_, Stmt_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Label = ptrType$4.nil;
- this.Colon = 0;
- this.Stmt = $ifaceNil;
- return;
- }
- this.Label = Label_;
- this.Colon = Colon_;
- this.Stmt = Stmt_;
- });
- ExprStmt = $pkg.ExprStmt = $newType(0, $kindStruct, "ast.ExprStmt", "ExprStmt", "go/ast", function(X_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.X = $ifaceNil;
- return;
- }
- this.X = X_;
- });
- SendStmt = $pkg.SendStmt = $newType(0, $kindStruct, "ast.SendStmt", "SendStmt", "go/ast", function(Chan_, Arrow_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Chan = $ifaceNil;
- this.Arrow = 0;
- this.Value = $ifaceNil;
- return;
- }
- this.Chan = Chan_;
- this.Arrow = Arrow_;
- this.Value = Value_;
- });
- IncDecStmt = $pkg.IncDecStmt = $newType(0, $kindStruct, "ast.IncDecStmt", "IncDecStmt", "go/ast", function(X_, TokPos_, Tok_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.X = $ifaceNil;
- this.TokPos = 0;
- this.Tok = 0;
- return;
- }
- this.X = X_;
- this.TokPos = TokPos_;
- this.Tok = Tok_;
- });
- AssignStmt = $pkg.AssignStmt = $newType(0, $kindStruct, "ast.AssignStmt", "AssignStmt", "go/ast", function(Lhs_, TokPos_, Tok_, Rhs_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lhs = sliceType$11.nil;
- this.TokPos = 0;
- this.Tok = 0;
- this.Rhs = sliceType$11.nil;
- return;
- }
- this.Lhs = Lhs_;
- this.TokPos = TokPos_;
- this.Tok = Tok_;
- this.Rhs = Rhs_;
- });
- GoStmt = $pkg.GoStmt = $newType(0, $kindStruct, "ast.GoStmt", "GoStmt", "go/ast", function(Go_, Call_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Go = 0;
- this.Call = ptrType$36.nil;
- return;
- }
- this.Go = Go_;
- this.Call = Call_;
- });
- DeferStmt = $pkg.DeferStmt = $newType(0, $kindStruct, "ast.DeferStmt", "DeferStmt", "go/ast", function(Defer_, Call_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Defer = 0;
- this.Call = ptrType$36.nil;
- return;
- }
- this.Defer = Defer_;
- this.Call = Call_;
- });
- ReturnStmt = $pkg.ReturnStmt = $newType(0, $kindStruct, "ast.ReturnStmt", "ReturnStmt", "go/ast", function(Return_, Results_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Return = 0;
- this.Results = sliceType$11.nil;
- return;
- }
- this.Return = Return_;
- this.Results = Results_;
- });
- BranchStmt = $pkg.BranchStmt = $newType(0, $kindStruct, "ast.BranchStmt", "BranchStmt", "go/ast", function(TokPos_, Tok_, Label_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.TokPos = 0;
- this.Tok = 0;
- this.Label = ptrType$4.nil;
- return;
- }
- this.TokPos = TokPos_;
- this.Tok = Tok_;
- this.Label = Label_;
- });
- BlockStmt = $pkg.BlockStmt = $newType(0, $kindStruct, "ast.BlockStmt", "BlockStmt", "go/ast", function(Lbrace_, List_, Rbrace_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lbrace = 0;
- this.List = sliceType$12.nil;
- this.Rbrace = 0;
- return;
- }
- this.Lbrace = Lbrace_;
- this.List = List_;
- this.Rbrace = Rbrace_;
- });
- IfStmt = $pkg.IfStmt = $newType(0, $kindStruct, "ast.IfStmt", "IfStmt", "go/ast", function(If_, Init_, Cond_, Body_, Else_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.If = 0;
- this.Init = $ifaceNil;
- this.Cond = $ifaceNil;
- this.Body = ptrType$5.nil;
- this.Else = $ifaceNil;
- return;
- }
- this.If = If_;
- this.Init = Init_;
- this.Cond = Cond_;
- this.Body = Body_;
- this.Else = Else_;
- });
- CaseClause = $pkg.CaseClause = $newType(0, $kindStruct, "ast.CaseClause", "CaseClause", "go/ast", function(Case_, List_, Colon_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Case = 0;
- this.List = sliceType$11.nil;
- this.Colon = 0;
- this.Body = sliceType$12.nil;
- return;
- }
- this.Case = Case_;
- this.List = List_;
- this.Colon = Colon_;
- this.Body = Body_;
- });
- SwitchStmt = $pkg.SwitchStmt = $newType(0, $kindStruct, "ast.SwitchStmt", "SwitchStmt", "go/ast", function(Switch_, Init_, Tag_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Switch = 0;
- this.Init = $ifaceNil;
- this.Tag = $ifaceNil;
- this.Body = ptrType$5.nil;
- return;
- }
- this.Switch = Switch_;
- this.Init = Init_;
- this.Tag = Tag_;
- this.Body = Body_;
- });
- TypeSwitchStmt = $pkg.TypeSwitchStmt = $newType(0, $kindStruct, "ast.TypeSwitchStmt", "TypeSwitchStmt", "go/ast", function(Switch_, Init_, Assign_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Switch = 0;
- this.Init = $ifaceNil;
- this.Assign = $ifaceNil;
- this.Body = ptrType$5.nil;
- return;
- }
- this.Switch = Switch_;
- this.Init = Init_;
- this.Assign = Assign_;
- this.Body = Body_;
- });
- CommClause = $pkg.CommClause = $newType(0, $kindStruct, "ast.CommClause", "CommClause", "go/ast", function(Case_, Comm_, Colon_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Case = 0;
- this.Comm = $ifaceNil;
- this.Colon = 0;
- this.Body = sliceType$12.nil;
- return;
- }
- this.Case = Case_;
- this.Comm = Comm_;
- this.Colon = Colon_;
- this.Body = Body_;
- });
- SelectStmt = $pkg.SelectStmt = $newType(0, $kindStruct, "ast.SelectStmt", "SelectStmt", "go/ast", function(Select_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Select = 0;
- this.Body = ptrType$5.nil;
- return;
- }
- this.Select = Select_;
- this.Body = Body_;
- });
- ForStmt = $pkg.ForStmt = $newType(0, $kindStruct, "ast.ForStmt", "ForStmt", "go/ast", function(For_, Init_, Cond_, Post_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.For = 0;
- this.Init = $ifaceNil;
- this.Cond = $ifaceNil;
- this.Post = $ifaceNil;
- this.Body = ptrType$5.nil;
- return;
- }
- this.For = For_;
- this.Init = Init_;
- this.Cond = Cond_;
- this.Post = Post_;
- this.Body = Body_;
- });
- RangeStmt = $pkg.RangeStmt = $newType(0, $kindStruct, "ast.RangeStmt", "RangeStmt", "go/ast", function(For_, Key_, Value_, TokPos_, Tok_, X_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.For = 0;
- this.Key = $ifaceNil;
- this.Value = $ifaceNil;
- this.TokPos = 0;
- this.Tok = 0;
- this.X = $ifaceNil;
- this.Body = ptrType$5.nil;
- return;
- }
- this.For = For_;
- this.Key = Key_;
- this.Value = Value_;
- this.TokPos = TokPos_;
- this.Tok = Tok_;
- this.X = X_;
- this.Body = Body_;
- });
- Spec = $pkg.Spec = $newType(8, $kindInterface, "ast.Spec", "Spec", "go/ast", null);
- ImportSpec = $pkg.ImportSpec = $newType(0, $kindStruct, "ast.ImportSpec", "ImportSpec", "go/ast", function(Doc_, Name_, Path_, Comment_, EndPos_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Doc = ptrType.nil;
- this.Name = ptrType$4.nil;
- this.Path = ptrType$1.nil;
- this.Comment = ptrType.nil;
- this.EndPos = 0;
- return;
- }
- this.Doc = Doc_;
- this.Name = Name_;
- this.Path = Path_;
- this.Comment = Comment_;
- this.EndPos = EndPos_;
- });
- ValueSpec = $pkg.ValueSpec = $newType(0, $kindStruct, "ast.ValueSpec", "ValueSpec", "go/ast", function(Doc_, Names_, Type_, Values_, Comment_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Doc = ptrType.nil;
- this.Names = sliceType$8.nil;
- this.Type = $ifaceNil;
- this.Values = sliceType$11.nil;
- this.Comment = ptrType.nil;
- return;
- }
- this.Doc = Doc_;
- this.Names = Names_;
- this.Type = Type_;
- this.Values = Values_;
- this.Comment = Comment_;
- });
- TypeSpec = $pkg.TypeSpec = $newType(0, $kindStruct, "ast.TypeSpec", "TypeSpec", "go/ast", function(Doc_, Name_, Type_, Comment_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Doc = ptrType.nil;
- this.Name = ptrType$4.nil;
- this.Type = $ifaceNil;
- this.Comment = ptrType.nil;
- return;
- }
- this.Doc = Doc_;
- this.Name = Name_;
- this.Type = Type_;
- this.Comment = Comment_;
- });
- BadDecl = $pkg.BadDecl = $newType(0, $kindStruct, "ast.BadDecl", "BadDecl", "go/ast", function(From_, To_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.From = 0;
- this.To = 0;
- return;
- }
- this.From = From_;
- this.To = To_;
- });
- GenDecl = $pkg.GenDecl = $newType(0, $kindStruct, "ast.GenDecl", "GenDecl", "go/ast", function(Doc_, TokPos_, Tok_, Lparen_, Specs_, Rparen_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Doc = ptrType.nil;
- this.TokPos = 0;
- this.Tok = 0;
- this.Lparen = 0;
- this.Specs = sliceType$13.nil;
- this.Rparen = 0;
- return;
- }
- this.Doc = Doc_;
- this.TokPos = TokPos_;
- this.Tok = Tok_;
- this.Lparen = Lparen_;
- this.Specs = Specs_;
- this.Rparen = Rparen_;
- });
- FuncDecl = $pkg.FuncDecl = $newType(0, $kindStruct, "ast.FuncDecl", "FuncDecl", "go/ast", function(Doc_, Recv_, Name_, Type_, Body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Doc = ptrType.nil;
- this.Recv = ptrType$2.nil;
- this.Name = ptrType$4.nil;
- this.Type = ptrType$16.nil;
- this.Body = ptrType$5.nil;
- return;
- }
- this.Doc = Doc_;
- this.Recv = Recv_;
- this.Name = Name_;
- this.Type = Type_;
- this.Body = Body_;
- });
- File = $pkg.File = $newType(0, $kindStruct, "ast.File", "File", "go/ast", function(Doc_, Package_, Name_, Decls_, Scope_, Imports_, Unresolved_, Comments_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Doc = ptrType.nil;
- this.Package = 0;
- this.Name = ptrType$4.nil;
- this.Decls = sliceType$6.nil;
- this.Scope = ptrType$26.nil;
- this.Imports = sliceType$7.nil;
- this.Unresolved = sliceType$8.nil;
- this.Comments = sliceType$2.nil;
- return;
- }
- this.Doc = Doc_;
- this.Package = Package_;
- this.Name = Name_;
- this.Decls = Decls_;
- this.Scope = Scope_;
- this.Imports = Imports_;
- this.Unresolved = Unresolved_;
- this.Comments = Comments_;
- });
- Package = $pkg.Package = $newType(0, $kindStruct, "ast.Package", "Package", "go/ast", function(Name_, Scope_, Imports_, Files_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Name = "";
- this.Scope = ptrType$26.nil;
- this.Imports = false;
- this.Files = false;
- return;
- }
- this.Name = Name_;
- this.Scope = Scope_;
- this.Imports = Imports_;
- this.Files = Files_;
- });
- byPos = $pkg.byPos = $newType(12, $kindSlice, "ast.byPos", "byPos", "go/ast", null);
- CommentMap = $pkg.CommentMap = $newType(4, $kindMap, "ast.CommentMap", "CommentMap", "go/ast", null);
- commentListReader = $pkg.commentListReader = $newType(0, $kindStruct, "ast.commentListReader", "commentListReader", "go/ast", function(fset_, list_, index_, comment_, pos_, end_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.fset = ptrType$7.nil;
- this.list = sliceType$2.nil;
- this.index = 0;
- this.comment = ptrType.nil;
- this.pos = new token.Position.ptr();
- this.end = new token.Position.ptr();
- return;
- }
- this.fset = fset_;
- this.list = list_;
- this.index = index_;
- this.comment = comment_;
- this.pos = pos_;
- this.end = end_;
- });
- nodeStack = $pkg.nodeStack = $newType(12, $kindSlice, "ast.nodeStack", "nodeStack", "go/ast", null);
- posSpan = $pkg.posSpan = $newType(0, $kindStruct, "ast.posSpan", "posSpan", "go/ast", function(Start_, End_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Start = 0;
- this.End = 0;
- return;
- }
- this.Start = Start_;
- this.End = End_;
- });
- byImportSpec = $pkg.byImportSpec = $newType(12, $kindSlice, "ast.byImportSpec", "byImportSpec", "go/ast", null);
- byCommentPos = $pkg.byCommentPos = $newType(12, $kindSlice, "ast.byCommentPos", "byCommentPos", "go/ast", null);
- Scope = $pkg.Scope = $newType(0, $kindStruct, "ast.Scope", "Scope", "go/ast", function(Outer_, Objects_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Outer = ptrType$26.nil;
- this.Objects = false;
- return;
- }
- this.Outer = Outer_;
- this.Objects = Objects_;
- });
- Object = $pkg.Object = $newType(0, $kindStruct, "ast.Object", "Object", "go/ast", function(Kind_, Name_, Decl_, Data_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Kind = 0;
- this.Name = "";
- this.Decl = $ifaceNil;
- this.Data = $ifaceNil;
- this.Type = $ifaceNil;
- return;
- }
- this.Kind = Kind_;
- this.Name = Name_;
- this.Decl = Decl_;
- this.Data = Data_;
- this.Type = Type_;
- });
- ObjKind = $pkg.ObjKind = $newType(4, $kindInt, "ast.ObjKind", "ObjKind", "go/ast", null);
- Visitor = $pkg.Visitor = $newType(8, $kindInterface, "ast.Visitor", "Visitor", "go/ast", null);
- inspector = $pkg.inspector = $newType(4, $kindFunc, "ast.inspector", "inspector", "go/ast", null);
- ptrType = $ptrType(CommentGroup);
- sliceType$1 = $sliceType($String);
- ptrType$1 = $ptrType(BasicLit);
- ptrType$2 = $ptrType(FieldList);
- ptrType$3 = $ptrType(Object);
- ptrType$4 = $ptrType(Ident);
- ptrType$5 = $ptrType(BlockStmt);
- sliceType$2 = $sliceType(ptrType);
- sliceType$3 = $sliceType(Node);
- ptrType$6 = $ptrType(Comment);
- ptrType$7 = $ptrType(token.FileSet);
- ptrType$8 = $ptrType(nodeStack);
- ptrType$9 = $ptrType(File);
- ptrType$10 = $ptrType(Field);
- sliceType$4 = $sliceType($emptyInterface);
- ptrType$11 = $ptrType(SelectorExpr);
- ptrType$12 = $ptrType(StarExpr);
- ptrType$13 = $ptrType(ParenExpr);
- ptrType$14 = $ptrType(ArrayType);
- ptrType$15 = $ptrType(StructType);
- ptrType$16 = $ptrType(FuncType);
- ptrType$17 = $ptrType(InterfaceType);
- ptrType$18 = $ptrType(MapType);
- ptrType$19 = $ptrType(ChanType);
- ptrType$20 = $ptrType(ValueSpec);
- ptrType$21 = $ptrType(TypeSpec);
- ptrType$22 = $ptrType(GenDecl);
- ptrType$23 = $ptrType(FuncDecl);
- sliceType$5 = $sliceType(ptrType$6);
- sliceType$6 = $sliceType(Decl);
- ptrType$24 = $ptrType(ImportSpec);
- sliceType$7 = $sliceType(ptrType$24);
- sliceType$8 = $sliceType(ptrType$4);
- sliceType$9 = $sliceType(posSpan);
- ptrType$26 = $ptrType(Scope);
- ptrType$27 = $ptrType(LabeledStmt);
- ptrType$28 = $ptrType(AssignStmt);
- ptrType$29 = $ptrType(BadExpr);
- ptrType$30 = $ptrType(Ellipsis);
- ptrType$31 = $ptrType(FuncLit);
- ptrType$32 = $ptrType(CompositeLit);
- ptrType$33 = $ptrType(IndexExpr);
- ptrType$34 = $ptrType(SliceExpr);
- ptrType$35 = $ptrType(TypeAssertExpr);
- ptrType$36 = $ptrType(CallExpr);
- ptrType$37 = $ptrType(UnaryExpr);
- ptrType$38 = $ptrType(BinaryExpr);
- ptrType$39 = $ptrType(KeyValueExpr);
- ptrType$40 = $ptrType(BadStmt);
- ptrType$41 = $ptrType(DeclStmt);
- ptrType$42 = $ptrType(EmptyStmt);
- ptrType$43 = $ptrType(ExprStmt);
- ptrType$44 = $ptrType(SendStmt);
- ptrType$45 = $ptrType(IncDecStmt);
- ptrType$46 = $ptrType(GoStmt);
- ptrType$47 = $ptrType(DeferStmt);
- ptrType$48 = $ptrType(ReturnStmt);
- ptrType$49 = $ptrType(BranchStmt);
- ptrType$50 = $ptrType(IfStmt);
- ptrType$51 = $ptrType(CaseClause);
- ptrType$52 = $ptrType(SwitchStmt);
- ptrType$53 = $ptrType(TypeSwitchStmt);
- ptrType$54 = $ptrType(CommClause);
- ptrType$55 = $ptrType(SelectStmt);
- ptrType$56 = $ptrType(ForStmt);
- ptrType$57 = $ptrType(RangeStmt);
- ptrType$58 = $ptrType(BadDecl);
- ptrType$59 = $ptrType(Package);
- sliceType$10 = $sliceType(ptrType$10);
- sliceType$11 = $sliceType(Expr);
- sliceType$12 = $sliceType(Stmt);
- sliceType$13 = $sliceType(Spec);
- mapType = $mapType($String, ptrType$3);
- mapType$1 = $mapType($String, ptrType$9);
- ptrType$60 = $ptrType(commentListReader);
- Comment.ptr.prototype.Pos = function() {
- var $ptr, c;
- c = this;
- return c.Slash;
- };
- Comment.prototype.Pos = function() { return this.$val.Pos(); };
- Comment.ptr.prototype.End = function() {
- var $ptr, c;
- c = this;
- return (((c.Slash >> 0) + c.Text.length >> 0) >> 0);
- };
- Comment.prototype.End = function() { return this.$val.End(); };
- CommentGroup.ptr.prototype.Pos = function() {
- var $ptr, g, x;
- g = this;
- return (x = g.List, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Pos();
- };
- CommentGroup.prototype.Pos = function() { return this.$val.Pos(); };
- CommentGroup.ptr.prototype.End = function() {
- var $ptr, g, x, x$1;
- g = this;
- return (x = g.List, x$1 = g.List.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End();
- };
- CommentGroup.prototype.End = function() { return this.$val.End(); };
- isWhitespace = function(ch) {
- var $ptr, ch;
- return (ch === 32) || (ch === 9) || (ch === 10) || (ch === 13);
- };
- stripTrailingWhitespace = function(s) {
- var $ptr, i, s;
- i = s.length;
- while (true) {
- if (!(i > 0 && isWhitespace(s.charCodeAt((i - 1 >> 0))))) { break; }
- i = i - (1) >> 0;
- }
- return s.substring(0, i);
- };
- CommentGroup.ptr.prototype.Text = function() {
- var $ptr, _i, _i$1, _i$2, _i$3, _ref, _ref$1, _ref$2, _ref$3, _ref$4, c, c$1, cl, comments, g, i, l, line, lines, n, x, x$1;
- g = this;
- if (g === ptrType.nil) {
- return "";
- }
- comments = $makeSlice(sliceType$1, g.List.$length);
- _ref = g.List;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= comments.$length) ? $throwRuntimeError("index out of range") : comments.$array[comments.$offset + i] = c.Text);
- _i++;
- }
- lines = $makeSlice(sliceType$1, 0, 10);
- _ref$1 = comments;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- c$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _ref$2 = c$1.charCodeAt(1);
- if (_ref$2 === 47) {
- c$1 = c$1.substring(2);
- if (c$1.length > 0 && (c$1.charCodeAt(0) === 32)) {
- c$1 = c$1.substring(1);
- }
- } else if (_ref$2 === 42) {
- c$1 = c$1.substring(2, (c$1.length - 2 >> 0));
- }
- cl = strings.Split(c$1, "\n");
- _ref$3 = cl;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$3.$length)) { break; }
- l = ((_i$2 < 0 || _i$2 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$2]);
- lines = $append(lines, stripTrailingWhitespace(l));
- _i$2++;
- }
- _i$1++;
- }
- n = 0;
- _ref$4 = lines;
- _i$3 = 0;
- while (true) {
- if (!(_i$3 < _ref$4.$length)) { break; }
- line = ((_i$3 < 0 || _i$3 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$3]);
- if (!(line === "") || n > 0 && !((x = n - 1 >> 0, ((x < 0 || x >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + x])) === "")) {
- ((n < 0 || n >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + n] = line);
- n = n + (1) >> 0;
- }
- _i$3++;
- }
- lines = $subslice(lines, 0, n);
- if (n > 0 && !((x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + x$1])) === "")) {
- lines = $append(lines, "");
- }
- return strings.Join(lines, "\n");
- };
- CommentGroup.prototype.Text = function() { return this.$val.Text(); };
- Field.ptr.prototype.Pos = function() {
- var $ptr, _r, f, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- if (f.Names.$length > 0) {
- return (x = f.Names, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Pos();
- }
- _r = f.Type.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Field.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Field.prototype.Pos = function() { return this.$val.Pos(); };
- Field.ptr.prototype.End = function() {
- var $ptr, _r, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- if (!(f.Tag === ptrType$1.nil)) {
- return f.Tag.End();
- }
- _r = f.Type.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Field.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- Field.prototype.End = function() { return this.$val.End(); };
- FieldList.ptr.prototype.Pos = function() {
- var $ptr, _r, f, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- if (new token.Pos(f.Opening).IsValid()) {
- return f.Opening;
- }
- /* */ if (f.List.$length > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (f.List.$length > 0) { */ case 1:
- _r = (x = f.List, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FieldList.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FieldList.prototype.Pos = function() { return this.$val.Pos(); };
- FieldList.ptr.prototype.End = function() {
- var $ptr, _r, f, n, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; n = $f.n; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- if (new token.Pos(f.Closing).IsValid()) {
- return f.Closing + 1 >> 0;
- }
- n = f.List.$length;
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- _r = (x = f.List, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FieldList.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- FieldList.prototype.End = function() { return this.$val.End(); };
- FieldList.ptr.prototype.NumFields = function() {
- var $ptr, _i, _ref, f, g, m, n;
- f = this;
- n = 0;
- if (!(f === ptrType$2.nil)) {
- _ref = f.List;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- g = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- m = g.Names.$length;
- if (m === 0) {
- m = 1;
- }
- n = n + (m) >> 0;
- _i++;
- }
- }
- return n;
- };
- FieldList.prototype.NumFields = function() { return this.$val.NumFields(); };
- BadExpr.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.From;
- };
- BadExpr.prototype.Pos = function() { return this.$val.Pos(); };
- Ident.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.NamePos;
- };
- Ident.prototype.Pos = function() { return this.$val.Pos(); };
- Ellipsis.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Ellipsis;
- };
- Ellipsis.prototype.Pos = function() { return this.$val.Pos(); };
- BasicLit.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.ValuePos;
- };
- BasicLit.prototype.Pos = function() { return this.$val.Pos(); };
- FuncLit.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Type.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FuncLit.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FuncLit.prototype.Pos = function() { return this.$val.Pos(); };
- CompositeLit.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- /* */ if (!($interfaceIsEqual(x.Type, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(x.Type, $ifaceNil))) { */ case 1:
- _r = x.Type.Pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return x.Lbrace;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: CompositeLit.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- CompositeLit.prototype.Pos = function() { return this.$val.Pos(); };
- ParenExpr.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Lparen;
- };
- ParenExpr.prototype.Pos = function() { return this.$val.Pos(); };
- SelectorExpr.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.X.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SelectorExpr.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- SelectorExpr.prototype.Pos = function() { return this.$val.Pos(); };
- IndexExpr.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.X.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: IndexExpr.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- IndexExpr.prototype.Pos = function() { return this.$val.Pos(); };
- SliceExpr.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.X.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SliceExpr.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- SliceExpr.prototype.Pos = function() { return this.$val.Pos(); };
- TypeAssertExpr.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.X.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TypeAssertExpr.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- TypeAssertExpr.prototype.Pos = function() { return this.$val.Pos(); };
- CallExpr.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Fun.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: CallExpr.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- CallExpr.prototype.Pos = function() { return this.$val.Pos(); };
- StarExpr.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Star;
- };
- StarExpr.prototype.Pos = function() { return this.$val.Pos(); };
- UnaryExpr.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.OpPos;
- };
- UnaryExpr.prototype.Pos = function() { return this.$val.Pos(); };
- BinaryExpr.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.X.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BinaryExpr.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- BinaryExpr.prototype.Pos = function() { return this.$val.Pos(); };
- KeyValueExpr.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Key.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: KeyValueExpr.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- KeyValueExpr.prototype.Pos = function() { return this.$val.Pos(); };
- ArrayType.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Lbrack;
- };
- ArrayType.prototype.Pos = function() { return this.$val.Pos(); };
- StructType.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Struct;
- };
- StructType.prototype.Pos = function() { return this.$val.Pos(); };
- FuncType.ptr.prototype.Pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- if (new token.Pos(x.Func).IsValid() || x.Params === ptrType$2.nil) {
- return x.Func;
- }
- _r = x.Params.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FuncType.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FuncType.prototype.Pos = function() { return this.$val.Pos(); };
- InterfaceType.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Interface;
- };
- InterfaceType.prototype.Pos = function() { return this.$val.Pos(); };
- MapType.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Map;
- };
- MapType.prototype.Pos = function() { return this.$val.Pos(); };
- ChanType.ptr.prototype.Pos = function() {
- var $ptr, x;
- x = this;
- return x.Begin;
- };
- ChanType.prototype.Pos = function() { return this.$val.Pos(); };
- BadExpr.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.To;
- };
- BadExpr.prototype.End = function() { return this.$val.End(); };
- Ident.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return (((x.NamePos >> 0) + x.Name.length >> 0) >> 0);
- };
- Ident.prototype.End = function() { return this.$val.End(); };
- Ellipsis.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- /* */ if (!($interfaceIsEqual(x.Elt, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(x.Elt, $ifaceNil))) { */ case 1:
- _r = x.Elt.End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return x.Ellipsis + 3 >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Ellipsis.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Ellipsis.prototype.End = function() { return this.$val.End(); };
- BasicLit.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return (((x.ValuePos >> 0) + x.Value.length >> 0) >> 0);
- };
- BasicLit.prototype.End = function() { return this.$val.End(); };
- FuncLit.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Body.End();
- };
- FuncLit.prototype.End = function() { return this.$val.End(); };
- CompositeLit.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Rbrace + 1 >> 0;
- };
- CompositeLit.prototype.End = function() { return this.$val.End(); };
- ParenExpr.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Rparen + 1 >> 0;
- };
- ParenExpr.prototype.End = function() { return this.$val.End(); };
- SelectorExpr.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Sel.End();
- };
- SelectorExpr.prototype.End = function() { return this.$val.End(); };
- IndexExpr.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Rbrack + 1 >> 0;
- };
- IndexExpr.prototype.End = function() { return this.$val.End(); };
- SliceExpr.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Rbrack + 1 >> 0;
- };
- SliceExpr.prototype.End = function() { return this.$val.End(); };
- TypeAssertExpr.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Rparen + 1 >> 0;
- };
- TypeAssertExpr.prototype.End = function() { return this.$val.End(); };
- CallExpr.ptr.prototype.End = function() {
- var $ptr, x;
- x = this;
- return x.Rparen + 1 >> 0;
- };
- CallExpr.prototype.End = function() { return this.$val.End(); };
- StarExpr.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.X.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StarExpr.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- StarExpr.prototype.End = function() { return this.$val.End(); };
- UnaryExpr.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.X.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: UnaryExpr.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- UnaryExpr.prototype.End = function() { return this.$val.End(); };
- BinaryExpr.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Y.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BinaryExpr.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- BinaryExpr.prototype.End = function() { return this.$val.End(); };
- KeyValueExpr.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Value.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: KeyValueExpr.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- KeyValueExpr.prototype.End = function() { return this.$val.End(); };
- ArrayType.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Elt.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ArrayType.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- ArrayType.prototype.End = function() { return this.$val.End(); };
- StructType.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Fields.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StructType.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- StructType.prototype.End = function() { return this.$val.End(); };
- FuncType.ptr.prototype.End = function() {
- var $ptr, _r, _r$1, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- /* */ if (!(x.Results === ptrType$2.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(x.Results === ptrType$2.nil)) { */ case 1:
- _r = x.Results.End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- _r$1 = x.Params.End(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FuncType.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- FuncType.prototype.End = function() { return this.$val.End(); };
- InterfaceType.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Methods.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: InterfaceType.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- InterfaceType.prototype.End = function() { return this.$val.End(); };
- MapType.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Value.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: MapType.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- MapType.prototype.End = function() { return this.$val.End(); };
- ChanType.ptr.prototype.End = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.Value.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ChanType.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- ChanType.prototype.End = function() { return this.$val.End(); };
- NewIdent = function(name) {
- var $ptr, name;
- return new Ident.ptr(0, name, ptrType$3.nil);
- };
- $pkg.NewIdent = NewIdent;
- IsExported = function(name) {
- var $ptr, _tuple, ch, name;
- _tuple = utf8.DecodeRuneInString(name); ch = _tuple[0];
- return unicode.IsUpper(ch);
- };
- $pkg.IsExported = IsExported;
- Ident.ptr.prototype.IsExported = function() {
- var $ptr, id;
- id = this;
- return IsExported(id.Name);
- };
- Ident.prototype.IsExported = function() { return this.$val.IsExported(); };
- Ident.ptr.prototype.String = function() {
- var $ptr, id;
- id = this;
- if (!(id === ptrType$4.nil)) {
- return id.Name;
- }
- return "";
- };
- Ident.prototype.String = function() { return this.$val.String(); };
- BadStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.From;
- };
- BadStmt.prototype.Pos = function() { return this.$val.Pos(); };
- DeclStmt.ptr.prototype.Pos = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.Decl.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: DeclStmt.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- DeclStmt.prototype.Pos = function() { return this.$val.Pos(); };
- EmptyStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Semicolon;
- };
- EmptyStmt.prototype.Pos = function() { return this.$val.Pos(); };
- LabeledStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Label.Pos();
- };
- LabeledStmt.prototype.Pos = function() { return this.$val.Pos(); };
- ExprStmt.ptr.prototype.Pos = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.X.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ExprStmt.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- ExprStmt.prototype.Pos = function() { return this.$val.Pos(); };
- SendStmt.ptr.prototype.Pos = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.Chan.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SendStmt.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- SendStmt.prototype.Pos = function() { return this.$val.Pos(); };
- IncDecStmt.ptr.prototype.Pos = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.X.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: IncDecStmt.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- IncDecStmt.prototype.Pos = function() { return this.$val.Pos(); };
- AssignStmt.ptr.prototype.Pos = function() {
- var $ptr, _r, s, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = (x = s.Lhs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: AssignStmt.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- AssignStmt.prototype.Pos = function() { return this.$val.Pos(); };
- GoStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Go;
- };
- GoStmt.prototype.Pos = function() { return this.$val.Pos(); };
- DeferStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Defer;
- };
- DeferStmt.prototype.Pos = function() { return this.$val.Pos(); };
- ReturnStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Return;
- };
- ReturnStmt.prototype.Pos = function() { return this.$val.Pos(); };
- BranchStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.TokPos;
- };
- BranchStmt.prototype.Pos = function() { return this.$val.Pos(); };
- BlockStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Lbrace;
- };
- BlockStmt.prototype.Pos = function() { return this.$val.Pos(); };
- IfStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.If;
- };
- IfStmt.prototype.Pos = function() { return this.$val.Pos(); };
- CaseClause.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Case;
- };
- CaseClause.prototype.Pos = function() { return this.$val.Pos(); };
- SwitchStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Switch;
- };
- SwitchStmt.prototype.Pos = function() { return this.$val.Pos(); };
- TypeSwitchStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Switch;
- };
- TypeSwitchStmt.prototype.Pos = function() { return this.$val.Pos(); };
- CommClause.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Case;
- };
- CommClause.prototype.Pos = function() { return this.$val.Pos(); };
- SelectStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Select;
- };
- SelectStmt.prototype.Pos = function() { return this.$val.Pos(); };
- ForStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.For;
- };
- ForStmt.prototype.Pos = function() { return this.$val.Pos(); };
- RangeStmt.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.For;
- };
- RangeStmt.prototype.Pos = function() { return this.$val.Pos(); };
- BadStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.To;
- };
- BadStmt.prototype.End = function() { return this.$val.End(); };
- DeclStmt.ptr.prototype.End = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.Decl.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: DeclStmt.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- DeclStmt.prototype.End = function() { return this.$val.End(); };
- EmptyStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Semicolon + 1 >> 0;
- };
- EmptyStmt.prototype.End = function() { return this.$val.End(); };
- LabeledStmt.ptr.prototype.End = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.Stmt.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: LabeledStmt.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- LabeledStmt.prototype.End = function() { return this.$val.End(); };
- ExprStmt.ptr.prototype.End = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.X.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ExprStmt.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- ExprStmt.prototype.End = function() { return this.$val.End(); };
- SendStmt.ptr.prototype.End = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.Value.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SendStmt.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- SendStmt.prototype.End = function() { return this.$val.End(); };
- IncDecStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.TokPos + 2 >> 0;
- };
- IncDecStmt.prototype.End = function() { return this.$val.End(); };
- AssignStmt.ptr.prototype.End = function() {
- var $ptr, _r, s, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = (x = s.Rhs, x$1 = s.Rhs.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: AssignStmt.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- AssignStmt.prototype.End = function() { return this.$val.End(); };
- GoStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Call.End();
- };
- GoStmt.prototype.End = function() { return this.$val.End(); };
- DeferStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Call.End();
- };
- DeferStmt.prototype.End = function() { return this.$val.End(); };
- ReturnStmt.ptr.prototype.End = function() {
- var $ptr, _r, n, s, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; s = $f.s; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- n = s.Results.$length;
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- _r = (x = s.Results, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return s.Return + 6 >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ReturnStmt.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- ReturnStmt.prototype.End = function() { return this.$val.End(); };
- BranchStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- if (!(s.Label === ptrType$4.nil)) {
- return s.Label.End();
- }
- return (((s.TokPos >> 0) + new token.Token(s.Tok).String().length >> 0) >> 0);
- };
- BranchStmt.prototype.End = function() { return this.$val.End(); };
- BlockStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Rbrace + 1 >> 0;
- };
- BlockStmt.prototype.End = function() { return this.$val.End(); };
- IfStmt.ptr.prototype.End = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* */ if (!($interfaceIsEqual(s.Else, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(s.Else, $ifaceNil))) { */ case 1:
- _r = s.Else.End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return s.Body.End();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: IfStmt.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- IfStmt.prototype.End = function() { return this.$val.End(); };
- CaseClause.ptr.prototype.End = function() {
- var $ptr, _r, n, s, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; s = $f.s; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- n = s.Body.$length;
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- _r = (x = s.Body, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return s.Colon + 1 >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: CaseClause.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- CaseClause.prototype.End = function() { return this.$val.End(); };
- SwitchStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Body.End();
- };
- SwitchStmt.prototype.End = function() { return this.$val.End(); };
- TypeSwitchStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Body.End();
- };
- TypeSwitchStmt.prototype.End = function() { return this.$val.End(); };
- CommClause.ptr.prototype.End = function() {
- var $ptr, _r, n, s, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; s = $f.s; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- n = s.Body.$length;
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- _r = (x = s.Body, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return s.Colon + 1 >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: CommClause.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- CommClause.prototype.End = function() { return this.$val.End(); };
- SelectStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Body.End();
- };
- SelectStmt.prototype.End = function() { return this.$val.End(); };
- ForStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Body.End();
- };
- ForStmt.prototype.End = function() { return this.$val.End(); };
- RangeStmt.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.Body.End();
- };
- RangeStmt.prototype.End = function() { return this.$val.End(); };
- ImportSpec.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- if (!(s.Name === ptrType$4.nil)) {
- return s.Name.Pos();
- }
- return s.Path.Pos();
- };
- ImportSpec.prototype.Pos = function() { return this.$val.Pos(); };
- ValueSpec.ptr.prototype.Pos = function() {
- var $ptr, s, x;
- s = this;
- return (x = s.Names, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Pos();
- };
- ValueSpec.prototype.Pos = function() { return this.$val.Pos(); };
- TypeSpec.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.Name.Pos();
- };
- TypeSpec.prototype.Pos = function() { return this.$val.Pos(); };
- ImportSpec.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- if (!((s.EndPos === 0))) {
- return s.EndPos;
- }
- return s.Path.End();
- };
- ImportSpec.prototype.End = function() { return this.$val.End(); };
- ValueSpec.ptr.prototype.End = function() {
- var $ptr, _r, _r$1, n, s, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; n = $f.n; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- n = s.Values.$length;
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- _r = (x = s.Values, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- /* */ if (!($interfaceIsEqual(s.Type, $ifaceNil))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!($interfaceIsEqual(s.Type, $ifaceNil))) { */ case 4:
- _r$1 = s.Type.End(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 5:
- return (x$2 = s.Names, x$3 = s.Names.$length - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3])).End();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ValueSpec.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.n = n; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- ValueSpec.prototype.End = function() { return this.$val.End(); };
- TypeSpec.ptr.prototype.End = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = s.Type.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TypeSpec.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- TypeSpec.prototype.End = function() { return this.$val.End(); };
- BadDecl.ptr.prototype.Pos = function() {
- var $ptr, d;
- d = this;
- return d.From;
- };
- BadDecl.prototype.Pos = function() { return this.$val.Pos(); };
- GenDecl.ptr.prototype.Pos = function() {
- var $ptr, d;
- d = this;
- return d.TokPos;
- };
- GenDecl.prototype.Pos = function() { return this.$val.Pos(); };
- FuncDecl.ptr.prototype.Pos = function() {
- var $ptr, _r, d, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; d = $f.d; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- _r = d.Type.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FuncDecl.ptr.prototype.Pos }; } $f.$ptr = $ptr; $f._r = _r; $f.d = d; $f.$s = $s; $f.$r = $r; return $f;
- };
- FuncDecl.prototype.Pos = function() { return this.$val.Pos(); };
- BadDecl.ptr.prototype.End = function() {
- var $ptr, d;
- d = this;
- return d.To;
- };
- BadDecl.prototype.End = function() { return this.$val.End(); };
- GenDecl.ptr.prototype.End = function() {
- var $ptr, _r, d, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; d = $f.d; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- if (new token.Pos(d.Rparen).IsValid()) {
- return d.Rparen + 1 >> 0;
- }
- _r = (x = d.Specs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: GenDecl.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.d = d; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- GenDecl.prototype.End = function() { return this.$val.End(); };
- FuncDecl.ptr.prototype.End = function() {
- var $ptr, _r, d, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; d = $f.d; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = this;
- if (!(d.Body === ptrType$5.nil)) {
- return d.Body.End();
- }
- _r = d.Type.End(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FuncDecl.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.d = d; $f.$s = $s; $f.$r = $r; return $f;
- };
- FuncDecl.prototype.End = function() { return this.$val.End(); };
- File.ptr.prototype.Pos = function() {
- var $ptr, f;
- f = this;
- return f.Package;
- };
- File.prototype.Pos = function() { return this.$val.Pos(); };
- File.ptr.prototype.End = function() {
- var $ptr, _r, f, n, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; n = $f.n; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this;
- n = f.Decls.$length;
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- _r = (x = f.Decls, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return f.Name.End();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.End }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.n = n; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- File.prototype.End = function() { return this.$val.End(); };
- Package.ptr.prototype.Pos = function() {
- var $ptr, p;
- p = this;
- return 0;
- };
- Package.prototype.Pos = function() { return this.$val.Pos(); };
- Package.ptr.prototype.End = function() {
- var $ptr, p;
- p = this;
- return 0;
- };
- Package.prototype.End = function() { return this.$val.End(); };
- byPos.prototype.Len = function() {
- var $ptr, a;
- a = this;
- return a.$length;
- };
- $ptrType(byPos).prototype.Len = function() { return this.$get().Len(); };
- byPos.prototype.Less = function(i, j) {
- var $ptr, a, i, j;
- a = this;
- return ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]).Pos() < ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]).Pos();
- };
- $ptrType(byPos).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- byPos.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, a, i, j;
- a = this;
- _tmp = ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]); _tmp$1 = ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]); ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = _tmp); ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j] = _tmp$1);
- };
- $ptrType(byPos).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- sortComments = function(list) {
- var $ptr, _r, list, orderedList, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; list = $f.list; orderedList = $f.orderedList; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- orderedList = $subslice(new byPos(list.$array), list.$offset, list.$offset + list.$length);
- _r = sort.IsSorted(orderedList); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!_r) { */ case 1:
- $r = sort.Sort(orderedList); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sortComments }; } $f.$ptr = $ptr; $f._r = _r; $f.list = list; $f.orderedList = orderedList; $f.$s = $s; $f.$r = $r; return $f;
- };
- CommentMap.prototype.addComment = function(n, c) {
- var $ptr, _entry, _key, c, cmap, list, n;
- cmap = this.$val;
- list = (_entry = cmap[Node.keyFor(n)], _entry !== undefined ? _entry.v : sliceType$2.nil);
- if (list.$length === 0) {
- list = new sliceType$2([c]);
- } else {
- list = $append(list, c);
- }
- _key = n; (cmap || $throwRuntimeError("assignment to entry in nil map"))[Node.keyFor(_key)] = { k: _key, v: list };
- };
- $ptrType(CommentMap).prototype.addComment = function(n, c) { return new CommentMap(this.$get()).addComment(n, c); };
- nodeList = function(n) {
- var $ptr, list, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; list = $f.list; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- list = [list];
- list[0] = sliceType$3.nil;
- $r = Inspect(n, (function(list) { return function(n$1) {
- var $ptr, _ref, n$1;
- _ref = n$1;
- if (_ref === $ifaceNil || $assertType(_ref, ptrType, true)[1] || $assertType(_ref, ptrType$6, true)[1]) {
- return false;
- }
- list[0] = $append(list[0], n$1);
- return true;
- }; })(list)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return list[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: nodeList }; } $f.$ptr = $ptr; $f.list = list; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- commentListReader.ptr.prototype.eol = function() {
- var $ptr, r;
- r = this;
- return r.index >= r.list.$length;
- };
- commentListReader.prototype.eol = function() { return this.$val.eol(); };
- commentListReader.ptr.prototype.next = function() {
- var $ptr, _r, _r$1, r, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; r = $f.r; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- /* */ if (!r.eol()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!r.eol()) { */ case 1:
- r.comment = (x = r.list, x$1 = r.index, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- _r = r.fset.Position(r.comment.Pos()); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $copy(r.pos, _r, token.Position);
- _r$1 = r.fset.Position(r.comment.End()); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $copy(r.end, _r$1, token.Position);
- r.index = r.index + (1) >> 0;
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: commentListReader.ptr.prototype.next }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- commentListReader.prototype.next = function() { return this.$val.next(); };
- $ptrType(nodeStack).prototype.push = function(n) {
- var $ptr, _r, _r$1, n, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; n = $f.n; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = n.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = s.pop(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- s.$set($append((s.$get()), n));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(nodeStack).prototype.push }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.n = n; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(nodeStack).prototype.pop = function(pos) {
- var $ptr, _r, _v, i, pos, s, top, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _v = $f._v; i = $f.i; pos = $f.pos; s = $f.s; top = $f.top; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- top = $ifaceNil;
- s = this;
- i = s.$get().$length;
- /* while (true) { */ case 1:
- if (!(i > 0)) { _v = false; $s = 3; continue s; }
- _r = (x = s.$get(), x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r <= pos; case 3:
- /* if (!(_v)) { break; } */ if(!(_v)) { $s = 2; continue; }
- top = (x$2 = s.$get(), x$3 = i - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3]));
- i = i - (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- s.$set($subslice((s.$get()), 0, i));
- top = top;
- return top;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(nodeStack).prototype.pop }; } $f.$ptr = $ptr; $f._r = _r; $f._v = _v; $f.i = i; $f.pos = pos; $f.s = s; $f.top = top; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- NewCommentMap = function(fset, node, comments) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, assoc, cmap, comments, fset, node, nodes, nonAsciiName, p, pend, pg, pgend, q, qpos, r, stack, tmp, top, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; assoc = $f.assoc; cmap = $f.cmap; comments = $f.comments; fset = $f.fset; node = $f.node; nodes = $f.nodes; nonAsciiName = $f.nonAsciiName; p = $f.p; pend = $f.pend; pg = $f.pg; pgend = $f.pgend; q = $f.q; qpos = $f.qpos; r = $f.r; stack = $f.stack; tmp = $f.tmp; top = $f.top; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (comments.$length === 0) {
- return false;
- }
- cmap = new $Map();
- tmp = $makeSlice(sliceType$2, comments.$length);
- $copySlice(tmp, comments);
- $r = sortComments(tmp); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- r = new commentListReader.ptr(fset, tmp, 0, ptrType.nil, new token.Position.ptr(), new token.Position.ptr());
- $r = r.next(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = nodeList(node); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- nodes = _r;
- nodes = $append(nodes, $ifaceNil);
- p = $ifaceNil;
- pend = $clone(new token.Position.ptr(), token.Position);
- pg = $ifaceNil;
- pgend = $clone(new token.Position.ptr(), token.Position);
- stack = nodeStack.nil;
- _ref = nodes;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- q = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- qpos = $clone(new token.Position.ptr(), token.Position);
- /* */ if (!($interfaceIsEqual(q, $ifaceNil))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!($interfaceIsEqual(q, $ifaceNil))) { */ case 6:
- _r$1 = q.Pos(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = fset.Position(_r$1); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $copy(qpos, _r$2, token.Position);
- $s = 8; continue;
- /* } else { */ case 7:
- qpos.Offset = 1073741824;
- qpos.Line = 1073741824;
- /* } */ case 8:
- /* while (true) { */ case 11:
- /* if (!(r.end.Offset <= qpos.Offset)) { break; } */ if(!(r.end.Offset <= qpos.Offset)) { $s = 12; continue; }
- _r$3 = (nonAsciiName || (nonAsciiName = new ptrType$8(function() { return stack; }, function($v) { stack = $v; }))).pop(r.comment.Pos()); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- top = _r$3;
- /* */ if (!($interfaceIsEqual(top, $ifaceNil))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!($interfaceIsEqual(top, $ifaceNil))) { */ case 14:
- pg = top;
- _r$4 = pg.End(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = fset.Position(_r$4); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $copy(pgend, _r$5, token.Position);
- /* } */ case 15:
- assoc = $ifaceNil;
- if (!($interfaceIsEqual(pg, $ifaceNil)) && ((pgend.Line === r.pos.Line) || ((pgend.Line + 1 >> 0) === r.pos.Line) && (r.end.Line + 1 >> 0) < qpos.Line)) {
- assoc = pg;
- } else if (!($interfaceIsEqual(p, $ifaceNil)) && ((pend.Line === r.pos.Line) || ((pend.Line + 1 >> 0) === r.pos.Line) && (r.end.Line + 1 >> 0) < qpos.Line || $interfaceIsEqual(q, $ifaceNil))) {
- assoc = p;
- } else {
- if ($interfaceIsEqual(q, $ifaceNil)) {
- $panic(new $String("internal error: no comments should be associated with sentinel"));
- }
- assoc = q;
- }
- new CommentMap(cmap).addComment(assoc, r.comment);
- if (r.eol()) {
- return cmap;
- }
- $r = r.next(); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 11; continue; case 12:
- p = q;
- _r$6 = p.End(); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = fset.Position(_r$6); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $copy(pend, _r$7, token.Position);
- _ref$1 = q;
- /* */ if ($assertType(_ref$1, ptrType$9, true)[1] || $assertType(_ref$1, ptrType$10, true)[1] || $assertType(_ref$1, Decl, true)[1] || $assertType(_ref$1, Spec, true)[1] || $assertType(_ref$1, Stmt, true)[1]) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if ($assertType(_ref$1, ptrType$9, true)[1] || $assertType(_ref$1, ptrType$10, true)[1] || $assertType(_ref$1, Decl, true)[1] || $assertType(_ref$1, Spec, true)[1] || $assertType(_ref$1, Stmt, true)[1]) { */ case 21:
- $r = (nonAsciiName || (nonAsciiName = new ptrType$8(function() { return stack; }, function($v) { stack = $v; }))).push(q); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 22:
- _i++;
- /* } */ $s = 4; continue; case 5:
- return cmap;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: NewCommentMap }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f.assoc = assoc; $f.cmap = cmap; $f.comments = comments; $f.fset = fset; $f.node = node; $f.nodes = nodes; $f.nonAsciiName = nonAsciiName; $f.p = p; $f.pend = pend; $f.pg = pg; $f.pgend = pgend; $f.q = q; $f.qpos = qpos; $f.r = r; $f.stack = stack; $f.tmp = tmp; $f.top = top; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.NewCommentMap = NewCommentMap;
- CommentMap.prototype.Update = function(old, new$1) {
- var $ptr, _entry, _entry$1, _key, cmap, list, new$1, old;
- cmap = this.$val;
- list = (_entry = cmap[Node.keyFor(old)], _entry !== undefined ? _entry.v : sliceType$2.nil);
- if (list.$length > 0) {
- delete cmap[Node.keyFor(old)];
- _key = new$1; (cmap || $throwRuntimeError("assignment to entry in nil map"))[Node.keyFor(_key)] = { k: _key, v: $appendSlice((_entry$1 = cmap[Node.keyFor(new$1)], _entry$1 !== undefined ? _entry$1.v : sliceType$2.nil), list) };
- }
- return new$1;
- };
- $ptrType(CommentMap).prototype.Update = function(old, new$1) { return new CommentMap(this.$get()).Update(old, new$1); };
- CommentMap.prototype.Filter = function(node) {
- var $ptr, cmap, node, umap, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; cmap = $f.cmap; node = $f.node; umap = $f.umap; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- cmap = [cmap];
- umap = [umap];
- cmap[0] = this.$val;
- umap[0] = new $Map();
- $r = Inspect(node, (function(cmap, umap) { return function(n) {
- var $ptr, _entry, _key, g, n;
- g = (_entry = cmap[0][Node.keyFor(n)], _entry !== undefined ? _entry.v : sliceType$2.nil);
- if (g.$length > 0) {
- _key = n; (umap[0] || $throwRuntimeError("assignment to entry in nil map"))[Node.keyFor(_key)] = { k: _key, v: g };
- }
- return true;
- }; })(cmap, umap)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return umap[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: CommentMap.prototype.Filter }; } $f.$ptr = $ptr; $f.cmap = cmap; $f.node = node; $f.umap = umap; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(CommentMap).prototype.Filter = function(node) { return new CommentMap(this.$get()).Filter(node); };
- CommentMap.prototype.Comments = function() {
- var $ptr, _entry, _i, _keys, _ref, cmap, e, list, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _ref = $f._ref; cmap = $f.cmap; e = $f.e; list = $f.list; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- cmap = this.$val;
- list = $makeSlice(sliceType$2, 0, $keys(cmap).length);
- _ref = cmap;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- e = _entry.v;
- list = $appendSlice(list, e);
- _i++;
- }
- $r = sortComments(list); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return list;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: CommentMap.prototype.Comments }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._ref = _ref; $f.cmap = cmap; $f.e = e; $f.list = list; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(CommentMap).prototype.Comments = function() { return new CommentMap(this.$get()).Comments(); };
- summary = function(list) {
- var $ptr, _i, _i$1, _i$2, _ref, _ref$1, _ref$2, _ref$3, b, buf, bytes$1, comment, group, i, list;
- buf = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _ref = list;
- _i = 0;
- loop:
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- group = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = group.List;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- comment = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- if (buf.Len() >= 40) {
- break loop;
- }
- buf.WriteString(comment.Text);
- _i$1++;
- }
- _i++;
- }
- if (buf.Len() > 40) {
- buf.Truncate(37);
- buf.WriteString("...");
- }
- bytes$1 = buf.Bytes();
- _ref$2 = bytes$1;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$2.$length)) { break; }
- i = _i$2;
- b = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- _ref$3 = b;
- if (_ref$3 === 9 || _ref$3 === 10 || _ref$3 === 13) {
- ((i < 0 || i >= bytes$1.$length) ? $throwRuntimeError("index out of range") : bytes$1.$array[bytes$1.$offset + i] = 32);
- }
- _i$2++;
- }
- return $bytesToString(bytes$1);
- };
- CommentMap.prototype.String = function() {
- var $ptr, _entry, _i, _keys, _r, _r$1, _r$2, _r$3, _ref, _tuple, buf, cmap, comment, ident, node, ok, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _tuple = $f._tuple; buf = $f.buf; cmap = $f.cmap; comment = $f.comment; ident = $f.ident; node = $f.node; ok = $f.ok; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- cmap = this.$val;
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _r = fmt.Fprintln(buf[0], new sliceType$4([new $String("CommentMap {")])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- _ref = cmap;
- _i = 0;
- _keys = $keys(_ref);
- /* while (true) { */ case 2:
- /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 3; continue; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- /* continue; */ $s = 2; continue;
- }
- node = _entry.k;
- comment = _entry.v;
- s = "";
- _tuple = $assertType(node, ptrType$4, true); ident = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (ok) { */ case 4:
- s = ident.Name;
- $s = 6; continue;
- /* } else { */ case 5:
- _r$1 = fmt.Sprintf("%T", new sliceType$4([node])); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- s = _r$1;
- /* } */ case 6:
- _r$2 = fmt.Fprintf(buf[0], "\t%p %20s: %s\n", new sliceType$4([node, new $String(s), new $String(summary(comment))])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- _i++;
- /* } */ $s = 2; continue; case 3:
- _r$3 = fmt.Fprintln(buf[0], new sliceType$4([new $String("}")])); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: CommentMap.prototype.String }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._tuple = _tuple; $f.buf = buf; $f.cmap = cmap; $f.comment = comment; $f.ident = ident; $f.node = node; $f.ok = ok; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(CommentMap).prototype.String = function() { return new CommentMap(this.$get()).String(); };
- SortImports = function(fset, f) {
- var $ptr, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _tuple, _v, d, d$1, f, fset, i, j, lastLine, lastSpec, ok, rParenLine, s, specs, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _v = $f._v; d = $f.d; d$1 = $f.d$1; f = $f.f; fset = $f.fset; i = $f.i; j = $f.j; lastLine = $f.lastLine; lastSpec = $f.lastSpec; ok = $f.ok; rParenLine = $f.rParenLine; s = $f.s; specs = $f.specs; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = f.Decls;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- d = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple = $assertType(d, ptrType$22, true); d$1 = _tuple[0]; ok = _tuple[1];
- if (!ok || !((d$1.Tok === 75))) {
- /* break; */ $s = 2; continue;
- }
- /* */ if (!new token.Pos(d$1.Lparen).IsValid()) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!new token.Pos(d$1.Lparen).IsValid()) { */ case 3:
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 4:
- i = 0;
- specs = $subslice(d$1.Specs, 0, 0);
- _ref$1 = d$1.Specs;
- _i$1 = 0;
- /* while (true) { */ case 5:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 6; continue; }
- j = _i$1;
- s = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- if (!(j > i)) { _v = false; $s = 9; continue s; }
- _r = s.Pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = fset.Position(_r); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = (x = d$1.Specs, x$1 = j - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).End(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = fset.Position(_r$2); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v = _r$1.Line > (1 + _r$3.Line >> 0); case 9:
- /* */ if (_v) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_v) { */ case 7:
- _r$4 = sortSpecs(fset, f, $subslice(d$1.Specs, i, j)); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- specs = $appendSlice(specs, _r$4);
- i = j;
- /* } */ case 8:
- _i$1++;
- /* } */ $s = 5; continue; case 6:
- _r$5 = sortSpecs(fset, f, $subslice(d$1.Specs, i)); /* */ $s = 15; case 15: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- specs = $appendSlice(specs, _r$5);
- d$1.Specs = specs;
- /* */ if (d$1.Specs.$length > 0) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (d$1.Specs.$length > 0) { */ case 16:
- lastSpec = (x$2 = d$1.Specs, x$3 = d$1.Specs.$length - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3]));
- _r$6 = lastSpec.Pos(); /* */ $s = 18; case 18: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = fset.Position(_r$6); /* */ $s = 19; case 19: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- lastLine = _r$7.Line;
- _r$8 = fset.Position(d$1.Rparen); /* */ $s = 20; case 20: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- rParenLine = _r$8.Line;
- /* */ if (rParenLine > (lastLine + 1 >> 0)) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (rParenLine > (lastLine + 1 >> 0)) { */ case 21:
- _r$9 = fset.File(d$1.Rparen); /* */ $s = 23; case 23: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- $r = _r$9.MergeLine(rParenLine - 1 >> 0); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 22:
- /* } */ case 17:
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SortImports }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._v = _v; $f.d = d; $f.d$1 = d$1; $f.f = f; $f.fset = fset; $f.i = i; $f.j = j; $f.lastLine = lastLine; $f.lastSpec = lastSpec; $f.ok = ok; $f.rParenLine = rParenLine; $f.s = s; $f.specs = specs; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.SortImports = SortImports;
- importPath = function(s) {
- var $ptr, _tuple, err, s, t;
- _tuple = strconv.Unquote($assertType(s, ptrType$24).Path.Value); t = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- return t;
- }
- return "";
- };
- importName = function(s) {
- var $ptr, n, s;
- n = $assertType(s, ptrType$24).Name;
- if (n === ptrType$4.nil) {
- return "";
- }
- return n.Name;
- };
- importComment = function(s) {
- var $ptr, c, s;
- c = $assertType(s, ptrType$24).Comment;
- if (c === ptrType.nil) {
- return "";
- }
- return c.Text();
- };
- collapse = function(prev, next) {
- var $ptr, next, prev;
- if (!(importPath(next) === importPath(prev)) || !(importName(next) === importName(prev))) {
- return false;
- }
- return $assertType(prev, ptrType$24).Comment === ptrType.nil;
- };
- sortSpecs = function(fset, f, specs) {
- var $ptr, _entry, _entry$1, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _key, _key$1, _map, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, c, cend, comments, cstart, deduped, f, fset, g, g$1, g$2, i, i$1, i$2, i$3, importComment$1, lastLine, p, pos, s, s$1, s$2, s$3, s$4, specIndex, specs, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _key = $f._key; _key$1 = $f._key$1; _map = $f._map; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; c = $f.c; cend = $f.cend; comments = $f.comments; cstart = $f.cstart; deduped = $f.deduped; f = $f.f; fset = $f.fset; g = $f.g; g$1 = $f.g$1; g$2 = $f.g$2; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; importComment$1 = $f.importComment$1; lastLine = $f.lastLine; p = $f.p; pos = $f.pos; s = $f.s; s$1 = $f.s$1; s$2 = $f.s$2; s$3 = $f.s$3; s$4 = $f.s$4; specIndex = $f.specIndex; specs = $f.specs; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (specs.$length <= 1) {
- return specs;
- }
- pos = $makeSlice(sliceType$9, specs.$length);
- _ref = specs;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = s.Pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = s.End(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $copy(((i < 0 || i >= pos.$length) ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + i]), new posSpan.ptr(_r, _r$1), posSpan);
- _i++;
- /* } */ $s = 1; continue; case 2:
- _r$2 = fset.Position((x = pos.$length - 1 >> 0, ((x < 0 || x >= pos.$length) ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + x])).End); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- lastLine = _r$2.Line;
- cstart = f.Comments.$length;
- cend = f.Comments.$length;
- _ref$1 = f.Comments;
- _i$1 = 0;
- /* while (true) { */ case 6:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 7; continue; }
- i$1 = _i$1;
- g = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- /* */ if (g.Pos() < (0 >= pos.$length ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + 0]).Start) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (g.Pos() < (0 >= pos.$length ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + 0]).Start) { */ case 8:
- _i$1++;
- /* continue; */ $s = 6; continue;
- /* } */ case 9:
- if (i$1 < cstart) {
- cstart = i$1;
- }
- _r$3 = fset.Position(g.End()); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3.Line > lastLine) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_r$3.Line > lastLine) { */ case 10:
- cend = i$1;
- /* break; */ $s = 7; continue;
- /* } */ case 11:
- _i$1++;
- /* } */ $s = 6; continue; case 7:
- comments = $subslice(f.Comments, cstart, cend);
- importComment$1 = (_map = new $Map(), _map);
- specIndex = 0;
- _ref$2 = comments;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$2.$length)) { break; }
- g$1 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- while (true) {
- if (!((specIndex + 1 >> 0) < specs.$length && (x$1 = specIndex + 1 >> 0, ((x$1 < 0 || x$1 >= pos.$length) ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + x$1])).Start <= g$1.Pos())) { break; }
- specIndex = specIndex + (1) >> 0;
- }
- s$1 = $assertType(((specIndex < 0 || specIndex >= specs.$length) ? $throwRuntimeError("index out of range") : specs.$array[specs.$offset + specIndex]), ptrType$24);
- _key$1 = s$1; (importComment$1 || $throwRuntimeError("assignment to entry in nil map"))[ptrType$24.keyFor(_key$1)] = { k: _key$1, v: $append((_entry = importComment$1[ptrType$24.keyFor(s$1)], _entry !== undefined ? _entry.v : sliceType$2.nil), g$1) };
- _i$2++;
- }
- $r = sort.Sort($subslice(new byImportSpec(specs.$array), specs.$offset, specs.$offset + specs.$length)); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- deduped = $subslice(specs, 0, 0);
- _ref$3 = specs;
- _i$3 = 0;
- /* while (true) { */ case 14:
- /* if (!(_i$3 < _ref$3.$length)) { break; } */ if(!(_i$3 < _ref$3.$length)) { $s = 15; continue; }
- i$2 = _i$3;
- s$2 = ((_i$3 < 0 || _i$3 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$3]);
- /* */ if ((i$2 === (specs.$length - 1 >> 0)) || !collapse(s$2, (x$2 = i$2 + 1 >> 0, ((x$2 < 0 || x$2 >= specs.$length) ? $throwRuntimeError("index out of range") : specs.$array[specs.$offset + x$2])))) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if ((i$2 === (specs.$length - 1 >> 0)) || !collapse(s$2, (x$2 = i$2 + 1 >> 0, ((x$2 < 0 || x$2 >= specs.$length) ? $throwRuntimeError("index out of range") : specs.$array[specs.$offset + x$2])))) { */ case 16:
- deduped = $append(deduped, s$2);
- $s = 18; continue;
- /* } else { */ case 17:
- _r$4 = s$2.Pos(); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- p = _r$4;
- _r$5 = fset.File(p); /* */ $s = 20; case 20: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = fset.Position(p); /* */ $s = 21; case 21: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = _r$5.MergeLine(_r$6.Line); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- _i$3++;
- /* } */ $s = 14; continue; case 15:
- specs = deduped;
- _ref$4 = specs;
- _i$4 = 0;
- while (true) {
- if (!(_i$4 < _ref$4.$length)) { break; }
- i$3 = _i$4;
- s$3 = ((_i$4 < 0 || _i$4 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$4]);
- s$4 = $assertType(s$3, ptrType$24);
- if (!(s$4.Name === ptrType$4.nil)) {
- s$4.Name.NamePos = ((i$3 < 0 || i$3 >= pos.$length) ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + i$3]).Start;
- }
- s$4.Path.ValuePos = ((i$3 < 0 || i$3 >= pos.$length) ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + i$3]).Start;
- s$4.EndPos = ((i$3 < 0 || i$3 >= pos.$length) ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + i$3]).End;
- _ref$5 = (_entry$1 = importComment$1[ptrType$24.keyFor(s$4)], _entry$1 !== undefined ? _entry$1.v : sliceType$2.nil);
- _i$5 = 0;
- while (true) {
- if (!(_i$5 < _ref$5.$length)) { break; }
- g$2 = ((_i$5 < 0 || _i$5 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$5]);
- _ref$6 = g$2.List;
- _i$6 = 0;
- while (true) {
- if (!(_i$6 < _ref$6.$length)) { break; }
- c = ((_i$6 < 0 || _i$6 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$6]);
- c.Slash = ((i$3 < 0 || i$3 >= pos.$length) ? $throwRuntimeError("index out of range") : pos.$array[pos.$offset + i$3]).End;
- _i$6++;
- }
- _i$5++;
- }
- _i$4++;
- }
- $r = sort.Sort($subslice(new byCommentPos(comments.$array), comments.$offset, comments.$offset + comments.$length)); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return specs;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sortSpecs }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._key = _key; $f._key$1 = _key$1; $f._map = _map; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f.c = c; $f.cend = cend; $f.comments = comments; $f.cstart = cstart; $f.deduped = deduped; $f.f = f; $f.fset = fset; $f.g = g; $f.g$1 = g$1; $f.g$2 = g$2; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.importComment$1 = importComment$1; $f.lastLine = lastLine; $f.p = p; $f.pos = pos; $f.s = s; $f.s$1 = s$1; $f.s$2 = s$2; $f.s$3 = s$3; $f.s$4 = s$4; $f.specIndex = specIndex; $f.specs = specs; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- byImportSpec.prototype.Len = function() {
- var $ptr, x;
- x = this;
- return x.$length;
- };
- $ptrType(byImportSpec).prototype.Len = function() { return this.$get().Len(); };
- byImportSpec.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, i, j, x;
- x = this;
- _tmp = ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]); _tmp$1 = ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]); ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = _tmp); ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j] = _tmp$1);
- };
- $ptrType(byImportSpec).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- byImportSpec.prototype.Less = function(i, j) {
- var $ptr, i, iname, ipath, j, jname, jpath, x;
- x = this;
- ipath = importPath(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- jpath = importPath(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]));
- if (!(ipath === jpath)) {
- return ipath < jpath;
- }
- iname = importName(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- jname = importName(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]));
- if (!(iname === jname)) {
- return iname < jname;
- }
- return importComment(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])) < importComment(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]));
- };
- $ptrType(byImportSpec).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- byCommentPos.prototype.Len = function() {
- var $ptr, x;
- x = this;
- return x.$length;
- };
- $ptrType(byCommentPos).prototype.Len = function() { return this.$get().Len(); };
- byCommentPos.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, i, j, x;
- x = this;
- _tmp = ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]); _tmp$1 = ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]); ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = _tmp); ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j] = _tmp$1);
- };
- $ptrType(byCommentPos).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- byCommentPos.prototype.Less = function(i, j) {
- var $ptr, i, j, x;
- x = this;
- return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).Pos() < ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).Pos();
- };
- $ptrType(byCommentPos).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- NewScope = function(outer) {
- var $ptr, outer;
- return new Scope.ptr(outer, new $Map());
- };
- $pkg.NewScope = NewScope;
- Scope.ptr.prototype.Lookup = function(name) {
- var $ptr, _entry, name, s;
- s = this;
- return (_entry = s.Objects[$String.keyFor(name)], _entry !== undefined ? _entry.v : ptrType$3.nil);
- };
- Scope.prototype.Lookup = function(name) { return this.$val.Lookup(name); };
- Scope.ptr.prototype.Insert = function(obj) {
- var $ptr, _entry, _key, alt, obj, s;
- alt = ptrType$3.nil;
- s = this;
- alt = (_entry = s.Objects[$String.keyFor(obj.Name)], _entry !== undefined ? _entry.v : ptrType$3.nil);
- if (alt === ptrType$3.nil) {
- _key = obj.Name; (s.Objects || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: obj };
- }
- return alt;
- };
- Scope.prototype.Insert = function(obj) { return this.$val.Insert(obj); };
- Scope.ptr.prototype.String = function() {
- var $ptr, _entry, _i, _keys, _r, _r$1, _r$2, _r$3, _ref, buf, obj, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; buf = $f.buf; obj = $f.obj; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- s = this;
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _r = fmt.Fprintf(buf[0], "scope %p {", new sliceType$4([s])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- /* */ if (!(s === ptrType$26.nil) && $keys(s.Objects).length > 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!(s === ptrType$26.nil) && $keys(s.Objects).length > 0) { */ case 2:
- _r$1 = fmt.Fprintln(buf[0], new sliceType$4([])); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- _ref = s.Objects;
- _i = 0;
- _keys = $keys(_ref);
- /* while (true) { */ case 5:
- /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 6; continue; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- /* continue; */ $s = 5; continue;
- }
- obj = _entry.v;
- _r$2 = fmt.Fprintf(buf[0], "\t%s %s\n", new sliceType$4([new ObjKind(obj.Kind), new $String(obj.Name)])); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- _i++;
- /* } */ $s = 5; continue; case 6:
- /* } */ case 3:
- _r$3 = fmt.Fprintf(buf[0], "}\n", new sliceType$4([])); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scope.ptr.prototype.String }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f.buf = buf; $f.obj = obj; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scope.prototype.String = function() { return this.$val.String(); };
- NewObj = function(kind, name) {
- var $ptr, kind, name;
- return new Object.ptr(kind, name, $ifaceNil, $ifaceNil, $ifaceNil);
- };
- $pkg.NewObj = NewObj;
- Object.ptr.prototype.Pos = function() {
- var $ptr, _i, _i$1, _i$2, _ref, _ref$1, _ref$2, _ref$3, _tuple, d, d$1, d$2, d$3, d$4, d$5, d$6, ident, isIdent, n, n$1, name, obj, x;
- obj = this;
- name = obj.Name;
- _ref = obj.Decl;
- if ($assertType(_ref, ptrType$10, true)[1]) {
- d = _ref.$val;
- _ref$1 = d.Names;
- _i = 0;
- while (true) {
- if (!(_i < _ref$1.$length)) { break; }
- n = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- if (n.Name === name) {
- return n.Pos();
- }
- _i++;
- }
- } else if ($assertType(_ref, ptrType$24, true)[1]) {
- d$1 = _ref.$val;
- if (!(d$1.Name === ptrType$4.nil) && d$1.Name.Name === name) {
- return d$1.Name.Pos();
- }
- return d$1.Path.Pos();
- } else if ($assertType(_ref, ptrType$20, true)[1]) {
- d$2 = _ref.$val;
- _ref$2 = d$2.Names;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$2.$length)) { break; }
- n$1 = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- if (n$1.Name === name) {
- return n$1.Pos();
- }
- _i$1++;
- }
- } else if ($assertType(_ref, ptrType$21, true)[1]) {
- d$3 = _ref.$val;
- if (d$3.Name.Name === name) {
- return d$3.Name.Pos();
- }
- } else if ($assertType(_ref, ptrType$23, true)[1]) {
- d$4 = _ref.$val;
- if (d$4.Name.Name === name) {
- return d$4.Name.Pos();
- }
- } else if ($assertType(_ref, ptrType$27, true)[1]) {
- d$5 = _ref.$val;
- if (d$5.Label.Name === name) {
- return d$5.Label.Pos();
- }
- } else if ($assertType(_ref, ptrType$28, true)[1]) {
- d$6 = _ref.$val;
- _ref$3 = d$6.Lhs;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$3.$length)) { break; }
- x = ((_i$2 < 0 || _i$2 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$2]);
- _tuple = $assertType(x, ptrType$4, true); ident = _tuple[0]; isIdent = _tuple[1];
- if (isIdent && ident.Name === name) {
- return ident.Pos();
- }
- _i$2++;
- }
- }
- return 0;
- };
- Object.prototype.Pos = function() { return this.$val.Pos(); };
- ObjKind.prototype.String = function() {
- var $ptr, kind;
- kind = this.$val;
- return ((kind < 0 || kind >= objKindStrings.length) ? $throwRuntimeError("index out of range") : objKindStrings[kind]);
- };
- $ptrType(ObjKind).prototype.String = function() { return new ObjKind(this.$get()).String(); };
- walkIdentList = function(v, list) {
- var $ptr, _i, _ref, list, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; list = $f.list; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = Walk(v, x); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: walkIdentList }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.list = list; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- walkExprList = function(v, list) {
- var $ptr, _i, _ref, list, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; list = $f.list; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = Walk(v, x); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: walkExprList }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.list = list; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- walkStmtList = function(v, list) {
- var $ptr, _i, _ref, list, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; list = $f.list; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = Walk(v, x); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: walkStmtList }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.list = list; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- walkDeclList = function(v, list) {
- var $ptr, _i, _ref, list, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; list = $f.list; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = Walk(v, x); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: walkDeclList }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.list = list; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Walk = function(v, node) {
- var $ptr, _entry, _i, _i$1, _i$2, _i$3, _keys, _r, _r$1, _r$2, _ref, _ref$1, _ref$2, _ref$3, _ref$4, c, f, f$1, n, n$1, n$10, n$11, n$12, n$13, n$14, n$15, n$16, n$17, n$18, n$19, n$2, n$20, n$21, n$22, n$23, n$24, n$25, n$26, n$27, n$28, n$29, n$3, n$30, n$31, n$32, n$33, n$34, n$35, n$36, n$37, n$38, n$39, n$4, n$40, n$41, n$42, n$43, n$44, n$45, n$46, n$47, n$48, n$49, n$5, n$50, n$51, n$52, n$53, n$6, n$7, n$8, n$9, node, s, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _keys = $f._keys; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; c = $f.c; f = $f.f; f$1 = $f.f$1; n = $f.n; n$1 = $f.n$1; n$10 = $f.n$10; n$11 = $f.n$11; n$12 = $f.n$12; n$13 = $f.n$13; n$14 = $f.n$14; n$15 = $f.n$15; n$16 = $f.n$16; n$17 = $f.n$17; n$18 = $f.n$18; n$19 = $f.n$19; n$2 = $f.n$2; n$20 = $f.n$20; n$21 = $f.n$21; n$22 = $f.n$22; n$23 = $f.n$23; n$24 = $f.n$24; n$25 = $f.n$25; n$26 = $f.n$26; n$27 = $f.n$27; n$28 = $f.n$28; n$29 = $f.n$29; n$3 = $f.n$3; n$30 = $f.n$30; n$31 = $f.n$31; n$32 = $f.n$32; n$33 = $f.n$33; n$34 = $f.n$34; n$35 = $f.n$35; n$36 = $f.n$36; n$37 = $f.n$37; n$38 = $f.n$38; n$39 = $f.n$39; n$4 = $f.n$4; n$40 = $f.n$40; n$41 = $f.n$41; n$42 = $f.n$42; n$43 = $f.n$43; n$44 = $f.n$44; n$45 = $f.n$45; n$46 = $f.n$46; n$47 = $f.n$47; n$48 = $f.n$48; n$49 = $f.n$49; n$5 = $f.n$5; n$50 = $f.n$50; n$51 = $f.n$51; n$52 = $f.n$52; n$53 = $f.n$53; n$6 = $f.n$6; n$7 = $f.n$7; n$8 = $f.n$8; n$9 = $f.n$9; node = $f.node; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = v.Visit(node); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- v = _r;
- /* */ if ($interfaceIsEqual(v, $ifaceNil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($interfaceIsEqual(v, $ifaceNil)) { */ case 2:
- return;
- /* } */ case 3:
- _ref = node;
- /* */ if ($assertType(_ref, ptrType$6, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$2, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$29, true)[1] || $assertType(_ref, ptrType$4, true)[1] || $assertType(_ref, ptrType$1, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$31, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$32, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$13, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, ptrType$33, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$34, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$35, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, ptrType$36, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref, ptrType$12, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref, ptrType$37, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref, ptrType$38, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref, ptrType$39, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref, ptrType$14, true)[1]) { $s = 22; continue; }
- /* */ if ($assertType(_ref, ptrType$15, true)[1]) { $s = 23; continue; }
- /* */ if ($assertType(_ref, ptrType$16, true)[1]) { $s = 24; continue; }
- /* */ if ($assertType(_ref, ptrType$17, true)[1]) { $s = 25; continue; }
- /* */ if ($assertType(_ref, ptrType$18, true)[1]) { $s = 26; continue; }
- /* */ if ($assertType(_ref, ptrType$19, true)[1]) { $s = 27; continue; }
- /* */ if ($assertType(_ref, ptrType$40, true)[1]) { $s = 28; continue; }
- /* */ if ($assertType(_ref, ptrType$41, true)[1]) { $s = 29; continue; }
- /* */ if ($assertType(_ref, ptrType$42, true)[1]) { $s = 30; continue; }
- /* */ if ($assertType(_ref, ptrType$27, true)[1]) { $s = 31; continue; }
- /* */ if ($assertType(_ref, ptrType$43, true)[1]) { $s = 32; continue; }
- /* */ if ($assertType(_ref, ptrType$44, true)[1]) { $s = 33; continue; }
- /* */ if ($assertType(_ref, ptrType$45, true)[1]) { $s = 34; continue; }
- /* */ if ($assertType(_ref, ptrType$28, true)[1]) { $s = 35; continue; }
- /* */ if ($assertType(_ref, ptrType$46, true)[1]) { $s = 36; continue; }
- /* */ if ($assertType(_ref, ptrType$47, true)[1]) { $s = 37; continue; }
- /* */ if ($assertType(_ref, ptrType$48, true)[1]) { $s = 38; continue; }
- /* */ if ($assertType(_ref, ptrType$49, true)[1]) { $s = 39; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1]) { $s = 40; continue; }
- /* */ if ($assertType(_ref, ptrType$50, true)[1]) { $s = 41; continue; }
- /* */ if ($assertType(_ref, ptrType$51, true)[1]) { $s = 42; continue; }
- /* */ if ($assertType(_ref, ptrType$52, true)[1]) { $s = 43; continue; }
- /* */ if ($assertType(_ref, ptrType$53, true)[1]) { $s = 44; continue; }
- /* */ if ($assertType(_ref, ptrType$54, true)[1]) { $s = 45; continue; }
- /* */ if ($assertType(_ref, ptrType$55, true)[1]) { $s = 46; continue; }
- /* */ if ($assertType(_ref, ptrType$56, true)[1]) { $s = 47; continue; }
- /* */ if ($assertType(_ref, ptrType$57, true)[1]) { $s = 48; continue; }
- /* */ if ($assertType(_ref, ptrType$24, true)[1]) { $s = 49; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 50; continue; }
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 51; continue; }
- /* */ if ($assertType(_ref, ptrType$58, true)[1]) { $s = 52; continue; }
- /* */ if ($assertType(_ref, ptrType$22, true)[1]) { $s = 53; continue; }
- /* */ if ($assertType(_ref, ptrType$23, true)[1]) { $s = 54; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 55; continue; }
- /* */ if ($assertType(_ref, ptrType$59, true)[1]) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if ($assertType(_ref, ptrType$6, true)[1]) { */ case 4:
- n = _ref.$val;
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType, true)[1]) { */ case 5:
- n$1 = _ref.$val;
- _ref$1 = n$1.List;
- _i = 0;
- /* while (true) { */ case 59:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 60; continue; }
- c = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- $r = Walk(v, c); /* */ $s = 61; case 61: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 59; continue; case 60:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1]) { */ case 6:
- n$2 = _ref.$val;
- /* */ if (!(n$2.Doc === ptrType.nil)) { $s = 62; continue; }
- /* */ $s = 63; continue;
- /* if (!(n$2.Doc === ptrType.nil)) { */ case 62:
- $r = Walk(v, n$2.Doc); /* */ $s = 64; case 64: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 63:
- $r = walkIdentList(v, n$2.Names); /* */ $s = 65; case 65: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$2.Type); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(n$2.Tag === ptrType$1.nil)) { $s = 67; continue; }
- /* */ $s = 68; continue;
- /* if (!(n$2.Tag === ptrType$1.nil)) { */ case 67:
- $r = Walk(v, n$2.Tag); /* */ $s = 69; case 69: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 68:
- /* */ if (!(n$2.Comment === ptrType.nil)) { $s = 70; continue; }
- /* */ $s = 71; continue;
- /* if (!(n$2.Comment === ptrType.nil)) { */ case 70:
- $r = Walk(v, n$2.Comment); /* */ $s = 72; case 72: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 71:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$2, true)[1]) { */ case 7:
- n$3 = _ref.$val;
- _ref$2 = n$3.List;
- _i$1 = 0;
- /* while (true) { */ case 73:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 74; continue; }
- f = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- $r = Walk(v, f); /* */ $s = 75; case 75: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 73; continue; case 74:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$29, true)[1] || $assertType(_ref, ptrType$4, true)[1] || $assertType(_ref, ptrType$1, true)[1]) { */ case 8:
- n$4 = _ref;
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 9:
- n$5 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$5.Elt, $ifaceNil))) { $s = 76; continue; }
- /* */ $s = 77; continue;
- /* if (!($interfaceIsEqual(n$5.Elt, $ifaceNil))) { */ case 76:
- $r = Walk(v, n$5.Elt); /* */ $s = 78; case 78: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 77:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$31, true)[1]) { */ case 10:
- n$6 = _ref.$val;
- $r = Walk(v, n$6.Type); /* */ $s = 79; case 79: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$6.Body); /* */ $s = 80; case 80: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$32, true)[1]) { */ case 11:
- n$7 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$7.Type, $ifaceNil))) { $s = 81; continue; }
- /* */ $s = 82; continue;
- /* if (!($interfaceIsEqual(n$7.Type, $ifaceNil))) { */ case 81:
- $r = Walk(v, n$7.Type); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 82:
- $r = walkExprList(v, n$7.Elts); /* */ $s = 84; case 84: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$13, true)[1]) { */ case 12:
- n$8 = _ref.$val;
- $r = Walk(v, n$8.X); /* */ $s = 85; case 85: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$11, true)[1]) { */ case 13:
- n$9 = _ref.$val;
- $r = Walk(v, n$9.X); /* */ $s = 86; case 86: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$9.Sel); /* */ $s = 87; case 87: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$33, true)[1]) { */ case 14:
- n$10 = _ref.$val;
- $r = Walk(v, n$10.X); /* */ $s = 88; case 88: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$10.Index); /* */ $s = 89; case 89: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$34, true)[1]) { */ case 15:
- n$11 = _ref.$val;
- $r = Walk(v, n$11.X); /* */ $s = 90; case 90: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(n$11.Low, $ifaceNil))) { $s = 91; continue; }
- /* */ $s = 92; continue;
- /* if (!($interfaceIsEqual(n$11.Low, $ifaceNil))) { */ case 91:
- $r = Walk(v, n$11.Low); /* */ $s = 93; case 93: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 92:
- /* */ if (!($interfaceIsEqual(n$11.High, $ifaceNil))) { $s = 94; continue; }
- /* */ $s = 95; continue;
- /* if (!($interfaceIsEqual(n$11.High, $ifaceNil))) { */ case 94:
- $r = Walk(v, n$11.High); /* */ $s = 96; case 96: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 95:
- /* */ if (!($interfaceIsEqual(n$11.Max, $ifaceNil))) { $s = 97; continue; }
- /* */ $s = 98; continue;
- /* if (!($interfaceIsEqual(n$11.Max, $ifaceNil))) { */ case 97:
- $r = Walk(v, n$11.Max); /* */ $s = 99; case 99: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 98:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$35, true)[1]) { */ case 16:
- n$12 = _ref.$val;
- $r = Walk(v, n$12.X); /* */ $s = 100; case 100: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(n$12.Type, $ifaceNil))) { $s = 101; continue; }
- /* */ $s = 102; continue;
- /* if (!($interfaceIsEqual(n$12.Type, $ifaceNil))) { */ case 101:
- $r = Walk(v, n$12.Type); /* */ $s = 103; case 103: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 102:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$36, true)[1]) { */ case 17:
- n$13 = _ref.$val;
- $r = Walk(v, n$13.Fun); /* */ $s = 104; case 104: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = walkExprList(v, n$13.Args); /* */ $s = 105; case 105: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$12, true)[1]) { */ case 18:
- n$14 = _ref.$val;
- $r = Walk(v, n$14.X); /* */ $s = 106; case 106: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$37, true)[1]) { */ case 19:
- n$15 = _ref.$val;
- $r = Walk(v, n$15.X); /* */ $s = 107; case 107: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$38, true)[1]) { */ case 20:
- n$16 = _ref.$val;
- $r = Walk(v, n$16.X); /* */ $s = 108; case 108: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$16.Y); /* */ $s = 109; case 109: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$39, true)[1]) { */ case 21:
- n$17 = _ref.$val;
- $r = Walk(v, n$17.Key); /* */ $s = 110; case 110: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$17.Value); /* */ $s = 111; case 111: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$14, true)[1]) { */ case 22:
- n$18 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$18.Len, $ifaceNil))) { $s = 112; continue; }
- /* */ $s = 113; continue;
- /* if (!($interfaceIsEqual(n$18.Len, $ifaceNil))) { */ case 112:
- $r = Walk(v, n$18.Len); /* */ $s = 114; case 114: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 113:
- $r = Walk(v, n$18.Elt); /* */ $s = 115; case 115: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$15, true)[1]) { */ case 23:
- n$19 = _ref.$val;
- $r = Walk(v, n$19.Fields); /* */ $s = 116; case 116: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$16, true)[1]) { */ case 24:
- n$20 = _ref.$val;
- /* */ if (!(n$20.Params === ptrType$2.nil)) { $s = 117; continue; }
- /* */ $s = 118; continue;
- /* if (!(n$20.Params === ptrType$2.nil)) { */ case 117:
- $r = Walk(v, n$20.Params); /* */ $s = 119; case 119: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 118:
- /* */ if (!(n$20.Results === ptrType$2.nil)) { $s = 120; continue; }
- /* */ $s = 121; continue;
- /* if (!(n$20.Results === ptrType$2.nil)) { */ case 120:
- $r = Walk(v, n$20.Results); /* */ $s = 122; case 122: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 121:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$17, true)[1]) { */ case 25:
- n$21 = _ref.$val;
- $r = Walk(v, n$21.Methods); /* */ $s = 123; case 123: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$18, true)[1]) { */ case 26:
- n$22 = _ref.$val;
- $r = Walk(v, n$22.Key); /* */ $s = 124; case 124: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$22.Value); /* */ $s = 125; case 125: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$19, true)[1]) { */ case 27:
- n$23 = _ref.$val;
- $r = Walk(v, n$23.Value); /* */ $s = 126; case 126: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$40, true)[1]) { */ case 28:
- n$24 = _ref.$val;
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$41, true)[1]) { */ case 29:
- n$25 = _ref.$val;
- $r = Walk(v, n$25.Decl); /* */ $s = 127; case 127: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$42, true)[1]) { */ case 30:
- n$26 = _ref.$val;
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$27, true)[1]) { */ case 31:
- n$27 = _ref.$val;
- $r = Walk(v, n$27.Label); /* */ $s = 128; case 128: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$27.Stmt); /* */ $s = 129; case 129: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$43, true)[1]) { */ case 32:
- n$28 = _ref.$val;
- $r = Walk(v, n$28.X); /* */ $s = 130; case 130: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$44, true)[1]) { */ case 33:
- n$29 = _ref.$val;
- $r = Walk(v, n$29.Chan); /* */ $s = 131; case 131: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$29.Value); /* */ $s = 132; case 132: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$45, true)[1]) { */ case 34:
- n$30 = _ref.$val;
- $r = Walk(v, n$30.X); /* */ $s = 133; case 133: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$28, true)[1]) { */ case 35:
- n$31 = _ref.$val;
- $r = walkExprList(v, n$31.Lhs); /* */ $s = 134; case 134: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = walkExprList(v, n$31.Rhs); /* */ $s = 135; case 135: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$46, true)[1]) { */ case 36:
- n$32 = _ref.$val;
- $r = Walk(v, n$32.Call); /* */ $s = 136; case 136: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$47, true)[1]) { */ case 37:
- n$33 = _ref.$val;
- $r = Walk(v, n$33.Call); /* */ $s = 137; case 137: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$48, true)[1]) { */ case 38:
- n$34 = _ref.$val;
- $r = walkExprList(v, n$34.Results); /* */ $s = 138; case 138: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$49, true)[1]) { */ case 39:
- n$35 = _ref.$val;
- /* */ if (!(n$35.Label === ptrType$4.nil)) { $s = 139; continue; }
- /* */ $s = 140; continue;
- /* if (!(n$35.Label === ptrType$4.nil)) { */ case 139:
- $r = Walk(v, n$35.Label); /* */ $s = 141; case 141: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 140:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1]) { */ case 40:
- n$36 = _ref.$val;
- $r = walkStmtList(v, n$36.List); /* */ $s = 142; case 142: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$50, true)[1]) { */ case 41:
- n$37 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$37.Init, $ifaceNil))) { $s = 143; continue; }
- /* */ $s = 144; continue;
- /* if (!($interfaceIsEqual(n$37.Init, $ifaceNil))) { */ case 143:
- $r = Walk(v, n$37.Init); /* */ $s = 145; case 145: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 144:
- $r = Walk(v, n$37.Cond); /* */ $s = 146; case 146: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$37.Body); /* */ $s = 147; case 147: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(n$37.Else, $ifaceNil))) { $s = 148; continue; }
- /* */ $s = 149; continue;
- /* if (!($interfaceIsEqual(n$37.Else, $ifaceNil))) { */ case 148:
- $r = Walk(v, n$37.Else); /* */ $s = 150; case 150: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 149:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$51, true)[1]) { */ case 42:
- n$38 = _ref.$val;
- $r = walkExprList(v, n$38.List); /* */ $s = 151; case 151: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = walkStmtList(v, n$38.Body); /* */ $s = 152; case 152: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$52, true)[1]) { */ case 43:
- n$39 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$39.Init, $ifaceNil))) { $s = 153; continue; }
- /* */ $s = 154; continue;
- /* if (!($interfaceIsEqual(n$39.Init, $ifaceNil))) { */ case 153:
- $r = Walk(v, n$39.Init); /* */ $s = 155; case 155: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 154:
- /* */ if (!($interfaceIsEqual(n$39.Tag, $ifaceNil))) { $s = 156; continue; }
- /* */ $s = 157; continue;
- /* if (!($interfaceIsEqual(n$39.Tag, $ifaceNil))) { */ case 156:
- $r = Walk(v, n$39.Tag); /* */ $s = 158; case 158: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 157:
- $r = Walk(v, n$39.Body); /* */ $s = 159; case 159: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$53, true)[1]) { */ case 44:
- n$40 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$40.Init, $ifaceNil))) { $s = 160; continue; }
- /* */ $s = 161; continue;
- /* if (!($interfaceIsEqual(n$40.Init, $ifaceNil))) { */ case 160:
- $r = Walk(v, n$40.Init); /* */ $s = 162; case 162: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 161:
- $r = Walk(v, n$40.Assign); /* */ $s = 163; case 163: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$40.Body); /* */ $s = 164; case 164: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$54, true)[1]) { */ case 45:
- n$41 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$41.Comm, $ifaceNil))) { $s = 165; continue; }
- /* */ $s = 166; continue;
- /* if (!($interfaceIsEqual(n$41.Comm, $ifaceNil))) { */ case 165:
- $r = Walk(v, n$41.Comm); /* */ $s = 167; case 167: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 166:
- $r = walkStmtList(v, n$41.Body); /* */ $s = 168; case 168: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$55, true)[1]) { */ case 46:
- n$42 = _ref.$val;
- $r = Walk(v, n$42.Body); /* */ $s = 169; case 169: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$56, true)[1]) { */ case 47:
- n$43 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$43.Init, $ifaceNil))) { $s = 170; continue; }
- /* */ $s = 171; continue;
- /* if (!($interfaceIsEqual(n$43.Init, $ifaceNil))) { */ case 170:
- $r = Walk(v, n$43.Init); /* */ $s = 172; case 172: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 171:
- /* */ if (!($interfaceIsEqual(n$43.Cond, $ifaceNil))) { $s = 173; continue; }
- /* */ $s = 174; continue;
- /* if (!($interfaceIsEqual(n$43.Cond, $ifaceNil))) { */ case 173:
- $r = Walk(v, n$43.Cond); /* */ $s = 175; case 175: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 174:
- /* */ if (!($interfaceIsEqual(n$43.Post, $ifaceNil))) { $s = 176; continue; }
- /* */ $s = 177; continue;
- /* if (!($interfaceIsEqual(n$43.Post, $ifaceNil))) { */ case 176:
- $r = Walk(v, n$43.Post); /* */ $s = 178; case 178: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 177:
- $r = Walk(v, n$43.Body); /* */ $s = 179; case 179: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$57, true)[1]) { */ case 48:
- n$44 = _ref.$val;
- /* */ if (!($interfaceIsEqual(n$44.Key, $ifaceNil))) { $s = 180; continue; }
- /* */ $s = 181; continue;
- /* if (!($interfaceIsEqual(n$44.Key, $ifaceNil))) { */ case 180:
- $r = Walk(v, n$44.Key); /* */ $s = 182; case 182: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 181:
- /* */ if (!($interfaceIsEqual(n$44.Value, $ifaceNil))) { $s = 183; continue; }
- /* */ $s = 184; continue;
- /* if (!($interfaceIsEqual(n$44.Value, $ifaceNil))) { */ case 183:
- $r = Walk(v, n$44.Value); /* */ $s = 185; case 185: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 184:
- $r = Walk(v, n$44.X); /* */ $s = 186; case 186: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$44.Body); /* */ $s = 187; case 187: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$24, true)[1]) { */ case 49:
- n$45 = _ref.$val;
- /* */ if (!(n$45.Doc === ptrType.nil)) { $s = 188; continue; }
- /* */ $s = 189; continue;
- /* if (!(n$45.Doc === ptrType.nil)) { */ case 188:
- $r = Walk(v, n$45.Doc); /* */ $s = 190; case 190: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 189:
- /* */ if (!(n$45.Name === ptrType$4.nil)) { $s = 191; continue; }
- /* */ $s = 192; continue;
- /* if (!(n$45.Name === ptrType$4.nil)) { */ case 191:
- $r = Walk(v, n$45.Name); /* */ $s = 193; case 193: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 192:
- $r = Walk(v, n$45.Path); /* */ $s = 194; case 194: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(n$45.Comment === ptrType.nil)) { $s = 195; continue; }
- /* */ $s = 196; continue;
- /* if (!(n$45.Comment === ptrType.nil)) { */ case 195:
- $r = Walk(v, n$45.Comment); /* */ $s = 197; case 197: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 196:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1]) { */ case 50:
- n$46 = _ref.$val;
- /* */ if (!(n$46.Doc === ptrType.nil)) { $s = 198; continue; }
- /* */ $s = 199; continue;
- /* if (!(n$46.Doc === ptrType.nil)) { */ case 198:
- $r = Walk(v, n$46.Doc); /* */ $s = 200; case 200: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 199:
- $r = walkIdentList(v, n$46.Names); /* */ $s = 201; case 201: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(n$46.Type, $ifaceNil))) { $s = 202; continue; }
- /* */ $s = 203; continue;
- /* if (!($interfaceIsEqual(n$46.Type, $ifaceNil))) { */ case 202:
- $r = Walk(v, n$46.Type); /* */ $s = 204; case 204: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 203:
- $r = walkExprList(v, n$46.Values); /* */ $s = 205; case 205: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(n$46.Comment === ptrType.nil)) { $s = 206; continue; }
- /* */ $s = 207; continue;
- /* if (!(n$46.Comment === ptrType.nil)) { */ case 206:
- $r = Walk(v, n$46.Comment); /* */ $s = 208; case 208: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 207:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$21, true)[1]) { */ case 51:
- n$47 = _ref.$val;
- /* */ if (!(n$47.Doc === ptrType.nil)) { $s = 209; continue; }
- /* */ $s = 210; continue;
- /* if (!(n$47.Doc === ptrType.nil)) { */ case 209:
- $r = Walk(v, n$47.Doc); /* */ $s = 211; case 211: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 210:
- $r = Walk(v, n$47.Name); /* */ $s = 212; case 212: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$47.Type); /* */ $s = 213; case 213: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(n$47.Comment === ptrType.nil)) { $s = 214; continue; }
- /* */ $s = 215; continue;
- /* if (!(n$47.Comment === ptrType.nil)) { */ case 214:
- $r = Walk(v, n$47.Comment); /* */ $s = 216; case 216: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 215:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$58, true)[1]) { */ case 52:
- n$48 = _ref.$val;
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$22, true)[1]) { */ case 53:
- n$49 = _ref.$val;
- /* */ if (!(n$49.Doc === ptrType.nil)) { $s = 217; continue; }
- /* */ $s = 218; continue;
- /* if (!(n$49.Doc === ptrType.nil)) { */ case 217:
- $r = Walk(v, n$49.Doc); /* */ $s = 219; case 219: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 218:
- _ref$3 = n$49.Specs;
- _i$2 = 0;
- /* while (true) { */ case 220:
- /* if (!(_i$2 < _ref$3.$length)) { break; } */ if(!(_i$2 < _ref$3.$length)) { $s = 221; continue; }
- s = ((_i$2 < 0 || _i$2 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$2]);
- $r = Walk(v, s); /* */ $s = 222; case 222: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 220; continue; case 221:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$23, true)[1]) { */ case 54:
- n$50 = _ref.$val;
- /* */ if (!(n$50.Doc === ptrType.nil)) { $s = 223; continue; }
- /* */ $s = 224; continue;
- /* if (!(n$50.Doc === ptrType.nil)) { */ case 223:
- $r = Walk(v, n$50.Doc); /* */ $s = 225; case 225: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 224:
- /* */ if (!(n$50.Recv === ptrType$2.nil)) { $s = 226; continue; }
- /* */ $s = 227; continue;
- /* if (!(n$50.Recv === ptrType$2.nil)) { */ case 226:
- $r = Walk(v, n$50.Recv); /* */ $s = 228; case 228: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 227:
- $r = Walk(v, n$50.Name); /* */ $s = 229; case 229: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = Walk(v, n$50.Type); /* */ $s = 230; case 230: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(n$50.Body === ptrType$5.nil)) { $s = 231; continue; }
- /* */ $s = 232; continue;
- /* if (!(n$50.Body === ptrType$5.nil)) { */ case 231:
- $r = Walk(v, n$50.Body); /* */ $s = 233; case 233: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 232:
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 55:
- n$51 = _ref.$val;
- /* */ if (!(n$51.Doc === ptrType.nil)) { $s = 234; continue; }
- /* */ $s = 235; continue;
- /* if (!(n$51.Doc === ptrType.nil)) { */ case 234:
- $r = Walk(v, n$51.Doc); /* */ $s = 236; case 236: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 235:
- $r = Walk(v, n$51.Name); /* */ $s = 237; case 237: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = walkDeclList(v, n$51.Decls); /* */ $s = 238; case 238: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 58; continue;
- /* } else if ($assertType(_ref, ptrType$59, true)[1]) { */ case 56:
- n$52 = _ref.$val;
- _ref$4 = n$52.Files;
- _i$3 = 0;
- _keys = $keys(_ref$4);
- /* while (true) { */ case 239:
- /* if (!(_i$3 < _keys.length)) { break; } */ if(!(_i$3 < _keys.length)) { $s = 240; continue; }
- _entry = _ref$4[_keys[_i$3]];
- if (_entry === undefined) {
- _i$3++;
- /* continue; */ $s = 239; continue;
- }
- f$1 = _entry.v;
- $r = Walk(v, f$1); /* */ $s = 241; case 241: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* } */ $s = 239; continue; case 240:
- $s = 58; continue;
- /* } else { */ case 57:
- n$53 = _ref;
- _r$1 = fmt.Printf("ast.Walk: unexpected node type %T", new sliceType$4([n$53])); /* */ $s = 242; case 242: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- $panic(new $String("ast.Walk"));
- /* } */ case 58:
- _r$2 = v.Visit($ifaceNil); /* */ $s = 243; case 243: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Walk }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._keys = _keys; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f.c = c; $f.f = f; $f.f$1 = f$1; $f.n = n; $f.n$1 = n$1; $f.n$10 = n$10; $f.n$11 = n$11; $f.n$12 = n$12; $f.n$13 = n$13; $f.n$14 = n$14; $f.n$15 = n$15; $f.n$16 = n$16; $f.n$17 = n$17; $f.n$18 = n$18; $f.n$19 = n$19; $f.n$2 = n$2; $f.n$20 = n$20; $f.n$21 = n$21; $f.n$22 = n$22; $f.n$23 = n$23; $f.n$24 = n$24; $f.n$25 = n$25; $f.n$26 = n$26; $f.n$27 = n$27; $f.n$28 = n$28; $f.n$29 = n$29; $f.n$3 = n$3; $f.n$30 = n$30; $f.n$31 = n$31; $f.n$32 = n$32; $f.n$33 = n$33; $f.n$34 = n$34; $f.n$35 = n$35; $f.n$36 = n$36; $f.n$37 = n$37; $f.n$38 = n$38; $f.n$39 = n$39; $f.n$4 = n$4; $f.n$40 = n$40; $f.n$41 = n$41; $f.n$42 = n$42; $f.n$43 = n$43; $f.n$44 = n$44; $f.n$45 = n$45; $f.n$46 = n$46; $f.n$47 = n$47; $f.n$48 = n$48; $f.n$49 = n$49; $f.n$5 = n$5; $f.n$50 = n$50; $f.n$51 = n$51; $f.n$52 = n$52; $f.n$53 = n$53; $f.n$6 = n$6; $f.n$7 = n$7; $f.n$8 = n$8; $f.n$9 = n$9; $f.node = node; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Walk = Walk;
- inspector.prototype.Visit = function(node) {
- var $ptr, _r, f, node, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; node = $f.node; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = this.$val;
- _r = f(node); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r) { */ case 1:
- return new inspector(f);
- /* } */ case 2:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: inspector.prototype.Visit }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.node = node; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(inspector).prototype.Visit = function(node) { return new inspector(this.$get()).Visit(node); };
- Inspect = function(node, f) {
- var $ptr, f, node, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; node = $f.node; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = Walk(new inspector(f), node); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Inspect }; } $f.$ptr = $ptr; $f.f = f; $f.node = node; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Inspect = Inspect;
- ptrType$6.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}];
- ptrType.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Text", name: "Text", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$10.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}];
- ptrType$2.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "NumFields", name: "NumFields", pkg: "", typ: $funcType([], [$Int], false)}];
- ptrType$29.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$4.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}, {prop: "IsExported", name: "IsExported", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$30.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$1.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$31.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$32.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$13.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$11.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$33.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$34.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$35.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$36.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$12.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$37.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$38.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$39.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$14.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$15.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$16.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$17.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$18.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$19.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$40.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$41.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$42.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$27.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$43.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$44.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$45.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$28.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$46.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$47.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$48.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$49.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$5.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$50.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$51.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$52.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$53.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$54.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$55.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$56.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$57.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$24.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "specNode", name: "specNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$20.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "specNode", name: "specNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$21.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "specNode", name: "specNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$58.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "declNode", name: "declNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$22.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "declNode", name: "declNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$23.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "declNode", name: "declNode", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$9.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}];
- ptrType$59.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}];
- byPos.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}];
- CommentMap.methods = [{prop: "addComment", name: "addComment", pkg: "go/ast", typ: $funcType([Node, ptrType], [], false)}, {prop: "Update", name: "Update", pkg: "", typ: $funcType([Node, Node], [Node], false)}, {prop: "Filter", name: "Filter", pkg: "", typ: $funcType([Node], [CommentMap], false)}, {prop: "Comments", name: "Comments", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$60.methods = [{prop: "eol", name: "eol", pkg: "go/ast", typ: $funcType([], [$Bool], false)}, {prop: "next", name: "next", pkg: "go/ast", typ: $funcType([], [], false)}];
- ptrType$8.methods = [{prop: "push", name: "push", pkg: "go/ast", typ: $funcType([Node], [], false)}, {prop: "pop", name: "pop", pkg: "go/ast", typ: $funcType([token.Pos], [Node], false)}];
- byImportSpec.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}];
- byCommentPos.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}];
- ptrType$26.methods = [{prop: "Lookup", name: "Lookup", pkg: "", typ: $funcType([$String], [ptrType$3], false)}, {prop: "Insert", name: "Insert", pkg: "", typ: $funcType([ptrType$3], [ptrType$3], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$3.methods = [{prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}];
- ObjKind.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- inspector.methods = [{prop: "Visit", name: "Visit", pkg: "", typ: $funcType([Node], [Visitor], false)}];
- Node.init([{prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}]);
- Expr.init([{prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "exprNode", name: "exprNode", pkg: "go/ast", typ: $funcType([], [], false)}]);
- Stmt.init([{prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "stmtNode", name: "stmtNode", pkg: "go/ast", typ: $funcType([], [], false)}]);
- Decl.init([{prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "declNode", name: "declNode", pkg: "go/ast", typ: $funcType([], [], false)}]);
- Comment.init([{prop: "Slash", name: "Slash", pkg: "", typ: token.Pos, tag: ""}, {prop: "Text", name: "Text", pkg: "", typ: $String, tag: ""}]);
- CommentGroup.init([{prop: "List", name: "List", pkg: "", typ: sliceType$5, tag: ""}]);
- Field.init([{prop: "Doc", name: "Doc", pkg: "", typ: ptrType, tag: ""}, {prop: "Names", name: "Names", pkg: "", typ: sliceType$8, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Expr, tag: ""}, {prop: "Tag", name: "Tag", pkg: "", typ: ptrType$1, tag: ""}, {prop: "Comment", name: "Comment", pkg: "", typ: ptrType, tag: ""}]);
- FieldList.init([{prop: "Opening", name: "Opening", pkg: "", typ: token.Pos, tag: ""}, {prop: "List", name: "List", pkg: "", typ: sliceType$10, tag: ""}, {prop: "Closing", name: "Closing", pkg: "", typ: token.Pos, tag: ""}]);
- BadExpr.init([{prop: "From", name: "From", pkg: "", typ: token.Pos, tag: ""}, {prop: "To", name: "To", pkg: "", typ: token.Pos, tag: ""}]);
- Ident.init([{prop: "NamePos", name: "NamePos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Obj", name: "Obj", pkg: "", typ: ptrType$3, tag: ""}]);
- Ellipsis.init([{prop: "Ellipsis", name: "Ellipsis", pkg: "", typ: token.Pos, tag: ""}, {prop: "Elt", name: "Elt", pkg: "", typ: Expr, tag: ""}]);
- BasicLit.init([{prop: "ValuePos", name: "ValuePos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Kind", name: "Kind", pkg: "", typ: token.Token, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: ""}]);
- FuncLit.init([{prop: "Type", name: "Type", pkg: "", typ: ptrType$16, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}]);
- CompositeLit.init([{prop: "Type", name: "Type", pkg: "", typ: Expr, tag: ""}, {prop: "Lbrace", name: "Lbrace", pkg: "", typ: token.Pos, tag: ""}, {prop: "Elts", name: "Elts", pkg: "", typ: sliceType$11, tag: ""}, {prop: "Rbrace", name: "Rbrace", pkg: "", typ: token.Pos, tag: ""}]);
- ParenExpr.init([{prop: "Lparen", name: "Lparen", pkg: "", typ: token.Pos, tag: ""}, {prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "Rparen", name: "Rparen", pkg: "", typ: token.Pos, tag: ""}]);
- SelectorExpr.init([{prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "Sel", name: "Sel", pkg: "", typ: ptrType$4, tag: ""}]);
- IndexExpr.init([{prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "Lbrack", name: "Lbrack", pkg: "", typ: token.Pos, tag: ""}, {prop: "Index", name: "Index", pkg: "", typ: Expr, tag: ""}, {prop: "Rbrack", name: "Rbrack", pkg: "", typ: token.Pos, tag: ""}]);
- SliceExpr.init([{prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "Lbrack", name: "Lbrack", pkg: "", typ: token.Pos, tag: ""}, {prop: "Low", name: "Low", pkg: "", typ: Expr, tag: ""}, {prop: "High", name: "High", pkg: "", typ: Expr, tag: ""}, {prop: "Max", name: "Max", pkg: "", typ: Expr, tag: ""}, {prop: "Slice3", name: "Slice3", pkg: "", typ: $Bool, tag: ""}, {prop: "Rbrack", name: "Rbrack", pkg: "", typ: token.Pos, tag: ""}]);
- TypeAssertExpr.init([{prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "Lparen", name: "Lparen", pkg: "", typ: token.Pos, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Expr, tag: ""}, {prop: "Rparen", name: "Rparen", pkg: "", typ: token.Pos, tag: ""}]);
- CallExpr.init([{prop: "Fun", name: "Fun", pkg: "", typ: Expr, tag: ""}, {prop: "Lparen", name: "Lparen", pkg: "", typ: token.Pos, tag: ""}, {prop: "Args", name: "Args", pkg: "", typ: sliceType$11, tag: ""}, {prop: "Ellipsis", name: "Ellipsis", pkg: "", typ: token.Pos, tag: ""}, {prop: "Rparen", name: "Rparen", pkg: "", typ: token.Pos, tag: ""}]);
- StarExpr.init([{prop: "Star", name: "Star", pkg: "", typ: token.Pos, tag: ""}, {prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}]);
- UnaryExpr.init([{prop: "OpPos", name: "OpPos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Op", name: "Op", pkg: "", typ: token.Token, tag: ""}, {prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}]);
- BinaryExpr.init([{prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "OpPos", name: "OpPos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Op", name: "Op", pkg: "", typ: token.Token, tag: ""}, {prop: "Y", name: "Y", pkg: "", typ: Expr, tag: ""}]);
- KeyValueExpr.init([{prop: "Key", name: "Key", pkg: "", typ: Expr, tag: ""}, {prop: "Colon", name: "Colon", pkg: "", typ: token.Pos, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: Expr, tag: ""}]);
- ArrayType.init([{prop: "Lbrack", name: "Lbrack", pkg: "", typ: token.Pos, tag: ""}, {prop: "Len", name: "Len", pkg: "", typ: Expr, tag: ""}, {prop: "Elt", name: "Elt", pkg: "", typ: Expr, tag: ""}]);
- StructType.init([{prop: "Struct", name: "Struct", pkg: "", typ: token.Pos, tag: ""}, {prop: "Fields", name: "Fields", pkg: "", typ: ptrType$2, tag: ""}, {prop: "Incomplete", name: "Incomplete", pkg: "", typ: $Bool, tag: ""}]);
- FuncType.init([{prop: "Func", name: "Func", pkg: "", typ: token.Pos, tag: ""}, {prop: "Params", name: "Params", pkg: "", typ: ptrType$2, tag: ""}, {prop: "Results", name: "Results", pkg: "", typ: ptrType$2, tag: ""}]);
- InterfaceType.init([{prop: "Interface", name: "Interface", pkg: "", typ: token.Pos, tag: ""}, {prop: "Methods", name: "Methods", pkg: "", typ: ptrType$2, tag: ""}, {prop: "Incomplete", name: "Incomplete", pkg: "", typ: $Bool, tag: ""}]);
- MapType.init([{prop: "Map", name: "Map", pkg: "", typ: token.Pos, tag: ""}, {prop: "Key", name: "Key", pkg: "", typ: Expr, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: Expr, tag: ""}]);
- ChanType.init([{prop: "Begin", name: "Begin", pkg: "", typ: token.Pos, tag: ""}, {prop: "Arrow", name: "Arrow", pkg: "", typ: token.Pos, tag: ""}, {prop: "Dir", name: "Dir", pkg: "", typ: ChanDir, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: Expr, tag: ""}]);
- BadStmt.init([{prop: "From", name: "From", pkg: "", typ: token.Pos, tag: ""}, {prop: "To", name: "To", pkg: "", typ: token.Pos, tag: ""}]);
- DeclStmt.init([{prop: "Decl", name: "Decl", pkg: "", typ: Decl, tag: ""}]);
- EmptyStmt.init([{prop: "Semicolon", name: "Semicolon", pkg: "", typ: token.Pos, tag: ""}]);
- LabeledStmt.init([{prop: "Label", name: "Label", pkg: "", typ: ptrType$4, tag: ""}, {prop: "Colon", name: "Colon", pkg: "", typ: token.Pos, tag: ""}, {prop: "Stmt", name: "Stmt", pkg: "", typ: Stmt, tag: ""}]);
- ExprStmt.init([{prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}]);
- SendStmt.init([{prop: "Chan", name: "Chan", pkg: "", typ: Expr, tag: ""}, {prop: "Arrow", name: "Arrow", pkg: "", typ: token.Pos, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: Expr, tag: ""}]);
- IncDecStmt.init([{prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "TokPos", name: "TokPos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Tok", name: "Tok", pkg: "", typ: token.Token, tag: ""}]);
- AssignStmt.init([{prop: "Lhs", name: "Lhs", pkg: "", typ: sliceType$11, tag: ""}, {prop: "TokPos", name: "TokPos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Tok", name: "Tok", pkg: "", typ: token.Token, tag: ""}, {prop: "Rhs", name: "Rhs", pkg: "", typ: sliceType$11, tag: ""}]);
- GoStmt.init([{prop: "Go", name: "Go", pkg: "", typ: token.Pos, tag: ""}, {prop: "Call", name: "Call", pkg: "", typ: ptrType$36, tag: ""}]);
- DeferStmt.init([{prop: "Defer", name: "Defer", pkg: "", typ: token.Pos, tag: ""}, {prop: "Call", name: "Call", pkg: "", typ: ptrType$36, tag: ""}]);
- ReturnStmt.init([{prop: "Return", name: "Return", pkg: "", typ: token.Pos, tag: ""}, {prop: "Results", name: "Results", pkg: "", typ: sliceType$11, tag: ""}]);
- BranchStmt.init([{prop: "TokPos", name: "TokPos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Tok", name: "Tok", pkg: "", typ: token.Token, tag: ""}, {prop: "Label", name: "Label", pkg: "", typ: ptrType$4, tag: ""}]);
- BlockStmt.init([{prop: "Lbrace", name: "Lbrace", pkg: "", typ: token.Pos, tag: ""}, {prop: "List", name: "List", pkg: "", typ: sliceType$12, tag: ""}, {prop: "Rbrace", name: "Rbrace", pkg: "", typ: token.Pos, tag: ""}]);
- IfStmt.init([{prop: "If", name: "If", pkg: "", typ: token.Pos, tag: ""}, {prop: "Init", name: "Init", pkg: "", typ: Stmt, tag: ""}, {prop: "Cond", name: "Cond", pkg: "", typ: Expr, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}, {prop: "Else", name: "Else", pkg: "", typ: Stmt, tag: ""}]);
- CaseClause.init([{prop: "Case", name: "Case", pkg: "", typ: token.Pos, tag: ""}, {prop: "List", name: "List", pkg: "", typ: sliceType$11, tag: ""}, {prop: "Colon", name: "Colon", pkg: "", typ: token.Pos, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: sliceType$12, tag: ""}]);
- SwitchStmt.init([{prop: "Switch", name: "Switch", pkg: "", typ: token.Pos, tag: ""}, {prop: "Init", name: "Init", pkg: "", typ: Stmt, tag: ""}, {prop: "Tag", name: "Tag", pkg: "", typ: Expr, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}]);
- TypeSwitchStmt.init([{prop: "Switch", name: "Switch", pkg: "", typ: token.Pos, tag: ""}, {prop: "Init", name: "Init", pkg: "", typ: Stmt, tag: ""}, {prop: "Assign", name: "Assign", pkg: "", typ: Stmt, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}]);
- CommClause.init([{prop: "Case", name: "Case", pkg: "", typ: token.Pos, tag: ""}, {prop: "Comm", name: "Comm", pkg: "", typ: Stmt, tag: ""}, {prop: "Colon", name: "Colon", pkg: "", typ: token.Pos, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: sliceType$12, tag: ""}]);
- SelectStmt.init([{prop: "Select", name: "Select", pkg: "", typ: token.Pos, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}]);
- ForStmt.init([{prop: "For", name: "For", pkg: "", typ: token.Pos, tag: ""}, {prop: "Init", name: "Init", pkg: "", typ: Stmt, tag: ""}, {prop: "Cond", name: "Cond", pkg: "", typ: Expr, tag: ""}, {prop: "Post", name: "Post", pkg: "", typ: Stmt, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}]);
- RangeStmt.init([{prop: "For", name: "For", pkg: "", typ: token.Pos, tag: ""}, {prop: "Key", name: "Key", pkg: "", typ: Expr, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: Expr, tag: ""}, {prop: "TokPos", name: "TokPos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Tok", name: "Tok", pkg: "", typ: token.Token, tag: ""}, {prop: "X", name: "X", pkg: "", typ: Expr, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}]);
- Spec.init([{prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "specNode", name: "specNode", pkg: "go/ast", typ: $funcType([], [], false)}]);
- ImportSpec.init([{prop: "Doc", name: "Doc", pkg: "", typ: ptrType, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: ptrType$4, tag: ""}, {prop: "Path", name: "Path", pkg: "", typ: ptrType$1, tag: ""}, {prop: "Comment", name: "Comment", pkg: "", typ: ptrType, tag: ""}, {prop: "EndPos", name: "EndPos", pkg: "", typ: token.Pos, tag: ""}]);
- ValueSpec.init([{prop: "Doc", name: "Doc", pkg: "", typ: ptrType, tag: ""}, {prop: "Names", name: "Names", pkg: "", typ: sliceType$8, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Expr, tag: ""}, {prop: "Values", name: "Values", pkg: "", typ: sliceType$11, tag: ""}, {prop: "Comment", name: "Comment", pkg: "", typ: ptrType, tag: ""}]);
- TypeSpec.init([{prop: "Doc", name: "Doc", pkg: "", typ: ptrType, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: ptrType$4, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Expr, tag: ""}, {prop: "Comment", name: "Comment", pkg: "", typ: ptrType, tag: ""}]);
- BadDecl.init([{prop: "From", name: "From", pkg: "", typ: token.Pos, tag: ""}, {prop: "To", name: "To", pkg: "", typ: token.Pos, tag: ""}]);
- GenDecl.init([{prop: "Doc", name: "Doc", pkg: "", typ: ptrType, tag: ""}, {prop: "TokPos", name: "TokPos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Tok", name: "Tok", pkg: "", typ: token.Token, tag: ""}, {prop: "Lparen", name: "Lparen", pkg: "", typ: token.Pos, tag: ""}, {prop: "Specs", name: "Specs", pkg: "", typ: sliceType$13, tag: ""}, {prop: "Rparen", name: "Rparen", pkg: "", typ: token.Pos, tag: ""}]);
- FuncDecl.init([{prop: "Doc", name: "Doc", pkg: "", typ: ptrType, tag: ""}, {prop: "Recv", name: "Recv", pkg: "", typ: ptrType$2, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: ptrType$4, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: ptrType$16, tag: ""}, {prop: "Body", name: "Body", pkg: "", typ: ptrType$5, tag: ""}]);
- File.init([{prop: "Doc", name: "Doc", pkg: "", typ: ptrType, tag: ""}, {prop: "Package", name: "Package", pkg: "", typ: token.Pos, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: ptrType$4, tag: ""}, {prop: "Decls", name: "Decls", pkg: "", typ: sliceType$6, tag: ""}, {prop: "Scope", name: "Scope", pkg: "", typ: ptrType$26, tag: ""}, {prop: "Imports", name: "Imports", pkg: "", typ: sliceType$7, tag: ""}, {prop: "Unresolved", name: "Unresolved", pkg: "", typ: sliceType$8, tag: ""}, {prop: "Comments", name: "Comments", pkg: "", typ: sliceType$2, tag: ""}]);
- Package.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Scope", name: "Scope", pkg: "", typ: ptrType$26, tag: ""}, {prop: "Imports", name: "Imports", pkg: "", typ: mapType, tag: ""}, {prop: "Files", name: "Files", pkg: "", typ: mapType$1, tag: ""}]);
- byPos.init(ptrType);
- CommentMap.init(Node, sliceType$2);
- commentListReader.init([{prop: "fset", name: "fset", pkg: "go/ast", typ: ptrType$7, tag: ""}, {prop: "list", name: "list", pkg: "go/ast", typ: sliceType$2, tag: ""}, {prop: "index", name: "index", pkg: "go/ast", typ: $Int, tag: ""}, {prop: "comment", name: "comment", pkg: "go/ast", typ: ptrType, tag: ""}, {prop: "pos", name: "pos", pkg: "go/ast", typ: token.Position, tag: ""}, {prop: "end", name: "end", pkg: "go/ast", typ: token.Position, tag: ""}]);
- nodeStack.init(Node);
- posSpan.init([{prop: "Start", name: "Start", pkg: "", typ: token.Pos, tag: ""}, {prop: "End", name: "End", pkg: "", typ: token.Pos, tag: ""}]);
- byImportSpec.init(Spec);
- byCommentPos.init(ptrType);
- Scope.init([{prop: "Outer", name: "Outer", pkg: "", typ: ptrType$26, tag: ""}, {prop: "Objects", name: "Objects", pkg: "", typ: mapType, tag: ""}]);
- Object.init([{prop: "Kind", name: "Kind", pkg: "", typ: ObjKind, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Decl", name: "Decl", pkg: "", typ: $emptyInterface, tag: ""}, {prop: "Data", name: "Data", pkg: "", typ: $emptyInterface, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: $emptyInterface, tag: ""}]);
- Visitor.init([{prop: "Visit", name: "Visit", pkg: "", typ: $funcType([Node], [Visitor], false)}]);
- inspector.init([Node], [$Bool], false);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = scanner.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = reflect.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- objKindStrings = $toNativeArray($kindString, ["bad", "package", "const", "type", "var", "func", "label"]);
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["container/heap"] = (function() {
- var $pkg = {}, $init, sort, Init, Pop, Fix, up, down;
- sort = $packages["sort"];
- Init = function(h) {
- var $ptr, _q, _r, h, i, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r = $f._r; h = $f.h; i = $f.i; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = h.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n = _r;
- i = (_q = n / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) - 1 >> 0;
- /* while (true) { */ case 2:
- /* if (!(i >= 0)) { break; } */ if(!(i >= 0)) { $s = 3; continue; }
- $r = down(h, i, n); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i - (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Init }; } $f.$ptr = $ptr; $f._q = _q; $f._r = _r; $f.h = h; $f.i = i; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Init = Init;
- Pop = function(h) {
- var $ptr, _r, _r$1, h, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; h = $f.h; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = h.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n = _r - 1 >> 0;
- $r = h.Swap(0, n); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = down(h, 0, n); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = h.Pop(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Pop }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.h = h; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Pop = Pop;
- Fix = function(h, i) {
- var $ptr, _arg, _arg$1, _arg$2, _r, h, i, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; h = $f.h; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _arg = h;
- _arg$1 = i;
- _r = h.Len(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$2 = _r;
- $r = down(_arg, _arg$1, _arg$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = up(h, i); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Fix }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f.h = h; $f.i = i; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Fix = Fix;
- up = function(h, j) {
- var $ptr, _q, _r, _v, h, i, j, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r = $f._r; _v = $f._v; h = $f.h; i = $f.i; j = $f.j; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* while (true) { */ case 1:
- i = (_q = ((j - 1 >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- if (i === j) { _v = true; $s = 5; continue s; }
- _r = h.Less(j, i); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = !_r; case 5:
- /* */ if (_v) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_v) { */ case 3:
- /* break; */ $s = 2; continue;
- /* } */ case 4:
- $r = h.Swap(i, j); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- j = i;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: up }; } $f.$ptr = $ptr; $f._q = _q; $f._r = _r; $f._v = _v; $f.h = h; $f.i = i; $f.j = j; $f.$s = $s; $f.$r = $r; return $f;
- };
- down = function(h, i, n) {
- var $ptr, _r, _r$1, _v, h, i, j, j1, j2, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; h = $f.h; i = $f.i; j = $f.j; j1 = $f.j1; j2 = $f.j2; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* while (true) { */ case 1:
- j1 = (2 * i >> 0) + 1 >> 0;
- if (j1 >= n || j1 < 0) {
- /* break; */ $s = 2; continue;
- }
- j = j1;
- j2 = j1 + 1 >> 0;
- if (!(j2 < n)) { _v = false; $s = 5; continue s; }
- _r = h.Less(j1, j2); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = !_r; case 5:
- /* */ if (_v) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_v) { */ case 3:
- j = j2;
- /* } */ case 4:
- _r$1 = h.Less(j, i); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!_r$1) { */ case 7:
- /* break; */ $s = 2; continue;
- /* } */ case 8:
- $r = h.Swap(i, j); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = j;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: down }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.h = h; $f.i = i; $f.j = j; $f.j1 = j1; $f.j2 = j2; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- };
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = sort.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["io/ioutil"] = (function() {
- var $pkg = {}, $init, bytes, io, os, filepath, sort, strconv, sync, time, sliceType, sliceType$1, ptrType, blackHolePool, readAll, ReadFile;
- bytes = $packages["bytes"];
- io = $packages["io"];
- os = $packages["os"];
- filepath = $packages["path/filepath"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- sync = $packages["sync"];
- time = $packages["time"];
- sliceType = $sliceType($emptyInterface);
- sliceType$1 = $sliceType($Uint8);
- ptrType = $ptrType(sliceType$1);
- readAll = function(r, capacity) {
- var $ptr, _r, _tmp, _tmp$1, _tuple, b, buf, capacity, err, r, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; buf = $f.buf; capacity = $f.capacity; err = $f.err; r = $f.r; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- b = sliceType$1.nil;
- err[0] = $ifaceNil;
- buf = bytes.NewBuffer($makeSlice(sliceType$1, 0, $flatten64(capacity)));
- $deferred.push([(function(err) { return function() {
- var $ptr, _tuple, e, ok, panicErr;
- e = $recover();
- if ($interfaceIsEqual(e, $ifaceNil)) {
- return;
- }
- _tuple = $assertType(e, $error, true); panicErr = _tuple[0]; ok = _tuple[1];
- if (ok && $interfaceIsEqual(panicErr, bytes.ErrTooLarge)) {
- err[0] = panicErr;
- } else {
- $panic(e);
- }
- }; })(err), []]);
- _r = buf.ReadFrom(r); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; err[0] = _tuple[1];
- _tmp = buf.Bytes(); _tmp$1 = err[0]; b = _tmp; err[0] = _tmp$1;
- return [b, err[0]];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [b, err[0]]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: readAll }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.buf = buf; $f.capacity = capacity; $f.err = err; $f.r = r; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- ReadFile = function(filename) {
- var $ptr, _r, _r$1, _tuple, _tuple$1, err, err$1, f, fi, filename, n, size, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; err = $f.err; err$1 = $f.err$1; f = $f.f; fi = $f.fi; filename = $f.filename; n = $f.n; size = $f.size; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- _tuple = os.Open(filename); f = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [sliceType$1.nil, err];
- }
- $deferred.push([$methodVal(f, "Close"), []]);
- n = new $Int64(0, 0);
- _tuple$1 = f.Stat(); fi = _tuple$1[0]; err$1 = _tuple$1[1];
- /* */ if ($interfaceIsEqual(err$1, $ifaceNil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ($interfaceIsEqual(err$1, $ifaceNil)) { */ case 1:
- _r = fi.Size(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- size = _r;
- /* */ if ((size.$high < 0 || (size.$high === 0 && size.$low < 1000000000))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ((size.$high < 0 || (size.$high === 0 && size.$low < 1000000000))) { */ case 4:
- n = size;
- /* } */ case 5:
- /* } */ case 2:
- _r$1 = readAll(f, new $Int64(n.$high + 0, n.$low + 512)); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return [sliceType$1.nil, $ifaceNil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: ReadFile }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.fi = fi; $f.filename = filename; $f.n = n; $f.size = size; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- $pkg.ReadFile = ReadFile;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = filepath.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = time.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- blackHolePool = new sync.Pool.ptr(0, 0, sliceType.nil, (function() {
- var $ptr, b, nonAsciiName;
- b = $makeSlice(sliceType$1, 8192);
- return (nonAsciiName || (nonAsciiName = new ptrType(function() { return b; }, function($v) { b = $v; })));
- }));
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["go/parser"] = (function() {
- var $pkg = {}, $init, bytes, errors, fmt, ast, scanner, token, io, ioutil, os, filepath, strconv, strings, unicode, Mode, parser, bailout, parseSpecFunction, sliceType, ptrType, ptrType$1, ptrType$2, ptrType$3, sliceType$1, ptrType$4, ptrType$5, sliceType$2, sliceType$3, sliceType$4, ptrType$7, ptrType$8, sliceType$6, ptrType$9, sliceType$7, sliceType$8, ptrType$10, ptrType$11, ptrType$12, sliceType$9, ptrType$13, ptrType$14, ptrType$15, ptrType$16, ptrType$17, ptrType$18, ptrType$19, sliceType$10, ptrType$20, arrayType, arrayType$1, ptrType$21, ptrType$22, ptrType$23, ptrType$24, ptrType$25, ptrType$26, ptrType$27, ptrType$28, ptrType$29, ptrType$30, ptrType$31, ptrType$32, ptrType$33, ptrType$34, ptrType$35, ptrType$36, ptrType$37, ptrType$38, ptrType$39, ptrType$40, ptrType$41, sliceType$11, ptrType$42, ptrType$43, ptrType$44, sliceType$12, ptrType$45, ptrType$46, funcType, unresolved, readSource, ParseFile, trace, un, assert, syncStmt, syncDecl, isTypeName, isLiteralType, deref, unparen, isTypeSwitchAssert, isTypeSwitchGuard, isValidImport;
- bytes = $packages["bytes"];
- errors = $packages["errors"];
- fmt = $packages["fmt"];
- ast = $packages["go/ast"];
- scanner = $packages["go/scanner"];
- token = $packages["go/token"];
- io = $packages["io"];
- ioutil = $packages["io/ioutil"];
- os = $packages["os"];
- filepath = $packages["path/filepath"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- unicode = $packages["unicode"];
- Mode = $pkg.Mode = $newType(4, $kindUint, "parser.Mode", "Mode", "go/parser", null);
- parser = $pkg.parser = $newType(0, $kindStruct, "parser.parser", "parser", "go/parser", function(file_, errors_, scanner_, mode_, trace_, indent_, comments_, leadComment_, lineComment_, pos_, tok_, lit_, syncPos_, syncCnt_, exprLev_, inRhs_, pkgScope_, topScope_, unresolved_, imports_, labelScope_, targetStack_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.file = ptrType$44.nil;
- this.errors = scanner.ErrorList.nil;
- this.scanner = new scanner.Scanner.ptr();
- this.mode = 0;
- this.trace = false;
- this.indent = 0;
- this.comments = sliceType$4.nil;
- this.leadComment = ptrType$2.nil;
- this.lineComment = ptrType$2.nil;
- this.pos = 0;
- this.tok = 0;
- this.lit = "";
- this.syncPos = 0;
- this.syncCnt = 0;
- this.exprLev = 0;
- this.inRhs = false;
- this.pkgScope = ptrType$4.nil;
- this.topScope = ptrType$4.nil;
- this.unresolved = sliceType$3.nil;
- this.imports = sliceType$2.nil;
- this.labelScope = ptrType$4.nil;
- this.targetStack = sliceType$12.nil;
- return;
- }
- this.file = file_;
- this.errors = errors_;
- this.scanner = scanner_;
- this.mode = mode_;
- this.trace = trace_;
- this.indent = indent_;
- this.comments = comments_;
- this.leadComment = leadComment_;
- this.lineComment = lineComment_;
- this.pos = pos_;
- this.tok = tok_;
- this.lit = lit_;
- this.syncPos = syncPos_;
- this.syncCnt = syncCnt_;
- this.exprLev = exprLev_;
- this.inRhs = inRhs_;
- this.pkgScope = pkgScope_;
- this.topScope = topScope_;
- this.unresolved = unresolved_;
- this.imports = imports_;
- this.labelScope = labelScope_;
- this.targetStack = targetStack_;
- });
- bailout = $pkg.bailout = $newType(0, $kindStruct, "parser.bailout", "bailout", "go/parser", function() {
- this.$val = this;
- if (arguments.length === 0) {
- return;
- }
- });
- parseSpecFunction = $pkg.parseSpecFunction = $newType(4, $kindFunc, "parser.parseSpecFunction", "parseSpecFunction", "go/parser", null);
- sliceType = $sliceType($Uint8);
- ptrType = $ptrType(bytes.Buffer);
- ptrType$1 = $ptrType(ast.File);
- ptrType$2 = $ptrType(ast.CommentGroup);
- ptrType$3 = $ptrType(ast.Ident);
- sliceType$1 = $sliceType(ast.Decl);
- ptrType$4 = $ptrType(ast.Scope);
- ptrType$5 = $ptrType(ast.ImportSpec);
- sliceType$2 = $sliceType(ptrType$5);
- sliceType$3 = $sliceType(ptrType$3);
- sliceType$4 = $sliceType(ptrType$2);
- ptrType$7 = $ptrType(scanner.ErrorList);
- ptrType$8 = $ptrType(ast.Object);
- sliceType$6 = $sliceType($emptyInterface);
- ptrType$9 = $ptrType(ast.Comment);
- sliceType$7 = $sliceType(ptrType$9);
- sliceType$8 = $sliceType(ast.Expr);
- ptrType$10 = $ptrType(ast.BadExpr);
- ptrType$11 = $ptrType(ast.BasicLit);
- ptrType$12 = $ptrType(ast.Field);
- sliceType$9 = $sliceType(ptrType$12);
- ptrType$13 = $ptrType(ast.FieldList);
- ptrType$14 = $ptrType(ast.StructType);
- ptrType$15 = $ptrType(ast.StarExpr);
- ptrType$16 = $ptrType(ast.FuncType);
- ptrType$17 = $ptrType(ast.InterfaceType);
- ptrType$18 = $ptrType(ast.MapType);
- ptrType$19 = $ptrType(ast.ChanType);
- sliceType$10 = $sliceType(ast.Stmt);
- ptrType$20 = $ptrType(ast.BlockStmt);
- arrayType = $arrayType(ast.Expr, 3);
- arrayType$1 = $arrayType(token.Pos, 2);
- ptrType$21 = $ptrType(ast.CallExpr);
- ptrType$22 = $ptrType(ast.FuncLit);
- ptrType$23 = $ptrType(ast.CompositeLit);
- ptrType$24 = $ptrType(ast.ParenExpr);
- ptrType$25 = $ptrType(ast.SelectorExpr);
- ptrType$26 = $ptrType(ast.IndexExpr);
- ptrType$27 = $ptrType(ast.SliceExpr);
- ptrType$28 = $ptrType(ast.TypeAssertExpr);
- ptrType$29 = $ptrType(ast.UnaryExpr);
- ptrType$30 = $ptrType(ast.BinaryExpr);
- ptrType$31 = $ptrType(ast.ArrayType);
- ptrType$32 = $ptrType(ast.Ellipsis);
- ptrType$33 = $ptrType(ast.ReturnStmt);
- ptrType$34 = $ptrType(ast.BranchStmt);
- ptrType$35 = $ptrType(ast.ExprStmt);
- ptrType$36 = $ptrType(ast.IfStmt);
- ptrType$37 = $ptrType(ast.CaseClause);
- ptrType$38 = $ptrType(ast.AssignStmt);
- ptrType$39 = $ptrType(ast.CommClause);
- ptrType$40 = $ptrType(ast.SelectStmt);
- ptrType$41 = $ptrType(ast.LabeledStmt);
- sliceType$11 = $sliceType(ast.Spec);
- ptrType$42 = $ptrType(ast.GenDecl);
- ptrType$43 = $ptrType(ast.FuncDecl);
- ptrType$44 = $ptrType(token.File);
- sliceType$12 = $sliceType(sliceType$3);
- ptrType$45 = $ptrType(token.FileSet);
- ptrType$46 = $ptrType(parser);
- funcType = $funcType([ptrType$46], [], false);
- readSource = function(filename, src) {
- var $ptr, _r, _r$1, _ref, _tuple, buf, err, filename, s, s$1, s$2, s$3, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tuple = $f._tuple; buf = $f.buf; err = $f.err; filename = $f.filename; s = $f.s; s$1 = $f.s$1; s$2 = $f.s$2; s$3 = $f.s$3; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- /* */ if (!($interfaceIsEqual(src, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(src, $ifaceNil))) { */ case 1:
- _ref = src;
- /* */ if ($assertType(_ref, $String, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, sliceType, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, io.Reader, true)[1]) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if ($assertType(_ref, $String, true)[1]) { */ case 3:
- s = _ref.$val;
- return [new sliceType($stringToBytes(s)), $ifaceNil];
- $s = 7; continue;
- /* } else if ($assertType(_ref, sliceType, true)[1]) { */ case 4:
- s$1 = _ref.$val;
- return [s$1, $ifaceNil];
- $s = 7; continue;
- /* } else if ($assertType(_ref, ptrType, true)[1]) { */ case 5:
- s$2 = _ref.$val;
- if (!(s$2 === ptrType.nil)) {
- return [s$2.Bytes(), $ifaceNil];
- }
- $s = 7; continue;
- /* } else if ($assertType(_ref, io.Reader, true)[1]) { */ case 6:
- s$3 = _ref;
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _r = io.Copy(buf[0], s$3); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 9:
- return [sliceType.nil, err];
- /* } */ case 10:
- return [buf[0].Bytes(), $ifaceNil];
- /* } */ case 7:
- return [sliceType.nil, errors.New("invalid source")];
- /* } */ case 2:
- _r$1 = ioutil.ReadFile(filename); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: readSource }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tuple = _tuple; $f.buf = buf; $f.err = err; $f.filename = filename; $f.s = s; $f.s$1 = s$1; $f.s$2 = s$2; $f.s$3 = s$3; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- ParseFile = function(fset, filename, src, mode) {
- var $ptr, _r, _r$1, _tmp, _tmp$1, _tuple, err, f, filename, fset, mode, p, src, text, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; filename = $f.filename; fset = $f.fset; mode = $f.mode; p = $f.p; src = $f.src; text = $f.text; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- f = [f];
- p = [p];
- f[0] = ptrType$1.nil;
- err[0] = $ifaceNil;
- _r = readSource(filename, src); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; text = _tuple[0]; err[0] = _tuple[1];
- if (!($interfaceIsEqual(err[0], $ifaceNil))) {
- _tmp = ptrType$1.nil; _tmp$1 = err[0]; f[0] = _tmp; err[0] = _tmp$1;
- return [f[0], err[0]];
- }
- p[0] = $clone(new parser.ptr(), parser);
- $deferred.push([(function(err, f, p) { return function $b() {
- var $ptr, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- e = $recover();
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- }
- if (f[0] === ptrType$1.nil) {
- f[0] = new ast.File.ptr(ptrType$2.nil, 0, new ast.Ident.ptr(), sliceType$1.nil, ast.NewScope(ptrType$4.nil), sliceType$2.nil, sliceType$3.nil, sliceType$4.nil);
- }
- $r = p[0].errors.Sort(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- err[0] = p[0].errors.Err();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- }; })(err, f, p), []]);
- $r = p[0].init(fset, filename, text, mode); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = p[0].parseFile(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- f[0] = _r$1;
- return [f[0], err[0]];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [f[0], err[0]]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: ParseFile }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.filename = filename; $f.fset = fset; $f.mode = mode; $f.p = p; $f.src = src; $f.text = text; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- $pkg.ParseFile = ParseFile;
- parser.ptr.prototype.init = function(fset, filename, src, mode) {
- var $ptr, eh, filename, fset, m, mode, p, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; eh = $f.eh; filename = $f.filename; fset = $f.fset; m = $f.m; mode = $f.mode; p = $f.p; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = [p];
- p[0] = this;
- p[0].file = fset.AddFile(filename, -1, src.$length);
- m = 0;
- if (!((((mode & 4) >>> 0) === 0))) {
- m = 1;
- }
- eh = (function(p) { return function(pos, msg) {
- var $ptr, msg, pos;
- (p[0].$ptr_errors || (p[0].$ptr_errors = new ptrType$7(function() { return this.$target.errors; }, function($v) { this.$target.errors = $v; }, p[0]))).Add(pos, msg);
- }; })(p);
- $r = p[0].scanner.Init(p[0].file, src, eh, m); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p[0].mode = mode;
- p[0].trace = !((((mode & 8) >>> 0) === 0));
- $r = p[0].next(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.init }; } $f.$ptr = $ptr; $f.eh = eh; $f.filename = filename; $f.fset = fset; $f.m = m; $f.mode = mode; $f.p = p; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.init = function(fset, filename, src, mode) { return this.$val.init(fset, filename, src, mode); };
- parser.ptr.prototype.openScope = function() {
- var $ptr, p;
- p = this;
- p.topScope = ast.NewScope(p.topScope);
- };
- parser.prototype.openScope = function() { return this.$val.openScope(); };
- parser.ptr.prototype.closeScope = function() {
- var $ptr, p;
- p = this;
- p.topScope = p.topScope.Outer;
- };
- parser.prototype.closeScope = function() { return this.$val.closeScope(); };
- parser.ptr.prototype.openLabelScope = function() {
- var $ptr, p;
- p = this;
- p.labelScope = ast.NewScope(p.labelScope);
- p.targetStack = $append(p.targetStack, sliceType$3.nil);
- };
- parser.prototype.openLabelScope = function() { return this.$val.openLabelScope(); };
- parser.ptr.prototype.closeLabelScope = function() {
- var $ptr, _arg, _arg$1, _i, _r, _ref, ident, n, p, scope, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _i = $f._i; _r = $f._r; _ref = $f._ref; ident = $f.ident; n = $f.n; p = $f.p; scope = $f.scope; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- n = p.targetStack.$length - 1 >> 0;
- scope = p.labelScope;
- _ref = (x = p.targetStack, ((n < 0 || n >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + n]));
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- ident = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ident.Obj = scope.Lookup(ident.Name);
- /* */ if (ident.Obj === ptrType$8.nil && !((((p.mode & 16) >>> 0) === 0))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (ident.Obj === ptrType$8.nil && !((((p.mode & 16) >>> 0) === 0))) { */ case 3:
- _arg = ident.Pos();
- _r = fmt.Sprintf("label %s undefined", new sliceType$6([new $String(ident.Name)])); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = _r;
- $r = p.error(_arg, _arg$1); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- p.targetStack = $subslice(p.targetStack, 0, n);
- p.labelScope = p.labelScope.Outer;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.closeLabelScope }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.ident = ident; $f.n = n; $f.p = p; $f.scope = scope; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.closeLabelScope = function() { return this.$val.closeLabelScope(); };
- parser.ptr.prototype.declare = function(decl, data, scope, kind, idents) {
- var $ptr, _arg, _arg$1, _arg$2, _i, _r, _r$1, _r$2, _ref, alt, data, decl, ident, idents, kind, obj, p, pos, prevDecl, scope, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; alt = $f.alt; data = $f.data; decl = $f.decl; ident = $f.ident; idents = $f.idents; kind = $f.kind; obj = $f.obj; p = $f.p; pos = $f.pos; prevDecl = $f.prevDecl; scope = $f.scope; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = idents;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- ident = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- assert(ident.Obj === ptrType$8.nil, "identifier already declared or resolved");
- obj = ast.NewObj(kind, ident.Name);
- obj.Decl = decl;
- obj.Data = data;
- ident.Obj = obj;
- /* */ if (!(ident.Name === "_")) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(ident.Name === "_")) { */ case 3:
- alt = scope.Insert(obj);
- /* */ if (!(alt === ptrType$8.nil) && !((((p.mode & 16) >>> 0) === 0))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!(alt === ptrType$8.nil) && !((((p.mode & 16) >>> 0) === 0))) { */ case 5:
- prevDecl = "";
- pos = alt.Pos();
- /* */ if (new token.Pos(pos).IsValid()) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (new token.Pos(pos).IsValid()) { */ case 7:
- _r = p.file.Position(pos); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg = (x = _r, new x.constructor.elem(x));
- _r$1 = fmt.Sprintf("\n\tprevious declaration at %s", new sliceType$6([_arg])); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- prevDecl = _r$1;
- /* } */ case 8:
- _arg$1 = ident.Pos();
- _r$2 = fmt.Sprintf("%s redeclared in this block%s", new sliceType$6([new $String(ident.Name), new $String(prevDecl)])); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$2 = _r$2;
- $r = p.error(_arg$1, _arg$2); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- /* } */ case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.declare }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.alt = alt; $f.data = data; $f.decl = decl; $f.ident = ident; $f.idents = idents; $f.kind = kind; $f.obj = obj; $f.p = p; $f.pos = pos; $f.prevDecl = prevDecl; $f.scope = scope; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.declare = function(decl, data, scope, kind, idents) { return this.$val.declare(decl, data, scope, kind, idents); };
- parser.ptr.prototype.shortVarDecl = function(decl, list) {
- var $ptr, _i, _r, _r$1, _ref, _tuple, alt, decl, ident, isIdent, list, n, obj, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tuple = $f._tuple; alt = $f.alt; decl = $f.decl; ident = $f.ident; isIdent = $f.isIdent; list = $f.list; n = $f.n; obj = $f.obj; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- n = 0;
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple = $assertType(x, ptrType$3, true); ident = _tuple[0]; isIdent = _tuple[1];
- /* */ if (isIdent) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (isIdent) { */ case 3:
- assert(ident.Obj === ptrType$8.nil, "identifier already declared or resolved");
- obj = ast.NewObj(4, ident.Name);
- obj.Decl = decl;
- ident.Obj = obj;
- if (!(ident.Name === "_")) {
- alt = p.topScope.Insert(obj);
- if (!(alt === ptrType$8.nil)) {
- ident.Obj = alt;
- } else {
- n = n + (1) >> 0;
- }
- }
- $s = 5; continue;
- /* } else { */ case 4:
- _r = x.Pos(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r, "identifier on left side of :="); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ if ((n === 0) && !((((p.mode & 16) >>> 0) === 0))) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ((n === 0) && !((((p.mode & 16) >>> 0) === 0))) { */ case 8:
- _r$1 = (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]).Pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = p.error(_r$1, "no new variables on left side of :="); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.shortVarDecl }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tuple = _tuple; $f.alt = alt; $f.decl = decl; $f.ident = ident; $f.isIdent = isIdent; $f.list = list; $f.n = n; $f.obj = obj; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.shortVarDecl = function(decl, list) { return this.$val.shortVarDecl(decl, list); };
- parser.ptr.prototype.tryResolve = function(x, collectUnresolved) {
- var $ptr, _tuple, collectUnresolved, ident, obj, p, s, x;
- p = this;
- _tuple = $assertType(x, ptrType$3, true); ident = _tuple[0];
- if (ident === ptrType$3.nil) {
- return;
- }
- assert(ident.Obj === ptrType$8.nil, "identifier already declared or resolved");
- if (ident.Name === "_") {
- return;
- }
- s = p.topScope;
- while (true) {
- if (!(!(s === ptrType$4.nil))) { break; }
- obj = s.Lookup(ident.Name);
- if (!(obj === ptrType$8.nil)) {
- ident.Obj = obj;
- return;
- }
- s = s.Outer;
- }
- if (collectUnresolved) {
- ident.Obj = unresolved;
- p.unresolved = $append(p.unresolved, ident);
- }
- };
- parser.prototype.tryResolve = function(x, collectUnresolved) { return this.$val.tryResolve(x, collectUnresolved); };
- parser.ptr.prototype.resolve = function(x) {
- var $ptr, p, x;
- p = this;
- p.tryResolve(x, true);
- };
- parser.prototype.resolve = function(x) { return this.$val.resolve(x); };
- parser.ptr.prototype.printTrace = function(a) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, a, i, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; a = $f.a; i = $f.i; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = p.file.Position(p.pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- pos = $clone(_r, token.Position);
- _r$1 = fmt.Printf("%5d:%3d: ", new sliceType$6([new $Int(pos.Line), new $Int(pos.Column)])); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- i = 2 * p.indent >> 0;
- /* while (true) { */ case 3:
- /* if (!(i > 64)) { break; } */ if(!(i > 64)) { $s = 4; continue; }
- _r$2 = fmt.Print(new sliceType$6([new $String(". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ")])); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- i = i - (64) >> 0;
- /* } */ $s = 3; continue; case 4:
- _r$3 = fmt.Print(new sliceType$6([new $String(". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ".substring(0, i))])); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- _r$4 = fmt.Println(a); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.printTrace }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.a = a; $f.i = i; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.printTrace = function(a) { return this.$val.printTrace(a); };
- trace = function(p, msg) {
- var $ptr, msg, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; msg = $f.msg; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = p.printTrace(new sliceType$6([new $String(msg), new $String("(")])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.indent = p.indent + (1) >> 0;
- return p;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: trace }; } $f.$ptr = $ptr; $f.msg = msg; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- un = function(p) {
- var $ptr, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p.indent = p.indent - (1) >> 0;
- $r = p.printTrace(new sliceType$6([new $String(")")])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: un }; } $f.$ptr = $ptr; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.ptr.prototype.next0 = function() {
- var $ptr, _r, _tuple, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (p.trace && new token.Pos(p.pos).IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace && new token.Pos(p.pos).IsValid()) { */ case 1:
- s = new token.Token(p.tok).String();
- /* */ if (new token.Token(p.tok).IsLiteral()) { $s = 3; continue; }
- /* */ if (new token.Token(p.tok).IsOperator() || new token.Token(p.tok).IsKeyword()) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (new token.Token(p.tok).IsLiteral()) { */ case 3:
- $r = p.printTrace(new sliceType$6([new $String(s), new $String(p.lit)])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if (new token.Token(p.tok).IsOperator() || new token.Token(p.tok).IsKeyword()) { */ case 4:
- $r = p.printTrace(new sliceType$6([new $String("\"" + s + "\"")])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else { */ case 5:
- $r = p.printTrace(new sliceType$6([new $String(s)])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- /* } */ case 2:
- _r = p.scanner.Scan(); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; p.pos = _tuple[0]; p.tok = _tuple[1]; p.lit = _tuple[2];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.next0 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.next0 = function() { return this.$val.next0(); };
- parser.ptr.prototype.consumeComment = function() {
- var $ptr, _r, comment, endline, i, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; comment = $f.comment; endline = $f.endline; i = $f.i; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- comment = ptrType$9.nil;
- endline = 0;
- p = this;
- _r = p.file.Line(p.pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- endline = _r;
- if (p.lit.charCodeAt(1) === 42) {
- i = 0;
- while (true) {
- if (!(i < p.lit.length)) { break; }
- if (p.lit.charCodeAt(i) === 10) {
- endline = endline + (1) >> 0;
- }
- i = i + (1) >> 0;
- }
- }
- comment = new ast.Comment.ptr(p.pos, p.lit);
- $r = p.next0(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [comment, endline];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.consumeComment }; } $f.$ptr = $ptr; $f._r = _r; $f.comment = comment; $f.endline = endline; $f.i = i; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.consumeComment = function() { return this.$val.consumeComment(); };
- parser.ptr.prototype.consumeCommentGroup = function(n) {
- var $ptr, _r, _r$1, _r$2, _tuple, _v, comment, comments, endline, list, n, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _v = $f._v; comment = $f.comment; comments = $f.comments; endline = $f.endline; list = $f.list; n = $f.n; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- comments = ptrType$2.nil;
- endline = 0;
- p = this;
- list = sliceType$7.nil;
- _r = p.file.Line(p.pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- endline = _r;
- /* while (true) { */ case 2:
- if (!(p.tok === 2)) { _v = false; $s = 4; continue s; }
- _r$1 = p.file.Line(p.pos); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1 <= (endline + n >> 0); case 4:
- /* if (!(_v)) { break; } */ if(!(_v)) { $s = 3; continue; }
- comment = ptrType$9.nil;
- _r$2 = p.consumeComment(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; comment = _tuple[0]; endline = _tuple[1];
- list = $append(list, comment);
- /* } */ $s = 2; continue; case 3:
- comments = new ast.CommentGroup.ptr(list);
- p.comments = $append(p.comments, comments);
- return [comments, endline];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.consumeCommentGroup }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._v = _v; $f.comment = comment; $f.comments = comments; $f.endline = endline; $f.list = list; $f.n = n; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.consumeCommentGroup = function(n) { return this.$val.consumeCommentGroup(n); };
- parser.ptr.prototype.next = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tuple, _tuple$1, comment, endline, p, prev, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; comment = $f.comment; endline = $f.endline; p = $f.p; prev = $f.prev; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- p.leadComment = ptrType$2.nil;
- p.lineComment = ptrType$2.nil;
- prev = p.pos;
- $r = p.next0(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (p.tok === 2) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (p.tok === 2) { */ case 2:
- comment = ptrType$2.nil;
- endline = 0;
- _r = p.file.Line(p.pos); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.file.Line(prev); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r === _r$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_r === _r$1) { */ case 4:
- _r$2 = p.consumeCommentGroup(0); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; comment = _tuple[0]; endline = _tuple[1];
- _r$3 = p.file.Line(p.pos); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!((_r$3 === endline))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!((_r$3 === endline))) { */ case 9:
- p.lineComment = comment;
- /* } */ case 10:
- /* } */ case 5:
- endline = -1;
- /* while (true) { */ case 12:
- /* if (!(p.tok === 2)) { break; } */ if(!(p.tok === 2)) { $s = 13; continue; }
- _r$4 = p.consumeCommentGroup(1); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple$1 = _r$4; comment = _tuple$1[0]; endline = _tuple$1[1];
- /* } */ $s = 12; continue; case 13:
- _r$5 = p.file.Line(p.pos); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- /* */ if ((endline + 1 >> 0) === _r$5) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if ((endline + 1 >> 0) === _r$5) { */ case 15:
- p.leadComment = comment;
- /* } */ case 16:
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.next }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.comment = comment; $f.endline = endline; $f.p = p; $f.prev = prev; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.next = function() { return this.$val.next(); };
- parser.ptr.prototype.error = function(pos, msg) {
- var $ptr, _r, epos, msg, n, p, pos, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; epos = $f.epos; msg = $f.msg; n = $f.n; p = $f.p; pos = $f.pos; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = p.file.Position(pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- epos = $clone(_r, token.Position);
- if (((p.mode & 32) >>> 0) === 0) {
- n = p.errors.$length;
- if (n > 0 && ((x = p.errors, x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).Pos.Line === epos.Line)) {
- return;
- }
- if (n > 10) {
- $panic((x$2 = new bailout.ptr(), new x$2.constructor.elem(x$2)));
- }
- }
- (p.$ptr_errors || (p.$ptr_errors = new ptrType$7(function() { return this.$target.errors; }, function($v) { this.$target.errors = $v; }, p))).Add(epos, msg);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.error }; } $f.$ptr = $ptr; $f._r = _r; $f.epos = epos; $f.msg = msg; $f.n = n; $f.p = p; $f.pos = pos; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.error = function(pos, msg) { return this.$val.error(pos, msg); };
- parser.ptr.prototype.errorExpected = function(pos, msg) {
- var $ptr, msg, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; msg = $f.msg; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- msg = "expected " + msg;
- if (pos === p.pos) {
- if ((p.tok === 57) && p.lit === "\n") {
- msg = msg + (", found newline");
- } else {
- msg = msg + (", found '" + new token.Token(p.tok).String() + "'");
- if (new token.Token(p.tok).IsLiteral()) {
- msg = msg + (" " + p.lit);
- }
- }
- }
- $r = p.error(pos, msg); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.errorExpected }; } $f.$ptr = $ptr; $f.msg = msg; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.errorExpected = function(pos, msg) { return this.$val.errorExpected(pos, msg); };
- parser.ptr.prototype.expect = function(tok) {
- var $ptr, p, pos, tok, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; pos = $f.pos; tok = $f.tok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- pos = p.pos;
- /* */ if (!((p.tok === tok))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((p.tok === tok))) { */ case 1:
- $r = p.errorExpected(pos, "'" + new token.Token(tok).String() + "'"); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- $r = p.next(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.expect }; } $f.$ptr = $ptr; $f.p = p; $f.pos = pos; $f.tok = tok; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.expect = function(tok) { return this.$val.expect(tok); };
- parser.ptr.prototype.expectClosing = function(tok, context) {
- var $ptr, _r, context, p, tok, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; context = $f.context; p = $f.p; tok = $f.tok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (!((p.tok === tok)) && (p.tok === 57) && p.lit === "\n") { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((p.tok === tok)) && (p.tok === 57) && p.lit === "\n") { */ case 1:
- $r = p.error(p.pos, "missing ',' before newline in " + context); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.next(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- _r = p.expect(tok); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.expectClosing }; } $f.$ptr = $ptr; $f._r = _r; $f.context = context; $f.p = p; $f.tok = tok; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.expectClosing = function(tok, context) { return this.$val.expectClosing(tok, context); };
- parser.ptr.prototype.expectSemi = function() {
- var $ptr, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (!((p.tok === 54)) && !((p.tok === 56))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((p.tok === 54)) && !((p.tok === 56))) { */ case 1:
- /* */ if (p.tok === 57) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (p.tok === 57) { */ case 3:
- $r = p.next(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else { */ case 4:
- $r = p.errorExpected(p.pos, "';'"); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = syncStmt(p); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.expectSemi }; } $f.$ptr = $ptr; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.expectSemi = function() { return this.$val.expectSemi(); };
- parser.ptr.prototype.atComma = function(context) {
- var $ptr, context, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; context = $f.context; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- if (p.tok === 52) {
- return true;
- }
- /* */ if ((p.tok === 57) && p.lit === "\n") { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((p.tok === 57) && p.lit === "\n") { */ case 1:
- $r = p.error(p.pos, "missing ',' before newline in " + context); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return true;
- /* } */ case 2:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.atComma }; } $f.$ptr = $ptr; $f.context = context; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.atComma = function(context) { return this.$val.atComma(context); };
- assert = function(cond, msg) {
- var $ptr, cond, msg;
- if (!cond) {
- $panic(new $String("go/parser internal error: " + msg));
- }
- };
- syncStmt = function(p) {
- var $ptr, _ref, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* while (true) { */ case 1:
- _ref = p.tok;
- if (_ref === 61 || _ref === 64 || _ref === 65 || _ref === 67 || _ref === 69 || _ref === 70 || _ref === 72 || _ref === 73 || _ref === 74 || _ref === 80 || _ref === 81 || _ref === 83 || _ref === 84 || _ref === 85) {
- if ((p.pos === p.syncPos) && p.syncCnt < 10) {
- p.syncCnt = p.syncCnt + (1) >> 0;
- return;
- }
- if (p.pos > p.syncPos) {
- p.syncPos = p.pos;
- p.syncCnt = 0;
- return;
- }
- } else if (_ref === 1) {
- return;
- }
- $r = p.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: syncStmt }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- syncDecl = function(p) {
- var $ptr, _ref, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* while (true) { */ case 1:
- _ref = p.tok;
- if (_ref === 64 || _ref === 84 || _ref === 85) {
- if ((p.pos === p.syncPos) && p.syncCnt < 10) {
- p.syncCnt = p.syncCnt + (1) >> 0;
- return;
- }
- if (p.pos > p.syncPos) {
- p.syncPos = p.pos;
- p.syncCnt = 0;
- return;
- }
- } else if (_ref === 1) {
- return;
- }
- $r = p.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: syncDecl }; } $f.$ptr = $ptr; $f._ref = _ref; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.ptr.prototype.safePos = function(pos) {
- var $ptr, p, pos, res, $deferred;
- /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- res = 0;
- p = this;
- $deferred.push([(function() {
- var $ptr;
- if (!($interfaceIsEqual($recover(), $ifaceNil))) {
- res = ((p.file.Base() + p.file.Size() >> 0) >> 0);
- }
- }), []]);
- p.file.Offset(pos);
- res = pos;
- return res;
- /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return res; } }
- };
- parser.prototype.safePos = function(pos) { return this.$val.safePos(pos); };
- parser.ptr.prototype.parseIdent = function() {
- var $ptr, _r, name, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- pos = p.pos;
- name = "_";
- /* */ if (p.tok === 4) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.tok === 4) { */ case 1:
- name = p.lit;
- $r = p.next(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 3; continue;
- /* } else { */ case 2:
- _r = p.expect(4); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- /* } */ case 3:
- return new ast.Ident.ptr(pos, name, ptrType$8.nil);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseIdent }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.parseIdent = function() { return this.$val.parseIdent(); };
- parser.ptr.prototype.parseIdentList = function() {
- var $ptr, _r, _r$1, _r$2, list, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; list = $f.list; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- list = sliceType$3.nil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "IdentList"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseIdent(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- list = $append(list, _r$1);
- /* while (true) { */ case 5:
- /* if (!(p.tok === 52)) { break; } */ if(!(p.tok === 52)) { $s = 6; continue; }
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = p.parseIdent(); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = $append(list, _r$2);
- /* } */ $s = 5; continue; case 6:
- return list;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return list; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseIdentList }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.list = list; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseIdentList = function() { return this.$val.parseIdentList(); };
- parser.ptr.prototype.parseExprList = function(lhs) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, lhs, list, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; lhs = $f.lhs; list = $f.list; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- list = sliceType$8.nil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ExpressionList"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseExpr(lhs); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.checkExpr(_r$1); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = $append(list, _r$2);
- /* while (true) { */ case 6:
- /* if (!(p.tok === 52)) { break; } */ if(!(p.tok === 52)) { $s = 7; continue; }
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = p.parseExpr(lhs); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = p.checkExpr(_r$3); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- list = $append(list, _r$4);
- /* } */ $s = 6; continue; case 7:
- return list;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return list; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseExprList }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.lhs = lhs; $f.list = list; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseExprList = function(lhs) { return this.$val.parseExprList(lhs); };
- parser.ptr.prototype.parseLhsList = function() {
- var $ptr, _i, _r, _ref, _ref$1, list, old, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; list = $f.list; old = $f.old; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- old = p.inRhs;
- p.inRhs = false;
- _r = p.parseExprList(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- list = _r;
- _ref = p.tok;
- if (_ref === 47) {
- } else if (_ref === 58) {
- } else {
- _ref$1 = list;
- _i = 0;
- while (true) {
- if (!(_i < _ref$1.$length)) { break; }
- x = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- p.resolve(x);
- _i++;
- }
- }
- p.inRhs = old;
- return list;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseLhsList }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.list = list; $f.old = old; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.parseLhsList = function() { return this.$val.parseLhsList(); };
- parser.ptr.prototype.parseRhsList = function() {
- var $ptr, _r, list, old, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; list = $f.list; old = $f.old; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- old = p.inRhs;
- p.inRhs = true;
- _r = p.parseExprList(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- list = _r;
- p.inRhs = old;
- return list;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseRhsList }; } $f.$ptr = $ptr; $f._r = _r; $f.list = list; $f.old = old; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.parseRhsList = function() { return this.$val.parseRhsList(); };
- parser.ptr.prototype.parseType = function() {
- var $ptr, _r, _r$1, p, pos, typ, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; p = $f.p; pos = $f.pos; typ = $f.typ; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Type"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.tryType(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- typ = _r$1;
- /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 5:
- pos = p.pos;
- $r = p.errorExpected(pos, "type"); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new ast.BadExpr.ptr(pos, p.pos);
- /* } */ case 6:
- return typ;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.pos = pos; $f.typ = typ; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseType = function() { return this.$val.parseType(); };
- parser.ptr.prototype.parseTypeName = function() {
- var $ptr, _r, _r$1, _r$2, ident, p, sel, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; ident = $f.ident; p = $f.p; sel = $f.sel; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "TypeName"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseIdent(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ident = _r$1;
- /* */ if (p.tok === 53) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (p.tok === 53) { */ case 5:
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.resolve(ident);
- _r$2 = p.parseIdent(); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- sel = _r$2;
- return new ast.SelectorExpr.ptr(ident, sel);
- /* } */ case 6:
- return ident;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseTypeName }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.ident = ident; $f.p = p; $f.sel = sel; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseTypeName = function() { return this.$val.parseTypeName(); };
- parser.ptr.prototype.parseArrayType = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, elt, lbrack, len, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; elt = $f.elt; lbrack = $f.lbrack; len = $f.len; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ArrayType"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(50); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lbrack = _r$1;
- p.exprLev = p.exprLev + (1) >> 0;
- len = $ifaceNil;
- /* */ if (p.tok === 48) { $s = 5; continue; }
- /* */ if (!((p.tok === 55))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (p.tok === 48) { */ case 5:
- len = new ast.Ellipsis.ptr(p.pos, $ifaceNil);
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 7; continue;
- /* } else if (!((p.tok === 55))) { */ case 6:
- _r$2 = p.parseRhs(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- len = _r$2;
- /* } */ case 7:
- p.exprLev = p.exprLev - (1) >> 0;
- _r$3 = p.expect(55); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- _r$4 = p.parseType(); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- elt = _r$4;
- return new ast.ArrayType.ptr(lbrack, len, elt);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseArrayType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.elt = elt; $f.lbrack = lbrack; $f.len = len; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseArrayType = function() { return this.$val.parseArrayType(); };
- parser.ptr.prototype.makeIdentList = function(list) {
- var $ptr, _i, _r, _r$1, _ref, _tuple, _tuple$1, i, ident, idents, isBad, isIdent, list, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; i = $f.i; ident = $f.ident; idents = $f.idents; isBad = $f.isBad; isIdent = $f.isIdent; list = $f.list; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- idents = $makeSlice(sliceType$3, list.$length);
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple = $assertType(x, ptrType$3, true); ident = _tuple[0]; isIdent = _tuple[1];
- /* */ if (!isIdent) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!isIdent) { */ case 3:
- _tuple$1 = $assertType(x, ptrType$10, true); isBad = _tuple$1[1];
- /* */ if (!isBad) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!isBad) { */ case 5:
- _r = x.Pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r, "identifier"); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- _r$1 = x.Pos(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ident = new ast.Ident.ptr(_r$1, "_", ptrType$8.nil);
- /* } */ case 4:
- ((i < 0 || i >= idents.$length) ? $throwRuntimeError("index out of range") : idents.$array[idents.$offset + i] = ident);
- _i++;
- /* } */ $s = 1; continue; case 2:
- return idents;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.makeIdentList }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.i = i; $f.ident = ident; $f.idents = idents; $f.isBad = isBad; $f.isIdent = isIdent; $f.list = list; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.makeIdentList = function(list) { return this.$val.makeIdentList(list); };
- parser.ptr.prototype.parseFieldDecl = function(scope) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tuple, doc, field, idents, list, n, p, pos, scope, tag, typ, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; doc = $f.doc; field = $f.field; idents = $f.idents; list = $f.list; n = $f.n; p = $f.p; pos = $f.pos; scope = $f.scope; tag = $f.tag; typ = $f.typ; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "FieldDecl"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- doc = p.leadComment;
- _r$1 = p.parseVarList(false); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; list = _tuple[0]; typ = _tuple[1];
- tag = ptrType$11.nil;
- /* */ if (p.tok === 9) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (p.tok === 9) { */ case 5:
- tag = new ast.BasicLit.ptr(p.pos, p.tok, p.lit);
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- idents = sliceType$3.nil;
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 8:
- _r$2 = p.makeIdentList(list); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- idents = _r$2;
- $s = 10; continue;
- /* } else { */ case 9:
- typ = (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]);
- n = list.$length;
- /* */ if (n > 1 || !isTypeName(deref(typ))) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (n > 1 || !isTypeName(deref(typ))) { */ case 12:
- _r$3 = typ.Pos(); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- pos = _r$3;
- $r = p.errorExpected(pos, "anonymous field"); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$4 = (x = n - 1 >> 0, ((x < 0 || x >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + x])).End(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.safePos(_r$4); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- typ = new ast.BadExpr.ptr(pos, _r$5);
- /* } */ case 13:
- /* } */ case 10:
- $r = p.expectSemi(); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- field = new ast.Field.ptr(doc, idents, typ, tag, p.lineComment);
- $r = p.declare(field, $ifaceNil, scope, 4, idents); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.resolve(typ);
- return field;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$12.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseFieldDecl }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f.doc = doc; $f.field = field; $f.idents = idents; $f.list = list; $f.n = n; $f.p = p; $f.pos = pos; $f.scope = scope; $f.tag = tag; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseFieldDecl = function(scope) { return this.$val.parseFieldDecl(scope); };
- parser.ptr.prototype.parseStructType = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, lbrace, list, p, pos, rbrace, scope, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; lbrace = $f.lbrace; list = $f.list; p = $f.p; pos = $f.pos; rbrace = $f.rbrace; scope = $f.scope; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "StructType"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(82); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _r$2 = p.expect(51); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- lbrace = _r$2;
- scope = ast.NewScope(ptrType$4.nil);
- list = sliceType$9.nil;
- /* while (true) { */ case 6:
- /* if (!((p.tok === 4) || (p.tok === 14) || (p.tok === 49))) { break; } */ if(!((p.tok === 4) || (p.tok === 14) || (p.tok === 49))) { $s = 7; continue; }
- _r$3 = p.parseFieldDecl(scope); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- list = $append(list, _r$3);
- /* } */ $s = 6; continue; case 7:
- _r$4 = p.expect(56); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- rbrace = _r$4;
- return new ast.StructType.ptr(pos, new ast.FieldList.ptr(lbrace, list, rbrace), false);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$14.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseStructType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.lbrace = lbrace; $f.list = list; $f.p = p; $f.pos = pos; $f.rbrace = rbrace; $f.scope = scope; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseStructType = function() { return this.$val.parseStructType(); };
- parser.ptr.prototype.parsePointerType = function() {
- var $ptr, _r, _r$1, _r$2, base, p, star, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; base = $f.base; p = $f.p; star = $f.star; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "PointerType"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(14); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- star = _r$1;
- _r$2 = p.parseType(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- base = _r$2;
- return new ast.StarExpr.ptr(star, base);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$15.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parsePointerType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.base = base; $f.p = p; $f.star = star; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parsePointerType = function() { return this.$val.parsePointerType(); };
- parser.ptr.prototype.tryVarType = function(isParam) {
- var $ptr, _r, _r$1, isParam, p, pos, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; isParam = $f.isParam; p = $f.p; pos = $f.pos; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (isParam && (p.tok === 48)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (isParam && (p.tok === 48)) { */ case 1:
- pos = p.pos;
- $r = p.next(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = p.tryIdentOrType(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ = _r;
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 5:
- p.resolve(typ);
- $s = 7; continue;
- /* } else { */ case 6:
- $r = p.error(pos, "'...' parameter is missing type"); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- typ = new ast.BadExpr.ptr(pos, p.pos);
- /* } */ case 7:
- return new ast.Ellipsis.ptr(pos, typ);
- /* } */ case 2:
- _r$1 = p.tryIdentOrType(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.tryVarType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.isParam = isParam; $f.p = p; $f.pos = pos; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.tryVarType = function(isParam) { return this.$val.tryVarType(isParam); };
- parser.ptr.prototype.parseVarType = function(isParam) {
- var $ptr, _r, isParam, p, pos, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; isParam = $f.isParam; p = $f.p; pos = $f.pos; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = p.tryVarType(isParam); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ = _r;
- /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 2:
- pos = p.pos;
- $r = p.errorExpected(pos, "type"); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.next(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- typ = new ast.BadExpr.ptr(pos, p.pos);
- /* } */ case 3:
- return typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseVarType }; } $f.$ptr = $ptr; $f._r = _r; $f.isParam = isParam; $f.p = p; $f.pos = pos; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.parseVarType = function(isParam) { return this.$val.parseVarType(isParam); };
- parser.ptr.prototype.parseVarList = function(isParam) {
- var $ptr, _r, _r$1, _r$2, _r$3, isParam, list, p, typ, typ$1, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; isParam = $f.isParam; list = $f.list; p = $f.p; typ = $f.typ; typ$1 = $f.typ$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- list = sliceType$8.nil;
- typ = $ifaceNil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "VarList"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseVarType(isParam); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- typ$1 = _r$1;
- /* while (true) { */ case 5:
- /* if (!(!($interfaceIsEqual(typ$1, $ifaceNil)))) { break; } */ if(!(!($interfaceIsEqual(typ$1, $ifaceNil)))) { $s = 6; continue; }
- list = $append(list, typ$1);
- if (!((p.tok === 52))) {
- /* break; */ $s = 6; continue;
- }
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = p.tryVarType(isParam); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- typ$1 = _r$2;
- /* } */ $s = 5; continue; case 6:
- _r$3 = p.tryVarType(isParam); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- typ = _r$3;
- return [list, typ];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [list, typ]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseVarList }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.isParam = isParam; $f.list = list; $f.p = p; $f.typ = typ; $f.typ$1 = typ$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseVarList = function(isParam) { return this.$val.parseVarList(isParam); };
- parser.ptr.prototype.parseParameterList = function(scope, ellipsisOk) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _tuple, ellipsisOk, field, field$1, i, idents, idents$1, list, p, params, scope, typ, typ$1, typ$2, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _tuple = $f._tuple; ellipsisOk = $f.ellipsisOk; field = $f.field; field$1 = $f.field$1; i = $f.i; idents = $f.idents; idents$1 = $f.idents$1; list = $f.list; p = $f.p; params = $f.params; scope = $f.scope; typ = $f.typ; typ$1 = $f.typ$1; typ$2 = $f.typ$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- params = sliceType$9.nil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ParameterList"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseVarList(ellipsisOk); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; list = _tuple[0]; typ = _tuple[1];
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 5:
- _r$2 = p.makeIdentList(list); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- idents = _r$2;
- field = new ast.Field.ptr(ptrType$2.nil, idents, typ, ptrType$11.nil, ptrType$2.nil);
- params = $append(params, field);
- $r = p.declare(field, $ifaceNil, scope, 4, idents); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.resolve(typ);
- _r$3 = p.atComma("parameter list"); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!_r$3) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!_r$3) { */ case 9:
- return params;
- /* } */ case 10:
- $r = p.next(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* while (true) { */ case 13:
- /* if (!(!((p.tok === 54)) && !((p.tok === 1)))) { break; } */ if(!(!((p.tok === 54)) && !((p.tok === 1)))) { $s = 14; continue; }
- _r$4 = p.parseIdentList(); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- idents$1 = _r$4;
- _r$5 = p.parseVarType(ellipsisOk); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- typ$1 = _r$5;
- field$1 = new ast.Field.ptr(ptrType$2.nil, idents$1, typ$1, ptrType$11.nil, ptrType$2.nil);
- params = $append(params, field$1);
- $r = p.declare(field$1, $ifaceNil, scope, 4, idents$1); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.resolve(typ$1);
- _r$6 = p.atComma("parameter list"); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- /* */ if (!_r$6) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!_r$6) { */ case 18:
- /* break; */ $s = 14; continue;
- /* } */ case 19:
- $r = p.next(); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 13; continue; case 14:
- return params;
- /* } */ case 6:
- params = $makeSlice(sliceType$9, list.$length);
- _ref = list;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- typ$2 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- p.resolve(typ$2);
- ((i < 0 || i >= params.$length) ? $throwRuntimeError("index out of range") : params.$array[params.$offset + i] = new ast.Field.ptr(ptrType$2.nil, sliceType$3.nil, typ$2, ptrType$11.nil, ptrType$2.nil));
- _i++;
- }
- return params;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return params; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseParameterList }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._tuple = _tuple; $f.ellipsisOk = ellipsisOk; $f.field = field; $f.field$1 = field$1; $f.i = i; $f.idents = idents; $f.idents$1 = idents$1; $f.list = list; $f.p = p; $f.params = params; $f.scope = scope; $f.typ = typ; $f.typ$1 = typ$1; $f.typ$2 = typ$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseParameterList = function(scope, ellipsisOk) { return this.$val.parseParameterList(scope, ellipsisOk); };
- parser.ptr.prototype.parseParameters = function(scope, ellipsisOk) {
- var $ptr, _r, _r$1, _r$2, _r$3, ellipsisOk, lparen, p, params, rparen, scope, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; ellipsisOk = $f.ellipsisOk; lparen = $f.lparen; p = $f.p; params = $f.params; rparen = $f.rparen; scope = $f.scope; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Parameters"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- params = sliceType$9.nil;
- _r$1 = p.expect(49); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lparen = _r$1;
- /* */ if (!((p.tok === 54))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((p.tok === 54))) { */ case 5:
- _r$2 = p.parseParameterList(scope, ellipsisOk); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- params = _r$2;
- /* } */ case 6:
- _r$3 = p.expect(54); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rparen = _r$3;
- return new ast.FieldList.ptr(lparen, params, rparen);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$13.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseParameters }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.ellipsisOk = ellipsisOk; $f.lparen = lparen; $f.p = p; $f.params = params; $f.rparen = rparen; $f.scope = scope; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseParameters = function(scope, ellipsisOk) { return this.$val.parseParameters(scope, ellipsisOk); };
- parser.ptr.prototype.parseResult = function(scope) {
- var $ptr, _r, _r$1, _r$2, list, p, scope, typ, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; list = $f.list; p = $f.p; scope = $f.scope; typ = $f.typ; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Result"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- /* */ if (p.tok === 49) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (p.tok === 49) { */ case 4:
- _r$1 = p.parseParameters(scope, false); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 5:
- _r$2 = p.tryType(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- typ = _r$2;
- if (!($interfaceIsEqual(typ, $ifaceNil))) {
- list = $makeSlice(sliceType$9, 1);
- (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0] = new ast.Field.ptr(ptrType$2.nil, sliceType$3.nil, typ, ptrType$11.nil, ptrType$2.nil));
- return new ast.FieldList.ptr(0, list, 0);
- }
- return ptrType$13.nil;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$13.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseResult }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.list = list; $f.p = p; $f.scope = scope; $f.typ = typ; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseResult = function(scope) { return this.$val.parseResult(scope); };
- parser.ptr.prototype.parseSignature = function(scope) {
- var $ptr, _r, _r$1, _r$2, p, params, results, scope, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; p = $f.p; params = $f.params; results = $f.results; scope = $f.scope; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- params = ptrType$13.nil;
- results = ptrType$13.nil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Signature"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseParameters(scope, true); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- params = _r$1;
- _r$2 = p.parseResult(scope); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- results = _r$2;
- return [params, results];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [params, results]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseSignature }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.p = p; $f.params = params; $f.results = results; $f.scope = scope; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseSignature = function(scope) { return this.$val.parseSignature(scope); };
- parser.ptr.prototype.parseFuncType = function() {
- var $ptr, _r, _r$1, _r$2, _tuple, p, params, pos, results, scope, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; p = $f.p; params = $f.params; pos = $f.pos; results = $f.results; scope = $f.scope; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "FuncType"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(71); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- scope = ast.NewScope(p.topScope);
- _r$2 = p.parseSignature(scope); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; params = _tuple[0]; results = _tuple[1];
- return [new ast.FuncType.ptr(pos, params, results), scope];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return [ptrType$16.nil, ptrType$4.nil]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseFuncType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.p = p; $f.params = params; $f.pos = pos; $f.results = results; $f.scope = scope; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseFuncType = function() { return this.$val.parseFuncType(); };
- parser.ptr.prototype.parseMethodSpec = function(scope) {
- var $ptr, _r, _r$1, _r$2, _tuple, _tuple$1, doc, ident, idents, isIdent, p, params, results, scope, scope$1, spec, typ, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; doc = $f.doc; ident = $f.ident; idents = $f.idents; isIdent = $f.isIdent; p = $f.p; params = $f.params; results = $f.results; scope = $f.scope; scope$1 = $f.scope$1; spec = $f.spec; typ = $f.typ; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "MethodSpec"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- doc = p.leadComment;
- idents = sliceType$3.nil;
- typ = $ifaceNil;
- _r$1 = p.parseTypeName(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- _tuple = $assertType(x, ptrType$3, true); ident = _tuple[0]; isIdent = _tuple[1];
- /* */ if (isIdent && (p.tok === 49)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (isIdent && (p.tok === 49)) { */ case 5:
- idents = new sliceType$3([ident]);
- scope$1 = ast.NewScope(ptrType$4.nil);
- _r$2 = p.parseSignature(scope$1); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; params = _tuple$1[0]; results = _tuple$1[1];
- typ = new ast.FuncType.ptr(0, params, results);
- $s = 7; continue;
- /* } else { */ case 6:
- typ = x;
- p.resolve(typ);
- /* } */ case 7:
- $r = p.expectSemi(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- spec = new ast.Field.ptr(doc, idents, typ, ptrType$11.nil, p.lineComment);
- $r = p.declare(spec, $ifaceNil, scope, 5, idents); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return spec;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$12.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseMethodSpec }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.doc = doc; $f.ident = ident; $f.idents = idents; $f.isIdent = isIdent; $f.p = p; $f.params = params; $f.results = results; $f.scope = scope; $f.scope$1 = scope$1; $f.spec = spec; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseMethodSpec = function(scope) { return this.$val.parseMethodSpec(scope); };
- parser.ptr.prototype.parseInterfaceType = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, lbrace, list, p, pos, rbrace, scope, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; lbrace = $f.lbrace; list = $f.list; p = $f.p; pos = $f.pos; rbrace = $f.rbrace; scope = $f.scope; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "InterfaceType"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(76); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _r$2 = p.expect(51); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- lbrace = _r$2;
- scope = ast.NewScope(ptrType$4.nil);
- list = sliceType$9.nil;
- /* while (true) { */ case 6:
- /* if (!(p.tok === 4)) { break; } */ if(!(p.tok === 4)) { $s = 7; continue; }
- _r$3 = p.parseMethodSpec(scope); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- list = $append(list, _r$3);
- /* } */ $s = 6; continue; case 7:
- _r$4 = p.expect(56); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- rbrace = _r$4;
- return new ast.InterfaceType.ptr(pos, new ast.FieldList.ptr(lbrace, list, rbrace), false);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$17.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseInterfaceType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.lbrace = lbrace; $f.list = list; $f.p = p; $f.pos = pos; $f.rbrace = rbrace; $f.scope = scope; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseInterfaceType = function() { return this.$val.parseInterfaceType(); };
- parser.ptr.prototype.parseMapType = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, key, p, pos, value, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; key = $f.key; p = $f.p; pos = $f.pos; value = $f.value; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "MapType"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(77); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _r$2 = p.expect(50); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- _r$3 = p.parseType(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- key = _r$3;
- _r$4 = p.expect(55); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- _r$5 = p.parseType(); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- value = _r$5;
- return new ast.MapType.ptr(pos, key, value);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$18.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseMapType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.key = key; $f.p = p; $f.pos = pos; $f.value = value; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseMapType = function() { return this.$val.parseMapType(); };
- parser.ptr.prototype.parseChanType = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, arrow, dir, p, pos, value, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; arrow = $f.arrow; dir = $f.dir; p = $f.p; pos = $f.pos; value = $f.value; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ChanType"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- pos = p.pos;
- dir = 3;
- arrow = 0;
- /* */ if (p.tok === 63) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (p.tok === 63) { */ case 4:
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (p.tok === 36) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (p.tok === 36) { */ case 8:
- arrow = p.pos;
- $r = p.next(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- dir = 1;
- /* } */ case 9:
- $s = 6; continue;
- /* } else { */ case 5:
- _r$1 = p.expect(36); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- arrow = _r$1;
- _r$2 = p.expect(63); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- dir = 2;
- /* } */ case 6:
- _r$3 = p.parseType(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- value = _r$3;
- return new ast.ChanType.ptr(pos, arrow, dir, value);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$19.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseChanType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.arrow = arrow; $f.dir = dir; $f.p = p; $f.pos = pos; $f.value = value; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseChanType = function() { return this.$val.parseChanType(); };
- parser.ptr.prototype.tryIdentOrType = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, lparen, p, rparen, typ, typ$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; lparen = $f.lparen; p = $f.p; rparen = $f.rparen; typ = $f.typ; typ$1 = $f.typ$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = p.tok;
- /* */ if (_ref === 4) { $s = 1; continue; }
- /* */ if (_ref === 50) { $s = 2; continue; }
- /* */ if (_ref === 82) { $s = 3; continue; }
- /* */ if (_ref === 14) { $s = 4; continue; }
- /* */ if (_ref === 71) { $s = 5; continue; }
- /* */ if (_ref === 76) { $s = 6; continue; }
- /* */ if (_ref === 77) { $s = 7; continue; }
- /* */ if (_ref === 63 || _ref === 36) { $s = 8; continue; }
- /* */ if (_ref === 49) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_ref === 4) { */ case 1:
- _r = p.parseTypeName(); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 10; continue;
- /* } else if (_ref === 50) { */ case 2:
- _r$1 = p.parseArrayType(); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 10; continue;
- /* } else if (_ref === 82) { */ case 3:
- _r$2 = p.parseStructType(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- $s = 10; continue;
- /* } else if (_ref === 14) { */ case 4:
- _r$3 = p.parsePointerType(); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 10; continue;
- /* } else if (_ref === 71) { */ case 5:
- _r$4 = p.parseFuncType(); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; typ = _tuple[0];
- return typ;
- $s = 10; continue;
- /* } else if (_ref === 76) { */ case 6:
- _r$5 = p.parseInterfaceType(); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- $s = 10; continue;
- /* } else if (_ref === 77) { */ case 7:
- _r$6 = p.parseMapType(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- $s = 10; continue;
- /* } else if (_ref === 63 || _ref === 36) { */ case 8:
- _r$7 = p.parseChanType(); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7;
- $s = 10; continue;
- /* } else if (_ref === 49) { */ case 9:
- lparen = p.pos;
- $r = p.next(); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$8 = p.parseType(); /* */ $s = 20; case 20: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- typ$1 = _r$8;
- _r$9 = p.expect(54); /* */ $s = 21; case 21: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- rparen = _r$9;
- return new ast.ParenExpr.ptr(lparen, typ$1, rparen);
- /* } */ case 10:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.tryIdentOrType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f.lparen = lparen; $f.p = p; $f.rparen = rparen; $f.typ = typ; $f.typ$1 = typ$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.tryIdentOrType = function() { return this.$val.tryIdentOrType(); };
- parser.ptr.prototype.tryType = function() {
- var $ptr, _r, p, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; p = $f.p; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = p.tryIdentOrType(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ = _r;
- if (!($interfaceIsEqual(typ, $ifaceNil))) {
- p.resolve(typ);
- }
- return typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.tryType }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.tryType = function() { return this.$val.tryType(); };
- parser.ptr.prototype.parseStmtList = function() {
- var $ptr, _r, _r$1, list, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; list = $f.list; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- list = sliceType$10.nil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "StatementList"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- /* while (true) { */ case 4:
- /* if (!(!((p.tok === 62)) && !((p.tok === 66)) && !((p.tok === 56)) && !((p.tok === 1)))) { break; } */ if(!(!((p.tok === 62)) && !((p.tok === 66)) && !((p.tok === 56)) && !((p.tok === 1)))) { $s = 5; continue; }
- _r$1 = p.parseStmt(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- list = $append(list, _r$1);
- /* } */ $s = 4; continue; case 5:
- return list;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return list; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseStmtList }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.list = list; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseStmtList = function() { return this.$val.parseStmtList(); };
- parser.ptr.prototype.parseBody = function(scope) {
- var $ptr, _r, _r$1, _r$2, _r$3, lbrace, list, p, rbrace, scope, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; lbrace = $f.lbrace; list = $f.list; p = $f.p; rbrace = $f.rbrace; scope = $f.scope; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Body"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(51); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lbrace = _r$1;
- p.topScope = scope;
- p.openLabelScope();
- _r$2 = p.parseStmtList(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = _r$2;
- $r = p.closeLabelScope(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.closeScope();
- _r$3 = p.expect(56); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rbrace = _r$3;
- return new ast.BlockStmt.ptr(lbrace, list, rbrace);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$20.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseBody }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.lbrace = lbrace; $f.list = list; $f.p = p; $f.rbrace = rbrace; $f.scope = scope; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseBody = function(scope) { return this.$val.parseBody(scope); };
- parser.ptr.prototype.parseBlockStmt = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, lbrace, list, p, rbrace, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; lbrace = $f.lbrace; list = $f.list; p = $f.p; rbrace = $f.rbrace; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "BlockStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(51); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lbrace = _r$1;
- p.openScope();
- _r$2 = p.parseStmtList(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = _r$2;
- p.closeScope();
- _r$3 = p.expect(56); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rbrace = _r$3;
- return new ast.BlockStmt.ptr(lbrace, list, rbrace);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$20.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseBlockStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.lbrace = lbrace; $f.list = list; $f.p = p; $f.rbrace = rbrace; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseBlockStmt = function() { return this.$val.parseBlockStmt(); };
- parser.ptr.prototype.parseFuncTypeOrLit = function() {
- var $ptr, _r, _r$1, _r$2, _tuple, body, p, scope, typ, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple = $f._tuple; body = $f.body; p = $f.p; scope = $f.scope; typ = $f.typ; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "FuncTypeOrLit"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseFuncType(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; typ = _tuple[0]; scope = _tuple[1];
- if (!((p.tok === 51))) {
- return typ;
- }
- p.exprLev = p.exprLev + (1) >> 0;
- _r$2 = p.parseBody(scope); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- body = _r$2;
- p.exprLev = p.exprLev - (1) >> 0;
- return new ast.FuncLit.ptr(typ, body);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseFuncTypeOrLit }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple = _tuple; $f.body = body; $f.p = p; $f.scope = scope; $f.typ = typ; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseFuncTypeOrLit = function() { return this.$val.parseFuncTypeOrLit(); };
- parser.ptr.prototype.parseOperand = function(lhs) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, _tuple, isIdent, lhs, lparen, p, pos, rparen, typ, x, x$1, x$2, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _tuple = $f._tuple; isIdent = $f.isIdent; lhs = $f.lhs; lparen = $f.lparen; p = $f.p; pos = $f.pos; rparen = $f.rparen; typ = $f.typ; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Operand"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _ref = p.tok;
- /* */ if (_ref === 4) { $s = 4; continue; }
- /* */ if (_ref === 5 || _ref === 6 || _ref === 7 || _ref === 8 || _ref === 9) { $s = 5; continue; }
- /* */ if (_ref === 49) { $s = 6; continue; }
- /* */ if (_ref === 71) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_ref === 4) { */ case 4:
- _r$1 = p.parseIdent(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- if (!lhs) {
- p.resolve(x);
- }
- return x;
- $s = 8; continue;
- /* } else if (_ref === 5 || _ref === 6 || _ref === 7 || _ref === 8 || _ref === 9) { */ case 5:
- x$1 = new ast.BasicLit.ptr(p.pos, p.tok, p.lit);
- $r = p.next(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return x$1;
- $s = 8; continue;
- /* } else if (_ref === 49) { */ case 6:
- lparen = p.pos;
- $r = p.next(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.exprLev = p.exprLev + (1) >> 0;
- _r$2 = p.parseRhsOrType(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- x$2 = _r$2;
- p.exprLev = p.exprLev - (1) >> 0;
- _r$3 = p.expect(54); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rparen = _r$3;
- return new ast.ParenExpr.ptr(lparen, x$2, rparen);
- $s = 8; continue;
- /* } else if (_ref === 71) { */ case 7:
- _r$4 = p.parseFuncTypeOrLit(); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- /* } */ case 8:
- _r$5 = p.tryIdentOrType(); /* */ $s = 15; case 15: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- typ = _r$5;
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 16:
- _tuple = $assertType(typ, ptrType$3, true); isIdent = _tuple[1];
- assert(!isIdent, "type cannot be identifier");
- return typ;
- /* } */ case 17:
- pos = p.pos;
- $r = p.errorExpected(pos, "operand"); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = syncStmt(p); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new ast.BadExpr.ptr(pos, p.pos);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseOperand }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._tuple = _tuple; $f.isIdent = isIdent; $f.lhs = lhs; $f.lparen = lparen; $f.p = p; $f.pos = pos; $f.rparen = rparen; $f.typ = typ; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseOperand = function(lhs) { return this.$val.parseOperand(lhs); };
- parser.ptr.prototype.parseSelector = function(x) {
- var $ptr, _r, _r$1, p, sel, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; p = $f.p; sel = $f.sel; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Selector"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseIdent(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- sel = _r$1;
- return new ast.SelectorExpr.ptr(x, sel);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseSelector }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.p = p; $f.sel = sel; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseSelector = function(x) { return this.$val.parseSelector(x); };
- parser.ptr.prototype.parseTypeAssertion = function(x) {
- var $ptr, _r, _r$1, _r$2, _r$3, lparen, p, rparen, typ, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; lparen = $f.lparen; p = $f.p; rparen = $f.rparen; typ = $f.typ; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "TypeAssertion"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(49); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lparen = _r$1;
- typ = $ifaceNil;
- /* */ if (p.tok === 84) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (p.tok === 84) { */ case 5:
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 7; continue;
- /* } else { */ case 6:
- _r$2 = p.parseType(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- typ = _r$2;
- /* } */ case 7:
- _r$3 = p.expect(54); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rparen = _r$3;
- return new ast.TypeAssertExpr.ptr(x, lparen, typ, rparen);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseTypeAssertion }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.lparen = lparen; $f.p = p; $f.rparen = rparen; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseTypeAssertion = function(x) { return this.$val.parseTypeAssertion(x); };
- parser.ptr.prototype.parseIndexOrSlice = function(x) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, colons, index, lbrack, ncolons, p, rbrack, slice3, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; colons = $f.colons; index = $f.index; lbrack = $f.lbrack; ncolons = $f.ncolons; p = $f.p; rbrack = $f.rbrack; slice3 = $f.slice3; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "IndexOrSlice"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(50); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lbrack = _r$1;
- p.exprLev = p.exprLev + (1) >> 0;
- index = $clone(arrayType.zero(), arrayType);
- colons = $clone(arrayType$1.zero(), arrayType$1);
- /* */ if (!((p.tok === 58))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((p.tok === 58))) { */ case 5:
- _r$2 = p.parseRhs(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- index[0] = _r$2;
- /* } */ case 6:
- ncolons = 0;
- /* while (true) { */ case 8:
- /* if (!((p.tok === 58) && ncolons < 2)) { break; } */ if(!((p.tok === 58) && ncolons < 2)) { $s = 9; continue; }
- ((ncolons < 0 || ncolons >= colons.length) ? $throwRuntimeError("index out of range") : colons[ncolons] = p.pos);
- ncolons = ncolons + (1) >> 0;
- $r = p.next(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!((p.tok === 58)) && !((p.tok === 55)) && !((p.tok === 1))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!((p.tok === 58)) && !((p.tok === 55)) && !((p.tok === 1))) { */ case 11:
- _r$3 = p.parseRhs(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- ((ncolons < 0 || ncolons >= index.length) ? $throwRuntimeError("index out of range") : index[ncolons] = _r$3);
- /* } */ case 12:
- /* } */ $s = 8; continue; case 9:
- p.exprLev = p.exprLev - (1) >> 0;
- _r$4 = p.expect(55); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- rbrack = _r$4;
- /* */ if (ncolons > 0) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (ncolons > 0) { */ case 15:
- slice3 = false;
- /* */ if (ncolons === 2) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (ncolons === 2) { */ case 17:
- slice3 = true;
- /* */ if ($interfaceIsEqual(index[1], $ifaceNil)) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if ($interfaceIsEqual(index[1], $ifaceNil)) { */ case 19:
- $r = p.error(colons[0], "2nd index required in 3-index slice"); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- index[1] = new ast.BadExpr.ptr(colons[0] + 1 >> 0, colons[1]);
- /* } */ case 20:
- /* */ if ($interfaceIsEqual(index[2], $ifaceNil)) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if ($interfaceIsEqual(index[2], $ifaceNil)) { */ case 22:
- $r = p.error(colons[1], "3rd index required in 3-index slice"); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- index[2] = new ast.BadExpr.ptr(colons[1] + 1 >> 0, rbrack);
- /* } */ case 23:
- /* } */ case 18:
- return new ast.SliceExpr.ptr(x, lbrack, index[0], index[1], index[2], slice3, rbrack);
- /* } */ case 16:
- return new ast.IndexExpr.ptr(x, lbrack, index[0], rbrack);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseIndexOrSlice }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.colons = colons; $f.index = index; $f.lbrack = lbrack; $f.ncolons = ncolons; $f.p = p; $f.rbrack = rbrack; $f.slice3 = slice3; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseIndexOrSlice = function(x) { return this.$val.parseIndexOrSlice(x); };
- parser.ptr.prototype.parseCallOrConversion = function(fun) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, ellipsis, fun, list, lparen, p, rparen, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; ellipsis = $f.ellipsis; fun = $f.fun; list = $f.list; lparen = $f.lparen; p = $f.p; rparen = $f.rparen; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "CallOrConversion"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(49); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lparen = _r$1;
- p.exprLev = p.exprLev + (1) >> 0;
- list = sliceType$8.nil;
- ellipsis = 0;
- /* while (true) { */ case 5:
- /* if (!(!((p.tok === 54)) && !((p.tok === 1)) && !new token.Pos(ellipsis).IsValid())) { break; } */ if(!(!((p.tok === 54)) && !((p.tok === 1)) && !new token.Pos(ellipsis).IsValid())) { $s = 6; continue; }
- _r$2 = p.parseRhsOrType(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = $append(list, _r$2);
- /* */ if (p.tok === 48) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (p.tok === 48) { */ case 8:
- ellipsis = p.pos;
- $r = p.next(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- _r$3 = p.atComma("argument list"); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!_r$3) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!_r$3) { */ case 11:
- /* break; */ $s = 6; continue;
- /* } */ case 12:
- $r = p.next(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 5; continue; case 6:
- p.exprLev = p.exprLev - (1) >> 0;
- _r$4 = p.expectClosing(54, "argument list"); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- rparen = _r$4;
- return new ast.CallExpr.ptr(fun, lparen, list, ellipsis, rparen);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$21.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseCallOrConversion }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.ellipsis = ellipsis; $f.fun = fun; $f.list = list; $f.lparen = lparen; $f.p = p; $f.rparen = rparen; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseCallOrConversion = function(fun) { return this.$val.parseCallOrConversion(fun); };
- parser.ptr.prototype.parseElement = function(keyOk) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, colon, keyOk, p, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; colon = $f.colon; keyOk = $f.keyOk; p = $f.p; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Element"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- /* */ if (p.tok === 51) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (p.tok === 51) { */ case 4:
- _r$1 = p.parseLiteralValue($ifaceNil); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 5:
- _r$2 = p.parseExpr(keyOk); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.checkExpr(_r$2); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- x = _r$3;
- /* */ if (keyOk) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (keyOk) { */ case 9:
- /* */ if (p.tok === 58) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (p.tok === 58) { */ case 11:
- colon = p.pos;
- $r = p.next(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.tryResolve(x, false);
- _r$4 = p.parseElement(false); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return new ast.KeyValueExpr.ptr(x, colon, _r$4);
- /* } */ case 12:
- p.resolve(x);
- /* } */ case 10:
- return x;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseElement }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.colon = colon; $f.keyOk = keyOk; $f.p = p; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseElement = function(keyOk) { return this.$val.parseElement(keyOk); };
- parser.ptr.prototype.parseElementList = function() {
- var $ptr, _r, _r$1, _r$2, list, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; list = $f.list; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- list = sliceType$8.nil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ElementList"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- /* while (true) { */ case 4:
- /* if (!(!((p.tok === 56)) && !((p.tok === 1)))) { break; } */ if(!(!((p.tok === 56)) && !((p.tok === 1)))) { $s = 5; continue; }
- _r$1 = p.parseElement(true); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- list = $append(list, _r$1);
- _r$2 = p.atComma("composite literal"); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!_r$2) { */ case 7:
- /* break; */ $s = 5; continue;
- /* } */ case 8:
- $r = p.next(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 4; continue; case 5:
- return list;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return list; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseElementList }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.list = list; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseElementList = function() { return this.$val.parseElementList(); };
- parser.ptr.prototype.parseLiteralValue = function(typ) {
- var $ptr, _r, _r$1, _r$2, _r$3, elts, lbrace, p, rbrace, typ, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; elts = $f.elts; lbrace = $f.lbrace; p = $f.p; rbrace = $f.rbrace; typ = $f.typ; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "LiteralValue"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(51); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lbrace = _r$1;
- elts = sliceType$8.nil;
- p.exprLev = p.exprLev + (1) >> 0;
- /* */ if (!((p.tok === 56))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((p.tok === 56))) { */ case 5:
- _r$2 = p.parseElementList(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- elts = _r$2;
- /* } */ case 6:
- p.exprLev = p.exprLev - (1) >> 0;
- _r$3 = p.expectClosing(56, "composite literal"); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rbrace = _r$3;
- return new ast.CompositeLit.ptr(typ, lbrace, elts, rbrace);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseLiteralValue }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.elts = elts; $f.lbrace = lbrace; $f.p = p; $f.rbrace = rbrace; $f.typ = typ; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseLiteralValue = function(typ) { return this.$val.parseLiteralValue(typ); };
- parser.ptr.prototype.checkExpr = function(x) {
- var $ptr, _r, _r$1, _r$2, _r$3, _ref, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = unparen(x);
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$22, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$23, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$24, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$25, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$26, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$27, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$28, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$15, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$29, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if ($assertType(_ref, ptrType$10, true)[1]) { */ case 1:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$11, true)[1]) { */ case 3:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$22, true)[1]) { */ case 4:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$23, true)[1]) { */ case 5:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$24, true)[1]) { */ case 6:
- $panic(new $String("unreachable"));
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$25, true)[1]) { */ case 7:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$26, true)[1]) { */ case 8:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$27, true)[1]) { */ case 9:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$28, true)[1]) { */ case 10:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$21, true)[1]) { */ case 11:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$15, true)[1]) { */ case 12:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$29, true)[1]) { */ case 13:
- $s = 16; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 14:
- $s = 16; continue;
- /* } else { */ case 15:
- _r = x.Pos(); /* */ $s = 17; case 17: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r, "expression"); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = x.Pos(); /* */ $s = 19; case 19: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = x.End(); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.safePos(_r$2); /* */ $s = 21; case 21: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- x = new ast.BadExpr.ptr(_r$1, _r$3);
- /* } */ case 16:
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.checkExpr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.checkExpr = function(x) { return this.$val.checkExpr(x); };
- isTypeName = function(x) {
- var $ptr, _ref, _tuple, isIdent, t, t$1, t$2, t$3, x;
- _ref = x;
- if ($assertType(_ref, ptrType$10, true)[1]) {
- t = _ref.$val;
- } else if ($assertType(_ref, ptrType$3, true)[1]) {
- t$1 = _ref.$val;
- } else if ($assertType(_ref, ptrType$25, true)[1]) {
- t$2 = _ref.$val;
- _tuple = $assertType(t$2.X, ptrType$3, true); isIdent = _tuple[1];
- return isIdent;
- } else {
- t$3 = _ref;
- return false;
- }
- return true;
- };
- isLiteralType = function(x) {
- var $ptr, _ref, _tuple, isIdent, t, t$1, t$2, t$3, t$4, t$5, t$6, x;
- _ref = x;
- if ($assertType(_ref, ptrType$10, true)[1]) {
- t = _ref.$val;
- } else if ($assertType(_ref, ptrType$3, true)[1]) {
- t$1 = _ref.$val;
- } else if ($assertType(_ref, ptrType$25, true)[1]) {
- t$2 = _ref.$val;
- _tuple = $assertType(t$2.X, ptrType$3, true); isIdent = _tuple[1];
- return isIdent;
- } else if ($assertType(_ref, ptrType$31, true)[1]) {
- t$3 = _ref.$val;
- } else if ($assertType(_ref, ptrType$14, true)[1]) {
- t$4 = _ref.$val;
- } else if ($assertType(_ref, ptrType$18, true)[1]) {
- t$5 = _ref.$val;
- } else {
- t$6 = _ref;
- return false;
- }
- return true;
- };
- deref = function(x) {
- var $ptr, _tuple, isPtr, p, x;
- _tuple = $assertType(x, ptrType$15, true); p = _tuple[0]; isPtr = _tuple[1];
- if (isPtr) {
- x = p.X;
- }
- return x;
- };
- unparen = function(x) {
- var $ptr, _tuple, isParen, p, x;
- _tuple = $assertType(x, ptrType$24, true); p = _tuple[0]; isParen = _tuple[1];
- if (isParen) {
- x = unparen(p.X);
- }
- return x;
- };
- parser.ptr.prototype.checkExprOrType = function(x) {
- var $ptr, _r, _r$1, _r$2, _ref, _tuple, isEllipsis, len, p, t, t$1, t$2, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; isEllipsis = $f.isEllipsis; len = $f.len; p = $f.p; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = unparen(x);
- /* */ if ($assertType(_ref, ptrType$24, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$29, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$31, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref, ptrType$24, true)[1]) { */ case 1:
- t = _ref.$val;
- $panic(new $String("unreachable"));
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$29, true)[1]) { */ case 2:
- t$1 = _ref.$val;
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$31, true)[1]) { */ case 3:
- t$2 = _ref.$val;
- _tuple = $assertType(t$2.Len, ptrType$32, true); len = _tuple[0]; isEllipsis = _tuple[1];
- /* */ if (isEllipsis) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (isEllipsis) { */ case 5:
- $r = p.error(len.Pos(), "expected array length, found '...'"); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = x.Pos(); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = x.End(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.safePos(_r$1); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- x = new ast.BadExpr.ptr(_r, _r$2);
- /* } */ case 6:
- /* } */ case 4:
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.checkExprOrType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f.isEllipsis = isEllipsis; $f.len = len; $f.p = p; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.checkExprOrType = function(x) { return this.$val.checkExprOrType(x); };
- parser.ptr.prototype.parsePrimaryExpr = function(lhs) {
- var $ptr, _r, _r$1, _r$10, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, lhs, p, pos, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; lhs = $f.lhs; p = $f.p; pos = $f.pos; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "PrimaryExpr"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseOperand(lhs); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- /* while (true) { */ case 5:
- _ref = p.tok;
- /* */ if (_ref === 53) { $s = 7; continue; }
- /* */ if (_ref === 50) { $s = 8; continue; }
- /* */ if (_ref === 49) { $s = 9; continue; }
- /* */ if (_ref === 51) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_ref === 53) { */ case 7:
- $r = p.next(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (lhs) {
- p.resolve(x);
- }
- _ref$1 = p.tok;
- /* */ if (_ref$1 === 4) { $s = 14; continue; }
- /* */ if (_ref$1 === 49) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_ref$1 === 4) { */ case 14:
- _r$2 = p.checkExprOrType(x); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.parseSelector(_r$2); /* */ $s = 19; case 19: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- x = _r$3;
- $s = 17; continue;
- /* } else if (_ref$1 === 49) { */ case 15:
- _r$4 = p.checkExpr(x); /* */ $s = 20; case 20: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.parseTypeAssertion(_r$4); /* */ $s = 21; case 21: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- x = _r$5;
- $s = 17; continue;
- /* } else { */ case 16:
- pos = p.pos;
- $r = p.errorExpected(pos, "selector or type assertion"); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.next(); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x = new ast.BadExpr.ptr(pos, p.pos);
- /* } */ case 17:
- $s = 12; continue;
- /* } else if (_ref === 50) { */ case 8:
- if (lhs) {
- p.resolve(x);
- }
- _r$6 = p.checkExpr(x); /* */ $s = 24; case 24: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = p.parseIndexOrSlice(_r$6); /* */ $s = 25; case 25: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- x = _r$7;
- $s = 12; continue;
- /* } else if (_ref === 49) { */ case 9:
- if (lhs) {
- p.resolve(x);
- }
- _r$8 = p.checkExprOrType(x); /* */ $s = 26; case 26: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = p.parseCallOrConversion(_r$8); /* */ $s = 27; case 27: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- x = _r$9;
- $s = 12; continue;
- /* } else if (_ref === 51) { */ case 10:
- /* */ if (isLiteralType(x) && (p.exprLev >= 0 || !isTypeName(x))) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (isLiteralType(x) && (p.exprLev >= 0 || !isTypeName(x))) { */ case 28:
- if (lhs) {
- p.resolve(x);
- }
- _r$10 = p.parseLiteralValue(x); /* */ $s = 31; case 31: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- x = _r$10;
- $s = 30; continue;
- /* } else { */ case 29:
- /* break L; */ $s = 6; continue s;
- /* } */ case 30:
- $s = 12; continue;
- /* } else { */ case 11:
- /* break L; */ $s = 6; continue s;
- /* } */ case 12:
- lhs = false;
- /* } */ $s = 5; continue; case 6:
- return x;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parsePrimaryExpr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f.lhs = lhs; $f.p = p; $f.pos = pos; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parsePrimaryExpr = function(lhs) { return this.$val.parsePrimaryExpr(lhs); };
- parser.ptr.prototype.parseUnaryExpr = function(lhs) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tuple, _tuple$1, arrow, dir, lhs, ok, op, p, pos, pos$1, typ, x, x$1, x$2, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; arrow = $f.arrow; dir = $f.dir; lhs = $f.lhs; ok = $f.ok; op = $f.op; p = $f.p; pos = $f.pos; pos$1 = $f.pos$1; typ = $f.typ; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "UnaryExpr"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _ref = p.tok;
- /* */ if (_ref === 12 || _ref === 13 || _ref === 43 || _ref === 19 || _ref === 17) { $s = 4; continue; }
- /* */ if (_ref === 36) { $s = 5; continue; }
- /* */ if (_ref === 14) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 12 || _ref === 13 || _ref === 43 || _ref === 19 || _ref === 17) { */ case 4:
- _tmp = p.pos; _tmp$1 = p.tok; pos = _tmp; op = _tmp$1;
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = p.parseUnaryExpr(false); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- _r$2 = p.checkExpr(x); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return new ast.UnaryExpr.ptr(pos, op, _r$2);
- $s = 7; continue;
- /* } else if (_ref === 36) { */ case 5:
- arrow = p.pos;
- $r = p.next(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = p.parseUnaryExpr(false); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- x$1 = _r$3;
- _tuple = $assertType(x$1, ptrType$19, true); typ = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (ok) { */ case 13:
- dir = 1;
- /* while (true) { */ case 15:
- /* if (!(ok && (dir === 1))) { break; } */ if(!(ok && (dir === 1))) { $s = 16; continue; }
- /* */ if (typ.Dir === 2) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (typ.Dir === 2) { */ case 17:
- $r = p.errorExpected(typ.Arrow, "'chan'"); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- _tmp$2 = typ.Arrow; _tmp$3 = arrow; _tmp$4 = arrow; arrow = _tmp$2; typ.Begin = _tmp$3; typ.Arrow = _tmp$4;
- _tmp$5 = typ.Dir; _tmp$6 = 2; dir = _tmp$5; typ.Dir = _tmp$6;
- _tuple$1 = $assertType(typ.Value, ptrType$19, true); typ = _tuple$1[0]; ok = _tuple$1[1];
- /* } */ $s = 15; continue; case 16:
- /* */ if (dir === 1) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (dir === 1) { */ case 20:
- $r = p.errorExpected(arrow, "channel type"); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 21:
- return x$1;
- /* } */ case 14:
- _r$4 = p.checkExpr(x$1); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return new ast.UnaryExpr.ptr(arrow, 36, _r$4);
- $s = 7; continue;
- /* } else if (_ref === 14) { */ case 6:
- pos$1 = p.pos;
- $r = p.next(); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$5 = p.parseUnaryExpr(false); /* */ $s = 25; case 25: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- x$2 = _r$5;
- _r$6 = p.checkExprOrType(x$2); /* */ $s = 26; case 26: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return new ast.StarExpr.ptr(pos$1, _r$6);
- /* } */ case 7:
- _r$7 = p.parsePrimaryExpr(lhs); /* */ $s = 27; case 27: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseUnaryExpr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.arrow = arrow; $f.dir = dir; $f.lhs = lhs; $f.ok = ok; $f.op = op; $f.p = p; $f.pos = pos; $f.pos$1 = pos$1; $f.typ = typ; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseUnaryExpr = function(lhs) { return this.$val.parseUnaryExpr(lhs); };
- parser.ptr.prototype.tokPrec = function() {
- var $ptr, p, tok;
- p = this;
- tok = p.tok;
- if (p.inRhs && (tok === 42)) {
- tok = 39;
- }
- return [tok, new token.Token(tok).Precedence()];
- };
- parser.prototype.tokPrec = function() { return this.$val.tokPrec(); };
- parser.ptr.prototype.parseBinaryExpr = function(lhs, prec1) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tuple, _tuple$1, lhs, op, oprec, p, pos, prec, prec1, x, y, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; lhs = $f.lhs; op = $f.op; oprec = $f.oprec; p = $f.p; pos = $f.pos; prec = $f.prec; prec1 = $f.prec1; x = $f.x; y = $f.y; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "BinaryExpr"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseUnaryExpr(lhs); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- _tuple = p.tokPrec(); prec = _tuple[1];
- /* while (true) { */ case 5:
- /* if (!(prec >= prec1)) { break; } */ if(!(prec >= prec1)) { $s = 6; continue; }
- /* while (true) { */ case 7:
- _tuple$1 = p.tokPrec(); op = _tuple$1[0]; oprec = _tuple$1[1];
- if (!((oprec === prec))) {
- /* break; */ $s = 8; continue;
- }
- _r$2 = p.expect(op); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- pos = _r$2;
- if (lhs) {
- p.resolve(x);
- lhs = false;
- }
- _r$3 = p.parseBinaryExpr(false, prec + 1 >> 0); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- y = _r$3;
- _r$4 = p.checkExpr(x); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.checkExpr(y); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- x = new ast.BinaryExpr.ptr(_r$4, pos, op, _r$5);
- /* } */ $s = 7; continue; case 8:
- prec = prec - (1) >> 0;
- /* } */ $s = 5; continue; case 6:
- return x;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseBinaryExpr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.lhs = lhs; $f.op = op; $f.oprec = oprec; $f.p = p; $f.pos = pos; $f.prec = prec; $f.prec1 = prec1; $f.x = x; $f.y = y; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseBinaryExpr = function(lhs, prec1) { return this.$val.parseBinaryExpr(lhs, prec1); };
- parser.ptr.prototype.parseExpr = function(lhs) {
- var $ptr, _r, _r$1, lhs, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; lhs = $f.lhs; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Expression"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseBinaryExpr(lhs, 1); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseExpr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.lhs = lhs; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseExpr = function(lhs) { return this.$val.parseExpr(lhs); };
- parser.ptr.prototype.parseRhs = function() {
- var $ptr, _r, _r$1, old, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; old = $f.old; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- old = p.inRhs;
- p.inRhs = true;
- _r = p.parseExpr(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.checkExpr(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- p.inRhs = old;
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseRhs }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.old = old; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.parseRhs = function() { return this.$val.parseRhs(); };
- parser.ptr.prototype.parseRhsOrType = function() {
- var $ptr, _r, _r$1, old, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; old = $f.old; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- old = p.inRhs;
- p.inRhs = true;
- _r = p.parseExpr(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.checkExprOrType(_r); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- p.inRhs = old;
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseRhsOrType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.old = old; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.parseRhsOrType = function() { return this.$val.parseRhsOrType(); };
- parser.ptr.prototype.parseSimpleStmt = function(mode) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, _tmp, _tmp$1, _tuple, arrow, as, colon, isIdent, isRange, label, mode, p, pos, pos$1, s, stmt, tok, x, y, y$1, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; arrow = $f.arrow; as = $f.as; colon = $f.colon; isIdent = $f.isIdent; isRange = $f.isRange; label = $f.label; mode = $f.mode; p = $f.p; pos = $f.pos; pos$1 = $f.pos$1; s = $f.s; stmt = $f.stmt; tok = $f.tok; x = $f.x; y = $f.y; y$1 = $f.y$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "SimpleStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseLhsList(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- x = _r$1;
- _ref = p.tok;
- /* */ if (_ref === 47 || _ref === 42 || _ref === 23 || _ref === 24 || _ref === 25 || _ref === 26 || _ref === 27 || _ref === 28 || _ref === 29 || _ref === 30 || _ref === 31 || _ref === 32 || _ref === 33) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref === 47 || _ref === 42 || _ref === 23 || _ref === 24 || _ref === 25 || _ref === 26 || _ref === 27 || _ref === 28 || _ref === 29 || _ref === 30 || _ref === 31 || _ref === 32 || _ref === 33) { */ case 5:
- _tmp = p.pos; _tmp$1 = p.tok; pos = _tmp; tok = _tmp$1;
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- y = sliceType$8.nil;
- isRange = false;
- /* */ if ((mode === 2) && (p.tok === 79) && ((tok === 47) || (tok === 42))) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ((mode === 2) && (p.tok === 79) && ((tok === 47) || (tok === 42))) { */ case 8:
- pos$1 = p.pos;
- $r = p.next(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = p.parseRhs(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- y = new sliceType$8([new ast.UnaryExpr.ptr(pos$1, 79, _r$2)]);
- isRange = true;
- $s = 10; continue;
- /* } else { */ case 9:
- _r$3 = p.parseRhsList(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- y = _r$3;
- /* } */ case 10:
- as = new ast.AssignStmt.ptr(x, pos, tok, y);
- /* */ if (tok === 47) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (tok === 47) { */ case 14:
- $r = p.shortVarDecl(as, x); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- return [as, isRange];
- /* } */ case 6:
- /* */ if (x.$length > 1) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (x.$length > 1) { */ case 17:
- _r$4 = (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]).Pos(); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r$4, "1 expression"); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- _ref$1 = p.tok;
- /* */ if (_ref$1 === 58) { $s = 21; continue; }
- /* */ if (_ref$1 === 36) { $s = 22; continue; }
- /* */ if (_ref$1 === 37 || _ref$1 === 38) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_ref$1 === 58) { */ case 21:
- colon = p.pos;
- $r = p.next(); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tuple = $assertType((0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]), ptrType$3, true); label = _tuple[0]; isIdent = _tuple[1];
- /* */ if ((mode === 1) && isIdent) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if ((mode === 1) && isIdent) { */ case 26:
- _r$5 = p.parseStmt(); /* */ $s = 28; case 28: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- stmt = new ast.LabeledStmt.ptr(label, colon, _r$5);
- $r = p.declare(stmt, $ifaceNil, p.labelScope, 6, new sliceType$3([label])); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [stmt, false];
- /* } */ case 27:
- $r = p.error(colon, "illegal label declaration"); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$6 = (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]).Pos(); /* */ $s = 31; case 31: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return [new ast.BadStmt.ptr(_r$6, colon + 1 >> 0), false];
- $s = 24; continue;
- /* } else if (_ref$1 === 36) { */ case 22:
- arrow = p.pos;
- $r = p.next(); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$7 = p.parseRhs(); /* */ $s = 33; case 33: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- y$1 = _r$7;
- return [new ast.SendStmt.ptr((0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]), arrow, y$1), false];
- $s = 24; continue;
- /* } else if (_ref$1 === 37 || _ref$1 === 38) { */ case 23:
- s = new ast.IncDecStmt.ptr((0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]), p.pos, p.tok);
- $r = p.next(); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [s, false];
- /* } */ case 24:
- return [new ast.ExprStmt.ptr((0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])), false];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return [$ifaceNil, false]; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseSimpleStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.arrow = arrow; $f.as = as; $f.colon = colon; $f.isIdent = isIdent; $f.isRange = isRange; $f.label = label; $f.mode = mode; $f.p = p; $f.pos = pos; $f.pos$1 = pos$1; $f.s = s; $f.stmt = stmt; $f.tok = tok; $f.x = x; $f.y = y; $f.y$1 = y$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseSimpleStmt = function(mode) { return this.$val.parseSimpleStmt(mode); };
- parser.ptr.prototype.parseCallExpr = function(callType) {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _tuple, _tuple$1, call, callType, isBad, isCall, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; call = $f.call; callType = $f.callType; isBad = $f.isBad; isCall = $f.isCall; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = p.parseRhsOrType(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- x = _r;
- _tuple = $assertType(x, ptrType$21, true); call = _tuple[0]; isCall = _tuple[1];
- if (isCall) {
- return call;
- }
- _tuple$1 = $assertType(x, ptrType$10, true); isBad = _tuple$1[1];
- /* */ if (!isBad) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!isBad) { */ case 2:
- _r$1 = x.End(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.safePos(_r$1); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg = _r$2;
- _r$3 = fmt.Sprintf("function must be invoked in %s statement", new sliceType$6([new $String(callType)])); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$1 = _r$3;
- $r = p.error(_arg, _arg$1); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- return ptrType$21.nil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseCallExpr }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.call = call; $f.callType = callType; $f.isBad = isBad; $f.isCall = isCall; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.parseCallExpr = function(callType) { return this.$val.parseCallExpr(callType); };
- parser.ptr.prototype.parseGoStmt = function() {
- var $ptr, _r, _r$1, _r$2, call, p, pos, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; call = $f.call; p = $f.p; pos = $f.pos; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "GoStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(72); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _r$2 = p.parseCallExpr("go"); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- call = _r$2;
- $r = p.expectSemi(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (call === ptrType$21.nil) {
- return new ast.BadStmt.ptr(pos, pos + 2 >> 0);
- }
- return new ast.GoStmt.ptr(pos, call);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseGoStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.call = call; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseGoStmt = function() { return this.$val.parseGoStmt(); };
- parser.ptr.prototype.parseDeferStmt = function() {
- var $ptr, _r, _r$1, _r$2, call, p, pos, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; call = $f.call; p = $f.p; pos = $f.pos; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "DeferStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(67); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _r$2 = p.parseCallExpr("defer"); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- call = _r$2;
- $r = p.expectSemi(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (call === ptrType$21.nil) {
- return new ast.BadStmt.ptr(pos, pos + 5 >> 0);
- }
- return new ast.DeferStmt.ptr(pos, call);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseDeferStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.call = call; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseDeferStmt = function() { return this.$val.parseDeferStmt(); };
- parser.ptr.prototype.parseReturnStmt = function() {
- var $ptr, _r, _r$1, _r$2, p, pos, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; p = $f.p; pos = $f.pos; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ReturnStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- pos = p.pos;
- _r$1 = p.expect(80); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- x = sliceType$8.nil;
- /* */ if (!((p.tok === 57)) && !((p.tok === 56))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((p.tok === 57)) && !((p.tok === 56))) { */ case 5:
- _r$2 = p.parseRhsList(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- x = _r$2;
- /* } */ case 6:
- $r = p.expectSemi(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new ast.ReturnStmt.ptr(pos, x);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$33.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseReturnStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.p = p; $f.pos = pos; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseReturnStmt = function() { return this.$val.parseReturnStmt(); };
- parser.ptr.prototype.parseBranchStmt = function(tok) {
- var $ptr, _r, _r$1, _r$2, label, n, p, pos, tok, x, x$1, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; label = $f.label; n = $f.n; p = $f.p; pos = $f.pos; tok = $f.tok; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "BranchStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(tok); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- label = ptrType$3.nil;
- /* */ if (!((tok === 69)) && (p.tok === 4)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((tok === 69)) && (p.tok === 4)) { */ case 5:
- _r$2 = p.parseIdent(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- label = _r$2;
- n = p.targetStack.$length - 1 >> 0;
- (x$1 = p.targetStack, ((n < 0 || n >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + n] = $append((x = p.targetStack, ((n < 0 || n >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + n])), label)));
- /* } */ case 6:
- $r = p.expectSemi(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new ast.BranchStmt.ptr(pos, tok, label);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$34.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseBranchStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.label = label; $f.n = n; $f.p = p; $f.pos = pos; $f.tok = tok; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseBranchStmt = function(tok) { return this.$val.parseBranchStmt(tok); };
- parser.ptr.prototype.makeExpr = function(s, kind) {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tuple, es, isExpr, kind, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; es = $f.es; isExpr = $f.isExpr; kind = $f.kind; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- if ($interfaceIsEqual(s, $ifaceNil)) {
- return $ifaceNil;
- }
- _tuple = $assertType(s, ptrType$35, true); es = _tuple[0]; isExpr = _tuple[1];
- /* */ if (isExpr) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (isExpr) { */ case 1:
- _r = p.checkExpr(es.X); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- _r$1 = s.Pos(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg = _r$1;
- _r$2 = fmt.Sprintf("expected %s, found simple statement (missing parentheses around composite literal?)", new sliceType$6([new $String(kind)])); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = _r$2;
- $r = p.error(_arg, _arg$1); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = s.Pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = s.End(); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.safePos(_r$4); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return new ast.BadExpr.ptr(_r$3, _r$5);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parser.ptr.prototype.makeExpr }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f.es = es; $f.isExpr = isExpr; $f.kind = kind; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- parser.prototype.makeExpr = function(s, kind) { return this.$val.makeExpr(s, kind); };
- parser.ptr.prototype.parseIfStmt = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, body, else_, p, pos, prevLev, s, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tuple = $f._tuple; body = $f.body; else_ = $f.else_; p = $f.p; pos = $f.pos; prevLev = $f.prevLev; s = $f.s; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "IfStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(74); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- p.openScope();
- $deferred.push([$methodVal(p, "closeScope"), []]);
- s = $ifaceNil;
- x = $ifaceNil;
- prevLev = p.exprLev;
- p.exprLev = -1;
- /* */ if (p.tok === 57) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (p.tok === 57) { */ case 5:
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = p.parseRhs(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- x = _r$2;
- $s = 7; continue;
- /* } else { */ case 6:
- _r$3 = p.parseSimpleStmt(0); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; s = _tuple[0];
- /* */ if (p.tok === 57) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (p.tok === 57) { */ case 11:
- $r = p.next(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$4 = p.parseRhs(); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- x = _r$4;
- $s = 13; continue;
- /* } else { */ case 12:
- _r$5 = p.makeExpr(s, "boolean expression"); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- x = _r$5;
- s = $ifaceNil;
- /* } */ case 13:
- /* } */ case 7:
- p.exprLev = prevLev;
- _r$6 = p.parseBlockStmt(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- body = _r$6;
- else_ = $ifaceNil;
- /* */ if (p.tok === 68) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (p.tok === 68) { */ case 18:
- $r = p.next(); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$7 = p.parseStmt(); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- else_ = _r$7;
- $s = 20; continue;
- /* } else { */ case 19:
- $r = p.expectSemi(); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- return new ast.IfStmt.ptr(pos, s, x, body, else_);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$36.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseIfStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tuple = _tuple; $f.body = body; $f.else_ = else_; $f.p = p; $f.pos = pos; $f.prevLev = prevLev; $f.s = s; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseIfStmt = function() { return this.$val.parseIfStmt(); };
- parser.ptr.prototype.parseTypeList = function() {
- var $ptr, _r, _r$1, _r$2, list, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; list = $f.list; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- list = sliceType$8.nil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "TypeList"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseType(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- list = $append(list, _r$1);
- /* while (true) { */ case 5:
- /* if (!(p.tok === 52)) { break; } */ if(!(p.tok === 52)) { $s = 6; continue; }
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = p.parseType(); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = $append(list, _r$2);
- /* } */ $s = 5; continue; case 6:
- return list;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return list; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseTypeList }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.list = list; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseTypeList = function() { return this.$val.parseTypeList(); };
- parser.ptr.prototype.parseCaseClause = function(typeSwitch) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, body, colon, list, p, pos, typeSwitch, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; body = $f.body; colon = $f.colon; list = $f.list; p = $f.p; pos = $f.pos; typeSwitch = $f.typeSwitch; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "CaseClause"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- pos = p.pos;
- list = sliceType$8.nil;
- /* */ if (p.tok === 62) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (p.tok === 62) { */ case 4:
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (typeSwitch) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (typeSwitch) { */ case 8:
- _r$1 = p.parseTypeList(); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- list = _r$1;
- $s = 10; continue;
- /* } else { */ case 9:
- _r$2 = p.parseRhsList(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = _r$2;
- /* } */ case 10:
- $s = 6; continue;
- /* } else { */ case 5:
- _r$3 = p.expect(66); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* } */ case 6:
- _r$4 = p.expect(58); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- colon = _r$4;
- p.openScope();
- _r$5 = p.parseStmtList(); /* */ $s = 15; case 15: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- body = _r$5;
- p.closeScope();
- return new ast.CaseClause.ptr(pos, list, colon, body);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$37.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseCaseClause }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.body = body; $f.colon = colon; $f.list = list; $f.p = p; $f.pos = pos; $f.typeSwitch = typeSwitch; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseCaseClause = function(typeSwitch) { return this.$val.parseCaseClause(typeSwitch); };
- isTypeSwitchAssert = function(x) {
- var $ptr, _tuple, a, ok, x;
- _tuple = $assertType(x, ptrType$28, true); a = _tuple[0]; ok = _tuple[1];
- return ok && $interfaceIsEqual(a.Type, $ifaceNil);
- };
- isTypeSwitchGuard = function(s) {
- var $ptr, _ref, s, t, t$1, x;
- _ref = s;
- if ($assertType(_ref, ptrType$35, true)[1]) {
- t = _ref.$val;
- return isTypeSwitchAssert(t.X);
- } else if ($assertType(_ref, ptrType$38, true)[1]) {
- t$1 = _ref.$val;
- return (t$1.Lhs.$length === 1) && (t$1.Tok === 47) && (t$1.Rhs.$length === 1) && isTypeSwitchAssert((x = t$1.Rhs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])));
- }
- return false;
- };
- parser.ptr.prototype.parseSwitchStmt = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tmp, _tmp$1, _tuple, _tuple$1, body, lbrace, list, p, pos, prevLev, rbrace, s1, s2, typeSwitch, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; body = $f.body; lbrace = $f.lbrace; list = $f.list; p = $f.p; pos = $f.pos; prevLev = $f.prevLev; rbrace = $f.rbrace; s1 = $f.s1; s2 = $f.s2; typeSwitch = $f.typeSwitch; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "SwitchStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(83); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- p.openScope();
- $deferred.push([$methodVal(p, "closeScope"), []]);
- _tmp = $ifaceNil; _tmp$1 = $ifaceNil; s1 = _tmp; s2 = _tmp$1;
- /* */ if (!((p.tok === 51))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((p.tok === 51))) { */ case 5:
- prevLev = p.exprLev;
- p.exprLev = -1;
- /* */ if (!((p.tok === 57))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!((p.tok === 57))) { */ case 7:
- _r$2 = p.parseSimpleStmt(0); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; s2 = _tuple[0];
- /* } */ case 8:
- /* */ if (p.tok === 57) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (p.tok === 57) { */ case 10:
- $r = p.next(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- s1 = s2;
- s2 = $ifaceNil;
- /* */ if (!((p.tok === 51))) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!((p.tok === 51))) { */ case 13:
- p.openScope();
- $deferred.push([$methodVal(p, "closeScope"), []]);
- _r$3 = p.parseSimpleStmt(0); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$1 = _r$3; s2 = _tuple$1[0];
- /* } */ case 14:
- /* } */ case 11:
- p.exprLev = prevLev;
- /* } */ case 6:
- typeSwitch = isTypeSwitchGuard(s2);
- _r$4 = p.expect(51); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- lbrace = _r$4;
- list = sliceType$10.nil;
- /* while (true) { */ case 17:
- /* if (!((p.tok === 62) || (p.tok === 66))) { break; } */ if(!((p.tok === 62) || (p.tok === 66))) { $s = 18; continue; }
- _r$5 = p.parseCaseClause(typeSwitch); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- list = $append(list, _r$5);
- /* } */ $s = 17; continue; case 18:
- _r$6 = p.expect(56); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- rbrace = _r$6;
- $r = p.expectSemi(); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- body = new ast.BlockStmt.ptr(lbrace, list, rbrace);
- if (typeSwitch) {
- return new ast.TypeSwitchStmt.ptr(pos, s1, s2, body);
- }
- _r$7 = p.makeExpr(s2, "switch expression"); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return new ast.SwitchStmt.ptr(pos, s1, _r$7, body);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseSwitchStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.body = body; $f.lbrace = lbrace; $f.list = list; $f.p = p; $f.pos = pos; $f.prevLev = prevLev; $f.rbrace = rbrace; $f.s1 = s1; $f.s2 = s2; $f.typeSwitch = typeSwitch; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseSwitchStmt = function() { return this.$val.parseSwitchStmt(); };
- parser.ptr.prototype.parseCommClause = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, arrow, as, body, colon, comm, lhs, p, pos, pos$1, rhs, rhs$1, tok, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; arrow = $f.arrow; as = $f.as; body = $f.body; colon = $f.colon; comm = $f.comm; lhs = $f.lhs; p = $f.p; pos = $f.pos; pos$1 = $f.pos$1; rhs = $f.rhs; rhs$1 = $f.rhs$1; tok = $f.tok; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "CommClause"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- p.openScope();
- pos = p.pos;
- comm = $ifaceNil;
- /* */ if (p.tok === 62) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (p.tok === 62) { */ case 4:
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = p.parseLhsList(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- lhs = _r$1;
- /* */ if (p.tok === 36) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (p.tok === 36) { */ case 9:
- /* */ if (lhs.$length > 1) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (lhs.$length > 1) { */ case 12:
- _r$2 = (0 >= lhs.$length ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + 0]).Pos(); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r$2, "1 expression"); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 13:
- arrow = p.pos;
- $r = p.next(); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = p.parseRhs(); /* */ $s = 17; case 17: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rhs = _r$3;
- comm = new ast.SendStmt.ptr((0 >= lhs.$length ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + 0]), arrow, rhs);
- $s = 11; continue;
- /* } else { */ case 10:
- tok = p.tok;
- /* */ if ((tok === 42) || (tok === 47)) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if ((tok === 42) || (tok === 47)) { */ case 18:
- /* */ if (lhs.$length > 2) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (lhs.$length > 2) { */ case 21:
- _r$4 = (0 >= lhs.$length ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + 0]).Pos(); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r$4, "1 or 2 expressions"); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- lhs = $subslice(lhs, 0, 2);
- /* } */ case 22:
- pos$1 = p.pos;
- $r = p.next(); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$5 = p.parseRhs(); /* */ $s = 26; case 26: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- rhs$1 = _r$5;
- as = new ast.AssignStmt.ptr(lhs, pos$1, tok, new sliceType$8([rhs$1]));
- /* */ if (tok === 47) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (tok === 47) { */ case 27:
- $r = p.shortVarDecl(as, lhs); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 28:
- comm = as;
- $s = 20; continue;
- /* } else { */ case 19:
- /* */ if (lhs.$length > 1) { $s = 30; continue; }
- /* */ $s = 31; continue;
- /* if (lhs.$length > 1) { */ case 30:
- _r$6 = (0 >= lhs.$length ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + 0]).Pos(); /* */ $s = 32; case 32: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r$6, "1 expression"); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 31:
- comm = new ast.ExprStmt.ptr((0 >= lhs.$length ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + 0]));
- /* } */ case 20:
- /* } */ case 11:
- $s = 6; continue;
- /* } else { */ case 5:
- _r$7 = p.expect(66); /* */ $s = 34; case 34: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$7;
- /* } */ case 6:
- _r$8 = p.expect(58); /* */ $s = 35; case 35: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- colon = _r$8;
- _r$9 = p.parseStmtList(); /* */ $s = 36; case 36: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- body = _r$9;
- p.closeScope();
- return new ast.CommClause.ptr(pos, comm, colon, body);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$39.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseCommClause }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f.arrow = arrow; $f.as = as; $f.body = body; $f.colon = colon; $f.comm = comm; $f.lhs = lhs; $f.p = p; $f.pos = pos; $f.pos$1 = pos$1; $f.rhs = rhs; $f.rhs$1 = rhs$1; $f.tok = tok; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseCommClause = function() { return this.$val.parseCommClause(); };
- parser.ptr.prototype.parseSelectStmt = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, body, lbrace, list, p, pos, rbrace, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; body = $f.body; lbrace = $f.lbrace; list = $f.list; p = $f.p; pos = $f.pos; rbrace = $f.rbrace; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "SelectStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(81); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _r$2 = p.expect(51); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- lbrace = _r$2;
- list = sliceType$10.nil;
- /* while (true) { */ case 6:
- /* if (!((p.tok === 62) || (p.tok === 66))) { break; } */ if(!((p.tok === 62) || (p.tok === 66))) { $s = 7; continue; }
- _r$3 = p.parseCommClause(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- list = $append(list, _r$3);
- /* } */ $s = 6; continue; case 7:
- _r$4 = p.expect(56); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- rbrace = _r$4;
- $r = p.expectSemi(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- body = new ast.BlockStmt.ptr(lbrace, list, rbrace);
- return new ast.SelectStmt.ptr(pos, body);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$40.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseSelectStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.body = body; $f.lbrace = lbrace; $f.list = list; $f.p = p; $f.pos = pos; $f.rbrace = rbrace; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseSelectStmt = function() { return this.$val.parseSelectStmt(); };
- parser.ptr.prototype.parseForStmt = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tuple, _tuple$1, _tuple$2, as, body, isRange, key, p, pos, pos$1, prevLev, s1, s2, s3, value, x, x$1, x$2, x$3, x$4, x$5, x$6, y, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; as = $f.as; body = $f.body; isRange = $f.isRange; key = $f.key; p = $f.p; pos = $f.pos; pos$1 = $f.pos$1; prevLev = $f.prevLev; s1 = $f.s1; s2 = $f.s2; s3 = $f.s3; value = $f.value; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; y = $f.y; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ForStmt"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.expect(70); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- p.openScope();
- $deferred.push([$methodVal(p, "closeScope"), []]);
- _tmp = $ifaceNil; _tmp$1 = $ifaceNil; _tmp$2 = $ifaceNil; s1 = _tmp; s2 = _tmp$1; s3 = _tmp$2;
- isRange = false;
- /* */ if (!((p.tok === 51))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!((p.tok === 51))) { */ case 5:
- prevLev = p.exprLev;
- p.exprLev = -1;
- /* */ if (!((p.tok === 57))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!((p.tok === 57))) { */ case 7:
- /* */ if (p.tok === 79) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (p.tok === 79) { */ case 9:
- pos$1 = p.pos;
- $r = p.next(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = p.parseRhs(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- y = new sliceType$8([new ast.UnaryExpr.ptr(pos$1, 79, _r$2)]);
- s2 = new ast.AssignStmt.ptr(sliceType$8.nil, 0, 0, y);
- isRange = true;
- $s = 11; continue;
- /* } else { */ case 10:
- _r$3 = p.parseSimpleStmt(2); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; s2 = _tuple[0]; isRange = _tuple[1];
- /* } */ case 11:
- /* } */ case 8:
- /* */ if (!isRange && (p.tok === 57)) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!isRange && (p.tok === 57)) { */ case 15:
- $r = p.next(); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- s1 = s2;
- s2 = $ifaceNil;
- /* */ if (!((p.tok === 57))) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!((p.tok === 57))) { */ case 18:
- _r$4 = p.parseSimpleStmt(0); /* */ $s = 20; case 20: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple$1 = _r$4; s2 = _tuple$1[0];
- /* } */ case 19:
- $r = p.expectSemi(); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!((p.tok === 51))) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (!((p.tok === 51))) { */ case 22:
- _r$5 = p.parseSimpleStmt(0); /* */ $s = 24; case 24: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _tuple$2 = _r$5; s3 = _tuple$2[0];
- /* } */ case 23:
- /* } */ case 16:
- p.exprLev = prevLev;
- /* } */ case 6:
- _r$6 = p.parseBlockStmt(); /* */ $s = 25; case 25: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- body = _r$6;
- $r = p.expectSemi(); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (isRange) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (isRange) { */ case 27:
- as = $assertType(s2, ptrType$38);
- _tmp$3 = $ifaceNil; _tmp$4 = $ifaceNil; key = _tmp$3; value = _tmp$4;
- _ref = as.Lhs.$length;
- /* */ if (_ref === 0) { $s = 29; continue; }
- /* */ if (_ref === 1) { $s = 30; continue; }
- /* */ if (_ref === 2) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (_ref === 0) { */ case 29:
- $s = 33; continue;
- /* } else if (_ref === 1) { */ case 30:
- key = (x = as.Lhs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]));
- $s = 33; continue;
- /* } else if (_ref === 2) { */ case 31:
- _tmp$5 = (x$1 = as.Lhs, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])); _tmp$6 = (x$2 = as.Lhs, (1 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 1])); key = _tmp$5; value = _tmp$6;
- $s = 33; continue;
- /* } else { */ case 32:
- _r$7 = (x$3 = as.Lhs, x$4 = as.Lhs.$length - 1 >> 0, ((x$4 < 0 || x$4 >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + x$4])).Pos(); /* */ $s = 34; case 34: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $r = p.errorExpected(_r$7, "at most 2 expressions"); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new ast.BadStmt.ptr(pos, p.safePos(body.End()));
- /* } */ case 33:
- x$6 = $assertType((x$5 = as.Rhs, (0 >= x$5.$length ? $throwRuntimeError("index out of range") : x$5.$array[x$5.$offset + 0])), ptrType$29).X;
- return new ast.RangeStmt.ptr(pos, key, value, as.TokPos, as.Tok, x$6, body);
- /* } */ case 28:
- _r$8 = p.makeExpr(s2, "boolean or range expression"); /* */ $s = 36; case 36: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- return new ast.ForStmt.ptr(pos, s1, _r$8, s3, body);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseForStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.as = as; $f.body = body; $f.isRange = isRange; $f.key = key; $f.p = p; $f.pos = pos; $f.pos$1 = pos$1; $f.prevLev = prevLev; $f.s1 = s1; $f.s2 = s2; $f.s3 = s3; $f.value = value; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.y = y; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseForStmt = function() { return this.$val.parseForStmt(); };
- parser.ptr.prototype.parseStmt = function() {
- var $ptr, _r, _r$1, _r$10, _r$11, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, _tuple$1, isLabeledStmt, p, pos, s, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; isLabeledStmt = $f.isLabeledStmt; p = $f.p; pos = $f.pos; s = $f.s; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- s = $ifaceNil;
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Statement"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _ref = p.tok;
- /* */ if (_ref === 64 || _ref === 84 || _ref === 85) { $s = 4; continue; }
- /* */ if (_ref === 4 || _ref === 5 || _ref === 6 || _ref === 7 || _ref === 8 || _ref === 9 || _ref === 71 || _ref === 49 || _ref === 50 || _ref === 82 || _ref === 12 || _ref === 13 || _ref === 14 || _ref === 17 || _ref === 19 || _ref === 36 || _ref === 43) { $s = 5; continue; }
- /* */ if (_ref === 72) { $s = 6; continue; }
- /* */ if (_ref === 67) { $s = 7; continue; }
- /* */ if (_ref === 80) { $s = 8; continue; }
- /* */ if (_ref === 61 || _ref === 65 || _ref === 73 || _ref === 69) { $s = 9; continue; }
- /* */ if (_ref === 51) { $s = 10; continue; }
- /* */ if (_ref === 74) { $s = 11; continue; }
- /* */ if (_ref === 83) { $s = 12; continue; }
- /* */ if (_ref === 81) { $s = 13; continue; }
- /* */ if (_ref === 70) { $s = 14; continue; }
- /* */ if (_ref === 57) { $s = 15; continue; }
- /* */ if (_ref === 56) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (_ref === 64 || _ref === 84 || _ref === 85) { */ case 4:
- _r$1 = p.parseDecl(syncStmt); /* */ $s = 19; case 19: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- s = new ast.DeclStmt.ptr(_r$1);
- $s = 18; continue;
- /* } else if (_ref === 4 || _ref === 5 || _ref === 6 || _ref === 7 || _ref === 8 || _ref === 9 || _ref === 71 || _ref === 49 || _ref === 50 || _ref === 82 || _ref === 12 || _ref === 13 || _ref === 14 || _ref === 17 || _ref === 19 || _ref === 36 || _ref === 43) { */ case 5:
- _r$2 = p.parseSimpleStmt(1); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; s = _tuple[0];
- _tuple$1 = $assertType(s, ptrType$41, true); isLabeledStmt = _tuple$1[1];
- /* */ if (!isLabeledStmt) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (!isLabeledStmt) { */ case 21:
- $r = p.expectSemi(); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 22:
- $s = 18; continue;
- /* } else if (_ref === 72) { */ case 6:
- _r$3 = p.parseGoStmt(); /* */ $s = 24; case 24: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- s = _r$3;
- $s = 18; continue;
- /* } else if (_ref === 67) { */ case 7:
- _r$4 = p.parseDeferStmt(); /* */ $s = 25; case 25: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- s = _r$4;
- $s = 18; continue;
- /* } else if (_ref === 80) { */ case 8:
- _r$5 = p.parseReturnStmt(); /* */ $s = 26; case 26: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- s = _r$5;
- $s = 18; continue;
- /* } else if (_ref === 61 || _ref === 65 || _ref === 73 || _ref === 69) { */ case 9:
- _r$6 = p.parseBranchStmt(p.tok); /* */ $s = 27; case 27: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- s = _r$6;
- $s = 18; continue;
- /* } else if (_ref === 51) { */ case 10:
- _r$7 = p.parseBlockStmt(); /* */ $s = 28; case 28: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- s = _r$7;
- $r = p.expectSemi(); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if (_ref === 74) { */ case 11:
- _r$8 = p.parseIfStmt(); /* */ $s = 30; case 30: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- s = _r$8;
- $s = 18; continue;
- /* } else if (_ref === 83) { */ case 12:
- _r$9 = p.parseSwitchStmt(); /* */ $s = 31; case 31: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- s = _r$9;
- $s = 18; continue;
- /* } else if (_ref === 81) { */ case 13:
- _r$10 = p.parseSelectStmt(); /* */ $s = 32; case 32: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- s = _r$10;
- $s = 18; continue;
- /* } else if (_ref === 70) { */ case 14:
- _r$11 = p.parseForStmt(); /* */ $s = 33; case 33: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- s = _r$11;
- $s = 18; continue;
- /* } else if (_ref === 57) { */ case 15:
- s = new ast.EmptyStmt.ptr(p.pos);
- $r = p.next(); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if (_ref === 56) { */ case 16:
- s = new ast.EmptyStmt.ptr(p.pos);
- $s = 18; continue;
- /* } else { */ case 17:
- pos = p.pos;
- $r = p.errorExpected(pos, "statement"); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = syncStmt(p); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- s = new ast.BadStmt.ptr(pos, p.pos);
- /* } */ case 18:
- return s;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return s; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseStmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.isLabeledStmt = isLabeledStmt; $f.p = p; $f.pos = pos; $f.s = s; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseStmt = function() { return this.$val.parseStmt(); };
- isValidImport = function(lit) {
- var $ptr, _i, _ref, _rune, _tuple, lit, r, s;
- _tuple = strconv.Unquote(lit); s = _tuple[0];
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- r = _rune[0];
- if (!unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune("!\"#$%&'()*,:;<=>?[\\]^{|}`\xEF\xBF\xBD", r)) {
- return false;
- }
- _i += _rune[1];
- }
- return !(s === "");
- };
- parser.ptr.prototype.parseImportSpec = function(doc, param, param$1) {
- var $ptr, _r, _r$1, _r$2, _ref, doc, ident, p, param, param$1, path, pos, spec, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; doc = $f.doc; ident = $f.ident; p = $f.p; param = $f.param; param$1 = $f.param$1; path = $f.path; pos = $f.pos; spec = $f.spec; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "ImportSpec"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- ident = ptrType$3.nil;
- _ref = p.tok;
- /* */ if (_ref === 53) { $s = 4; continue; }
- /* */ if (_ref === 4) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref === 53) { */ case 4:
- ident = new ast.Ident.ptr(p.pos, ".", ptrType$8.nil);
- $r = p.next(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if (_ref === 4) { */ case 5:
- _r$1 = p.parseIdent(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ident = _r$1;
- /* } */ case 6:
- pos = p.pos;
- path = "";
- /* */ if (p.tok === 9) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (p.tok === 9) { */ case 9:
- path = p.lit;
- /* */ if (!isValidImport(path)) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (!isValidImport(path)) { */ case 12:
- $r = p.error(pos, "invalid import path: " + path); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 13:
- $r = p.next(); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 11; continue;
- /* } else { */ case 10:
- _r$2 = p.expect(9); /* */ $s = 16; case 16: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* } */ case 11:
- $r = p.expectSemi(); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- spec = new ast.ImportSpec.ptr(doc, ident, new ast.BasicLit.ptr(pos, 9, path), p.lineComment, 0);
- p.imports = $append(p.imports, spec);
- return spec;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseImportSpec }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.doc = doc; $f.ident = ident; $f.p = p; $f.param = param; $f.param$1 = param$1; $f.path = path; $f.pos = pos; $f.spec = spec; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseImportSpec = function(doc, param, param$1) { return this.$val.parseImportSpec(doc, param, param$1); };
- parser.ptr.prototype.parseValueSpec = function(doc, keyword, iota) {
- var $ptr, _r, _r$1, _r$2, _r$3, doc, idents, iota, keyword, kind, p, spec, typ, values, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; doc = $f.doc; idents = $f.idents; iota = $f.iota; keyword = $f.keyword; kind = $f.kind; p = $f.p; spec = $f.spec; typ = $f.typ; values = $f.values; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, new token.Token(keyword).String() + "Spec"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseIdentList(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- idents = _r$1;
- _r$2 = p.tryType(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- typ = _r$2;
- values = sliceType$8.nil;
- /* */ if (p.tok === 42) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (p.tok === 42) { */ case 6:
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = p.parseRhsList(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- values = _r$3;
- /* } */ case 7:
- $r = p.expectSemi(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- spec = new ast.ValueSpec.ptr(doc, idents, typ, values, p.lineComment);
- kind = 2;
- if (keyword === 85) {
- kind = 4;
- }
- $r = p.declare(spec, new $Int(iota), p.topScope, kind, idents); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return spec;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseValueSpec }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.doc = doc; $f.idents = idents; $f.iota = iota; $f.keyword = keyword; $f.kind = kind; $f.p = p; $f.spec = spec; $f.typ = typ; $f.values = values; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseValueSpec = function(doc, keyword, iota) { return this.$val.parseValueSpec(doc, keyword, iota); };
- parser.ptr.prototype.parseTypeSpec = function(doc, param, param$1) {
- var $ptr, _r, _r$1, _r$2, doc, ident, p, param, param$1, spec, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; doc = $f.doc; ident = $f.ident; p = $f.p; param = $f.param; param$1 = $f.param$1; spec = $f.spec; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "TypeSpec"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- _r$1 = p.parseIdent(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ident = _r$1;
- spec = new ast.TypeSpec.ptr(doc, ident, $ifaceNil, ptrType$2.nil);
- $r = p.declare(spec, $ifaceNil, p.topScope, 3, new sliceType$3([ident])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = p.parseType(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- spec.Type = _r$2;
- $r = p.expectSemi(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- spec.Comment = p.lineComment;
- return spec;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseTypeSpec }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.doc = doc; $f.ident = ident; $f.p = p; $f.param = param; $f.param$1 = param$1; $f.spec = spec; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseTypeSpec = function(doc, param, param$1) { return this.$val.parseTypeSpec(doc, param, param$1); };
- parser.ptr.prototype.parseGenDecl = function(keyword, f) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _tmp, _tmp$1, doc, f, iota, keyword, list, lparen, p, pos, rparen, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; doc = $f.doc; f = $f.f; iota = $f.iota; keyword = $f.keyword; list = $f.list; lparen = $f.lparen; p = $f.p; pos = $f.pos; rparen = $f.rparen; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "GenDecl(" + new token.Token(keyword).String() + ")"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- doc = p.leadComment;
- _r$1 = p.expect(keyword); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _tmp = 0; _tmp$1 = 0; lparen = _tmp; rparen = _tmp$1;
- list = sliceType$11.nil;
- /* */ if (p.tok === 49) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (p.tok === 49) { */ case 5:
- lparen = p.pos;
- $r = p.next(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- iota = 0;
- /* while (true) { */ case 9:
- /* if (!(!((p.tok === 54)) && !((p.tok === 1)))) { break; } */ if(!(!((p.tok === 54)) && !((p.tok === 1)))) { $s = 10; continue; }
- _r$2 = f(p.leadComment, keyword, iota); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- list = $append(list, _r$2);
- iota = iota + (1) >> 0;
- /* } */ $s = 9; continue; case 10:
- _r$3 = p.expect(54); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- rparen = _r$3;
- $r = p.expectSemi(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 7; continue;
- /* } else { */ case 6:
- _r$4 = f(ptrType$2.nil, keyword, 0); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- list = $append(list, _r$4);
- /* } */ case 7:
- return new ast.GenDecl.ptr(doc, pos, keyword, lparen, list, rparen);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$42.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseGenDecl }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.doc = doc; $f.f = f; $f.iota = iota; $f.keyword = keyword; $f.list = list; $f.lparen = lparen; $f.p = p; $f.pos = pos; $f.rparen = rparen; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseGenDecl = function(keyword, f) { return this.$val.parseGenDecl(keyword, f); };
- parser.ptr.prototype.parseFuncDecl = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tuple, body, decl, doc, ident, p, params, pos, recv, results, scope, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; body = $f.body; decl = $f.decl; doc = $f.doc; ident = $f.ident; p = $f.p; params = $f.params; pos = $f.pos; recv = $f.recv; results = $f.results; scope = $f.scope; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "FunctionDecl"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- doc = p.leadComment;
- _r$1 = p.expect(71); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- scope = ast.NewScope(p.topScope);
- recv = ptrType$13.nil;
- /* */ if (p.tok === 49) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (p.tok === 49) { */ case 5:
- _r$2 = p.parseParameters(scope, false); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- recv = _r$2;
- /* } */ case 6:
- _r$3 = p.parseIdent(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- ident = _r$3;
- _r$4 = p.parseSignature(scope); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; params = _tuple[0]; results = _tuple[1];
- body = ptrType$20.nil;
- /* */ if (p.tok === 51) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (p.tok === 51) { */ case 10:
- _r$5 = p.parseBody(scope); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- body = _r$5;
- /* } */ case 11:
- $r = p.expectSemi(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- decl = new ast.FuncDecl.ptr(doc, recv, ident, new ast.FuncType.ptr(pos, params, results), body);
- /* */ if (recv === ptrType$13.nil) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (recv === ptrType$13.nil) { */ case 14:
- /* */ if (!(ident.Name === "init")) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (!(ident.Name === "init")) { */ case 16:
- $r = p.declare(decl, $ifaceNil, p.pkgScope, 5, new sliceType$3([ident])); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 17:
- /* } */ case 15:
- return decl;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$43.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseFuncDecl }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f.body = body; $f.decl = decl; $f.doc = doc; $f.ident = ident; $f.p = p; $f.params = params; $f.pos = pos; $f.recv = recv; $f.results = results; $f.scope = scope; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseFuncDecl = function() { return this.$val.parseFuncDecl(); };
- parser.ptr.prototype.parseDecl = function(sync) {
- var $ptr, _r, _r$1, _r$2, _ref, f, p, pos, sync, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; f = $f.f; p = $f.p; pos = $f.pos; sync = $f.sync; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "Declaration"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- f = $throwNilPointerError;
- _ref = p.tok;
- /* */ if (_ref === 64 || _ref === 85) { $s = 4; continue; }
- /* */ if (_ref === 84) { $s = 5; continue; }
- /* */ if (_ref === 71) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 64 || _ref === 85) { */ case 4:
- f = $methodVal(p, "parseValueSpec");
- $s = 8; continue;
- /* } else if (_ref === 84) { */ case 5:
- f = $methodVal(p, "parseTypeSpec");
- $s = 8; continue;
- /* } else if (_ref === 71) { */ case 6:
- _r$1 = p.parseFuncDecl(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 8; continue;
- /* } else { */ case 7:
- pos = p.pos;
- $r = p.errorExpected(pos, "declaration"); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync(p); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new ast.BadDecl.ptr(pos, p.pos);
- /* } */ case 8:
- _r$2 = p.parseGenDecl(p.tok, f); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return $ifaceNil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseDecl }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.f = f; $f.p = p; $f.pos = pos; $f.sync = sync; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseDecl = function(sync) { return this.$val.parseDecl(sync); };
- parser.ptr.prototype.parseFile = function() {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _ref, decls, doc, i, ident, ident$1, p, pos, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; decls = $f.decls; doc = $f.doc; i = $f.i; ident = $f.ident; ident$1 = $f.ident$1; p = $f.p; pos = $f.pos; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- /* */ if (p.trace) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.trace) { */ case 1:
- _r = trace(p, "File"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $deferred.push([un, [_r]]);
- /* } */ case 2:
- if (!((p.errors.Len() === 0))) {
- return ptrType$1.nil;
- }
- doc = p.leadComment;
- _r$1 = p.expect(78); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- _r$2 = p.parseIdent(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- ident = _r$2;
- /* */ if (ident.Name === "_" && !((((p.mode & 16) >>> 0) === 0))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (ident.Name === "_" && !((((p.mode & 16) >>> 0) === 0))) { */ case 6:
- $r = p.error(p.pos, "invalid package name _"); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- $r = p.expectSemi(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!((p.errors.Len() === 0))) {
- return ptrType$1.nil;
- }
- p.openScope();
- p.pkgScope = p.topScope;
- decls = sliceType$1.nil;
- /* */ if (((p.mode & 1) >>> 0) === 0) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (((p.mode & 1) >>> 0) === 0) { */ case 10:
- /* while (true) { */ case 12:
- /* if (!(p.tok === 75)) { break; } */ if(!(p.tok === 75)) { $s = 13; continue; }
- _r$3 = p.parseGenDecl(75, $methodVal(p, "parseImportSpec")); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- decls = $append(decls, _r$3);
- /* } */ $s = 12; continue; case 13:
- /* */ if (((p.mode & 2) >>> 0) === 0) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (((p.mode & 2) >>> 0) === 0) { */ case 15:
- /* while (true) { */ case 17:
- /* if (!(!((p.tok === 1)))) { break; } */ if(!(!((p.tok === 1)))) { $s = 18; continue; }
- _r$4 = p.parseDecl(syncDecl); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- decls = $append(decls, _r$4);
- /* } */ $s = 17; continue; case 18:
- /* } */ case 16:
- /* } */ case 11:
- p.closeScope();
- assert(p.topScope === ptrType$4.nil, "unbalanced scopes");
- assert(p.labelScope === ptrType$4.nil, "unbalanced label scopes");
- i = 0;
- _ref = p.unresolved;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- ident$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- assert(ident$1.Obj === unresolved, "object already resolved");
- ident$1.Obj = p.pkgScope.Lookup(ident$1.Name);
- if (ident$1.Obj === ptrType$8.nil) {
- (x = p.unresolved, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = ident$1));
- i = i + (1) >> 0;
- }
- _i++;
- }
- return new ast.File.ptr(doc, pos, ident, decls, p.pkgScope, p.imports, $subslice(p.unresolved, 0, i), p.comments);
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return ptrType$1.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: parser.ptr.prototype.parseFile }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.decls = decls; $f.doc = doc; $f.i = i; $f.ident = ident; $f.ident$1 = ident$1; $f.p = p; $f.pos = pos; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- parser.prototype.parseFile = function() { return this.$val.parseFile(); };
- ptrType$46.methods = [{prop: "init", name: "init", pkg: "go/parser", typ: $funcType([ptrType$45, $String, sliceType, Mode], [], false)}, {prop: "openScope", name: "openScope", pkg: "go/parser", typ: $funcType([], [], false)}, {prop: "closeScope", name: "closeScope", pkg: "go/parser", typ: $funcType([], [], false)}, {prop: "openLabelScope", name: "openLabelScope", pkg: "go/parser", typ: $funcType([], [], false)}, {prop: "closeLabelScope", name: "closeLabelScope", pkg: "go/parser", typ: $funcType([], [], false)}, {prop: "declare", name: "declare", pkg: "go/parser", typ: $funcType([$emptyInterface, $emptyInterface, ptrType$4, ast.ObjKind, sliceType$3], [], true)}, {prop: "shortVarDecl", name: "shortVarDecl", pkg: "go/parser", typ: $funcType([ptrType$38, sliceType$8], [], false)}, {prop: "tryResolve", name: "tryResolve", pkg: "go/parser", typ: $funcType([ast.Expr, $Bool], [], false)}, {prop: "resolve", name: "resolve", pkg: "go/parser", typ: $funcType([ast.Expr], [], false)}, {prop: "printTrace", name: "printTrace", pkg: "go/parser", typ: $funcType([sliceType$6], [], true)}, {prop: "next0", name: "next0", pkg: "go/parser", typ: $funcType([], [], false)}, {prop: "consumeComment", name: "consumeComment", pkg: "go/parser", typ: $funcType([], [ptrType$9, $Int], false)}, {prop: "consumeCommentGroup", name: "consumeCommentGroup", pkg: "go/parser", typ: $funcType([$Int], [ptrType$2, $Int], false)}, {prop: "next", name: "next", pkg: "go/parser", typ: $funcType([], [], false)}, {prop: "error", name: "error", pkg: "go/parser", typ: $funcType([token.Pos, $String], [], false)}, {prop: "errorExpected", name: "errorExpected", pkg: "go/parser", typ: $funcType([token.Pos, $String], [], false)}, {prop: "expect", name: "expect", pkg: "go/parser", typ: $funcType([token.Token], [token.Pos], false)}, {prop: "expectClosing", name: "expectClosing", pkg: "go/parser", typ: $funcType([token.Token, $String], [token.Pos], false)}, {prop: "expectSemi", name: "expectSemi", pkg: "go/parser", typ: $funcType([], [], false)}, {prop: "atComma", name: "atComma", pkg: "go/parser", typ: $funcType([$String], [$Bool], false)}, {prop: "safePos", name: "safePos", pkg: "go/parser", typ: $funcType([token.Pos], [token.Pos], false)}, {prop: "parseIdent", name: "parseIdent", pkg: "go/parser", typ: $funcType([], [ptrType$3], false)}, {prop: "parseIdentList", name: "parseIdentList", pkg: "go/parser", typ: $funcType([], [sliceType$3], false)}, {prop: "parseExprList", name: "parseExprList", pkg: "go/parser", typ: $funcType([$Bool], [sliceType$8], false)}, {prop: "parseLhsList", name: "parseLhsList", pkg: "go/parser", typ: $funcType([], [sliceType$8], false)}, {prop: "parseRhsList", name: "parseRhsList", pkg: "go/parser", typ: $funcType([], [sliceType$8], false)}, {prop: "parseType", name: "parseType", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "parseTypeName", name: "parseTypeName", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "parseArrayType", name: "parseArrayType", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "makeIdentList", name: "makeIdentList", pkg: "go/parser", typ: $funcType([sliceType$8], [sliceType$3], false)}, {prop: "parseFieldDecl", name: "parseFieldDecl", pkg: "go/parser", typ: $funcType([ptrType$4], [ptrType$12], false)}, {prop: "parseStructType", name: "parseStructType", pkg: "go/parser", typ: $funcType([], [ptrType$14], false)}, {prop: "parsePointerType", name: "parsePointerType", pkg: "go/parser", typ: $funcType([], [ptrType$15], false)}, {prop: "tryVarType", name: "tryVarType", pkg: "go/parser", typ: $funcType([$Bool], [ast.Expr], false)}, {prop: "parseVarType", name: "parseVarType", pkg: "go/parser", typ: $funcType([$Bool], [ast.Expr], false)}, {prop: "parseVarList", name: "parseVarList", pkg: "go/parser", typ: $funcType([$Bool], [sliceType$8, ast.Expr], false)}, {prop: "parseParameterList", name: "parseParameterList", pkg: "go/parser", typ: $funcType([ptrType$4, $Bool], [sliceType$9], false)}, {prop: "parseParameters", name: "parseParameters", pkg: "go/parser", typ: $funcType([ptrType$4, $Bool], [ptrType$13], false)}, {prop: "parseResult", name: "parseResult", pkg: "go/parser", typ: $funcType([ptrType$4], [ptrType$13], false)}, {prop: "parseSignature", name: "parseSignature", pkg: "go/parser", typ: $funcType([ptrType$4], [ptrType$13, ptrType$13], false)}, {prop: "parseFuncType", name: "parseFuncType", pkg: "go/parser", typ: $funcType([], [ptrType$16, ptrType$4], false)}, {prop: "parseMethodSpec", name: "parseMethodSpec", pkg: "go/parser", typ: $funcType([ptrType$4], [ptrType$12], false)}, {prop: "parseInterfaceType", name: "parseInterfaceType", pkg: "go/parser", typ: $funcType([], [ptrType$17], false)}, {prop: "parseMapType", name: "parseMapType", pkg: "go/parser", typ: $funcType([], [ptrType$18], false)}, {prop: "parseChanType", name: "parseChanType", pkg: "go/parser", typ: $funcType([], [ptrType$19], false)}, {prop: "tryIdentOrType", name: "tryIdentOrType", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "tryType", name: "tryType", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "parseStmtList", name: "parseStmtList", pkg: "go/parser", typ: $funcType([], [sliceType$10], false)}, {prop: "parseBody", name: "parseBody", pkg: "go/parser", typ: $funcType([ptrType$4], [ptrType$20], false)}, {prop: "parseBlockStmt", name: "parseBlockStmt", pkg: "go/parser", typ: $funcType([], [ptrType$20], false)}, {prop: "parseFuncTypeOrLit", name: "parseFuncTypeOrLit", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "parseOperand", name: "parseOperand", pkg: "go/parser", typ: $funcType([$Bool], [ast.Expr], false)}, {prop: "parseSelector", name: "parseSelector", pkg: "go/parser", typ: $funcType([ast.Expr], [ast.Expr], false)}, {prop: "parseTypeAssertion", name: "parseTypeAssertion", pkg: "go/parser", typ: $funcType([ast.Expr], [ast.Expr], false)}, {prop: "parseIndexOrSlice", name: "parseIndexOrSlice", pkg: "go/parser", typ: $funcType([ast.Expr], [ast.Expr], false)}, {prop: "parseCallOrConversion", name: "parseCallOrConversion", pkg: "go/parser", typ: $funcType([ast.Expr], [ptrType$21], false)}, {prop: "parseElement", name: "parseElement", pkg: "go/parser", typ: $funcType([$Bool], [ast.Expr], false)}, {prop: "parseElementList", name: "parseElementList", pkg: "go/parser", typ: $funcType([], [sliceType$8], false)}, {prop: "parseLiteralValue", name: "parseLiteralValue", pkg: "go/parser", typ: $funcType([ast.Expr], [ast.Expr], false)}, {prop: "checkExpr", name: "checkExpr", pkg: "go/parser", typ: $funcType([ast.Expr], [ast.Expr], false)}, {prop: "checkExprOrType", name: "checkExprOrType", pkg: "go/parser", typ: $funcType([ast.Expr], [ast.Expr], false)}, {prop: "parsePrimaryExpr", name: "parsePrimaryExpr", pkg: "go/parser", typ: $funcType([$Bool], [ast.Expr], false)}, {prop: "parseUnaryExpr", name: "parseUnaryExpr", pkg: "go/parser", typ: $funcType([$Bool], [ast.Expr], false)}, {prop: "tokPrec", name: "tokPrec", pkg: "go/parser", typ: $funcType([], [token.Token, $Int], false)}, {prop: "parseBinaryExpr", name: "parseBinaryExpr", pkg: "go/parser", typ: $funcType([$Bool, $Int], [ast.Expr], false)}, {prop: "parseExpr", name: "parseExpr", pkg: "go/parser", typ: $funcType([$Bool], [ast.Expr], false)}, {prop: "parseRhs", name: "parseRhs", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "parseRhsOrType", name: "parseRhsOrType", pkg: "go/parser", typ: $funcType([], [ast.Expr], false)}, {prop: "parseSimpleStmt", name: "parseSimpleStmt", pkg: "go/parser", typ: $funcType([$Int], [ast.Stmt, $Bool], false)}, {prop: "parseCallExpr", name: "parseCallExpr", pkg: "go/parser", typ: $funcType([$String], [ptrType$21], false)}, {prop: "parseGoStmt", name: "parseGoStmt", pkg: "go/parser", typ: $funcType([], [ast.Stmt], false)}, {prop: "parseDeferStmt", name: "parseDeferStmt", pkg: "go/parser", typ: $funcType([], [ast.Stmt], false)}, {prop: "parseReturnStmt", name: "parseReturnStmt", pkg: "go/parser", typ: $funcType([], [ptrType$33], false)}, {prop: "parseBranchStmt", name: "parseBranchStmt", pkg: "go/parser", typ: $funcType([token.Token], [ptrType$34], false)}, {prop: "makeExpr", name: "makeExpr", pkg: "go/parser", typ: $funcType([ast.Stmt, $String], [ast.Expr], false)}, {prop: "parseIfStmt", name: "parseIfStmt", pkg: "go/parser", typ: $funcType([], [ptrType$36], false)}, {prop: "parseTypeList", name: "parseTypeList", pkg: "go/parser", typ: $funcType([], [sliceType$8], false)}, {prop: "parseCaseClause", name: "parseCaseClause", pkg: "go/parser", typ: $funcType([$Bool], [ptrType$37], false)}, {prop: "parseSwitchStmt", name: "parseSwitchStmt", pkg: "go/parser", typ: $funcType([], [ast.Stmt], false)}, {prop: "parseCommClause", name: "parseCommClause", pkg: "go/parser", typ: $funcType([], [ptrType$39], false)}, {prop: "parseSelectStmt", name: "parseSelectStmt", pkg: "go/parser", typ: $funcType([], [ptrType$40], false)}, {prop: "parseForStmt", name: "parseForStmt", pkg: "go/parser", typ: $funcType([], [ast.Stmt], false)}, {prop: "parseStmt", name: "parseStmt", pkg: "go/parser", typ: $funcType([], [ast.Stmt], false)}, {prop: "parseImportSpec", name: "parseImportSpec", pkg: "go/parser", typ: $funcType([ptrType$2, token.Token, $Int], [ast.Spec], false)}, {prop: "parseValueSpec", name: "parseValueSpec", pkg: "go/parser", typ: $funcType([ptrType$2, token.Token, $Int], [ast.Spec], false)}, {prop: "parseTypeSpec", name: "parseTypeSpec", pkg: "go/parser", typ: $funcType([ptrType$2, token.Token, $Int], [ast.Spec], false)}, {prop: "parseGenDecl", name: "parseGenDecl", pkg: "go/parser", typ: $funcType([token.Token, parseSpecFunction], [ptrType$42], false)}, {prop: "parseFuncDecl", name: "parseFuncDecl", pkg: "go/parser", typ: $funcType([], [ptrType$43], false)}, {prop: "parseDecl", name: "parseDecl", pkg: "go/parser", typ: $funcType([funcType], [ast.Decl], false)}, {prop: "parseFile", name: "parseFile", pkg: "go/parser", typ: $funcType([], [ptrType$1], false)}];
- parser.init([{prop: "file", name: "file", pkg: "go/parser", typ: ptrType$44, tag: ""}, {prop: "errors", name: "errors", pkg: "go/parser", typ: scanner.ErrorList, tag: ""}, {prop: "scanner", name: "scanner", pkg: "go/parser", typ: scanner.Scanner, tag: ""}, {prop: "mode", name: "mode", pkg: "go/parser", typ: Mode, tag: ""}, {prop: "trace", name: "trace", pkg: "go/parser", typ: $Bool, tag: ""}, {prop: "indent", name: "indent", pkg: "go/parser", typ: $Int, tag: ""}, {prop: "comments", name: "comments", pkg: "go/parser", typ: sliceType$4, tag: ""}, {prop: "leadComment", name: "leadComment", pkg: "go/parser", typ: ptrType$2, tag: ""}, {prop: "lineComment", name: "lineComment", pkg: "go/parser", typ: ptrType$2, tag: ""}, {prop: "pos", name: "pos", pkg: "go/parser", typ: token.Pos, tag: ""}, {prop: "tok", name: "tok", pkg: "go/parser", typ: token.Token, tag: ""}, {prop: "lit", name: "lit", pkg: "go/parser", typ: $String, tag: ""}, {prop: "syncPos", name: "syncPos", pkg: "go/parser", typ: token.Pos, tag: ""}, {prop: "syncCnt", name: "syncCnt", pkg: "go/parser", typ: $Int, tag: ""}, {prop: "exprLev", name: "exprLev", pkg: "go/parser", typ: $Int, tag: ""}, {prop: "inRhs", name: "inRhs", pkg: "go/parser", typ: $Bool, tag: ""}, {prop: "pkgScope", name: "pkgScope", pkg: "go/parser", typ: ptrType$4, tag: ""}, {prop: "topScope", name: "topScope", pkg: "go/parser", typ: ptrType$4, tag: ""}, {prop: "unresolved", name: "unresolved", pkg: "go/parser", typ: sliceType$3, tag: ""}, {prop: "imports", name: "imports", pkg: "go/parser", typ: sliceType$2, tag: ""}, {prop: "labelScope", name: "labelScope", pkg: "go/parser", typ: ptrType$4, tag: ""}, {prop: "targetStack", name: "targetStack", pkg: "go/parser", typ: sliceType$12, tag: ""}]);
- bailout.init([]);
- parseSpecFunction.init([ptrType$2, token.Token, $Int], [ast.Spec], false);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = scanner.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ioutil.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = filepath.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- unresolved = new ast.Object.ptr();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["math/rand"] = (function() {
- var $pkg = {}, $init, nosync, math, testing, Source, Rand, lockedSource, rngSource, sliceType$1, ptrType$1, ptrType$2, arrayType, ptrType$3, ke, we, fe, kn, wn, fn, globalRand, rng_cooked, absInt32, NewSource, New, seedrand;
- nosync = $packages["github.com/gopherjs/gopherjs/nosync"];
- math = $packages["math"];
- testing = $packages["testing"];
- Source = $pkg.Source = $newType(8, $kindInterface, "rand.Source", "Source", "math/rand", null);
- Rand = $pkg.Rand = $newType(0, $kindStruct, "rand.Rand", "Rand", "math/rand", function(src_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.src = $ifaceNil;
- return;
- }
- this.src = src_;
- });
- lockedSource = $pkg.lockedSource = $newType(0, $kindStruct, "rand.lockedSource", "lockedSource", "math/rand", function(lk_, src_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.lk = new nosync.Mutex.ptr();
- this.src = $ifaceNil;
- return;
- }
- this.lk = lk_;
- this.src = src_;
- });
- rngSource = $pkg.rngSource = $newType(0, $kindStruct, "rand.rngSource", "rngSource", "math/rand", function(tap_, feed_, vec_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.tap = 0;
- this.feed = 0;
- this.vec = arrayType.zero();
- return;
- }
- this.tap = tap_;
- this.feed = feed_;
- this.vec = vec_;
- });
- sliceType$1 = $sliceType($Int);
- ptrType$1 = $ptrType(Rand);
- ptrType$2 = $ptrType(lockedSource);
- arrayType = $arrayType($Int64, 607);
- ptrType$3 = $ptrType(rngSource);
- Rand.ptr.prototype.ExpFloat64 = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, i, j, r, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; j = $f.j; r = $f.r; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- /* while (true) { */ case 1:
- _r = r.Uint32(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- j = _r;
- i = (j & 255) >>> 0;
- x = j * ((i < 0 || i >= we.length) ? $throwRuntimeError("index out of range") : we[i]);
- if (j < ((i < 0 || i >= ke.length) ? $throwRuntimeError("index out of range") : ke[i])) {
- return x;
- }
- /* */ if (i === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (i === 0) { */ case 4:
- _r$1 = r.Float64(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = math.Log(_r$1); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return 7.69711747013105 - _r$2;
- /* } */ case 5:
- _r$3 = r.Float64(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if ($fround(((i < 0 || i >= fe.length) ? $throwRuntimeError("index out of range") : fe[i]) + $fround($fround(_r$3) * ($fround((x$1 = i - 1 >>> 0, ((x$1 < 0 || x$1 >= fe.length) ? $throwRuntimeError("index out of range") : fe[x$1])) - ((i < 0 || i >= fe.length) ? $throwRuntimeError("index out of range") : fe[i]))))) < $fround(math.Exp(-x))) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($fround(((i < 0 || i >= fe.length) ? $throwRuntimeError("index out of range") : fe[i]) + $fround($fround(_r$3) * ($fround((x$1 = i - 1 >>> 0, ((x$1 < 0 || x$1 >= fe.length) ? $throwRuntimeError("index out of range") : fe[x$1])) - ((i < 0 || i >= fe.length) ? $throwRuntimeError("index out of range") : fe[i]))))) < $fround(math.Exp(-x))) { */ case 8:
- return x;
- /* } */ case 9:
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.ExpFloat64 }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.j = j; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.ExpFloat64 = function() { return this.$val.ExpFloat64(); };
- absInt32 = function(i) {
- var $ptr, i;
- if (i < 0) {
- return (-i >>> 0);
- }
- return (i >>> 0);
- };
- Rand.ptr.prototype.NormFloat64 = function() {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, i, j, r, x, x$1, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; i = $f.i; j = $f.j; r = $f.r; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- /* while (true) { */ case 1:
- _r = r.Uint32(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- j = (_r >> 0);
- i = j & 127;
- x = j * ((i < 0 || i >= wn.length) ? $throwRuntimeError("index out of range") : wn[i]);
- if (absInt32(j) < ((i < 0 || i >= kn.length) ? $throwRuntimeError("index out of range") : kn[i])) {
- return x;
- }
- /* */ if (i === 0) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (i === 0) { */ case 4:
- /* while (true) { */ case 6:
- _r$1 = r.Float64(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = math.Log(_r$1); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- x = -_r$2 * 0.29047645161474317;
- _r$3 = r.Float64(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = math.Log(_r$3); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- y = -_r$4;
- if (y + y >= x * x) {
- /* break; */ $s = 7; continue;
- }
- /* } */ $s = 6; continue; case 7:
- if (j > 0) {
- return 3.442619855899 + x;
- }
- return -3.442619855899 - x;
- /* } */ case 5:
- _r$5 = r.Float64(); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- /* */ if ($fround(((i < 0 || i >= fn.length) ? $throwRuntimeError("index out of range") : fn[i]) + $fround($fround(_r$5) * ($fround((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= fn.length) ? $throwRuntimeError("index out of range") : fn[x$1])) - ((i < 0 || i >= fn.length) ? $throwRuntimeError("index out of range") : fn[i]))))) < $fround(math.Exp(-0.5 * x * x))) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ($fround(((i < 0 || i >= fn.length) ? $throwRuntimeError("index out of range") : fn[i]) + $fround($fround(_r$5) * ($fround((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= fn.length) ? $throwRuntimeError("index out of range") : fn[x$1])) - ((i < 0 || i >= fn.length) ? $throwRuntimeError("index out of range") : fn[i]))))) < $fround(math.Exp(-0.5 * x * x))) { */ case 12:
- return x;
- /* } */ case 13:
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.NormFloat64 }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.i = i; $f.j = j; $f.r = r; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.NormFloat64 = function() { return this.$val.NormFloat64(); };
- NewSource = function(seed) {
- var $ptr, rng, seed;
- rng = $clone(new rngSource.ptr(), rngSource);
- rng.Seed(seed);
- return rng;
- };
- $pkg.NewSource = NewSource;
- New = function(src) {
- var $ptr, src;
- return new Rand.ptr(src);
- };
- $pkg.New = New;
- Rand.ptr.prototype.Seed = function(seed) {
- var $ptr, r, seed, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- $r = r.src.Seed(seed); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Seed }; } $f.$ptr = $ptr; $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Seed = function(seed) { return this.$val.Seed(seed); };
- Rand.ptr.prototype.Int63 = function() {
- var $ptr, _r, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- _r = r.src.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int63 }; } $f.$ptr = $ptr; $f._r = _r; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Int63 = function() { return this.$val.Int63(); };
- Rand.ptr.prototype.Uint32 = function() {
- var $ptr, _r, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return ($shiftRightInt64(_r, 31).$low >>> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Uint32 }; } $f.$ptr = $ptr; $f._r = _r; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Uint32 = function() { return this.$val.Uint32(); };
- Rand.ptr.prototype.Int31 = function() {
- var $ptr, _r, r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return ((x = $shiftRightInt64(_r, 32), x.$low + ((x.$high >> 31) * 4294967296)) >> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int31 }; } $f.$ptr = $ptr; $f._r = _r; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Int31 = function() { return this.$val.Int31(); };
- Rand.ptr.prototype.Int = function() {
- var $ptr, _r, r, u, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; r = $f.r; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- u = (_r.$low >>> 0);
- return (((u << 1 >>> 0) >>> 1 >>> 0) >> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int }; } $f.$ptr = $ptr; $f._r = _r; $f.r = r; $f.u = u; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Int = function() { return this.$val.Int(); };
- Rand.ptr.prototype.Int63n = function(n) {
- var $ptr, _r, _r$1, _r$2, max, n, r, v, x, x$1, x$2, x$3, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; max = $f.max; n = $f.n; r = $f.r; v = $f.v; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- if ((n.$high < 0 || (n.$high === 0 && n.$low <= 0))) {
- $panic(new $String("invalid argument to Int63n"));
- }
- /* */ if ((x = (x$1 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(n.$high & x$1.$high, (n.$low & x$1.$low) >>> 0)), (x.$high === 0 && x.$low === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((x = (x$1 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(n.$high & x$1.$high, (n.$low & x$1.$low) >>> 0)), (x.$high === 0 && x.$low === 0))) { */ case 1:
- _r = r.Int63(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return (x$2 = _r, x$3 = new $Int64(n.$high - 0, n.$low - 1), new $Int64(x$2.$high & x$3.$high, (x$2.$low & x$3.$low) >>> 0));
- /* } */ case 2:
- max = (x$4 = (x$5 = $div64(new $Uint64(2147483648, 0), new $Uint64(n.$high, n.$low), true), new $Uint64(2147483647 - x$5.$high, 4294967295 - x$5.$low)), new $Int64(x$4.$high, x$4.$low));
- _r$1 = r.Int63(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- v = _r$1;
- /* while (true) { */ case 5:
- /* if (!((v.$high > max.$high || (v.$high === max.$high && v.$low > max.$low)))) { break; } */ if(!((v.$high > max.$high || (v.$high === max.$high && v.$low > max.$low)))) { $s = 6; continue; }
- _r$2 = r.Int63(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- /* } */ $s = 5; continue; case 6:
- return $div64(v, n, true);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int63n }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.max = max; $f.n = n; $f.r = r; $f.v = v; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Int63n = function(n) { return this.$val.Int63n(n); };
- Rand.ptr.prototype.Int31n = function(n) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, max, n, r, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; max = $f.max; n = $f.n; r = $f.r; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- if (n <= 0) {
- $panic(new $String("invalid argument to Int31n"));
- }
- /* */ if ((n & ((n - 1 >> 0))) === 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((n & ((n - 1 >> 0))) === 0) { */ case 1:
- _r = r.Int31(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r & ((n - 1 >> 0));
- /* } */ case 2:
- max = ((2147483647 - (_r$1 = 2147483648 % (n >>> 0), _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) >>> 0) >> 0);
- _r$2 = r.Int31(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- v = _r$2;
- /* while (true) { */ case 5:
- /* if (!(v > max)) { break; } */ if(!(v > max)) { $s = 6; continue; }
- _r$3 = r.Int31(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- v = _r$3;
- /* } */ $s = 5; continue; case 6:
- return (_r$4 = v % n, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero"));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Int31n }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.max = max; $f.n = n; $f.r = r; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Int31n = function(n) { return this.$val.Int31n(n); };
- Rand.ptr.prototype.Intn = function(n) {
- var $ptr, _r, _r$1, n, r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; n = $f.n; r = $f.r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- if (n <= 0) {
- $panic(new $String("invalid argument to Intn"));
- }
- /* */ if (n <= 2147483647) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n <= 2147483647) { */ case 1:
- _r = r.Int31n((n >> 0)); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return (_r >> 0);
- /* } */ case 2:
- _r$1 = r.Int63n(new $Int64(0, n)); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return ((x = _r$1, x.$low + ((x.$high >> 31) * 4294967296)) >> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Intn }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.n = n; $f.r = r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Intn = function(n) { return this.$val.Intn(n); };
- Rand.ptr.prototype.Float64 = function() {
- var $ptr, _r, f, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- _r = r.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- f = $flatten64(_r) / 9.223372036854776e+18;
- if (f === 1) {
- f = 0;
- }
- return f;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Float64 }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Float64 = function() { return this.$val.Float64(); };
- Rand.ptr.prototype.Float32 = function() {
- var $ptr, _r, f, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- _r = r.Float64(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- f = $fround(_r);
- if (f === 1) {
- f = 0;
- }
- return f;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Float32 }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Float32 = function() { return this.$val.Float32(); };
- Rand.ptr.prototype.Perm = function(n) {
- var $ptr, _r, i, j, m, n, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; j = $f.j; m = $f.m; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- m = $makeSlice(sliceType$1, n);
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; }
- _r = r.Intn(i + 1 >> 0); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- j = _r;
- ((i < 0 || i >= m.$length) ? $throwRuntimeError("index out of range") : m.$array[m.$offset + i] = ((j < 0 || j >= m.$length) ? $throwRuntimeError("index out of range") : m.$array[m.$offset + j]));
- ((j < 0 || j >= m.$length) ? $throwRuntimeError("index out of range") : m.$array[m.$offset + j] = i);
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- return m;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rand.ptr.prototype.Perm }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.j = j; $f.m = m; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rand.prototype.Perm = function(n) { return this.$val.Perm(n); };
- lockedSource.ptr.prototype.Int63 = function() {
- var $ptr, _r, n, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = new $Int64(0, 0);
- r = this;
- r.lk.Lock();
- _r = r.src.Int63(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n = _r;
- r.lk.Unlock();
- return n;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Int63 }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- lockedSource.prototype.Int63 = function() { return this.$val.Int63(); };
- lockedSource.ptr.prototype.Seed = function(seed) {
- var $ptr, r, seed, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; seed = $f.seed; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- r.lk.Lock();
- $r = r.src.Seed(seed); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- r.lk.Unlock();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: lockedSource.ptr.prototype.Seed }; } $f.$ptr = $ptr; $f.r = r; $f.seed = seed; $f.$s = $s; $f.$r = $r; return $f;
- };
- lockedSource.prototype.Seed = function(seed) { return this.$val.Seed(seed); };
- seedrand = function(x) {
- var $ptr, _q, _r, hi, lo, x;
- hi = (_q = x / 44488, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- lo = (_r = x % 44488, _r === _r ? _r : $throwRuntimeError("integer divide by zero"));
- x = ((((48271 >>> 16 << 16) * lo >> 0) + (48271 << 16 >>> 16) * lo) >> 0) - ((((3399 >>> 16 << 16) * hi >> 0) + (3399 << 16 >>> 16) * hi) >> 0) >> 0;
- if (x < 0) {
- x = x + (2147483647) >> 0;
- }
- return x;
- };
- rngSource.ptr.prototype.Seed = function(seed) {
- var $ptr, i, rng, seed, u, x, x$1, x$2, x$3, x$4, x$5;
- rng = this;
- rng.tap = 0;
- rng.feed = 334;
- seed = $div64(seed, new $Int64(0, 2147483647), true);
- if ((seed.$high < 0 || (seed.$high === 0 && seed.$low < 0))) {
- seed = (x = new $Int64(0, 2147483647), new $Int64(seed.$high + x.$high, seed.$low + x.$low));
- }
- if ((seed.$high === 0 && seed.$low === 0)) {
- seed = new $Int64(0, 89482311);
- }
- x$1 = ((seed.$low + ((seed.$high >> 31) * 4294967296)) >> 0);
- i = -20;
- while (true) {
- if (!(i < 607)) { break; }
- x$1 = seedrand(x$1);
- if (i >= 0) {
- u = new $Int64(0, 0);
- u = $shiftLeft64(new $Int64(0, x$1), 40);
- x$1 = seedrand(x$1);
- u = (x$2 = $shiftLeft64(new $Int64(0, x$1), 20), new $Int64(u.$high ^ x$2.$high, (u.$low ^ x$2.$low) >>> 0));
- x$1 = seedrand(x$1);
- u = (x$3 = new $Int64(0, x$1), new $Int64(u.$high ^ x$3.$high, (u.$low ^ x$3.$low) >>> 0));
- u = (x$4 = ((i < 0 || i >= rng_cooked.length) ? $throwRuntimeError("index out of range") : rng_cooked[i]), new $Int64(u.$high ^ x$4.$high, (u.$low ^ x$4.$low) >>> 0));
- (x$5 = rng.vec, ((i < 0 || i >= x$5.length) ? $throwRuntimeError("index out of range") : x$5[i] = new $Int64(u.$high & 2147483647, (u.$low & 4294967295) >>> 0)));
- }
- i = i + (1) >> 0;
- }
- };
- rngSource.prototype.Seed = function(seed) { return this.$val.Seed(seed); };
- rngSource.ptr.prototype.Int63 = function() {
- var $ptr, rng, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- rng = this;
- rng.tap = rng.tap - (1) >> 0;
- if (rng.tap < 0) {
- rng.tap = rng.tap + (607) >> 0;
- }
- rng.feed = rng.feed - (1) >> 0;
- if (rng.feed < 0) {
- rng.feed = rng.feed + (607) >> 0;
- }
- x$7 = (x = (x$1 = (x$2 = rng.vec, x$3 = rng.feed, ((x$3 < 0 || x$3 >= x$2.length) ? $throwRuntimeError("index out of range") : x$2[x$3])), x$4 = (x$5 = rng.vec, x$6 = rng.tap, ((x$6 < 0 || x$6 >= x$5.length) ? $throwRuntimeError("index out of range") : x$5[x$6])), new $Int64(x$1.$high + x$4.$high, x$1.$low + x$4.$low)), new $Int64(x.$high & 2147483647, (x.$low & 4294967295) >>> 0));
- (x$8 = rng.vec, x$9 = rng.feed, ((x$9 < 0 || x$9 >= x$8.length) ? $throwRuntimeError("index out of range") : x$8[x$9] = x$7));
- return x$7;
- };
- rngSource.prototype.Int63 = function() { return this.$val.Int63(); };
- ptrType$1.methods = [{prop: "ExpFloat64", name: "ExpFloat64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "NormFloat64", name: "NormFloat64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint32", name: "Uint32", pkg: "", typ: $funcType([], [$Uint32], false)}, {prop: "Int31", name: "Int31", pkg: "", typ: $funcType([], [$Int32], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Int63n", name: "Int63n", pkg: "", typ: $funcType([$Int64], [$Int64], false)}, {prop: "Int31n", name: "Int31n", pkg: "", typ: $funcType([$Int32], [$Int32], false)}, {prop: "Intn", name: "Intn", pkg: "", typ: $funcType([$Int], [$Int], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32], false)}, {prop: "Perm", name: "Perm", pkg: "", typ: $funcType([$Int], [sliceType$1], false)}];
- ptrType$2.methods = [{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}];
- ptrType$3.methods = [{prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}, {prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}];
- Source.init([{prop: "Int63", name: "Int63", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Seed", name: "Seed", pkg: "", typ: $funcType([$Int64], [], false)}]);
- Rand.init([{prop: "src", name: "src", pkg: "math/rand", typ: Source, tag: ""}]);
- lockedSource.init([{prop: "lk", name: "lk", pkg: "math/rand", typ: nosync.Mutex, tag: ""}, {prop: "src", name: "src", pkg: "math/rand", typ: Source, tag: ""}]);
- rngSource.init([{prop: "tap", name: "tap", pkg: "math/rand", typ: $Int, tag: ""}, {prop: "feed", name: "feed", pkg: "math/rand", typ: $Int, tag: ""}, {prop: "vec", name: "vec", pkg: "math/rand", typ: arrayType, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = nosync.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = testing.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- ke = $toNativeArray($kindUint32, [3801129273, 0, 2615860924, 3279400049, 3571300752, 3733536696, 3836274812, 3906990442, 3958562475, 3997804264, 4028649213, 4053523342, 4074002619, 4091154507, 4105727352, 4118261130, 4129155133, 4138710916, 4147160435, 4154685009, 4161428406, 4167506077, 4173011791, 4178022498, 4182601930, 4186803325, 4190671498, 4194244443, 4197554582, 4200629752, 4203493986, 4206168142, 4208670408, 4211016720, 4213221098, 4215295924, 4217252177, 4219099625, 4220846988, 4222502074, 4224071896, 4225562770, 4226980400, 4228329951, 4229616109, 4230843138, 4232014925, 4233135020, 4234206673, 4235232866, 4236216336, 4237159604, 4238064994, 4238934652, 4239770563, 4240574564, 4241348362, 4242093539, 4242811568, 4243503822, 4244171579, 4244816032, 4245438297, 4246039419, 4246620374, 4247182079, 4247725394, 4248251127, 4248760037, 4249252839, 4249730206, 4250192773, 4250641138, 4251075867, 4251497493, 4251906522, 4252303431, 4252688672, 4253062674, 4253425844, 4253778565, 4254121205, 4254454110, 4254777611, 4255092022, 4255397640, 4255694750, 4255983622, 4256264513, 4256537670, 4256803325, 4257061702, 4257313014, 4257557464, 4257795244, 4258026541, 4258251531, 4258470383, 4258683258, 4258890309, 4259091685, 4259287526, 4259477966, 4259663135, 4259843154, 4260018142, 4260188212, 4260353470, 4260514019, 4260669958, 4260821380, 4260968374, 4261111028, 4261249421, 4261383632, 4261513736, 4261639802, 4261761900, 4261880092, 4261994441, 4262105003, 4262211835, 4262314988, 4262414513, 4262510454, 4262602857, 4262691764, 4262777212, 4262859239, 4262937878, 4263013162, 4263085118, 4263153776, 4263219158, 4263281289, 4263340187, 4263395872, 4263448358, 4263497660, 4263543789, 4263586755, 4263626565, 4263663224, 4263696735, 4263727099, 4263754314, 4263778377, 4263799282, 4263817020, 4263831582, 4263842955, 4263851124, 4263856071, 4263857776, 4263856218, 4263851370, 4263843206, 4263831695, 4263816804, 4263798497, 4263776735, 4263751476, 4263722676, 4263690284, 4263654251, 4263614520, 4263571032, 4263523724, 4263472530, 4263417377, 4263358192, 4263294892, 4263227394, 4263155608, 4263079437, 4262998781, 4262913534, 4262823581, 4262728804, 4262629075, 4262524261, 4262414220, 4262298801, 4262177846, 4262051187, 4261918645, 4261780032, 4261635148, 4261483780, 4261325704, 4261160681, 4260988457, 4260808763, 4260621313, 4260425802, 4260221905, 4260009277, 4259787550, 4259556329, 4259315195, 4259063697, 4258801357, 4258527656, 4258242044, 4257943926, 4257632664, 4257307571, 4256967906, 4256612870, 4256241598, 4255853155, 4255446525, 4255020608, 4254574202, 4254106002, 4253614578, 4253098370, 4252555662, 4251984571, 4251383021, 4250748722, 4250079132, 4249371435, 4248622490, 4247828790, 4246986404, 4246090910, 4245137315, 4244119963, 4243032411, 4241867296, 4240616155, 4239269214, 4237815118, 4236240596, 4234530035, 4232664930, 4230623176, 4228378137, 4225897409, 4223141146, 4220059768, 4216590757, 4212654085, 4208145538, 4202926710, 4196809522, 4189531420, 4180713890, 4169789475, 4155865042, 4137444620, 4111806704, 4073393724, 4008685917, 3873074895]);
- we = $toNativeArray($kindFloat32, [2.0249555365836613e-09, 1.4866739783681027e-11, 2.4409616689036184e-11, 3.1968806074589295e-11, 3.844677007314168e-11, 4.42282044321729e-11, 4.951644302919611e-11, 5.443358958023836e-11, 5.905943789574764e-11, 6.34494193296753e-11, 6.764381416113352e-11, 7.167294535648239e-11, 7.556032188826833e-11, 7.932458162551725e-11, 8.298078890689453e-11, 8.654132271912474e-11, 9.001651507523079e-11, 9.341507428706208e-11, 9.674443190998971e-11, 1.0001099254308699e-10, 1.0322031424037093e-10, 1.0637725422757427e-10, 1.0948611461891744e-10, 1.1255067711157807e-10, 1.1557434870246297e-10, 1.1856014781042035e-10, 1.2151082917633005e-10, 1.2442885610752796e-10, 1.2731647680563896e-10, 1.3017574518325858e-10, 1.330085347417409e-10, 1.3581656632677408e-10, 1.386014220061682e-10, 1.413645728254309e-10, 1.4410737880776736e-10, 1.4683107507629245e-10, 1.4953686899854546e-10, 1.522258291641876e-10, 1.5489899640730442e-10, 1.575573282952547e-10, 1.6020171300645814e-10, 1.628330109637588e-10, 1.6545202707884954e-10, 1.68059510752272e-10, 1.7065616975120435e-10, 1.73242697965037e-10, 1.758197337720091e-10, 1.783878739169964e-10, 1.8094774290045024e-10, 1.834998542005195e-10, 1.8604476292871652e-10, 1.8858298256319017e-10, 1.9111498494872592e-10, 1.9364125580789704e-10, 1.9616222535212557e-10, 1.9867835154840918e-10, 2.011900368525943e-10, 2.0369768372052732e-10, 2.062016807302669e-10, 2.0870240258208383e-10, 2.1120022397624894e-10, 2.136955057352452e-10, 2.1618855317040442e-10, 2.1867974098199738e-10, 2.2116936060356807e-10, 2.2365774510202385e-10, 2.2614519978869652e-10, 2.2863201609713002e-10, 2.3111849933865614e-10, 2.3360494094681883e-10, 2.3609159072179864e-10, 2.3857874009713953e-10, 2.4106666662859766e-10, 2.4355562011635357e-10, 2.460458781161634e-10, 2.485376904282077e-10, 2.5103127909709144e-10, 2.5352694943414633e-10, 2.560248957284017e-10, 2.585253955356137e-10, 2.610286709003873e-10, 2.6353494386732734e-10, 2.6604446423661443e-10, 2.6855745405285347e-10, 2.71074163116225e-10, 2.7359478571575835e-10, 2.7611959940720965e-10, 2.786487707240326e-10, 2.8118254946640775e-10, 2.8372118543451563e-10, 2.8626484516180994e-10, 2.8881380620404684e-10, 2.9136826285025563e-10, 2.9392840938946563e-10, 2.96494523377433e-10, 2.990667713476114e-10, 3.016454031001814e-10, 3.042306406797479e-10, 3.068226783753403e-10, 3.09421765987139e-10, 3.12028125559749e-10, 3.1464195138219964e-10, 3.17263521010247e-10, 3.1989300097734485e-10, 3.225306410836737e-10, 3.2517669112941405e-10, 3.2783134540359526e-10, 3.3049485370639786e-10, 3.3316743808242677e-10, 3.3584937608743815e-10, 3.385408342548857e-10, 3.4124211789610115e-10, 3.4395342130011386e-10, 3.4667499426710435e-10, 3.494071143528288e-10, 3.521500313574677e-10, 3.54903967325626e-10, 3.576691720574843e-10, 3.6044595086437425e-10, 3.632345535464765e-10, 3.660352021483959e-10, 3.688482297370399e-10, 3.716738583570134e-10, 3.7451239331964814e-10, 3.773641121807003e-10, 3.802292924959261e-10, 3.831082673322328e-10, 3.8600128648980103e-10, 3.8890865527996255e-10, 3.9183070676962473e-10, 3.9476774627011935e-10, 3.977200790927782e-10, 4.006880383045086e-10, 4.0367195697221803e-10, 4.066721681628138e-10, 4.0968900494320337e-10, 4.127228558914453e-10, 4.15774054074447e-10, 4.188429603146915e-10, 4.2192993543466173e-10, 4.25035395767992e-10, 4.2815970213716525e-10, 4.313032986313914e-10, 4.3446651831757777e-10, 4.376498607960855e-10, 4.408536868893975e-10, 4.4407846844229937e-10, 4.4732464954400086e-10, 4.5059267428371186e-10, 4.538830145062178e-10, 4.5719619756745544e-10, 4.605326675566346e-10, 4.638929240741163e-10, 4.672775499869886e-10, 4.706869893844612e-10, 4.74121908400349e-10, 4.775827511238617e-10, 4.810701836888143e-10, 4.845848167178701e-10, 4.881271498113904e-10, 4.916979601254923e-10, 4.952977472605369e-10, 4.989272883726414e-10, 5.025872495956207e-10, 5.062783525744408e-10, 5.100013189540675e-10, 5.13756870379467e-10, 5.175458395179078e-10, 5.21369003525507e-10, 5.252272505806843e-10, 5.29121357839557e-10, 5.330522134805449e-10, 5.3702081670437e-10, 5.41028055689452e-10, 5.450749851476644e-10, 5.491624932574268e-10, 5.532918012640664e-10, 5.574638528571541e-10, 5.616799247931681e-10, 5.659410717839819e-10, 5.702485705860738e-10, 5.746036979559221e-10, 5.790077306500052e-10, 5.83462111958255e-10, 5.879682296594524e-10, 5.925275825546805e-10, 5.971417249561739e-10, 6.01812211176167e-10, 6.065408175714992e-10, 6.113292094767075e-10, 6.16179329782085e-10, 6.21092954844471e-10, 6.260721940876124e-10, 6.311191569352559e-10, 6.362359528111483e-10, 6.414249686947926e-10, 6.466885360545405e-10, 6.520292639144998e-10, 6.574497612987784e-10, 6.629528592760892e-10, 6.685415554485985e-10, 6.742187919073217e-10, 6.799880103436351e-10, 6.858525969377638e-10, 6.918161599145378e-10, 6.978825850545434e-10, 7.040559801829716e-10, 7.103406751696184e-10, 7.167412219288849e-10, 7.232625609532306e-10, 7.2990985477972e-10, 7.366885990123251e-10, 7.436047333442275e-10, 7.506645305355164e-10, 7.57874762946642e-10, 7.652426470272644e-10, 7.727759543385559e-10, 7.804830115532013e-10, 7.883728114777e-10, 7.964550685635174e-10, 8.047402189070851e-10, 8.132396422944055e-10, 8.219657177122031e-10, 8.309318788590758e-10, 8.401527806789488e-10, 8.496445214056791e-10, 8.594246980742071e-10, 8.695127395874636e-10, 8.799300732498239e-10, 8.90700457834015e-10, 9.01850316648023e-10, 9.134091816243028e-10, 9.254100818978372e-10, 9.37890431984556e-10, 9.508922538259412e-10, 9.64463842123564e-10, 9.78660263939446e-10, 9.935448019859905e-10, 1.0091912860943353e-09, 1.0256859805934937e-09, 1.0431305819125214e-09, 1.0616465484503124e-09, 1.0813799855569073e-09, 1.1025096391392708e-09, 1.1252564435793033e-09, 1.149898620766976e-09, 1.176793218427008e-09, 1.2064089727203964e-09, 1.2393785997488749e-09, 1.2765849488616254e-09, 1.319313880365769e-09, 1.36954347862428e-09, 1.4305497897382224e-09, 1.5083649884672923e-09, 1.6160853766322703e-09, 1.7921247819074893e-09]);
- fe = $toNativeArray($kindFloat32, [1, 0.9381436705589294, 0.900469958782196, 0.8717043399810791, 0.847785472869873, 0.8269932866096497, 0.8084216713905334, 0.7915276288986206, 0.7759568691253662, 0.7614634037017822, 0.7478685975074768, 0.7350381016731262, 0.7228676676750183, 0.7112747430801392, 0.7001926302909851, 0.6895664930343628, 0.6793505549430847, 0.669506311416626, 0.6600008606910706, 0.6508058309555054, 0.6418967247009277, 0.633251965045929, 0.62485271692276, 0.6166821718215942, 0.608725368976593, 0.6009689569473267, 0.5934008955955505, 0.5860103368759155, 0.5787873864173889, 0.5717230439186096, 0.5648092031478882, 0.5580382943153381, 0.5514034032821655, 0.5448982119560242, 0.5385168790817261, 0.5322538614273071, 0.526104211807251, 0.5200631618499756, 0.5141264200210571, 0.5082897543907166, 0.5025495290756226, 0.4969019889831543, 0.4913438558578491, 0.4858720004558563, 0.48048335313796997, 0.4751752018928528, 0.4699448347091675, 0.4647897481918335, 0.4597076177597046, 0.4546961486339569, 0.4497532546520233, 0.44487687945365906, 0.4400651156902313, 0.4353161156177521, 0.4306281507015228, 0.42599955201148987, 0.42142874002456665, 0.4169141948223114, 0.4124544560909271, 0.40804818272590637, 0.4036940038204193, 0.39939069747924805, 0.3951369822025299, 0.39093172550201416, 0.38677382469177246, 0.38266217708587646, 0.378595769405365, 0.37457355856895447, 0.37059465050697327, 0.366658091545105, 0.362762987613678, 0.358908474445343, 0.35509374737739563, 0.35131800174713135, 0.3475804924964905, 0.34388044476509094, 0.34021714329719543, 0.33658990263938904, 0.3329980671405792, 0.3294409513473511, 0.32591795921325684, 0.32242849469184875, 0.3189719021320343, 0.3155476748943329, 0.31215524673461914, 0.3087940812110901, 0.30546361207962036, 0.30216339230537415, 0.29889291524887085, 0.29565170407295227, 0.2924392819404602, 0.2892552316188812, 0.28609907627105713, 0.2829704284667969, 0.27986884117126465, 0.2767939269542694, 0.2737452983856201, 0.2707225978374481, 0.26772540807724, 0.26475343108177185, 0.2618062496185303, 0.258883535861969, 0.2559850215911865, 0.25311028957366943, 0.25025907158851624, 0.24743106961250305, 0.2446259707212448, 0.24184346199035645, 0.23908329010009766, 0.23634515702724457, 0.2336287796497345, 0.23093391954898834, 0.22826029360294342, 0.22560766339302063, 0.22297576069831848, 0.22036437690258026, 0.21777324378490448, 0.21520215272903442, 0.212650865316391, 0.21011915802955627, 0.20760682225227356, 0.20511364936828613, 0.20263944566249847, 0.20018397271633148, 0.19774706661701202, 0.1953285187482834, 0.19292815029621124, 0.19054576754570007, 0.18818120658397675, 0.18583425879478455, 0.18350479006767273, 0.18119260668754578, 0.17889754474163055, 0.17661945521831512, 0.17435817420482635, 0.1721135377883911, 0.16988539695739746, 0.16767361760139465, 0.16547803580760956, 0.16329853236675262, 0.16113494336605072, 0.1589871346950531, 0.15685498714447021, 0.15473836660385132, 0.15263713896274567, 0.1505511850118637, 0.1484803706407547, 0.14642459154129028, 0.1443837285041809, 0.14235764741897583, 0.1403462439775467, 0.13834942877292633, 0.136367067694664, 0.13439907133579254, 0.1324453204870224, 0.1305057406425476, 0.12858019769191742, 0.12666863203048706, 0.12477091699838638, 0.12288697808980942, 0.1210167184472084, 0.11916005611419678, 0.11731690168380737, 0.11548716574907303, 0.11367076635360718, 0.11186762899160385, 0.11007767915725708, 0.1083008274435997, 0.10653700679540634, 0.10478614270687103, 0.1030481606721878, 0.10132300108671188, 0.0996105819940567, 0.09791085124015808, 0.09622374176979065, 0.09454918652772903, 0.09288713335990906, 0.09123751521110535, 0.08960027992725372, 0.08797537535429001, 0.08636274188756943, 0.0847623273730278, 0.08317409455776215, 0.08159798383712769, 0.08003395050764084, 0.07848194986581802, 0.07694194465875626, 0.07541389018297195, 0.07389774918556213, 0.07239348441362381, 0.070901058614254, 0.06942043453454971, 0.06795158982276917, 0.06649449467658997, 0.06504911929368973, 0.06361543387174606, 0.06219341605901718, 0.06078304722905159, 0.0593843050301075, 0.05799717456102371, 0.05662164092063904, 0.05525768920779228, 0.05390531197190285, 0.05256449431180954, 0.05123523622751236, 0.04991753399372101, 0.04861138388514519, 0.047316793352365494, 0.04603376239538193, 0.044762298464775085, 0.04350241273641586, 0.04225412383675575, 0.04101744294166565, 0.039792392402887344, 0.03857899457216263, 0.03737728297710419, 0.03618728369474411, 0.03500903770327568, 0.03384258225560188, 0.0326879620552063, 0.031545232981443405, 0.030414443463087082, 0.0292956605553627, 0.028188949450850487, 0.027094384655356407, 0.02601204626262188, 0.024942025542259216, 0.023884421214461327, 0.022839335724711418, 0.021806888282299042, 0.020787203684449196, 0.019780423492193222, 0.018786700442433357, 0.017806200310587883, 0.016839107498526573, 0.015885621309280396, 0.014945968054234982, 0.01402039173990488, 0.013109165243804455, 0.012212592177093029, 0.011331013403832912, 0.010464809834957123, 0.009614413604140282, 0.008780314587056637, 0.007963077165186405, 0.007163353264331818, 0.0063819061033427715, 0.005619642324745655, 0.004877655766904354, 0.004157294984906912, 0.003460264764726162, 0.0027887988835573196, 0.0021459676790982485, 0.001536299823783338, 0.0009672692976891994, 0.0004541343660093844]);
- kn = $toNativeArray($kindUint32, [1991057938, 0, 1611602771, 1826899878, 1918584482, 1969227037, 2001281515, 2023368125, 2039498179, 2051788381, 2061460127, 2069267110, 2075699398, 2081089314, 2085670119, 2089610331, 2093034710, 2096037586, 2098691595, 2101053571, 2103168620, 2105072996, 2106796166, 2108362327, 2109791536, 2111100552, 2112303493, 2113412330, 2114437283, 2115387130, 2116269447, 2117090813, 2117856962, 2118572919, 2119243101, 2119871411, 2120461303, 2121015852, 2121537798, 2122029592, 2122493434, 2122931299, 2123344971, 2123736059, 2124106020, 2124456175, 2124787725, 2125101763, 2125399283, 2125681194, 2125948325, 2126201433, 2126441213, 2126668298, 2126883268, 2127086657, 2127278949, 2127460589, 2127631985, 2127793506, 2127945490, 2128088244, 2128222044, 2128347141, 2128463758, 2128572095, 2128672327, 2128764606, 2128849065, 2128925811, 2128994934, 2129056501, 2129110560, 2129157136, 2129196237, 2129227847, 2129251929, 2129268426, 2129277255, 2129278312, 2129271467, 2129256561, 2129233410, 2129201800, 2129161480, 2129112170, 2129053545, 2128985244, 2128906855, 2128817916, 2128717911, 2128606255, 2128482298, 2128345305, 2128194452, 2128028813, 2127847342, 2127648860, 2127432031, 2127195339, 2126937058, 2126655214, 2126347546, 2126011445, 2125643893, 2125241376, 2124799783, 2124314271, 2123779094, 2123187386, 2122530867, 2121799464, 2120980787, 2120059418, 2119015917, 2117825402, 2116455471, 2114863093, 2112989789, 2110753906, 2108037662, 2104664315, 2100355223, 2094642347, 2086670106, 2074676188, 2054300022, 2010539237]);
- wn = $toNativeArray($kindFloat32, [1.7290404663583558e-09, 1.2680928529462676e-10, 1.689751810696194e-10, 1.9862687883343e-10, 2.223243117382978e-10, 2.4244936613904144e-10, 2.601613091623989e-10, 2.761198769629658e-10, 2.9073962681813725e-10, 3.042996965518796e-10, 3.169979556627567e-10, 3.289802041894774e-10, 3.4035738116777736e-10, 3.5121602848242617e-10, 3.61625090983253e-10, 3.7164057942185025e-10, 3.813085680537398e-10, 3.906675816178762e-10, 3.997501218933053e-10, 4.0858399996679395e-10, 4.1719308563337165e-10, 4.255982233303257e-10, 4.3381759295968436e-10, 4.4186720948857783e-10, 4.497613115272969e-10, 4.57512583373898e-10, 4.6513240481438345e-10, 4.726310454117311e-10, 4.800177477726209e-10, 4.873009773476156e-10, 4.944885056978876e-10, 5.015873272284921e-10, 5.086040477664255e-10, 5.155446070048697e-10, 5.224146670812502e-10, 5.292193350214802e-10, 5.359634958068682e-10, 5.426517013518151e-10, 5.492881705038144e-10, 5.558769555769061e-10, 5.624218868405251e-10, 5.689264614971989e-10, 5.75394121238304e-10, 5.818281967329142e-10, 5.882316855831959e-10, 5.946076964136182e-10, 6.009590047817426e-10, 6.072883862451306e-10, 6.135985053390414e-10, 6.19892026598734e-10, 6.261713370037114e-10, 6.324390455780815e-10, 6.386973727678935e-10, 6.449488165749528e-10, 6.511955974453087e-10, 6.574400468473129e-10, 6.636843297158634e-10, 6.699307220081607e-10, 6.761814441702541e-10, 6.824387166481927e-10, 6.887046488657234e-10, 6.949815167800466e-10, 7.012714853260604e-10, 7.075767749498141e-10, 7.13899661608508e-10, 7.202424212593428e-10, 7.266072743483676e-10, 7.329966078550854e-10, 7.394128087589991e-10, 7.458582640396116e-10, 7.523354716987285e-10, 7.588469852493063e-10, 7.653954137154528e-10, 7.719834771435785e-10, 7.786139510912449e-10, 7.852897221383159e-10, 7.920137878869582e-10, 7.987892014504894e-10, 8.056192379868321e-10, 8.125072836762115e-10, 8.194568912323064e-10, 8.264716688799467e-10, 8.3355555791087e-10, 8.407127216614185e-10, 8.479473234679347e-10, 8.552640262671218e-10, 8.626675485068347e-10, 8.701631637464402e-10, 8.777562010564566e-10, 8.854524335966119e-10, 8.932581896381464e-10, 9.011799639857543e-10, 9.092249730890956e-10, 9.174008219758889e-10, 9.25715837318819e-10, 9.341788453909317e-10, 9.42799727177146e-10, 9.515889187738935e-10, 9.605578554783278e-10, 9.697193048552322e-10, 9.790869226478094e-10, 9.886760299337993e-10, 9.985036131254788e-10, 1.008588212947359e-09, 1.0189509236369076e-09, 1.0296150598776421e-09, 1.040606933955246e-09, 1.0519566329136865e-09, 1.0636980185552147e-09, 1.0758701707302976e-09, 1.0885182755160372e-09, 1.101694735439196e-09, 1.115461056855338e-09, 1.1298901814171813e-09, 1.1450695946990663e-09, 1.1611052119775422e-09, 1.178127595480305e-09, 1.1962995039027646e-09, 1.2158286599728285e-09, 1.2369856250415978e-09, 1.2601323318151003e-09, 1.2857697129220469e-09, 1.3146201904845611e-09, 1.3477839955200466e-09, 1.3870635751089821e-09, 1.43574030442295e-09, 1.5008658760251592e-09, 1.6030947680434338e-09]);
- fn = $toNativeArray($kindFloat32, [1, 0.963599681854248, 0.9362826943397522, 0.9130436182022095, 0.8922816514968872, 0.8732430338859558, 0.8555005788803101, 0.8387836217880249, 0.8229072093963623, 0.8077383041381836, 0.7931770086288452, 0.7791460752487183, 0.7655841708183289, 0.7524415850639343, 0.7396772503852844, 0.7272568941116333, 0.7151514887809753, 0.7033361196517944, 0.6917891502380371, 0.6804918646812439, 0.6694276928901672, 0.6585819721221924, 0.6479418277740479, 0.6374954581260681, 0.6272324919700623, 0.6171433925628662, 0.6072195172309875, 0.5974531769752502, 0.5878370404243469, 0.5783646702766418, 0.5690299868583679, 0.5598273873329163, 0.550751805305481, 0.5417983531951904, 0.5329626798629761, 0.5242405533790588, 0.5156282186508179, 0.5071220397949219, 0.49871864914894104, 0.4904148280620575, 0.48220765590667725, 0.47409430146217346, 0.466072142124176, 0.45813870429992676, 0.45029163360595703, 0.44252872467041016, 0.4348478317260742, 0.42724698781967163, 0.41972434520721436, 0.41227802634239197, 0.40490642189979553, 0.39760786294937134, 0.3903807997703552, 0.3832238018512726, 0.3761354684829712, 0.3691144585609436, 0.36215949058532715, 0.3552693724632263, 0.3484429717063904, 0.3416791558265686, 0.33497685194015503, 0.32833510637283325, 0.3217529058456421, 0.3152293860912323, 0.30876362323760986, 0.3023548424243927, 0.2960021495819092, 0.2897048592567444, 0.28346219658851624, 0.2772735059261322, 0.271138072013855, 0.2650552988052368, 0.25902456045150757, 0.25304529070854187, 0.24711695313453674, 0.24123899638652802, 0.23541094362735748, 0.22963231801986694, 0.22390270233154297, 0.21822164952754974, 0.21258877217769623, 0.20700371265411377, 0.20146611332893372, 0.1959756463766098, 0.19053204357624054, 0.18513499200344086, 0.17978426814079285, 0.1744796335697174, 0.16922089457511902, 0.16400785744190216, 0.1588403731584549, 0.15371830761432648, 0.14864157140254974, 0.14361007511615753, 0.13862377405166626, 0.13368265330791473, 0.12878671288490295, 0.12393598258495331, 0.11913054436445236, 0.11437050998210907, 0.10965602099895477, 0.1049872562289238, 0.10036443918943405, 0.09578784555196762, 0.09125780314207077, 0.08677466958761215, 0.08233889937400818, 0.07795098423957825, 0.07361150532960892, 0.06932111829519272, 0.06508058309555054, 0.06089077144861221, 0.05675266310572624, 0.05266740173101425, 0.048636294901371, 0.044660862535238266, 0.040742866694927216, 0.03688438981771469, 0.03308788686990738, 0.029356317594647408, 0.025693291798233986, 0.02210330404341221, 0.018592102453112602, 0.015167297795414925, 0.011839478276669979, 0.0086244847625494, 0.005548994988203049, 0.0026696291752159595]);
- rng_cooked = $toNativeArray($kindInt64, [new $Int64(1173834291, 3952672746), new $Int64(1081821761, 3130416987), new $Int64(324977939, 3414273807), new $Int64(1241840476, 2806224363), new $Int64(669549340, 1997590414), new $Int64(2103305448, 2402795971), new $Int64(1663160183, 1140819369), new $Int64(1120601685, 1788868961), new $Int64(1848035537, 1089001426), new $Int64(1235702047, 873593504), new $Int64(1911387977, 581324885), new $Int64(492609478, 1609182556), new $Int64(1069394745, 1241596776), new $Int64(1895445337, 1771189259), new $Int64(772864846, 3467012610), new $Int64(2006957225, 2344407434), new $Int64(402115761, 782467244), new $Int64(26335124, 3404933915), new $Int64(1063924276, 618867887), new $Int64(1178782866, 520164395), new $Int64(555910815, 1341358184), new $Int64(632398609, 665794848), new $Int64(1527227641, 3183648150), new $Int64(1781176124, 696329606), new $Int64(1789146075, 4151988961), new $Int64(60039534, 998951326), new $Int64(1535158725, 1364957564), new $Int64(63173359, 4090230633), new $Int64(649454641, 4009697548), new $Int64(248009524, 2569622517), new $Int64(778703922, 3742421481), new $Int64(1038377625, 1506914633), new $Int64(1738099768, 1983412561), new $Int64(236311649, 1436266083), new $Int64(1035966148, 3922894967), new $Int64(810508934, 1792680179), new $Int64(563141142, 1188796351), new $Int64(1349617468, 405968250), new $Int64(1044074554, 433754187), new $Int64(870549669, 4073162024), new $Int64(1053232044, 433121399), new $Int64(2451824, 4162580594), new $Int64(2010221076, 4132415622), new $Int64(611252600, 3033822028), new $Int64(2016407895, 824682382), new $Int64(2366218, 3583765414), new $Int64(1522878809, 535386927), new $Int64(1637219058, 2286693689), new $Int64(1453075389, 2968466525), new $Int64(193683513, 1351410206), new $Int64(1863677552, 1412813499), new $Int64(492736522, 4126267639), new $Int64(512765208, 2105529399), new $Int64(2132966268, 2413882233), new $Int64(947457634, 32226200), new $Int64(1149341356, 2032329073), new $Int64(106485445, 1356518208), new $Int64(79673492, 3430061722), new $Int64(663048513, 3820169661), new $Int64(481498454, 2981816134), new $Int64(1017155588, 4184371017), new $Int64(206574701, 2119206761), new $Int64(1295374591, 2472200560), new $Int64(1587026100, 2853524696), new $Int64(1307803389, 1681119904), new $Int64(1972496813, 95608918), new $Int64(392686347, 3690479145), new $Int64(941912722, 1397922290), new $Int64(988169623, 1516129515), new $Int64(1827305493, 1547420459), new $Int64(1311333971, 1470949486), new $Int64(194013850, 1336785672), new $Int64(2102397034, 4131677129), new $Int64(755205548, 4246329084), new $Int64(1004983461, 3788585631), new $Int64(2081005363, 3080389532), new $Int64(1501045284, 2215402037), new $Int64(391002300, 1171593935), new $Int64(1408774047, 1423855166), new $Int64(1628305930, 2276716302), new $Int64(1779030508, 2068027241), new $Int64(1369359303, 3427553297), new $Int64(189241615, 3289637845), new $Int64(1057480830, 3486407650), new $Int64(634572984, 3071877822), new $Int64(1159653919, 3363620705), new $Int64(1213226718, 4159821533), new $Int64(2070861710, 1894661), new $Int64(1472989750, 1156868282), new $Int64(348271067, 776219088), new $Int64(1646054810, 2425634259), new $Int64(1716021749, 680510161), new $Int64(1573220192, 1310101429), new $Int64(1095885995, 2964454134), new $Int64(1821788136, 3467098407), new $Int64(1990672920, 2109628894), new $Int64(7834944, 1232604732), new $Int64(309412934, 3261916179), new $Int64(1699175360, 434597899), new $Int64(235436061, 1624796439), new $Int64(521080809, 3589632480), new $Int64(1198416575, 864579159), new $Int64(208735487, 1380889830), new $Int64(619206309, 2654509477), new $Int64(1419738251, 1468209306), new $Int64(403198876, 100794388), new $Int64(956062190, 2991674471), new $Int64(1938816907, 2224662036), new $Int64(1973824487, 977097250), new $Int64(1351320195, 726419512), new $Int64(1964023751, 1747974366), new $Int64(1394388465, 1556430604), new $Int64(1097991433, 1080776742), new $Int64(1761636690, 280794874), new $Int64(117767733, 919835643), new $Int64(1180474222, 3434019658), new $Int64(196069168, 2461941785), new $Int64(133215641, 3615001066), new $Int64(417204809, 3103414427), new $Int64(790056561, 3380809712), new $Int64(879802240, 2724693469), new $Int64(547796833, 598827710), new $Int64(300924196, 3452273442), new $Int64(2071705424, 649274915), new $Int64(1346182319, 2585724112), new $Int64(636549385, 3165579553), new $Int64(1185578221, 2635894283), new $Int64(2094573470, 2053289721), new $Int64(985976581, 3169337108), new $Int64(1170569632, 144717764), new $Int64(1079216270, 1383666384), new $Int64(2022678706, 681540375), new $Int64(1375448925, 537050586), new $Int64(182715304, 315246468), new $Int64(226402871, 849323088), new $Int64(1262421183, 45543944), new $Int64(1201038398, 2319052083), new $Int64(2106775454, 3613090841), new $Int64(560472520, 2992171180), new $Int64(1765620479, 2068244785), new $Int64(917538188, 4239862634), new $Int64(777927839, 3892253031), new $Int64(720683925, 958186149), new $Int64(1724185863, 1877702262), new $Int64(1357886971, 837674867), new $Int64(1837048883, 1507589294), new $Int64(1905518400, 873336795), new $Int64(267722611, 2764496274), new $Int64(341003118, 4196182374), new $Int64(1080717893, 550964545), new $Int64(818747069, 420611474), new $Int64(222653272, 204265180), new $Int64(1549974541, 1787046383), new $Int64(1215581865, 3102292318), new $Int64(418321538, 1552199393), new $Int64(1243493047, 980542004), new $Int64(267284263, 3293718720), new $Int64(1179528763, 3771917473), new $Int64(599484404, 2195808264), new $Int64(252818753, 3894702887), new $Int64(780007692, 2099949527), new $Int64(1424094358, 338442522), new $Int64(490737398, 637158004), new $Int64(419862118, 281976339), new $Int64(574970164, 3619802330), new $Int64(1715552825, 3084554784), new $Int64(882872465, 4129772886), new $Int64(43084605, 1680378557), new $Int64(525521057, 3339087776), new $Int64(1680500332, 4220317857), new $Int64(211654685, 2959322499), new $Int64(1675600481, 1488354890), new $Int64(1312620086, 3958162143), new $Int64(920972075, 2773705983), new $Int64(1876039582, 225908689), new $Int64(963748535, 908216283), new $Int64(1541787429, 3574646075), new $Int64(319760557, 1936937569), new $Int64(1519770881, 75492235), new $Int64(816689472, 1935193178), new $Int64(2142521206, 2018250883), new $Int64(455141620, 3943126022), new $Int64(1546084160, 3066544345), new $Int64(1932392669, 2793082663), new $Int64(908474287, 3297036421), new $Int64(1640597065, 2206987825), new $Int64(1594236910, 807894872), new $Int64(366158341, 766252117), new $Int64(2060649606, 3833114345), new $Int64(845619743, 1255067973), new $Int64(1201145605, 741697208), new $Int64(671241040, 2810093753), new $Int64(1109032642, 4229340371), new $Int64(1462188720, 1361684224), new $Int64(988084219, 1906263026), new $Int64(475781207, 3904421704), new $Int64(1523946520, 1769075545), new $Int64(1062308525, 2621599764), new $Int64(1279509432, 3431891480), new $Int64(404732502, 1871896503), new $Int64(128756421, 1412808876), new $Int64(1605404688, 952876175), new $Int64(1917039957, 1824438899), new $Int64(1662295856, 1005035476), new $Int64(1990909507, 527508597), new $Int64(1288873303, 3066806859), new $Int64(565995893, 3244940914), new $Int64(1257737460, 209092916), new $Int64(1899814242, 1242699167), new $Int64(1433653252, 456723774), new $Int64(1776978905, 1001252870), new $Int64(1468772157, 2026725874), new $Int64(857254202, 2137562569), new $Int64(765939740, 3183366709), new $Int64(1533887628, 2612072960), new $Int64(56977098, 1727148468), new $Int64(949899753, 3803658212), new $Int64(1883670356, 479946959), new $Int64(685713571, 1562982345), new $Int64(201241205, 1766109365), new $Int64(700596547, 3257093788), new $Int64(1962768719, 2365720207), new $Int64(93384808, 3742754173), new $Int64(1689098413, 2878193673), new $Int64(1096135042, 2174002182), new $Int64(1313222695, 3573511231), new $Int64(1392911121, 1760299077), new $Int64(771856457, 2260779833), new $Int64(1281464374, 1452805722), new $Int64(917811730, 2940011802), new $Int64(1890251082, 1886183802), new $Int64(893897673, 2514369088), new $Int64(1644345561, 3924317791), new $Int64(172616216, 500935732), new $Int64(1403501753, 676580929), new $Int64(581571365, 1184984890), new $Int64(1455515235, 1271474274), new $Int64(318728910, 3163791473), new $Int64(2051027584, 2842487377), new $Int64(1511537551, 2170968612), new $Int64(573262976, 3535856740), new $Int64(94256461, 1488599718), new $Int64(966951817, 3408913763), new $Int64(60951736, 2501050084), new $Int64(1272353200, 1639124157), new $Int64(138001144, 4088176393), new $Int64(1574896563, 3989947576), new $Int64(1982239940, 3414355209), new $Int64(1355154361, 2275136352), new $Int64(89709303, 2151835223), new $Int64(1216338715, 1654534827), new $Int64(1467562197, 377892833), new $Int64(1664767638, 660204544), new $Int64(85706799, 390828249), new $Int64(725310955, 3402783878), new $Int64(678849488, 3717936603), new $Int64(1113532086, 2211058823), new $Int64(1564224320, 2692150867), new $Int64(1952770442, 1928910388), new $Int64(788716862, 3931011137), new $Int64(1083670504, 1112701047), new $Int64(2079333076, 2452299106), new $Int64(1251318826, 2337204777), new $Int64(1774877857, 273889282), new $Int64(1798719843, 1462008793), new $Int64(2138834788, 1554494002), new $Int64(952516517, 182675323), new $Int64(548928884, 1882802136), new $Int64(589279648, 3700220025), new $Int64(381039426, 3083431543), new $Int64(1295624457, 3622207527), new $Int64(338126939, 432729309), new $Int64(480013522, 2391914317), new $Int64(297925497, 235747924), new $Int64(2120733629, 3088823825), new $Int64(1402403853, 2314658321), new $Int64(1165929723, 2957634338), new $Int64(501323675, 4117056981), new $Int64(1564699815, 1482500298), new $Int64(1406657158, 840489337), new $Int64(799522364, 3483178565), new $Int64(532129761, 2074004656), new $Int64(724246478, 3643392642), new $Int64(1482330167, 1583624461), new $Int64(1261660694, 287473085), new $Int64(1667835381, 3136843981), new $Int64(1138806821, 1266970974), new $Int64(135185781, 1998688839), new $Int64(392094735, 1492900209), new $Int64(1031326774, 1538112737), new $Int64(76914806, 2207265429), new $Int64(260686035, 963263315), new $Int64(1671145500, 2295892134), new $Int64(1068469660, 2002560897), new $Int64(1791233343, 1369254035), new $Int64(33436120, 3353312708), new $Int64(57507843, 947771099), new $Int64(201728503, 1747061399), new $Int64(1507240140, 2047354631), new $Int64(720000810, 4165367136), new $Int64(479265078, 3388864963), new $Int64(1195302398, 286492130), new $Int64(2045622690, 2795735007), new $Int64(1431753082, 3703961339), new $Int64(1999047161, 1797825479), new $Int64(1429039600, 1116589674), new $Int64(482063550, 2593309206), new $Int64(1329049334, 3404995677), new $Int64(1396904208, 3453462936), new $Int64(1014767077, 3016498634), new $Int64(75698599, 1650371545), new $Int64(1592007860, 212344364), new $Int64(1127766888, 3843932156), new $Int64(1399463792, 3573129983), new $Int64(1256901817, 665897820), new $Int64(1071492673, 1675628772), new $Int64(243225682, 2831752928), new $Int64(2120298836, 1486294219), new $Int64(193076235, 268782709), new $Int64(1145360145, 4186179080), new $Int64(624342951, 1613720397), new $Int64(857179861, 2703686015), new $Int64(1235864944, 2205342611), new $Int64(1474779655, 1411666394), new $Int64(619028749, 677744900), new $Int64(270855115, 4172867247), new $Int64(135494707, 2163418403), new $Int64(849547544, 2841526879), new $Int64(1029966689, 1082141470), new $Int64(377371856, 4046134367), new $Int64(51415528, 2142943655), new $Int64(1897659315, 3124627521), new $Int64(998228909, 219992939), new $Int64(1068692697, 1756846531), new $Int64(1283749206, 1225118210), new $Int64(1621625642, 1647770243), new $Int64(111523943, 444807907), new $Int64(2036369448, 3952076173), new $Int64(53201823, 1461839639), new $Int64(315761893, 3699250910), new $Int64(702974850, 1373688981), new $Int64(734022261, 147523747), new $Int64(100152742, 1211276581), new $Int64(1294440951, 2548832680), new $Int64(1144696256, 1995631888), new $Int64(154500578, 2011457303), new $Int64(796460974, 3057425772), new $Int64(667839456, 81484597), new $Int64(465502760, 3646681560), new $Int64(775020923, 635548515), new $Int64(602489502, 2508044581), new $Int64(353263531, 1014917157), new $Int64(719992433, 3214891315), new $Int64(852684611, 959582252), new $Int64(226415134, 3347040449), new $Int64(1784615552, 4102971975), new $Int64(397887437, 4078022210), new $Int64(1610679822, 2851767182), new $Int64(749162636, 1540160644), new $Int64(598384772, 1057290595), new $Int64(2034890660, 3907769253), new $Int64(579300318, 4248952684), new $Int64(1092907599, 132554364), new $Int64(1061621234, 1029351092), new $Int64(697840928, 2583007416), new $Int64(298619124, 1486185789), new $Int64(55905697, 2871589073), new $Int64(2017643612, 723203291), new $Int64(146250550, 2494333952), new $Int64(1064490251, 2230939180), new $Int64(342915576, 3943232912), new $Int64(1768732449, 2181367922), new $Int64(1418222537, 2889274791), new $Int64(1824032949, 2046728161), new $Int64(1653899792, 1376052477), new $Int64(1022327048, 381236993), new $Int64(1034385958, 3188942166), new $Int64(2073003539, 350070824), new $Int64(144881592, 61758415), new $Int64(1405659422, 3492950336), new $Int64(117440928, 3093818430), new $Int64(1693893113, 2962480613), new $Int64(235432940, 3154871160), new $Int64(511005079, 3228564679), new $Int64(610731502, 888276216), new $Int64(1200780674, 3574998604), new $Int64(870415268, 1967526716), new $Int64(591335707, 1554691298), new $Int64(574459414, 339944798), new $Int64(1223764147, 1154515356), new $Int64(1825645307, 967516237), new $Int64(1546195135, 596588202), new $Int64(279882768, 3764362170), new $Int64(492091056, 266611402), new $Int64(1754227768, 2047856075), new $Int64(1146757215, 21444105), new $Int64(1198058894, 3065563181), new $Int64(1915064845, 1140663212), new $Int64(633187674, 2323741028), new $Int64(2126290159, 3103873707), new $Int64(1008658319, 2766828349), new $Int64(1661896145, 1970872996), new $Int64(1628585413, 3766615585), new $Int64(1552335120, 2036813414), new $Int64(152606527, 3105536507), new $Int64(13954645, 3396176938), new $Int64(1426081645, 1377154485), new $Int64(2085644467, 3807014186), new $Int64(543009040, 3710110597), new $Int64(396058129, 916420443), new $Int64(734556788, 2103831255), new $Int64(381322154, 717331943), new $Int64(572884752, 3550505941), new $Int64(45939673, 378749927), new $Int64(149867929, 611017331), new $Int64(592130075, 758907650), new $Int64(1012992349, 154266815), new $Int64(1107028706, 1407468696), new $Int64(469292398, 970098704), new $Int64(1862426162, 1971660656), new $Int64(998365243, 3332747885), new $Int64(1947089649, 1935189867), new $Int64(1510248801, 203520055), new $Int64(842317902, 3916463034), new $Int64(1758884993, 3474113316), new $Int64(1036101639, 316544223), new $Int64(373738757, 1650844677), new $Int64(1240292229, 4267565603), new $Int64(1077208624, 2501167616), new $Int64(626831785, 3929401789), new $Int64(56122796, 337170252), new $Int64(1186981558, 2061966842), new $Int64(1843292800, 2508461464), new $Int64(206012532, 2791377107), new $Int64(1240791848, 1227227588), new $Int64(1813978778, 1709681848), new $Int64(1153692192, 3768820575), new $Int64(1145186199, 2887126398), new $Int64(700372314, 296561685), new $Int64(700300844, 3729960077), new $Int64(575172304, 372833036), new $Int64(2078875613, 2409779288), new $Int64(1829161290, 555274064), new $Int64(1041887929, 4239804901), new $Int64(1839403216, 3723486978), new $Int64(498390553, 2145871984), new $Int64(564717933, 3565480803), new $Int64(578829821, 2197313814), new $Int64(974785092, 3613674566), new $Int64(438638731, 3042093666), new $Int64(2050927384, 3324034321), new $Int64(869420878, 3708873369), new $Int64(946682149, 1698090092), new $Int64(1618900382, 4213940712), new $Int64(304003901, 2087477361), new $Int64(381315848, 2407950639), new $Int64(851258090, 3942568569), new $Int64(923583198, 4088074412), new $Int64(723260036, 2964773675), new $Int64(1473561819, 1539178386), new $Int64(1062961552, 2694849566), new $Int64(460977733, 2120273838), new $Int64(542912908, 2484608657), new $Int64(880846449, 2956190677), new $Int64(1970902366, 4223313749), new $Int64(662161910, 3502682327), new $Int64(705634754, 4133891139), new $Int64(1116124348, 1166449596), new $Int64(1038247601, 3362705993), new $Int64(93734798, 3892921029), new $Int64(1876124043, 786869787), new $Int64(1057490746, 1046342263), new $Int64(242763728, 493777327), new $Int64(1293910447, 3304827646), new $Int64(616460742, 125356352), new $Int64(499300063, 74094113), new $Int64(1351896723, 2500816079), new $Int64(1657235204, 514015239), new $Int64(1377565129, 543520454), new $Int64(107706923, 3614531153), new $Int64(2056746300, 2356753985), new $Int64(1390062617, 2018141668), new $Int64(131272971, 2087974891), new $Int64(644556607, 3166972343), new $Int64(372256200, 1517638666), new $Int64(1212207984, 173466846), new $Int64(1451709187, 4241513471), new $Int64(733932806, 2783126920), new $Int64(1972004134, 4167264826), new $Int64(29260506, 3907395640), new $Int64(1236582087, 1539634186), new $Int64(1551526350, 178241987), new $Int64(2034206012, 182168164), new $Int64(1044953189, 2386154934), new $Int64(1379126408, 4077374341), new $Int64(32803926, 1732699140), new $Int64(1726425903, 1041306002), new $Int64(1860414813, 2068001749), new $Int64(1005320202, 3208962910), new $Int64(844054010, 697710380), new $Int64(638124245, 2228431183), new $Int64(1337169671, 3554678728), new $Int64(1396494601, 173470263), new $Int64(2061597383, 3848297795), new $Int64(1220546671, 246236185), new $Int64(163293187, 2066374846), new $Int64(1771673660, 312890749), new $Int64(703378057, 3573310289), new $Int64(1548631747, 143166754), new $Int64(613554316, 2081511079), new $Int64(1197802104, 486038032), new $Int64(240999859, 2982218564), new $Int64(364901986, 1000939191), new $Int64(1902782651, 2750454885), new $Int64(1475638791, 3375313137), new $Int64(503615608, 881302957), new $Int64(638698903, 2514186393), new $Int64(443860803, 360024739), new $Int64(1399671872, 292500025), new $Int64(1381210821, 2276300752), new $Int64(521803381, 4069087683), new $Int64(208500981, 1637778212), new $Int64(720490469, 1676670893), new $Int64(1067262482, 3855174429), new $Int64(2114075974, 2067248671), new $Int64(2058057389, 2884561259), new $Int64(1341742553, 2456511185), new $Int64(983726246, 561175414), new $Int64(427994085, 432588903), new $Int64(885133709, 4059399550), new $Int64(2054387382, 1075014784), new $Int64(413651020, 2728058415), new $Int64(1839142064, 1299703678), new $Int64(1262333188, 2347583393), new $Int64(1285481956, 2468164145), new $Int64(989129637, 1140014346), new $Int64(2033889184, 1936972070), new $Int64(409904655, 3870530098), new $Int64(1662989391, 1717789158), new $Int64(1914486492, 1153452491), new $Int64(1157059232, 3948827651), new $Int64(790338018, 2101413152), new $Int64(1495744672, 3854091229), new $Int64(83644069, 4215565463), new $Int64(762206335, 1202710438), new $Int64(1582574611, 2072216740), new $Int64(705690639, 2066751068), new $Int64(33900336, 173902580), new $Int64(1405499842, 142459001), new $Int64(172391592, 1889151926), new $Int64(1648540523, 3034199774), new $Int64(1618587731, 516490102), new $Int64(93114264, 3692577783), new $Int64(68662295, 2953948865), new $Int64(1826544975, 4041040923), new $Int64(204965672, 592046130), new $Int64(1441840008, 384297211), new $Int64(95834184, 265863924), new $Int64(2101717619, 1333136237), new $Int64(1499611781, 1406273556), new $Int64(1074670496, 426305476), new $Int64(125704633, 2750898176), new $Int64(488068495, 1633944332), new $Int64(2037723464, 3236349343), new $Int64(444060402, 4013676611), new $Int64(1718532237, 2265047407), new $Int64(1433593806, 875071080), new $Int64(1804436145, 1418843655), new $Int64(2009228711, 451657300), new $Int64(1229446621, 1866374663), new $Int64(1653472867, 1551455622), new $Int64(577191481, 3560962459), new $Int64(1669204077, 3347903778), new $Int64(1849156454, 2675874918), new $Int64(316128071, 2762991672), new $Int64(530492383, 3689068477), new $Int64(844089962, 4071997905), new $Int64(1508155730, 1381702441), new $Int64(2089931018, 2373284878), new $Int64(1283216186, 2143983064), new $Int64(308739063, 1938207195), new $Int64(1754949306, 1188152253), new $Int64(1272345009, 615870490), new $Int64(742653194, 2662252621), new $Int64(1477718295, 3839976789), new $Int64(56149435, 306752547), new $Int64(720795581, 2162363077), new $Int64(2090431015, 2767224719), new $Int64(675859549, 2628837712), new $Int64(1678405918, 2967771969), new $Int64(1694285728, 499792248), new $Int64(403352367, 4285253508), new $Int64(962357072, 2856511070), new $Int64(679471692, 2526409716), new $Int64(353777175, 1240875658), new $Int64(1232590226, 2577342868), new $Int64(1146185433, 4136853496), new $Int64(670368674, 2403540137), new $Int64(1372824515, 1371410668), new $Int64(1970921600, 371758825), new $Int64(1706420536, 1528834084), new $Int64(2075795018, 1504757260), new $Int64(685663576, 699052551), new $Int64(1641940109, 3347789870), new $Int64(1951619734, 3430604759), new $Int64(2119672219, 1935601723), new $Int64(966789690, 834676166)]);
- globalRand = New(new lockedSource.ptr(new nosync.Mutex.ptr(), NewSource(new $Int64(0, 1))));
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["math/big"] = (function() {
- var $pkg = {}, $init, binary, errors, fmt, nosync, io, math, rand, strings, Word, Int, nat, divisor, Rat, arrayType, structType, sliceType, sliceType$1, ptrType, sliceType$2, ptrType$1, sliceType$3, arrayType$1, ptrType$2, ptrType$3, ptrType$4, intOne, natOne, natTwo, natTen, karatsubaThreshold, leafSize, cacheBase10, deBruijn32Lookup, deBruijn64Lookup, mulWW, divWW, addVV, subVV, addVW, subVW, shlVU, shrVU, mulAddVWW, addMulVVW, divWVW, bitLen, addWW_g, subWW_g, mulWW_g, mulAddWWW_g, bitLen_g, leadingZeros, divWW_g, addVV_g, subVV_g, addVW_g, subVW_g, shlVU_g, shrVU_g, mulAddVWW_g, addMulVVW_g, divWVW_g, NewInt, charset, writeMultiple, low32, low64, basicMul, karatsubaAdd, karatsubaSub, karatsuba, alias, addAt, max, karatsubaLen, hexValue, divisors, trailingZeroBits, greaterThan, NewRat, quotToFloat32, quotToFloat64, mulDenom, scaleDenom, ratTok;
- binary = $packages["encoding/binary"];
- errors = $packages["errors"];
- fmt = $packages["fmt"];
- nosync = $packages["github.com/gopherjs/gopherjs/nosync"];
- io = $packages["io"];
- math = $packages["math"];
- rand = $packages["math/rand"];
- strings = $packages["strings"];
- Word = $pkg.Word = $newType(4, $kindUintptr, "big.Word", "Word", "math/big", null);
- Int = $pkg.Int = $newType(0, $kindStruct, "big.Int", "Int", "math/big", function(neg_, abs_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.neg = false;
- this.abs = nat.nil;
- return;
- }
- this.neg = neg_;
- this.abs = abs_;
- });
- nat = $pkg.nat = $newType(12, $kindSlice, "big.nat", "nat", "math/big", null);
- divisor = $pkg.divisor = $newType(0, $kindStruct, "big.divisor", "divisor", "math/big", function(bbb_, nbits_, ndigits_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.bbb = nat.nil;
- this.nbits = 0;
- this.ndigits = 0;
- return;
- }
- this.bbb = bbb_;
- this.nbits = nbits_;
- this.ndigits = ndigits_;
- });
- Rat = $pkg.Rat = $newType(0, $kindStruct, "big.Rat", "Rat", "math/big", function(a_, b_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.a = new Int.ptr();
- this.b = new Int.ptr();
- return;
- }
- this.a = a_;
- this.b = b_;
- });
- arrayType = $arrayType(divisor, 64);
- structType = $structType([{prop: "Mutex", name: "", pkg: "", typ: nosync.Mutex, tag: ""}, {prop: "table", name: "table", pkg: "math/big", typ: arrayType, tag: ""}]);
- sliceType = $sliceType($Uint8);
- sliceType$1 = $sliceType(Word);
- ptrType = $ptrType(Int);
- sliceType$2 = $sliceType($emptyInterface);
- ptrType$1 = $ptrType(Word);
- sliceType$3 = $sliceType(divisor);
- arrayType$1 = $arrayType(nat, 16);
- ptrType$2 = $ptrType(nat);
- ptrType$3 = $ptrType(Rat);
- ptrType$4 = $ptrType(rand.Rand);
- mulWW = function(x, y) {
- var $ptr, _tuple, x, y, z0, z1;
- z1 = 0;
- z0 = 0;
- _tuple = mulWW_g(x, y); z1 = _tuple[0]; z0 = _tuple[1];
- return [z1, z0];
- };
- divWW = function(x1, x0, y) {
- var $ptr, _tuple, q, r, x0, x1, y;
- q = 0;
- r = 0;
- _tuple = divWW_g(x1, x0, y); q = _tuple[0]; r = _tuple[1];
- return [q, r];
- };
- addVV = function(z, x, y) {
- var $ptr, c, x, y, z;
- c = 0;
- c = addVV_g(z, x, y);
- return c;
- };
- subVV = function(z, x, y) {
- var $ptr, c, x, y, z;
- c = 0;
- c = subVV_g(z, x, y);
- return c;
- };
- addVW = function(z, x, y) {
- var $ptr, c, x, y, z;
- c = 0;
- c = addVW_g(z, x, y);
- return c;
- };
- subVW = function(z, x, y) {
- var $ptr, c, x, y, z;
- c = 0;
- c = subVW_g(z, x, y);
- return c;
- };
- shlVU = function(z, x, s) {
- var $ptr, c, s, x, z;
- c = 0;
- c = shlVU_g(z, x, s);
- return c;
- };
- shrVU = function(z, x, s) {
- var $ptr, c, s, x, z;
- c = 0;
- c = shrVU_g(z, x, s);
- return c;
- };
- mulAddVWW = function(z, x, y, r) {
- var $ptr, c, r, x, y, z;
- c = 0;
- c = mulAddVWW_g(z, x, y, r);
- return c;
- };
- addMulVVW = function(z, x, y) {
- var $ptr, c, x, y, z;
- c = 0;
- c = addMulVVW_g(z, x, y);
- return c;
- };
- divWVW = function(z, xn, x, y) {
- var $ptr, r, x, xn, y, z;
- r = 0;
- r = divWVW_g(z, xn, x, y);
- return r;
- };
- bitLen = function(x) {
- var $ptr, n, x;
- n = 0;
- n = bitLen_g(x);
- return n;
- };
- addWW_g = function(x, y, c) {
- var $ptr, c, x, y, yc, z0, z1;
- z1 = 0;
- z0 = 0;
- yc = y + c >>> 0;
- z0 = x + yc >>> 0;
- if (z0 < x || yc < y) {
- z1 = 1;
- }
- return [z1, z0];
- };
- subWW_g = function(x, y, c) {
- var $ptr, c, x, y, yc, z0, z1;
- z1 = 0;
- z0 = 0;
- yc = y + c >>> 0;
- z0 = x - yc >>> 0;
- if (z0 > x || yc < y) {
- z1 = 1;
- }
- return [z1, z0];
- };
- mulWW_g = function(x, y) {
- var $ptr, t, w0, w1, w2, x, x0, x1, y, y0, y1, z0, z1;
- z1 = 0;
- z0 = 0;
- x0 = (x & 65535) >>> 0;
- x1 = x >>> 16 >>> 0;
- y0 = (y & 65535) >>> 0;
- y1 = y >>> 16 >>> 0;
- w0 = (((x0 >>> 16 << 16) * y0 >>> 0) + (x0 << 16 >>> 16) * y0) >>> 0;
- t = ((((x1 >>> 16 << 16) * y0 >>> 0) + (x1 << 16 >>> 16) * y0) >>> 0) + (w0 >>> 16 >>> 0) >>> 0;
- w1 = (t & 65535) >>> 0;
- w2 = t >>> 16 >>> 0;
- w1 = w1 + (((((x0 >>> 16 << 16) * y1 >>> 0) + (x0 << 16 >>> 16) * y1) >>> 0)) >>> 0;
- z1 = (((((x1 >>> 16 << 16) * y1 >>> 0) + (x1 << 16 >>> 16) * y1) >>> 0) + w2 >>> 0) + (w1 >>> 16 >>> 0) >>> 0;
- z0 = (((x >>> 16 << 16) * y >>> 0) + (x << 16 >>> 16) * y) >>> 0;
- return [z1, z0];
- };
- mulAddWWW_g = function(x, y, c) {
- var $ptr, _tuple, c, x, y, z0, z1, zz0;
- z1 = 0;
- z0 = 0;
- _tuple = mulWW(x, y); z1 = _tuple[0]; zz0 = _tuple[1];
- z0 = zz0 + c >>> 0;
- if (z0 < zz0) {
- z1 = z1 + (1) >>> 0;
- }
- return [z1, z0];
- };
- bitLen_g = function(x) {
- var $ptr, n, x, y, y$1, y$2, y$3;
- n = 0;
- while (true) {
- if (!(x >= 32768)) { break; }
- n = n + (16) >> 0;
- x = (y = (16), y < 32 ? (x >>> y) : 0) >>> 0;
- }
- if (x >= 128) {
- x = (y$1 = (8), y$1 < 32 ? (x >>> y$1) : 0) >>> 0;
- n = n + (8) >> 0;
- }
- if (x >= 8) {
- x = (y$2 = (4), y$2 < 32 ? (x >>> y$2) : 0) >>> 0;
- n = n + (4) >> 0;
- }
- if (x >= 2) {
- x = (y$3 = (2), y$3 < 32 ? (x >>> y$3) : 0) >>> 0;
- n = n + (2) >> 0;
- }
- if (x >= 1) {
- n = n + (1) >> 0;
- }
- return n;
- };
- leadingZeros = function(x) {
- var $ptr, x;
- return ((32 - bitLen(x) >> 0) >>> 0);
- };
- divWW_g = function(u1, u0, v) {
- var $ptr, _q, _q$1, _tmp, _tmp$1, _tmp$2, _tmp$3, q, q0, q1, r, rhat, s, u0, u1, un0, un1, un10, un21, un32, v, vn0, vn1, y, y$1, y$2, y$3, y$4;
- q = 0;
- r = 0;
- if (u1 >= v) {
- _tmp = 4294967295; _tmp$1 = 4294967295; q = _tmp; r = _tmp$1;
- return [q, r];
- }
- s = leadingZeros(v);
- v = (y = (s), y < 32 ? (v << y) : 0) >>> 0;
- vn1 = v >>> 16 >>> 0;
- vn0 = (v & 65535) >>> 0;
- un32 = (((y$1 = s, y$1 < 32 ? (u1 << y$1) : 0) >>> 0) | ((y$2 = ((32 - s >>> 0)), y$2 < 32 ? (u0 >>> y$2) : 0) >>> 0)) >>> 0;
- un10 = (y$3 = s, y$3 < 32 ? (u0 << y$3) : 0) >>> 0;
- un1 = un10 >>> 16 >>> 0;
- un0 = (un10 & 65535) >>> 0;
- q1 = (_q = un32 / vn1, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- rhat = un32 - ((((q1 >>> 16 << 16) * vn1 >>> 0) + (q1 << 16 >>> 16) * vn1) >>> 0) >>> 0;
- while (true) {
- if (!(q1 >= 65536 || ((((q1 >>> 16 << 16) * vn0 >>> 0) + (q1 << 16 >>> 16) * vn0) >>> 0) > (((((65536 >>> 16 << 16) * rhat >>> 0) + (65536 << 16 >>> 16) * rhat) >>> 0) + un1 >>> 0))) { break; }
- q1 = q1 - (1) >>> 0;
- rhat = rhat + (vn1) >>> 0;
- if (rhat >= 65536) {
- break;
- }
- }
- un21 = (((((un32 >>> 16 << 16) * 65536 >>> 0) + (un32 << 16 >>> 16) * 65536) >>> 0) + un1 >>> 0) - ((((q1 >>> 16 << 16) * v >>> 0) + (q1 << 16 >>> 16) * v) >>> 0) >>> 0;
- q0 = (_q$1 = un21 / vn1, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero"));
- rhat = un21 - ((((q0 >>> 16 << 16) * vn1 >>> 0) + (q0 << 16 >>> 16) * vn1) >>> 0) >>> 0;
- while (true) {
- if (!(q0 >= 65536 || ((((q0 >>> 16 << 16) * vn0 >>> 0) + (q0 << 16 >>> 16) * vn0) >>> 0) > (((((65536 >>> 16 << 16) * rhat >>> 0) + (65536 << 16 >>> 16) * rhat) >>> 0) + un0 >>> 0))) { break; }
- q0 = q0 - (1) >>> 0;
- rhat = rhat + (vn1) >>> 0;
- if (rhat >= 65536) {
- break;
- }
- }
- _tmp$2 = ((((q1 >>> 16 << 16) * 65536 >>> 0) + (q1 << 16 >>> 16) * 65536) >>> 0) + q0 >>> 0; _tmp$3 = (y$4 = s, y$4 < 32 ? ((((((((un21 >>> 16 << 16) * 65536 >>> 0) + (un21 << 16 >>> 16) * 65536) >>> 0) + un0 >>> 0) - ((((q0 >>> 16 << 16) * v >>> 0) + (q0 << 16 >>> 16) * v) >>> 0) >>> 0)) >>> y$4) : 0) >>> 0; q = _tmp$2; r = _tmp$3;
- return [q, r];
- };
- addVV_g = function(z, x, y) {
- var $ptr, _i, _ref, _tuple, c, i, x, y, z;
- c = 0;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- _tuple = addWW_g(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i]), c); c = _tuple[0]; ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = _tuple[1]);
- _i++;
- }
- return c;
- };
- subVV_g = function(z, x, y) {
- var $ptr, _i, _ref, _tuple, c, i, x, y, z;
- c = 0;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- _tuple = subWW_g(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i]), c); c = _tuple[0]; ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = _tuple[1]);
- _i++;
- }
- return c;
- };
- addVW_g = function(z, x, y) {
- var $ptr, _i, _ref, _tuple, c, i, x, y, z;
- c = 0;
- c = y;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- _tuple = addWW_g(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), c, 0); c = _tuple[0]; ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = _tuple[1]);
- _i++;
- }
- return c;
- };
- subVW_g = function(z, x, y) {
- var $ptr, _i, _ref, _tuple, c, i, x, y, z;
- c = 0;
- c = y;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- _tuple = subWW_g(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), c, 0); c = _tuple[0]; ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = _tuple[1]);
- _i++;
- }
- return c;
- };
- shlVU_g = function(z, x, s) {
- var $ptr, c, i, n, nonAsciiName, s, w, w1, x, x$1, x$2, y, y$1, y$2, y$3, z;
- c = 0;
- n = z.$length;
- if (n > 0) {
- nonAsciiName = 32 - s >>> 0;
- w1 = (x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- c = (y = nonAsciiName, y < 32 ? (w1 >>> y) : 0) >>> 0;
- i = n - 1 >> 0;
- while (true) {
- if (!(i > 0)) { break; }
- w = w1;
- w1 = (x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$2]));
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (((y$1 = s, y$1 < 32 ? (w << y$1) : 0) >>> 0) | ((y$2 = nonAsciiName, y$2 < 32 ? (w1 >>> y$2) : 0) >>> 0)) >>> 0);
- i = i - (1) >> 0;
- }
- (0 >= z.$length ? $throwRuntimeError("index out of range") : z.$array[z.$offset + 0] = (y$3 = s, y$3 < 32 ? (w1 << y$3) : 0) >>> 0);
- }
- return c;
- };
- shrVU_g = function(z, x, s) {
- var $ptr, c, i, n, nonAsciiName, s, w, w1, x, x$1, x$2, y, y$1, y$2, y$3, z;
- c = 0;
- n = z.$length;
- if (n > 0) {
- nonAsciiName = 32 - s >>> 0;
- w1 = (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]);
- c = (y = nonAsciiName, y < 32 ? (w1 << y) : 0) >>> 0;
- i = 0;
- while (true) {
- if (!(i < (n - 1 >> 0))) { break; }
- w = w1;
- w1 = (x$1 = i + 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (((y$1 = s, y$1 < 32 ? (w >>> y$1) : 0) >>> 0) | ((y$2 = nonAsciiName, y$2 < 32 ? (w1 << y$2) : 0) >>> 0)) >>> 0);
- i = i + (1) >> 0;
- }
- (x$2 = n - 1 >> 0, ((x$2 < 0 || x$2 >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + x$2] = (y$3 = s, y$3 < 32 ? (w1 >>> y$3) : 0) >>> 0));
- }
- return c;
- };
- mulAddVWW_g = function(z, x, y, r) {
- var $ptr, _i, _ref, _tuple, c, i, r, x, y, z;
- c = 0;
- c = r;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- _tuple = mulAddWWW_g(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), y, c); c = _tuple[0]; ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = _tuple[1]);
- _i++;
- }
- return c;
- };
- addMulVVW_g = function(z, x, y) {
- var $ptr, _i, _ref, _tuple, _tuple$1, c, i, x, y, z, z0, z1;
- c = 0;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- _tuple = mulAddWWW_g(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), y, ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i])); z1 = _tuple[0]; z0 = _tuple[1];
- _tuple$1 = addWW_g(z0, c, 0); c = _tuple$1[0]; ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = _tuple$1[1]);
- c = c + (z1) >>> 0;
- _i++;
- }
- return c;
- };
- divWVW_g = function(z, xn, x, y) {
- var $ptr, _tuple, i, r, x, xn, y, z;
- r = 0;
- r = xn;
- i = z.$length - 1 >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- _tuple = divWW_g(r, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), y); ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = _tuple[0]); r = _tuple[1];
- i = i - (1) >> 0;
- }
- return r;
- };
- Int.ptr.prototype.Sign = function() {
- var $ptr, x;
- x = this;
- if (x.abs.$length === 0) {
- return 0;
- }
- if (x.neg) {
- return -1;
- }
- return 1;
- };
- Int.prototype.Sign = function() { return this.$val.Sign(); };
- Int.ptr.prototype.SetInt64 = function(x) {
- var $ptr, neg, x, z;
- z = this;
- neg = false;
- if ((x.$high < 0 || (x.$high === 0 && x.$low < 0))) {
- neg = true;
- x = new $Int64(-x.$high, -x.$low);
- }
- z.abs = z.abs.setUint64(new $Uint64(x.$high, x.$low));
- z.neg = neg;
- return z;
- };
- Int.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); };
- Int.ptr.prototype.SetUint64 = function(x) {
- var $ptr, x, z;
- z = this;
- z.abs = z.abs.setUint64(x);
- z.neg = false;
- return z;
- };
- Int.prototype.SetUint64 = function(x) { return this.$val.SetUint64(x); };
- NewInt = function(x) {
- var $ptr, x;
- return new Int.ptr().SetInt64(x);
- };
- $pkg.NewInt = NewInt;
- Int.ptr.prototype.Set = function(x) {
- var $ptr, x, z;
- z = this;
- if (!(z === x)) {
- z.abs = z.abs.set(x.abs);
- z.neg = x.neg;
- }
- return z;
- };
- Int.prototype.Set = function(x) { return this.$val.Set(x); };
- Int.ptr.prototype.Bits = function() {
- var $ptr, x, x$1;
- x = this;
- return (x$1 = x.abs, $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length));
- };
- Int.prototype.Bits = function() { return this.$val.Bits(); };
- Int.ptr.prototype.SetBits = function(abs) {
- var $ptr, abs, z;
- z = this;
- z.abs = $subslice(new nat(abs.$array), abs.$offset, abs.$offset + abs.$length).norm();
- z.neg = false;
- return z;
- };
- Int.prototype.SetBits = function(abs) { return this.$val.SetBits(abs); };
- Int.ptr.prototype.Abs = function(x) {
- var $ptr, x, z;
- z = this;
- z.Set(x);
- z.neg = false;
- return z;
- };
- Int.prototype.Abs = function(x) { return this.$val.Abs(x); };
- Int.ptr.prototype.Neg = function(x) {
- var $ptr, x, z;
- z = this;
- z.Set(x);
- z.neg = z.abs.$length > 0 && !z.neg;
- return z;
- };
- Int.prototype.Neg = function(x) { return this.$val.Neg(x); };
- Int.ptr.prototype.Add = function(x, y) {
- var $ptr, neg, x, y, z;
- z = this;
- neg = x.neg;
- if (x.neg === y.neg) {
- z.abs = z.abs.add(x.abs, y.abs);
- } else {
- if (x.abs.cmp(y.abs) >= 0) {
- z.abs = z.abs.sub(x.abs, y.abs);
- } else {
- neg = !neg;
- z.abs = z.abs.sub(y.abs, x.abs);
- }
- }
- z.neg = z.abs.$length > 0 && neg;
- return z;
- };
- Int.prototype.Add = function(x, y) { return this.$val.Add(x, y); };
- Int.ptr.prototype.Sub = function(x, y) {
- var $ptr, neg, x, y, z;
- z = this;
- neg = x.neg;
- if (!(x.neg === y.neg)) {
- z.abs = z.abs.add(x.abs, y.abs);
- } else {
- if (x.abs.cmp(y.abs) >= 0) {
- z.abs = z.abs.sub(x.abs, y.abs);
- } else {
- neg = !neg;
- z.abs = z.abs.sub(y.abs, x.abs);
- }
- }
- z.neg = z.abs.$length > 0 && neg;
- return z;
- };
- Int.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); };
- Int.ptr.prototype.Mul = function(x, y) {
- var $ptr, x, y, z;
- z = this;
- z.abs = z.abs.mul(x.abs, y.abs);
- z.neg = z.abs.$length > 0 && !(x.neg === y.neg);
- return z;
- };
- Int.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); };
- Int.ptr.prototype.MulRange = function(a, b) {
- var $ptr, _tmp, _tmp$1, a, b, neg, x, x$1, z;
- z = this;
- if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) {
- return z.SetInt64(new $Int64(0, 1));
- } else if ((a.$high < 0 || (a.$high === 0 && a.$low <= 0)) && (b.$high > 0 || (b.$high === 0 && b.$low >= 0))) {
- return z.SetInt64(new $Int64(0, 0));
- }
- neg = false;
- if ((a.$high < 0 || (a.$high === 0 && a.$low < 0))) {
- neg = (x = (x$1 = new $Int64(b.$high - a.$high, b.$low - a.$low), new $Int64(x$1.$high & 0, (x$1.$low & 1) >>> 0)), (x.$high === 0 && x.$low === 0));
- _tmp = new $Int64(-b.$high, -b.$low); _tmp$1 = new $Int64(-a.$high, -a.$low); a = _tmp; b = _tmp$1;
- }
- z.abs = z.abs.mulRange(new $Uint64(a.$high, a.$low), new $Uint64(b.$high, b.$low));
- z.neg = neg;
- return z;
- };
- Int.prototype.MulRange = function(a, b) { return this.$val.MulRange(a, b); };
- Int.ptr.prototype.Binomial = function(n, k) {
- var $ptr, _tmp, _tmp$1, a, b, k, n, x, z;
- z = this;
- _tmp = $clone(new Int.ptr(), Int); _tmp$1 = $clone(new Int.ptr(), Int); a = $clone(_tmp, Int); b = $clone(_tmp$1, Int);
- a.MulRange((x = new $Int64(n.$high - k.$high, n.$low - k.$low), new $Int64(x.$high + 0, x.$low + 1)), n);
- b.MulRange(new $Int64(0, 1), k);
- return z.Quo(a, b);
- };
- Int.prototype.Binomial = function(n, k) { return this.$val.Binomial(n, k); };
- Int.ptr.prototype.Quo = function(x, y) {
- var $ptr, _tuple, x, y, z;
- z = this;
- _tuple = z.abs.div(nat.nil, x.abs, y.abs); z.abs = _tuple[0];
- z.neg = z.abs.$length > 0 && !(x.neg === y.neg);
- return z;
- };
- Int.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); };
- Int.ptr.prototype.Rem = function(x, y) {
- var $ptr, _tuple, x, y, z;
- z = this;
- _tuple = nat.nil.div(z.abs, x.abs, y.abs); z.abs = _tuple[1];
- z.neg = z.abs.$length > 0 && x.neg;
- return z;
- };
- Int.prototype.Rem = function(x, y) { return this.$val.Rem(x, y); };
- Int.ptr.prototype.QuoRem = function(x, y, r) {
- var $ptr, _tmp, _tmp$1, _tuple, r, x, y, z;
- z = this;
- _tuple = z.abs.div(r.abs, x.abs, y.abs); z.abs = _tuple[0]; r.abs = _tuple[1];
- _tmp = z.abs.$length > 0 && !(x.neg === y.neg); _tmp$1 = r.abs.$length > 0 && x.neg; z.neg = _tmp; r.neg = _tmp$1;
- return [z, r];
- };
- Int.prototype.QuoRem = function(x, y, r) { return this.$val.QuoRem(x, y, r); };
- Int.ptr.prototype.Div = function(x, y) {
- var $ptr, r, x, y, y_neg, z;
- z = this;
- y_neg = y.neg;
- r = $clone(new Int.ptr(), Int);
- z.QuoRem(x, y, r);
- if (r.neg) {
- if (y_neg) {
- z.Add(z, intOne);
- } else {
- z.Sub(z, intOne);
- }
- }
- return z;
- };
- Int.prototype.Div = function(x, y) { return this.$val.Div(x, y); };
- Int.ptr.prototype.Mod = function(x, y) {
- var $ptr, q, x, y, y0, z;
- z = this;
- y0 = y;
- if (z === y || alias(z.abs, y.abs)) {
- y0 = new Int.ptr().Set(y);
- }
- q = $clone(new Int.ptr(), Int);
- q.QuoRem(x, y, z);
- if (z.neg) {
- if (y0.neg) {
- z.Sub(z, y0);
- } else {
- z.Add(z, y0);
- }
- }
- return z;
- };
- Int.prototype.Mod = function(x, y) { return this.$val.Mod(x, y); };
- Int.ptr.prototype.DivMod = function(x, y, m) {
- var $ptr, m, x, y, y0, z;
- z = this;
- y0 = y;
- if (z === y || alias(z.abs, y.abs)) {
- y0 = new Int.ptr().Set(y);
- }
- z.QuoRem(x, y, m);
- if (m.neg) {
- if (y0.neg) {
- z.Add(z, intOne);
- m.Sub(m, y0);
- } else {
- z.Sub(z, intOne);
- m.Add(m, y0);
- }
- }
- return [z, m];
- };
- Int.prototype.DivMod = function(x, y, m) { return this.$val.DivMod(x, y, m); };
- Int.ptr.prototype.Cmp = function(y) {
- var $ptr, r, x, y;
- r = 0;
- x = this;
- if (x.neg === y.neg) {
- r = x.abs.cmp(y.abs);
- if (x.neg) {
- r = -r;
- }
- } else if (x.neg) {
- r = -1;
- } else {
- r = 1;
- }
- return r;
- };
- Int.prototype.Cmp = function(y) { return this.$val.Cmp(y); };
- Int.ptr.prototype.String = function() {
- var $ptr, x;
- x = this;
- if (x === ptrType.nil) {
- return "";
- } else if (x.neg) {
- return "-" + x.abs.decimalString();
- }
- return x.abs.decimalString();
- };
- Int.prototype.String = function() { return this.$val.String(); };
- charset = function(ch) {
- var $ptr, _ref, ch;
- _ref = ch;
- if (_ref === 98) {
- return "0123456789abcdefghijklmnopqrstuvwxyz".substring(0, 2);
- } else if (_ref === 111) {
- return "0123456789abcdefghijklmnopqrstuvwxyz".substring(0, 8);
- } else if (_ref === 100 || _ref === 115 || _ref === 118) {
- return "0123456789abcdefghijklmnopqrstuvwxyz".substring(0, 10);
- } else if (_ref === 120) {
- return "0123456789abcdefghijklmnopqrstuvwxyz".substring(0, 16);
- } else if (_ref === 88) {
- return "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".substring(0, 16);
- }
- return "";
- };
- writeMultiple = function(s, text, count) {
- var $ptr, _r, b, count, s, text, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; b = $f.b; count = $f.count; s = $f.s; text = $f.text; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (text.length > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (text.length > 0) { */ case 1:
- b = new sliceType($stringToBytes(text));
- /* while (true) { */ case 3:
- /* if (!(count > 0)) { break; } */ if(!(count > 0)) { $s = 4; continue; }
- _r = s.Write(b); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- count = count - (1) >> 0;
- /* } */ $s = 3; continue; case 4:
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: writeMultiple }; } $f.$ptr = $ptr; $f._r = _r; $f.b = b; $f.count = count; $f.s = s; $f.text = text; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.ptr.prototype.Format = function(s, ch) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _tuple, _tuple$1, ch, cs, d, digits, left, length, precision, precisionSet, prefix, right, s, sign, width, widthSet, x, zeroes, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; ch = $f.ch; cs = $f.cs; d = $f.d; digits = $f.digits; left = $f.left; length = $f.length; precision = $f.precision; precisionSet = $f.precisionSet; prefix = $f.prefix; right = $f.right; s = $f.s; sign = $f.sign; width = $f.width; widthSet = $f.widthSet; x = $f.x; zeroes = $f.zeroes; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- cs = charset(ch);
- /* */ if (cs === "") { $s = 1; continue; }
- /* */ if (x === ptrType.nil) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (cs === "") { */ case 1:
- _r = fmt.Fprintf(s, "%%!%c(big.Int=%s)", new sliceType$2([new $Int32(ch), new $String(x.String())])); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- return;
- $s = 3; continue;
- /* } else if (x === ptrType.nil) { */ case 2:
- _r$1 = fmt.Fprint(s, new sliceType$2([new $String("")])); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- return;
- /* } */ case 3:
- sign = "";
- /* */ if (x.neg) { $s = 6; continue; }
- _r$2 = s.Flag(43); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 7; continue; }
- _r$3 = s.Flag(32); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (x.neg) { */ case 6:
- sign = "-";
- $s = 9; continue;
- /* } else if (_r$2) { */ case 7:
- sign = "+";
- $s = 9; continue;
- /* } else if (_r$3) { */ case 8:
- sign = " ";
- /* } */ case 9:
- prefix = "";
- _r$4 = s.Flag(35); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (_r$4) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (_r$4) { */ case 12:
- _ref = ch;
- if (_ref === 111) {
- prefix = "0";
- } else if (_ref === 120) {
- prefix = "0x";
- } else if (_ref === 88) {
- prefix = "0X";
- }
- /* } */ case 13:
- digits = x.abs.string(cs);
- left = 0;
- zeroes = 0;
- right = 0;
- _r$5 = s.Precision(); /* */ $s = 15; case 15: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _tuple = _r$5; precision = _tuple[0]; precisionSet = _tuple[1];
- if (precisionSet) {
- if (digits.length < precision) {
- zeroes = precision - digits.length >> 0;
- } else if (digits === "0" && (precision === 0)) {
- return;
- }
- }
- length = ((sign.length + prefix.length >> 0) + zeroes >> 0) + digits.length >> 0;
- _r$6 = s.Width(); /* */ $s = 16; case 16: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$1 = _r$6; width = _tuple$1[0]; widthSet = _tuple$1[1];
- /* */ if (widthSet && length < width) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (widthSet && length < width) { */ case 17:
- d = width - length >> 0;
- _r$7 = s.Flag(45); /* */ $s = 23; case 23: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (_r$7) { $s = 19; continue; }
- _r$8 = s.Flag(48); /* */ $s = 24; case 24: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- /* */ if (_r$8 && !precisionSet) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (_r$7) { */ case 19:
- right = d;
- $s = 22; continue;
- /* } else if (_r$8 && !precisionSet) { */ case 20:
- zeroes = d;
- $s = 22; continue;
- /* } else { */ case 21:
- left = d;
- /* } */ case 22:
- /* } */ case 18:
- $r = writeMultiple(s, " ", left); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = writeMultiple(s, sign, 1); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = writeMultiple(s, prefix, 1); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = writeMultiple(s, "0", zeroes); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = writeMultiple(s, digits, 1); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = writeMultiple(s, " ", right); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Format }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.ch = ch; $f.cs = cs; $f.d = d; $f.digits = digits; $f.left = left; $f.length = length; $f.precision = precision; $f.precisionSet = precisionSet; $f.prefix = prefix; $f.right = right; $f.s = s; $f.sign = sign; $f.width = width; $f.widthSet = widthSet; $f.x = x; $f.zeroes = zeroes; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.Format = function(s, ch) { return this.$val.Format(s, ch); };
- Int.ptr.prototype.scan = function(r, base) {
- var $ptr, _r, _r$1, _r$2, _ref, _tuple, _tuple$1, base, ch, err, neg, r, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; ch = $f.ch; err = $f.err; neg = $f.neg; r = $f.r; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- _r = r.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; ch = _tuple[0]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [ptrType.nil, 0, err];
- }
- neg = false;
- _ref = ch;
- /* */ if (_ref === 45) { $s = 2; continue; }
- /* */ if (_ref === 43) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_ref === 45) { */ case 2:
- neg = true;
- $s = 5; continue;
- /* } else if (_ref === 43) { */ case 3:
- $s = 5; continue;
- /* } else { */ case 4:
- _r$1 = r.UnreadRune(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- /* } */ case 5:
- _r$2 = z.abs.scan(r, base); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$1 = _r$2; z.abs = _tuple$1[0]; base = _tuple$1[1]; err = _tuple$1[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [ptrType.nil, base, err];
- }
- z.neg = z.abs.$length > 0 && neg;
- return [z, base, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.scan }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.ch = ch; $f.err = err; $f.neg = neg; $f.r = r; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.scan = function(r, base) { return this.$val.scan(r, base); };
- Int.ptr.prototype.Scan = function(s, ch) {
- var $ptr, _r, _ref, _tuple, base, ch, err, s, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; base = $f.base; ch = $f.ch; err = $f.err; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- $r = s.SkipSpace(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- base = 0;
- _ref = ch;
- if (_ref === 98) {
- base = 2;
- } else if (_ref === 111) {
- base = 8;
- } else if (_ref === 100) {
- base = 10;
- } else if (_ref === 120 || _ref === 88) {
- base = 16;
- } else if (_ref === 115 || _ref === 118) {
- } else {
- return errors.New("Int.Scan: invalid verb");
- }
- _r = z.scan(s, base); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; err = _tuple[2];
- return err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Scan }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.base = base; $f.ch = ch; $f.err = err; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); };
- low32 = function(z) {
- var $ptr, z;
- if (z.$length === 0) {
- return 0;
- }
- return ((0 >= z.$length ? $throwRuntimeError("index out of range") : z.$array[z.$offset + 0]) >>> 0);
- };
- low64 = function(z) {
- var $ptr, v, x, x$1, x$2, z;
- if (z.$length === 0) {
- return new $Uint64(0, 0);
- }
- v = (x = (0 >= z.$length ? $throwRuntimeError("index out of range") : z.$array[z.$offset + 0]), new $Uint64(0, x.constructor === Number ? x : 1));
- if (true && z.$length > 1) {
- v = (x$1 = $shiftLeft64((x$2 = (1 >= z.$length ? $throwRuntimeError("index out of range") : z.$array[z.$offset + 1]), new $Uint64(0, x$2.constructor === Number ? x$2 : 1)), 32), new $Uint64(v.$high | x$1.$high, (v.$low | x$1.$low) >>> 0));
- }
- return v;
- };
- Int.ptr.prototype.Int64 = function() {
- var $ptr, v, x, x$1;
- x = this;
- v = (x$1 = low64(x.abs), new $Int64(x$1.$high, x$1.$low));
- if (x.neg) {
- v = new $Int64(-v.$high, -v.$low);
- }
- return v;
- };
- Int.prototype.Int64 = function() { return this.$val.Int64(); };
- Int.ptr.prototype.Uint64 = function() {
- var $ptr, x;
- x = this;
- return low64(x.abs);
- };
- Int.prototype.Uint64 = function() { return this.$val.Uint64(); };
- Int.ptr.prototype.SetString = function(s, base) {
- var $ptr, _r, _tuple, _tuple$1, base, err, r, s, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; base = $f.base; err = $f.err; r = $f.r; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- r = strings.NewReader(s);
- _r = z.scan(r, base); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [ptrType.nil, false];
- }
- _tuple$1 = r.ReadRune(); err = _tuple$1[2];
- if (!($interfaceIsEqual(err, io.EOF))) {
- return [ptrType.nil, false];
- }
- return [z, true];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.SetString }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.base = base; $f.err = err; $f.r = r; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.SetString = function(s, base) { return this.$val.SetString(s, base); };
- Int.ptr.prototype.SetBytes = function(buf) {
- var $ptr, buf, z;
- z = this;
- z.abs = z.abs.setBytes(buf);
- z.neg = false;
- return z;
- };
- Int.prototype.SetBytes = function(buf) { return this.$val.SetBytes(buf); };
- Int.ptr.prototype.Bytes = function() {
- var $ptr, buf, x;
- x = this;
- buf = $makeSlice(sliceType, (x.abs.$length * 4 >> 0));
- return $subslice(buf, x.abs.bytes(buf));
- };
- Int.prototype.Bytes = function() { return this.$val.Bytes(); };
- Int.ptr.prototype.BitLen = function() {
- var $ptr, x;
- x = this;
- return x.abs.bitLen();
- };
- Int.prototype.BitLen = function() { return this.$val.BitLen(); };
- Int.ptr.prototype.Exp = function(x, y, m) {
- var $ptr, m, mWords, x, y, yWords, z;
- z = this;
- yWords = nat.nil;
- if (!y.neg) {
- yWords = y.abs;
- }
- mWords = nat.nil;
- if (!(m === ptrType.nil)) {
- mWords = m.abs;
- }
- z.abs = z.abs.expNN(x.abs, yWords, mWords);
- z.neg = z.abs.$length > 0 && x.neg && yWords.$length > 0 && ((((0 >= yWords.$length ? $throwRuntimeError("index out of range") : yWords.$array[yWords.$offset + 0]) & 1) >>> 0) === 1);
- if (z.neg && mWords.$length > 0) {
- z.abs = z.abs.sub(mWords, z.abs);
- z.neg = false;
- }
- return z;
- };
- Int.prototype.Exp = function(x, y, m) { return this.$val.Exp(x, y, m); };
- Int.ptr.prototype.GCD = function(x, y, a, b) {
- var $ptr, A, B, X, Y, _tmp, _tmp$1, _tuple, a, b, lastX, lastY, q, r, temp, x, y, z;
- z = this;
- if (a.Sign() <= 0 || b.Sign() <= 0) {
- z.SetInt64(new $Int64(0, 0));
- if (!(x === ptrType.nil)) {
- x.SetInt64(new $Int64(0, 0));
- }
- if (!(y === ptrType.nil)) {
- y.SetInt64(new $Int64(0, 0));
- }
- return z;
- }
- if (x === ptrType.nil && y === ptrType.nil) {
- return z.binaryGCD(a, b);
- }
- A = new Int.ptr().Set(a);
- B = new Int.ptr().Set(b);
- X = new Int.ptr();
- Y = new Int.ptr().SetInt64(new $Int64(0, 1));
- lastX = new Int.ptr().SetInt64(new $Int64(0, 1));
- lastY = new Int.ptr();
- q = new Int.ptr();
- temp = new Int.ptr();
- while (true) {
- if (!(B.abs.$length > 0)) { break; }
- r = new Int.ptr();
- _tuple = q.QuoRem(A, B, r); q = _tuple[0]; r = _tuple[1];
- _tmp = B; _tmp$1 = r; A = _tmp; B = _tmp$1;
- temp.Set(X);
- X.Mul(X, q);
- X.neg = !X.neg;
- X.Add(X, lastX);
- lastX.Set(temp);
- temp.Set(Y);
- Y.Mul(Y, q);
- Y.neg = !Y.neg;
- Y.Add(Y, lastY);
- lastY.Set(temp);
- }
- if (!(x === ptrType.nil)) {
- $copy(x, lastX, Int);
- }
- if (!(y === ptrType.nil)) {
- $copy(y, lastY, Int);
- }
- $copy(z, A, Int);
- return z;
- };
- Int.prototype.GCD = function(x, y, a, b) { return this.$val.GCD(x, y, a, b); };
- Int.ptr.prototype.binaryGCD = function(a, b) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, a, b, k, t, u, v, vk, x, z;
- z = this;
- u = z;
- v = new Int.ptr();
- if (a.abs.$length > b.abs.$length) {
- u.Set(b);
- v.Rem(a, b);
- } else if (a.abs.$length < b.abs.$length) {
- u.Set(a);
- v.Rem(b, a);
- } else {
- u.Set(a);
- v.Set(b);
- }
- if (v.abs.$length === 0) {
- return u;
- }
- k = u.abs.trailingZeroBits();
- vk = v.abs.trailingZeroBits();
- if (vk < k) {
- k = vk;
- }
- u.Rsh(u, k);
- v.Rsh(v, k);
- t = new Int.ptr();
- if (!(((((x = u.abs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])) & 1) >>> 0) === 0))) {
- t.Neg(v);
- } else {
- t.Set(u);
- }
- while (true) {
- if (!(t.abs.$length > 0)) { break; }
- t.Rsh(t, t.abs.trailingZeroBits());
- if (t.neg) {
- _tmp = t; _tmp$1 = v; v = _tmp; t = _tmp$1;
- v.neg = v.abs.$length > 0 && !v.neg;
- } else {
- _tmp$2 = t; _tmp$3 = u; u = _tmp$2; t = _tmp$3;
- }
- t.Sub(u, v);
- }
- return z.Lsh(u, k);
- };
- Int.prototype.binaryGCD = function(a, b) { return this.$val.binaryGCD(a, b); };
- Int.ptr.prototype.ProbablyPrime = function(n) {
- var $ptr, _r, _v, n, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _v = $f._v; n = $f.n; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- if (!(!x.neg)) { _v = false; $s = 1; continue s; }
- _r = x.abs.probablyPrime(n); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 1:
- return _v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.ProbablyPrime }; } $f.$ptr = $ptr; $f._r = _r; $f._v = _v; $f.n = n; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.ProbablyPrime = function(n) { return this.$val.ProbablyPrime(n); };
- Int.ptr.prototype.Rand = function(rnd, n) {
- var $ptr, _r, n, rnd, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; rnd = $f.rnd; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- z.neg = false;
- if (n.neg || (n.abs.$length === 0)) {
- z.abs = nat.nil;
- return z;
- }
- _r = z.abs.random(rnd, n.abs, n.abs.bitLen()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- z.abs = _r;
- return z;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.Rand }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.rnd = rnd; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.Rand = function(rnd, n) { return this.$val.Rand(rnd, n); };
- Int.ptr.prototype.ModInverse = function(g, n) {
- var $ptr, d, g, n, z;
- z = this;
- d = $clone(new Int.ptr(), Int);
- d.GCD(z, ptrType.nil, g, n);
- if (z.neg) {
- z.Add(z, n);
- }
- return z;
- };
- Int.prototype.ModInverse = function(g, n) { return this.$val.ModInverse(g, n); };
- Int.ptr.prototype.Lsh = function(x, n) {
- var $ptr, n, x, z;
- z = this;
- z.abs = z.abs.shl(x.abs, n);
- z.neg = x.neg;
- return z;
- };
- Int.prototype.Lsh = function(x, n) { return this.$val.Lsh(x, n); };
- Int.ptr.prototype.Rsh = function(x, n) {
- var $ptr, n, t, x, z;
- z = this;
- if (x.neg) {
- t = z.abs.sub(x.abs, natOne);
- t = t.shr(t, n);
- z.abs = t.add(t, natOne);
- z.neg = true;
- return z;
- }
- z.abs = z.abs.shr(x.abs, n);
- z.neg = false;
- return z;
- };
- Int.prototype.Rsh = function(x, n) { return this.$val.Rsh(x, n); };
- Int.ptr.prototype.Bit = function(i) {
- var $ptr, i, t, x, x$1;
- x = this;
- if (i === 0) {
- if (x.abs.$length > 0) {
- return ((((x$1 = x.abs, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])) & 1) >>> 0) >>> 0);
- }
- return 0;
- }
- if (i < 0) {
- $panic(new $String("negative bit index"));
- }
- if (x.neg) {
- t = nat.nil.sub(x.abs, natOne);
- return (t.bit((i >>> 0)) ^ 1) >>> 0;
- }
- return x.abs.bit((i >>> 0));
- };
- Int.prototype.Bit = function(i) { return this.$val.Bit(i); };
- Int.ptr.prototype.SetBit = function(x, i, b) {
- var $ptr, b, i, t, x, z;
- z = this;
- if (i < 0) {
- $panic(new $String("negative bit index"));
- }
- if (x.neg) {
- t = z.abs.sub(x.abs, natOne);
- t = t.setBit(t, (i >>> 0), (b ^ 1) >>> 0);
- z.abs = t.add(t, natOne);
- z.neg = z.abs.$length > 0;
- return z;
- }
- z.abs = z.abs.setBit(x.abs, (i >>> 0), b);
- z.neg = false;
- return z;
- };
- Int.prototype.SetBit = function(x, i, b) { return this.$val.SetBit(x, i, b); };
- Int.ptr.prototype.And = function(x, y) {
- var $ptr, _tmp, _tmp$1, x, x1, y, y1, y1$1, z;
- z = this;
- if (x.neg === y.neg) {
- if (x.neg) {
- x1 = nat.nil.sub(x.abs, natOne);
- y1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.add(z.abs.or(x1, y1), natOne);
- z.neg = true;
- return z;
- }
- z.abs = z.abs.and(x.abs, y.abs);
- z.neg = false;
- return z;
- }
- if (x.neg) {
- _tmp = y; _tmp$1 = x; x = _tmp; y = _tmp$1;
- }
- y1$1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.andNot(x.abs, y1$1);
- z.neg = false;
- return z;
- };
- Int.prototype.And = function(x, y) { return this.$val.And(x, y); };
- Int.ptr.prototype.AndNot = function(x, y) {
- var $ptr, x, x1, x1$1, y, y1, y1$1, z;
- z = this;
- if (x.neg === y.neg) {
- if (x.neg) {
- x1 = nat.nil.sub(x.abs, natOne);
- y1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.andNot(y1, x1);
- z.neg = false;
- return z;
- }
- z.abs = z.abs.andNot(x.abs, y.abs);
- z.neg = false;
- return z;
- }
- if (x.neg) {
- x1$1 = nat.nil.sub(x.abs, natOne);
- z.abs = z.abs.add(z.abs.or(x1$1, y.abs), natOne);
- z.neg = true;
- return z;
- }
- y1$1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.and(x.abs, y1$1);
- z.neg = false;
- return z;
- };
- Int.prototype.AndNot = function(x, y) { return this.$val.AndNot(x, y); };
- Int.ptr.prototype.Or = function(x, y) {
- var $ptr, _tmp, _tmp$1, x, x1, y, y1, y1$1, z;
- z = this;
- if (x.neg === y.neg) {
- if (x.neg) {
- x1 = nat.nil.sub(x.abs, natOne);
- y1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.add(z.abs.and(x1, y1), natOne);
- z.neg = true;
- return z;
- }
- z.abs = z.abs.or(x.abs, y.abs);
- z.neg = false;
- return z;
- }
- if (x.neg) {
- _tmp = y; _tmp$1 = x; x = _tmp; y = _tmp$1;
- }
- y1$1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.add(z.abs.andNot(y1$1, x.abs), natOne);
- z.neg = true;
- return z;
- };
- Int.prototype.Or = function(x, y) { return this.$val.Or(x, y); };
- Int.ptr.prototype.Xor = function(x, y) {
- var $ptr, _tmp, _tmp$1, x, x1, y, y1, y1$1, z;
- z = this;
- if (x.neg === y.neg) {
- if (x.neg) {
- x1 = nat.nil.sub(x.abs, natOne);
- y1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.xor(x1, y1);
- z.neg = false;
- return z;
- }
- z.abs = z.abs.xor(x.abs, y.abs);
- z.neg = false;
- return z;
- }
- if (x.neg) {
- _tmp = y; _tmp$1 = x; x = _tmp; y = _tmp$1;
- }
- y1$1 = nat.nil.sub(y.abs, natOne);
- z.abs = z.abs.add(z.abs.xor(x.abs, y1$1), natOne);
- z.neg = true;
- return z;
- };
- Int.prototype.Xor = function(x, y) { return this.$val.Xor(x, y); };
- Int.ptr.prototype.Not = function(x) {
- var $ptr, x, z;
- z = this;
- if (x.neg) {
- z.abs = z.abs.sub(x.abs, natOne);
- z.neg = false;
- return z;
- }
- z.abs = z.abs.add(x.abs, natOne);
- z.neg = true;
- return z;
- };
- Int.prototype.Not = function(x) { return this.$val.Not(x); };
- Int.ptr.prototype.GobEncode = function() {
- var $ptr, b, buf, i, x;
- x = this;
- if (x === ptrType.nil) {
- return [sliceType.nil, $ifaceNil];
- }
- buf = $makeSlice(sliceType, (1 + (x.abs.$length * 4 >> 0) >> 0));
- i = x.abs.bytes(buf) - 1 >> 0;
- b = 2;
- if (x.neg) {
- b = (b | (1)) >>> 0;
- }
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = b);
- return [$subslice(buf, i), $ifaceNil];
- };
- Int.prototype.GobEncode = function() { return this.$val.GobEncode(); };
- Int.ptr.prototype.GobDecode = function(buf) {
- var $ptr, _r, _r$1, b, buf, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; b = $f.b; buf = $f.buf; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- if (buf.$length === 0) {
- $copy(z, new Int.ptr(false, nat.nil), Int);
- return $ifaceNil;
- }
- b = (0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]);
- /* */ if (!(((b >>> 1 << 24 >>> 24) === 1))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(((b >>> 1 << 24 >>> 24) === 1))) { */ case 1:
- _r = fmt.Sprintf("Int.GobDecode: encoding version %d not supported", new sliceType$2([new $Uint8((b >>> 1 << 24 >>> 24))])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = errors.New(_r); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 2:
- z.neg = !((((b & 1) >>> 0) === 0));
- z.abs = z.abs.setBytes($subslice(buf, 1));
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.GobDecode }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.buf = buf; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); };
- Int.ptr.prototype.MarshalJSON = function() {
- var $ptr, z;
- z = this;
- return [new sliceType($stringToBytes(z.String())), $ifaceNil];
- };
- Int.prototype.MarshalJSON = function() { return this.$val.MarshalJSON(); };
- Int.ptr.prototype.UnmarshalJSON = function(text) {
- var $ptr, _r, _r$1, _tuple, ok, text, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; ok = $f.ok; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- _r = z.SetString($bytesToString(text), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; ok = _tuple[1];
- /* */ if (!ok) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!ok) { */ case 2:
- _r$1 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", new sliceType$2([text])); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 3:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.UnmarshalJSON }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.ok = ok; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.UnmarshalJSON = function(text) { return this.$val.UnmarshalJSON(text); };
- Int.ptr.prototype.MarshalText = function() {
- var $ptr, _tmp, _tmp$1, err, text, z;
- text = sliceType.nil;
- err = $ifaceNil;
- z = this;
- _tmp = new sliceType($stringToBytes(z.String())); _tmp$1 = $ifaceNil; text = _tmp; err = _tmp$1;
- return [text, err];
- };
- Int.prototype.MarshalText = function() { return this.$val.MarshalText(); };
- Int.ptr.prototype.UnmarshalText = function(text) {
- var $ptr, _r, _r$1, _tuple, ok, text, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; ok = $f.ok; text = $f.text; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- _r = z.SetString($bytesToString(text), 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; ok = _tuple[1];
- /* */ if (!ok) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!ok) { */ case 2:
- _r$1 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", new sliceType$2([text])); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 3:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int.ptr.prototype.UnmarshalText }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.ok = ok; $f.text = text; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Int.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); };
- nat.prototype.clear = function() {
- var $ptr, _i, _ref, i, z;
- z = this;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = 0);
- _i++;
- }
- };
- $ptrType(nat).prototype.clear = function() { return this.$get().clear(); };
- nat.prototype.norm = function() {
- var $ptr, i, x, z;
- z = this;
- i = z.$length;
- while (true) {
- if (!(i > 0 && ((x = i - 1 >> 0, ((x < 0 || x >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + x])) === 0))) { break; }
- i = i - (1) >> 0;
- }
- return $subslice(z, 0, i);
- };
- $ptrType(nat).prototype.norm = function() { return this.$get().norm(); };
- nat.prototype.make = function(n) {
- var $ptr, n, z;
- z = this;
- if (n <= z.$capacity) {
- return $subslice(z, 0, n);
- }
- return $makeSlice(nat, n, (n + 4 >> 0));
- };
- $ptrType(nat).prototype.make = function(n) { return this.$get().make(n); };
- nat.prototype.setWord = function(x) {
- var $ptr, x, z;
- z = this;
- if (x === 0) {
- return z.make(0);
- }
- z = z.make(1);
- (0 >= z.$length ? $throwRuntimeError("index out of range") : z.$array[z.$offset + 0] = x);
- return z;
- };
- $ptrType(nat).prototype.setWord = function(x) { return this.$get().setWord(x); };
- nat.prototype.setUint64 = function(x) {
- var $ptr, _i, _ref, i, n, t, w, x, x$1, z;
- z = this;
- w = (x.$low >>> 0);
- if ((x$1 = new $Uint64(0, w.constructor === Number ? w : 1), (x$1.$high === x.$high && x$1.$low === x.$low))) {
- return z.setWord(w);
- }
- n = 0;
- t = x;
- while (true) {
- if (!((t.$high > 0 || (t.$high === 0 && t.$low > 0)))) { break; }
- n = n + (1) >> 0;
- t = $shiftRightUint64(t, (32));
- }
- z = z.make(n);
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (new $Uint64(x.$high & 0, (x.$low & 4294967295) >>> 0).$low >>> 0));
- x = $shiftRightUint64(x, (32));
- _i++;
- }
- return z;
- };
- $ptrType(nat).prototype.setUint64 = function(x) { return this.$get().setUint64(x); };
- nat.prototype.set = function(x) {
- var $ptr, x, z;
- z = this;
- z = z.make(x.$length);
- $copySlice(z, x);
- return z;
- };
- $ptrType(nat).prototype.set = function(x) { return this.$get().set(x); };
- nat.prototype.add = function(x, y) {
- var $ptr, c, m, n, x, x$1, x$2, x$3, y, z;
- z = this;
- m = x.$length;
- n = y.$length;
- if (m < n) {
- return z.add(y, x);
- } else if (m === 0) {
- return z.make(0);
- } else if (n === 0) {
- return z.set(x);
- }
- z = z.make(m + 1 >> 0);
- c = addVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length), $subslice(new sliceType$1(y.$array), y.$offset, y.$offset + y.$length));
- if (m > n) {
- c = addVW((x$2 = $subslice(z, n, m), $subslice(new sliceType$1(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(x, n), $subslice(new sliceType$1(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c);
- }
- ((m < 0 || m >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + m] = c);
- return z.norm();
- };
- $ptrType(nat).prototype.add = function(x, y) { return this.$get().add(x, y); };
- nat.prototype.sub = function(x, y) {
- var $ptr, c, m, n, x, x$1, x$2, x$3, y, z;
- z = this;
- m = x.$length;
- n = y.$length;
- if (m < n) {
- $panic(new $String("underflow"));
- } else if (m === 0) {
- return z.make(0);
- } else if (n === 0) {
- return z.set(x);
- }
- z = z.make(m);
- c = subVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length), $subslice(new sliceType$1(y.$array), y.$offset, y.$offset + y.$length));
- if (m > n) {
- c = subVW((x$2 = $subslice(z, n), $subslice(new sliceType$1(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(x, n), $subslice(new sliceType$1(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c);
- }
- if (!((c === 0))) {
- $panic(new $String("underflow"));
- }
- return z.norm();
- };
- $ptrType(nat).prototype.sub = function(x, y) { return this.$get().sub(x, y); };
- nat.prototype.cmp = function(y) {
- var $ptr, i, m, n, r, x, y;
- r = 0;
- x = this;
- m = x.$length;
- n = y.$length;
- if (!((m === n)) || (m === 0)) {
- if (m < n) {
- r = -1;
- } else if (m > n) {
- r = 1;
- }
- return r;
- }
- i = m - 1 >> 0;
- while (true) {
- if (!(i > 0 && (((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) === ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i])))) { break; }
- i = i - (1) >> 0;
- }
- if (((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) < ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i])) {
- r = -1;
- } else if (((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) > ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i])) {
- r = 1;
- }
- return r;
- };
- $ptrType(nat).prototype.cmp = function(y) { return this.$get().cmp(y); };
- nat.prototype.mulAddWW = function(x, y, r) {
- var $ptr, m, r, x, x$1, y, z;
- z = this;
- m = x.$length;
- if ((m === 0) || (y === 0)) {
- return z.setWord(r);
- }
- z = z.make(m + 1 >> 0);
- ((m < 0 || m >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + m] = mulAddVWW((x$1 = $subslice(z, 0, m), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length), y, r));
- return z.norm();
- };
- $ptrType(nat).prototype.mulAddWW = function(x, y, r) { return this.$get().mulAddWW(x, y, r); };
- basicMul = function(z, x, y) {
- var $ptr, _i, _ref, d, i, x, x$1, x$2, y, z;
- $subslice(z, 0, (x.$length + y.$length >> 0)).clear();
- _ref = y;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- d = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!((d === 0))) {
- (x$2 = x.$length + i >> 0, ((x$2 < 0 || x$2 >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + x$2] = addMulVVW((x$1 = $subslice(z, i, (i + x.$length >> 0)), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length), d)));
- }
- _i++;
- }
- };
- karatsubaAdd = function(z, x, n) {
- var $ptr, c, n, x, x$1, x$2, x$3, z;
- c = addVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length));
- if (!((c === 0))) {
- addVW((x$2 = $subslice(z, n, (n + (n >> 1 >> 0) >> 0)), $subslice(new sliceType$1(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(z, n), $subslice(new sliceType$1(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c);
- }
- };
- karatsubaSub = function(z, x, n) {
- var $ptr, c, n, x, x$1, x$2, x$3, z;
- c = subVV((x$1 = $subslice(z, 0, n), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(z.$array), z.$offset, z.$offset + z.$length), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length));
- if (!((c === 0))) {
- subVW((x$2 = $subslice(z, n, (n + (n >> 1 >> 0) >> 0)), $subslice(new sliceType$1(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), (x$3 = $subslice(z, n), $subslice(new sliceType$1(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), c);
- }
- };
- karatsuba = function(z, x, y) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, n, n2, p, r, s, x, x0, x1, xd, y, y0, y1, yd, z;
- n = y.$length;
- if (!(((n & 1) === 0)) || n < karatsubaThreshold || n < 2) {
- basicMul(z, x, y);
- return;
- }
- n2 = n >> 1 >> 0;
- _tmp = $subslice(x, n2); _tmp$1 = $subslice(x, 0, n2); x1 = _tmp; x0 = _tmp$1;
- _tmp$2 = $subslice(y, n2); _tmp$3 = $subslice(y, 0, n2); y1 = _tmp$2; y0 = _tmp$3;
- karatsuba(z, x0, y0);
- karatsuba($subslice(z, n), x1, y1);
- s = 1;
- xd = $subslice(z, (2 * n >> 0), ((2 * n >> 0) + n2 >> 0));
- if (!((subVV($subslice(new sliceType$1(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$1(x1.$array), x1.$offset, x1.$offset + x1.$length), $subslice(new sliceType$1(x0.$array), x0.$offset, x0.$offset + x0.$length)) === 0))) {
- s = -s;
- subVV($subslice(new sliceType$1(xd.$array), xd.$offset, xd.$offset + xd.$length), $subslice(new sliceType$1(x0.$array), x0.$offset, x0.$offset + x0.$length), $subslice(new sliceType$1(x1.$array), x1.$offset, x1.$offset + x1.$length));
- }
- yd = $subslice(z, ((2 * n >> 0) + n2 >> 0), (3 * n >> 0));
- if (!((subVV($subslice(new sliceType$1(yd.$array), yd.$offset, yd.$offset + yd.$length), $subslice(new sliceType$1(y0.$array), y0.$offset, y0.$offset + y0.$length), $subslice(new sliceType$1(y1.$array), y1.$offset, y1.$offset + y1.$length)) === 0))) {
- s = -s;
- subVV($subslice(new sliceType$1(yd.$array), yd.$offset, yd.$offset + yd.$length), $subslice(new sliceType$1(y1.$array), y1.$offset, y1.$offset + y1.$length), $subslice(new sliceType$1(y0.$array), y0.$offset, y0.$offset + y0.$length));
- }
- p = $subslice(z, (n * 3 >> 0));
- karatsuba(p, xd, yd);
- r = $subslice(z, (n * 4 >> 0));
- $copySlice(r, $subslice(z, 0, (n * 2 >> 0)));
- karatsubaAdd($subslice(z, n2), r, n);
- karatsubaAdd($subslice(z, n2), $subslice(r, n), n);
- if (s > 0) {
- karatsubaAdd($subslice(z, n2), p, n);
- } else {
- karatsubaSub($subslice(z, n2), p, n);
- }
- };
- alias = function(x, y) {
- var $ptr, x, x$1, x$2, y;
- return x.$capacity > 0 && y.$capacity > 0 && (x$1 = $subslice(x, 0, x.$capacity), $indexPtr(x$1.$array, x$1.$offset + (x.$capacity - 1 >> 0), ptrType$1)) === (x$2 = $subslice(y, 0, y.$capacity), $indexPtr(x$2.$array, x$2.$offset + (y.$capacity - 1 >> 0), ptrType$1));
- };
- addAt = function(z, x, i) {
- var $ptr, c, i, j, n, x, x$1, x$2, x$3, x$4, z;
- n = x.$length;
- if (n > 0) {
- c = addVV((x$1 = $subslice(z, i, (i + n >> 0)), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (x$2 = $subslice(z, i), $subslice(new sliceType$1(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length)), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length));
- if (!((c === 0))) {
- j = i + n >> 0;
- if (j < z.$length) {
- addVW((x$3 = $subslice(z, j), $subslice(new sliceType$1(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length)), (x$4 = $subslice(z, j), $subslice(new sliceType$1(x$4.$array), x$4.$offset, x$4.$offset + x$4.$length)), c);
- }
- }
- }
- };
- max = function(x, y) {
- var $ptr, x, y;
- if (x > y) {
- return x;
- }
- return y;
- };
- karatsubaLen = function(n) {
- var $ptr, i, n, y;
- i = 0;
- while (true) {
- if (!(n > karatsubaThreshold)) { break; }
- n = (n >> $min((1), 31)) >> 0;
- i = i + (1) >>> 0;
- }
- return (y = i, y < 32 ? (n << y) : 0) >> 0;
- };
- nat.prototype.mul = function(x, y) {
- var $ptr, i, k, m, n, t, x, x0, x0$1, xi, y, y0, y0$1, y1, z;
- z = this;
- m = x.$length;
- n = y.$length;
- if (m < n) {
- return z.mul(y, x);
- } else if ((m === 0) || (n === 0)) {
- return z.make(0);
- } else if (n === 1) {
- return z.mulAddWW(x, (0 >= y.$length ? $throwRuntimeError("index out of range") : y.$array[y.$offset + 0]), 0);
- }
- if (alias(z, x) || alias(z, y)) {
- z = nat.nil;
- }
- if (n < karatsubaThreshold) {
- z = z.make(m + n >> 0);
- basicMul(z, x, y);
- return z.norm();
- }
- k = karatsubaLen(n);
- x0 = $subslice(x, 0, k);
- y0 = $subslice(y, 0, k);
- z = z.make(max(6 * k >> 0, m + n >> 0));
- karatsuba(z, x0, y0);
- z = $subslice(z, 0, (m + n >> 0));
- $subslice(z, (2 * k >> 0)).clear();
- if (k < n || !((m === n))) {
- t = nat.nil;
- x0$1 = x0.norm();
- y1 = $subslice(y, k);
- t = t.mul(x0$1, y1);
- addAt(z, t, k);
- y0$1 = y0.norm();
- i = k;
- while (true) {
- if (!(i < x.$length)) { break; }
- xi = $subslice(x, i);
- if (xi.$length > k) {
- xi = $subslice(xi, 0, k);
- }
- xi = xi.norm();
- t = t.mul(xi, y0$1);
- addAt(z, t, i);
- t = t.mul(xi, y1);
- addAt(z, t, i + k >> 0);
- i = i + (k) >> 0;
- }
- }
- return z.norm();
- };
- $ptrType(nat).prototype.mul = function(x, y) { return this.$get().mul(x, y); };
- nat.prototype.mulRange = function(a, b) {
- var $ptr, a, b, m, x, z;
- z = this;
- if ((a.$high === 0 && a.$low === 0)) {
- return z.setUint64(new $Uint64(0, 0));
- } else if ((a.$high > b.$high || (a.$high === b.$high && a.$low > b.$low))) {
- return z.setUint64(new $Uint64(0, 1));
- } else if ((a.$high === b.$high && a.$low === b.$low)) {
- return z.setUint64(a);
- } else if ((x = new $Uint64(a.$high + 0, a.$low + 1), (x.$high === b.$high && x.$low === b.$low))) {
- return z.mul(nat.nil.setUint64(a), nat.nil.setUint64(b));
- }
- m = $div64((new $Uint64(a.$high + b.$high, a.$low + b.$low)), new $Uint64(0, 2), false);
- return z.mul(nat.nil.mulRange(a, m), nat.nil.mulRange(new $Uint64(m.$high + 0, m.$low + 1), b));
- };
- $ptrType(nat).prototype.mulRange = function(a, b) { return this.$get().mulRange(a, b); };
- nat.prototype.divW = function(x, y) {
- var $ptr, m, q, r, x, y, z;
- q = nat.nil;
- r = 0;
- z = this;
- m = x.$length;
- if (y === 0) {
- $panic(new $String("division by zero"));
- } else if (y === 1) {
- q = z.set(x);
- return [q, r];
- } else if (m === 0) {
- q = z.make(0);
- return [q, r];
- }
- z = z.make(m);
- r = divWVW($subslice(new sliceType$1(z.$array), z.$offset, z.$offset + z.$length), 0, $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length), y);
- q = z.norm();
- return [q, r];
- };
- $ptrType(nat).prototype.divW = function(x, y) { return this.$get().divW(x, y); };
- nat.prototype.div = function(z2, u, v) {
- var $ptr, _tuple, _tuple$1, q, r, r2, u, v, z, z2;
- q = nat.nil;
- r = nat.nil;
- z = this;
- if (v.$length === 0) {
- $panic(new $String("division by zero"));
- }
- if (u.cmp(v) < 0) {
- q = z.make(0);
- r = z2.set(u);
- return [q, r];
- }
- if (v.$length === 1) {
- r2 = 0;
- _tuple = z.divW(u, (0 >= v.$length ? $throwRuntimeError("index out of range") : v.$array[v.$offset + 0])); q = _tuple[0]; r2 = _tuple[1];
- r = z2.setWord(r2);
- return [q, r];
- }
- _tuple$1 = z.divLarge(z2, u, v); q = _tuple$1[0]; r = _tuple$1[1];
- return [q, r];
- };
- $ptrType(nat).prototype.div = function(z2, u, v) { return this.$get().div(z2, u, v); };
- nat.prototype.divLarge = function(u, uIn, v) {
- var $ptr, _index, _tmp, _tmp$1, _tuple, _tuple$1, _tuple$2, c, c$1, j, m, n, prevRhat, q, qhat, qhatv, r, rhat, shift, u, uIn, v, v1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, x1, x2, z;
- q = nat.nil;
- r = nat.nil;
- z = this;
- n = v.$length;
- m = uIn.$length - n >> 0;
- if (alias(z, uIn) || alias(z, v)) {
- z = nat.nil;
- }
- q = z.make(m + 1 >> 0);
- qhatv = $makeSlice(nat, (n + 1 >> 0));
- if (alias(u, uIn) || alias(u, v)) {
- u = nat.nil;
- }
- u = u.make(uIn.$length + 1 >> 0);
- u.clear();
- shift = leadingZeros((x = n - 1 >> 0, ((x < 0 || x >= v.$length) ? $throwRuntimeError("index out of range") : v.$array[v.$offset + x])));
- if (shift > 0) {
- v1 = $makeSlice(nat, n);
- shlVU($subslice(new sliceType$1(v1.$array), v1.$offset, v1.$offset + v1.$length), $subslice(new sliceType$1(v.$array), v.$offset, v.$offset + v.$length), shift);
- v = v1;
- }
- (x$2 = uIn.$length, ((x$2 < 0 || x$2 >= u.$length) ? $throwRuntimeError("index out of range") : u.$array[u.$offset + x$2] = shlVU((x$1 = $subslice(u, 0, uIn.$length), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(uIn.$array), uIn.$offset, uIn.$offset + uIn.$length), shift)));
- j = m;
- while (true) {
- if (!(j >= 0)) { break; }
- qhat = 4294967295;
- if (!(((x$3 = j + n >> 0, ((x$3 < 0 || x$3 >= u.$length) ? $throwRuntimeError("index out of range") : u.$array[u.$offset + x$3])) === (x$4 = n - 1 >> 0, ((x$4 < 0 || x$4 >= v.$length) ? $throwRuntimeError("index out of range") : v.$array[v.$offset + x$4]))))) {
- rhat = 0;
- _tuple = divWW((x$5 = j + n >> 0, ((x$5 < 0 || x$5 >= u.$length) ? $throwRuntimeError("index out of range") : u.$array[u.$offset + x$5])), (x$6 = (j + n >> 0) - 1 >> 0, ((x$6 < 0 || x$6 >= u.$length) ? $throwRuntimeError("index out of range") : u.$array[u.$offset + x$6])), (x$7 = n - 1 >> 0, ((x$7 < 0 || x$7 >= v.$length) ? $throwRuntimeError("index out of range") : v.$array[v.$offset + x$7]))); qhat = _tuple[0]; rhat = _tuple[1];
- _tuple$1 = mulWW(qhat, (x$8 = n - 2 >> 0, ((x$8 < 0 || x$8 >= v.$length) ? $throwRuntimeError("index out of range") : v.$array[v.$offset + x$8]))); x1 = _tuple$1[0]; x2 = _tuple$1[1];
- while (true) {
- if (!(greaterThan(x1, x2, rhat, (x$9 = (j + n >> 0) - 2 >> 0, ((x$9 < 0 || x$9 >= u.$length) ? $throwRuntimeError("index out of range") : u.$array[u.$offset + x$9]))))) { break; }
- qhat = qhat - (1) >>> 0;
- prevRhat = rhat;
- rhat = rhat + ((x$10 = n - 1 >> 0, ((x$10 < 0 || x$10 >= v.$length) ? $throwRuntimeError("index out of range") : v.$array[v.$offset + x$10]))) >>> 0;
- if (rhat < prevRhat) {
- break;
- }
- _tuple$2 = mulWW(qhat, (x$11 = n - 2 >> 0, ((x$11 < 0 || x$11 >= v.$length) ? $throwRuntimeError("index out of range") : v.$array[v.$offset + x$11]))); x1 = _tuple$2[0]; x2 = _tuple$2[1];
- }
- }
- ((n < 0 || n >= qhatv.$length) ? $throwRuntimeError("index out of range") : qhatv.$array[qhatv.$offset + n] = mulAddVWW((x$12 = $subslice(qhatv, 0, n), $subslice(new sliceType$1(x$12.$array), x$12.$offset, x$12.$offset + x$12.$length)), $subslice(new sliceType$1(v.$array), v.$offset, v.$offset + v.$length), qhat, 0));
- c = subVV((x$13 = $subslice(u, j, (j + qhatv.$length >> 0)), $subslice(new sliceType$1(x$13.$array), x$13.$offset, x$13.$offset + x$13.$length)), (x$14 = $subslice(u, j), $subslice(new sliceType$1(x$14.$array), x$14.$offset, x$14.$offset + x$14.$length)), $subslice(new sliceType$1(qhatv.$array), qhatv.$offset, qhatv.$offset + qhatv.$length));
- if (!((c === 0))) {
- c$1 = addVV((x$15 = $subslice(u, j, (j + n >> 0)), $subslice(new sliceType$1(x$15.$array), x$15.$offset, x$15.$offset + x$15.$length)), (x$16 = $subslice(u, j), $subslice(new sliceType$1(x$16.$array), x$16.$offset, x$16.$offset + x$16.$length)), $subslice(new sliceType$1(v.$array), v.$offset, v.$offset + v.$length));
- _index = j + n >> 0;
- ((_index < 0 || _index >= u.$length) ? $throwRuntimeError("index out of range") : u.$array[u.$offset + _index] = ((_index < 0 || _index >= u.$length) ? $throwRuntimeError("index out of range") : u.$array[u.$offset + _index]) + (c$1) >>> 0);
- qhat = qhat - (1) >>> 0;
- }
- ((j < 0 || j >= q.$length) ? $throwRuntimeError("index out of range") : q.$array[q.$offset + j] = qhat);
- j = j - (1) >> 0;
- }
- q = q.norm();
- shrVU($subslice(new sliceType$1(u.$array), u.$offset, u.$offset + u.$length), $subslice(new sliceType$1(u.$array), u.$offset, u.$offset + u.$length), shift);
- r = u.norm();
- _tmp = q; _tmp$1 = r; q = _tmp; r = _tmp$1;
- return [q, r];
- };
- $ptrType(nat).prototype.divLarge = function(u, uIn, v) { return this.$get().divLarge(u, uIn, v); };
- nat.prototype.bitLen = function() {
- var $ptr, i, x;
- x = this;
- i = x.$length - 1 >> 0;
- if (i >= 0) {
- return (i * 32 >> 0) + bitLen(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])) >> 0;
- }
- return 0;
- };
- $ptrType(nat).prototype.bitLen = function() { return this.$get().bitLen(); };
- hexValue = function(ch) {
- var $ptr, ch, d;
- d = 37;
- if (48 <= ch && ch <= 57) {
- d = ((ch - 48 >> 0) >> 0);
- } else if (97 <= ch && ch <= 122) {
- d = (((ch - 97 >> 0) + 10 >> 0) >> 0);
- } else if (65 <= ch && ch <= 90) {
- d = (((ch - 65 >> 0) + 10 >> 0) >> 0);
- }
- return (d >>> 0);
- };
- nat.prototype.scan = function(r, base) {
- var $ptr, _q, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, _tuple$3, b, base, bb, ch, d, dd, err, max$1, r, x, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; b = $f.b; base = $f.base; bb = $f.bb; ch = $f.ch; d = $f.d; dd = $f.dd; err = $f.err; max$1 = $f.max$1; r = $f.r; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- if (base < 0 || (base === 1) || 36 < base) {
- return [z, 0, errors.New("illegal number base")];
- }
- _r = r.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; ch = _tuple[0]; err = _tuple[2];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [z, 0, err];
- }
- b = (base >>> 0);
- /* */ if (base === 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (base === 0) { */ case 2:
- b = 10;
- /* */ if (ch === 48) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (ch === 48) { */ case 4:
- _r$1 = r.ReadRune(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; ch = _tuple$1[0]; err = _tuple$1[2];
- _ref = err;
- /* */ if ($interfaceIsEqual(_ref, $ifaceNil)) { $s = 7; continue; }
- /* */ if ($interfaceIsEqual(_ref, io.EOF)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($interfaceIsEqual(_ref, $ifaceNil)) { */ case 7:
- b = 8;
- _ref$1 = ch;
- if (_ref$1 === 120 || _ref$1 === 88) {
- b = 16;
- } else if (_ref$1 === 98 || _ref$1 === 66) {
- b = 2;
- }
- /* */ if ((b === 2) || (b === 16)) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ((b === 2) || (b === 16)) { */ case 11:
- _r$2 = r.ReadRune(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$2 = _r$2; ch = _tuple$2[0]; err = _tuple$2[2];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 14:
- return [z, 0, err];
- /* } */ case 15:
- /* } */ case 12:
- $s = 10; continue;
- /* } else if ($interfaceIsEqual(_ref, io.EOF)) { */ case 8:
- return [z.make(0), 10, $ifaceNil];
- $s = 10; continue;
- /* } else { */ case 9:
- return [z, 10, err];
- /* } */ case 10:
- /* } */ case 5:
- /* } */ case 3:
- z = z.make(0);
- bb = 1;
- dd = 0;
- max$1 = (_q = 4294967295 / b, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- /* while (true) { */ case 16:
- d = hexValue(ch);
- /* */ if (d >= b) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (d >= b) { */ case 18:
- _r$3 = r.UnreadRune(); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* break; */ $s = 17; continue;
- /* } */ case 19:
- if (bb <= max$1) {
- bb = (x = b, (((bb >>> 16 << 16) * x >>> 0) + (bb << 16 >>> 16) * x) >>> 0);
- dd = ((((dd >>> 16 << 16) * b >>> 0) + (dd << 16 >>> 16) * b) >>> 0) + d >>> 0;
- } else {
- z = z.mulAddWW(z, bb, dd);
- bb = b;
- dd = d;
- }
- _r$4 = r.ReadRune(); /* */ $s = 21; case 21: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple$3 = _r$4; ch = _tuple$3[0]; err = _tuple$3[2];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 22:
- if (!($interfaceIsEqual(err, io.EOF))) {
- return [z, (b >> 0), err];
- }
- /* break; */ $s = 17; continue;
- /* } */ case 23:
- /* } */ $s = 16; continue; case 17:
- if (bb > 1) {
- z = z.mulAddWW(z, bb, dd);
- } else if ((base === 0) && (b === 8)) {
- return [z, 10, $ifaceNil];
- } else if (!((base === 0)) || !((b === 8))) {
- return [z, (b >> 0), errors.New("syntax error scanning number")];
- }
- return [z.norm(), (b >> 0), $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: nat.prototype.scan }; } $f.$ptr = $ptr; $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.b = b; $f.base = base; $f.bb = bb; $f.ch = ch; $f.d = d; $f.dd = dd; $f.err = err; $f.max$1 = max$1; $f.r = r; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(nat).prototype.scan = function(r, base) { return this.$get().scan(r, base); };
- nat.prototype.decimalString = function() {
- var $ptr, x;
- x = this;
- return x.string("0123456789abcdefghijklmnopqrstuvwxyz".substring(0, 10));
- };
- $ptrType(nat).prototype.decimalString = function() { return this.$get().decimalString(); };
- nat.prototype.string = function(charset$1) {
- var $ptr, _q, b, bb, charset$1, i, k, mask, max$1, nbits, ndigits, q, s, shift, table, w, x, x$1, y, y$1, y$2, y$3, y$4, zero;
- x = this;
- b = (charset$1.length >>> 0);
- if (b < 2 || false) {
- $panic(new $String("illegal base"));
- } else if (x.$length === 0) {
- return $encodeRune(charset$1.charCodeAt(0));
- }
- i = (x.bitLen() / math.Log2(b) >> 0) + 1 >> 0;
- s = $makeSlice(sliceType, i);
- if (b === ((b & (-b >>> 0)) >>> 0)) {
- shift = trailingZeroBits(b);
- mask = ((y = shift, y < 32 ? (1 << y) : 0) >>> 0) - 1 >>> 0;
- w = (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]);
- nbits = 32;
- k = 1;
- while (true) {
- if (!(k < x.$length)) { break; }
- while (true) {
- if (!(nbits >= shift)) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i] = charset$1.charCodeAt(((w & mask) >>> 0)));
- w = (y$1 = (shift), y$1 < 32 ? (w >>> y$1) : 0) >>> 0;
- nbits = nbits - (shift) >>> 0;
- }
- if (nbits === 0) {
- w = ((k < 0 || k >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + k]);
- nbits = 32;
- } else {
- w = (w | (((y$2 = nbits, y$2 < 32 ? (((k < 0 || k >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + k]) << y$2) : 0) >>> 0))) >>> 0;
- i = i - (1) >> 0;
- ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i] = charset$1.charCodeAt(((w & mask) >>> 0)));
- w = (y$3 = ((shift - nbits >>> 0)), y$3 < 32 ? (((k < 0 || k >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + k]) >>> y$3) : 0) >>> 0;
- nbits = 32 - ((shift - nbits >>> 0)) >>> 0;
- }
- k = k + (1) >> 0;
- }
- while (true) {
- if (!(nbits >= 0 && !((w === 0)))) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i] = charset$1.charCodeAt(((w & mask) >>> 0)));
- w = (y$4 = (shift), y$4 < 32 ? (w >>> y$4) : 0) >>> 0;
- nbits = nbits - (shift) >>> 0;
- }
- } else {
- bb = b;
- ndigits = 1;
- max$1 = (_q = 4294967295 / b, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- while (true) {
- if (!(bb <= max$1)) { break; }
- ndigits = ndigits + (1) >> 0;
- bb = (x$1 = b, (((bb >>> 16 << 16) * x$1 >>> 0) + (bb << 16 >>> 16) * x$1) >>> 0);
- }
- table = divisors(x.$length, b, ndigits, bb);
- q = nat.nil.set(x);
- q.convertWords(s, charset$1, b, ndigits, bb, table);
- i = 0;
- zero = charset$1.charCodeAt(0);
- while (true) {
- if (!(((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i]) === zero)) { break; }
- i = i + (1) >> 0;
- }
- }
- return $bytesToString($subslice(s, i));
- };
- $ptrType(nat).prototype.string = function(charset$1) { return this.$get().string(charset$1); };
- nat.prototype.convertWords = function(s, charset$1, b, ndigits, bb, table) {
- var $ptr, _q, _q$1, _r, _tuple, _tuple$1, _tuple$2, b, bb, charset$1, h, i, index, j, j$1, maxLength, minLength, ndigits, q, r, r$1, s, t, table, x, zero;
- q = this;
- if (!(table === sliceType$3.nil)) {
- r = nat.nil;
- index = table.$length - 1 >> 0;
- while (true) {
- if (!(q.$length > leafSize)) { break; }
- maxLength = q.bitLen();
- minLength = maxLength >> 1 >> 0;
- while (true) {
- if (!(index > 0 && (x = index - 1 >> 0, ((x < 0 || x >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + x])).nbits > minLength)) { break; }
- index = index - (1) >> 0;
- }
- if (((index < 0 || index >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + index]).nbits >= maxLength && ((index < 0 || index >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + index]).bbb.cmp(q) >= 0) {
- index = index - (1) >> 0;
- if (index < 0) {
- $panic(new $String("internal inconsistency"));
- }
- }
- _tuple = q.div(r, q, ((index < 0 || index >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + index]).bbb); q = _tuple[0]; r = _tuple[1];
- h = s.$length - ((index < 0 || index >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + index]).ndigits >> 0;
- r.convertWords($subslice(s, h), charset$1, b, ndigits, bb, $subslice(table, 0, index));
- s = $subslice(s, 0, h);
- }
- }
- i = s.$length;
- r$1 = 0;
- if (b === 10) {
- while (true) {
- if (!(q.$length > 0)) { break; }
- _tuple$1 = q.divW(q, bb); q = _tuple$1[0]; r$1 = _tuple$1[1];
- j = 0;
- while (true) {
- if (!(j < ndigits && i > 0)) { break; }
- i = i - (1) >> 0;
- t = (_q = r$1 / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero"));
- ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i] = charset$1.charCodeAt((((r$1 - (t << 3 >>> 0) >>> 0) - t >>> 0) - t >>> 0)));
- r$1 = t;
- j = j + (1) >> 0;
- }
- }
- } else {
- while (true) {
- if (!(q.$length > 0)) { break; }
- _tuple$2 = q.divW(q, bb); q = _tuple$2[0]; r$1 = _tuple$2[1];
- j$1 = 0;
- while (true) {
- if (!(j$1 < ndigits && i > 0)) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i] = charset$1.charCodeAt((_r = r$1 % b, _r === _r ? _r : $throwRuntimeError("integer divide by zero"))));
- r$1 = (_q$1 = r$1 / (b), (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero"));
- j$1 = j$1 + (1) >> 0;
- }
- }
- }
- zero = charset$1.charCodeAt(0);
- while (true) {
- if (!(i > 0)) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i] = zero);
- }
- };
- $ptrType(nat).prototype.convertWords = function(s, charset$1, b, ndigits, bb, table) { return this.$get().convertWords(s, charset$1, b, ndigits, bb, table); };
- nat.prototype.expWW = function(x, y) {
- var $ptr, x, y, z;
- z = this;
- return z.expNN(nat.nil.setWord(x), nat.nil.setWord(y), nat.nil);
- };
- $ptrType(nat).prototype.expWW = function(x, y) { return this.$get().expWW(x, y); };
- divisors = function(m, b, ndigits, bb) {
- var $ptr, b, bb, i, k, larger, m, ndigits, table, words, x, x$1, x$2, x$3, y;
- if ((leafSize === 0) || m <= leafSize) {
- return sliceType$3.nil;
- }
- k = 1;
- words = leafSize;
- while (true) {
- if (!(words < (m >> 1 >> 0) && k < 64)) { break; }
- k = k + (1) >> 0;
- words = (y = (1), y < 32 ? (words << y) : 0) >> 0;
- }
- table = sliceType$3.nil;
- if (b === 10) {
- cacheBase10.Mutex.Lock();
- table = $subslice(new sliceType$3(cacheBase10.table), 0, k);
- } else {
- table = $makeSlice(sliceType$3, k);
- }
- if ((x = k - 1 >> 0, ((x < 0 || x >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + x])).ndigits === 0) {
- larger = nat.nil;
- i = 0;
- while (true) {
- if (!(i < k)) { break; }
- if (((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).ndigits === 0) {
- if (i === 0) {
- (0 >= table.$length ? $throwRuntimeError("index out of range") : table.$array[table.$offset + 0]).bbb = nat.nil.expWW(bb, (leafSize >>> 0));
- (0 >= table.$length ? $throwRuntimeError("index out of range") : table.$array[table.$offset + 0]).ndigits = ndigits * leafSize >> 0;
- } else {
- ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).bbb = nat.nil.mul((x$1 = i - 1 >> 0, ((x$1 < 0 || x$1 >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + x$1])).bbb, (x$2 = i - 1 >> 0, ((x$2 < 0 || x$2 >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + x$2])).bbb);
- ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).ndigits = 2 * (x$3 = i - 1 >> 0, ((x$3 < 0 || x$3 >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + x$3])).ndigits >> 0;
- }
- larger = nat.nil.set(((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).bbb);
- while (true) {
- if (!(mulAddVWW($subslice(new sliceType$1(larger.$array), larger.$offset, larger.$offset + larger.$length), $subslice(new sliceType$1(larger.$array), larger.$offset, larger.$offset + larger.$length), b, 0) === 0)) { break; }
- ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).bbb = ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).bbb.set(larger);
- ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).ndigits = ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).ndigits + (1) >> 0;
- }
- ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).nbits = ((i < 0 || i >= table.$length) ? $throwRuntimeError("index out of range") : table.$array[table.$offset + i]).bbb.bitLen();
- }
- i = i + (1) >> 0;
- }
- }
- if (b === 10) {
- cacheBase10.Mutex.Unlock();
- }
- return table;
- };
- trailingZeroBits = function(x) {
- var $ptr, x, x$1, x$2, x$3, x$4;
- if (32 === 32) {
- return ((x$1 = ((x$2 = ((x & (-x >>> 0)) >>> 0), (((x$2 >>> 16 << 16) * 125613361 >>> 0) + (x$2 << 16 >>> 16) * 125613361) >>> 0)) >>> 27 >>> 0, ((x$1 < 0 || x$1 >= deBruijn32Lookup.$length) ? $throwRuntimeError("index out of range") : deBruijn32Lookup.$array[deBruijn32Lookup.$offset + x$1])) >>> 0);
- } else if (32 === 64) {
- return ((x$3 = ((x$4 = ((x & (-x >>> 0)) >>> 0), (((x$4 >>> 16 << 16) * 3033172745 >>> 0) + (x$4 << 16 >>> 16) * 3033172745) >>> 0)) >>> 58 >>> 0, ((x$3 < 0 || x$3 >= deBruijn64Lookup.$length) ? $throwRuntimeError("index out of range") : deBruijn64Lookup.$array[deBruijn64Lookup.$offset + x$3])) >>> 0);
- } else {
- $panic(new $String("unknown word size"));
- }
- };
- nat.prototype.trailingZeroBits = function() {
- var $ptr, i, x;
- x = this;
- if (x.$length === 0) {
- return 0;
- }
- i = 0;
- while (true) {
- if (!(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) === 0)) { break; }
- i = i + (1) >>> 0;
- }
- return (i * 32 >>> 0) + trailingZeroBits(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])) >>> 0;
- };
- $ptrType(nat).prototype.trailingZeroBits = function() { return this.$get().trailingZeroBits(); };
- nat.prototype.shl = function(x, s) {
- var $ptr, _q, _r, m, n, s, x, x$1, z;
- z = this;
- m = x.$length;
- if (m === 0) {
- return z.make(0);
- }
- n = m + ((_q = s / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0) >> 0;
- z = z.make(n + 1 >> 0);
- ((n < 0 || n >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + n] = shlVU((x$1 = $subslice(z, (n - m >> 0), n), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length), (_r = s % 32, _r === _r ? _r : $throwRuntimeError("integer divide by zero"))));
- $subslice(z, 0, (n - m >> 0)).clear();
- return z.norm();
- };
- $ptrType(nat).prototype.shl = function(x, s) { return this.$get().shl(x, s); };
- nat.prototype.shr = function(x, s) {
- var $ptr, _q, _r, m, n, s, x, x$1, z;
- z = this;
- m = x.$length;
- n = m - ((_q = s / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0) >> 0;
- if (n <= 0) {
- return z.make(0);
- }
- z = z.make(n);
- shrVU($subslice(new sliceType$1(z.$array), z.$offset, z.$offset + z.$length), (x$1 = $subslice(x, (m - n >> 0)), $subslice(new sliceType$1(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length)), (_r = s % 32, _r === _r ? _r : $throwRuntimeError("integer divide by zero")));
- return z.norm();
- };
- $ptrType(nat).prototype.shr = function(x, s) { return this.$get().shr(x, s); };
- nat.prototype.setBit = function(x, i, b) {
- var $ptr, _q, _r, _ref, b, i, j, m, n, x, y, z;
- z = this;
- j = ((_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0);
- m = (y = ((_r = i % 32, _r === _r ? _r : $throwRuntimeError("integer divide by zero"))), y < 32 ? (1 << y) : 0) >>> 0;
- n = x.$length;
- _ref = b;
- if (_ref === 0) {
- z = z.make(n);
- $copySlice(z, x);
- if (j >= n) {
- return z;
- }
- ((j < 0 || j >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + j] = (((j < 0 || j >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + j]) & ~(m)) >>> 0);
- return z.norm();
- } else if (_ref === 1) {
- if (j >= n) {
- z = z.make(j + 1 >> 0);
- $subslice(z, n).clear();
- } else {
- z = z.make(n);
- }
- $copySlice(z, x);
- ((j < 0 || j >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + j] = (((j < 0 || j >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + j]) | (m)) >>> 0);
- return z;
- }
- $panic(new $String("set bit is not 0 or 1"));
- };
- $ptrType(nat).prototype.setBit = function(x, i, b) { return this.$get().setBit(x, i, b); };
- nat.prototype.bit = function(i) {
- var $ptr, _q, _r, i, j, y, z;
- z = this;
- j = ((_q = i / 32, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")) >> 0);
- if (j >= z.$length) {
- return 0;
- }
- return (((((y = ((_r = i % 32, _r === _r ? _r : $throwRuntimeError("integer divide by zero"))), y < 32 ? (((j < 0 || j >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + j]) >>> y) : 0) >>> 0) & 1) >>> 0) >>> 0);
- };
- $ptrType(nat).prototype.bit = function(i) { return this.$get().bit(i); };
- nat.prototype.and = function(x, y) {
- var $ptr, i, m, n, x, y, z;
- z = this;
- m = x.$length;
- n = y.$length;
- if (m > n) {
- m = n;
- }
- z = z.make(m);
- i = 0;
- while (true) {
- if (!(i < m)) { break; }
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) & ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i])) >>> 0);
- i = i + (1) >> 0;
- }
- return z.norm();
- };
- $ptrType(nat).prototype.and = function(x, y) { return this.$get().and(x, y); };
- nat.prototype.andNot = function(x, y) {
- var $ptr, i, m, n, x, y, z;
- z = this;
- m = x.$length;
- n = y.$length;
- if (n > m) {
- n = m;
- }
- z = z.make(m);
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) & ~((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i])) >>> 0);
- i = i + (1) >> 0;
- }
- $copySlice($subslice(z, n, m), $subslice(x, n, m));
- return z.norm();
- };
- $ptrType(nat).prototype.andNot = function(x, y) { return this.$get().andNot(x, y); };
- nat.prototype.or = function(x, y) {
- var $ptr, _tmp, _tmp$1, i, m, n, s, x, y, z;
- z = this;
- m = x.$length;
- n = y.$length;
- s = x;
- if (m < n) {
- _tmp = m; _tmp$1 = n; n = _tmp; m = _tmp$1;
- s = y;
- }
- z = z.make(m);
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) | ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i])) >>> 0);
- i = i + (1) >> 0;
- }
- $copySlice($subslice(z, n, m), $subslice(s, n, m));
- return z.norm();
- };
- $ptrType(nat).prototype.or = function(x, y) { return this.$get().or(x, y); };
- nat.prototype.xor = function(x, y) {
- var $ptr, _tmp, _tmp$1, i, m, n, s, x, y, z;
- z = this;
- m = x.$length;
- n = y.$length;
- s = x;
- if (m < n) {
- _tmp = m; _tmp$1 = n; n = _tmp; m = _tmp$1;
- s = y;
- }
- z = z.make(m);
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]) ^ ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i])) >>> 0);
- i = i + (1) >> 0;
- }
- $copySlice($subslice(z, n, m), $subslice(s, n, m));
- return z.norm();
- };
- $ptrType(nat).prototype.xor = function(x, y) { return this.$get().xor(x, y); };
- greaterThan = function(x1, x2, y1, y2) {
- var $ptr, x1, x2, y1, y2;
- return x1 > y1 || (x1 === y1) && x2 > y2;
- };
- nat.prototype.modW = function(d) {
- var $ptr, d, q, r, x;
- r = 0;
- x = this;
- q = nat.nil;
- q = q.make(x.$length);
- r = divWVW($subslice(new sliceType$1(q.$array), q.$offset, q.$offset + q.$length), 0, $subslice(new sliceType$1(x.$array), x.$offset, x.$offset + x.$length), d);
- return r;
- };
- $ptrType(nat).prototype.modW = function(d) { return this.$get().modW(d); };
- nat.prototype.random = function(rand$1, limit, n) {
- var $ptr, _i, _i$1, _index, _r, _r$1, _r$2, _r$3, _ref, _ref$1, bitLengthOfMSW, i, i$1, limit, mask, n, rand$1, y, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _index = $f._index; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; bitLengthOfMSW = $f.bitLengthOfMSW; i = $f.i; i$1 = $f.i$1; limit = $f.limit; mask = $f.mask; n = $f.n; rand$1 = $f.rand$1; y = $f.y; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- if (alias(z, limit)) {
- z = nat.nil;
- }
- z = z.make(limit.$length);
- bitLengthOfMSW = ((_r = n % 32, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) >>> 0);
- if (bitLengthOfMSW === 0) {
- bitLengthOfMSW = 32;
- }
- mask = ((((y = bitLengthOfMSW, y < 32 ? (1 << y) : 0) >>> 0)) - 1 >>> 0);
- /* while (true) { */ case 1:
- /* */ if (32 === 32) { $s = 3; continue; }
- /* */ if (32 === 64) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (32 === 32) { */ case 3:
- _ref = z;
- _i = 0;
- /* while (true) { */ case 7:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 8; continue; }
- i = _i;
- _r$1 = rand$1.Uint32(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ((i < 0 || i >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i] = (_r$1 >>> 0));
- _i++;
- /* } */ $s = 7; continue; case 8:
- $s = 6; continue;
- /* } else if (32 === 64) { */ case 4:
- _ref$1 = z;
- _i$1 = 0;
- /* while (true) { */ case 10:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 11; continue; }
- i$1 = _i$1;
- _r$2 = rand$1.Uint32(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = rand$1.Uint32(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- ((i$1 < 0 || i$1 >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + i$1] = ((_r$2 >>> 0) | ((_r$3 >>> 0) << 32 >>> 0)) >>> 0);
- _i$1++;
- /* } */ $s = 10; continue; case 11:
- $s = 6; continue;
- /* } else { */ case 5:
- $panic(new $String("unknown word size"));
- /* } */ case 6:
- _index = limit.$length - 1 >> 0;
- ((_index < 0 || _index >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + _index] = (((_index < 0 || _index >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + _index]) & (mask)) >>> 0);
- if (z.cmp(limit) < 0) {
- /* break; */ $s = 2; continue;
- }
- /* } */ $s = 1; continue; case 2:
- return z.norm();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: nat.prototype.random }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._index = _index; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.bitLengthOfMSW = bitLengthOfMSW; $f.i = i; $f.i$1 = i$1; $f.limit = limit; $f.mask = mask; $f.n = n; $f.rand$1 = rand$1; $f.y = y; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(nat).prototype.random = function(rand$1, limit, n) { return this.$get().random(rand$1, limit, n); };
- nat.prototype.expNN = function(x, y, m) {
- var $ptr, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, i, j, j$1, m, q, r, shift, v, w, x, x$1, y, y$1, y$2, y$3, z, zz;
- z = this;
- if (alias(z, x) || alias(z, y)) {
- z = nat.nil;
- }
- if ((m.$length === 1) && ((0 >= m.$length ? $throwRuntimeError("index out of range") : m.$array[m.$offset + 0]) === 1)) {
- return z.setWord(0);
- }
- if (y.$length === 0) {
- return z.setWord(1);
- }
- if (!((m.$length === 0))) {
- z = z.make(m.$length);
- }
- z = z.set(x);
- if (x.$length > 1 && y.$length > 1 && m.$length > 0) {
- return z.expNNWindowed(x, y, m);
- }
- v = (x$1 = y.$length - 1 >> 0, ((x$1 < 0 || x$1 >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + x$1]));
- shift = leadingZeros(v) + 1 >>> 0;
- v = (y$1 = (shift), y$1 < 32 ? (v << y$1) : 0) >>> 0;
- q = nat.nil;
- w = 32 - (shift >> 0) >> 0;
- _tmp = nat.nil; _tmp$1 = nat.nil; zz = _tmp; r = _tmp$1;
- j = 0;
- while (true) {
- if (!(j < w)) { break; }
- zz = zz.mul(z, z);
- _tmp$2 = z; _tmp$3 = zz; zz = _tmp$2; z = _tmp$3;
- if (!((((v & 2147483648) >>> 0) === 0))) {
- zz = zz.mul(z, x);
- _tmp$4 = z; _tmp$5 = zz; zz = _tmp$4; z = _tmp$5;
- }
- if (!((m.$length === 0))) {
- _tuple = zz.div(r, z, m); zz = _tuple[0]; r = _tuple[1];
- _tmp$6 = q; _tmp$7 = z; _tmp$8 = zz; _tmp$9 = r; zz = _tmp$6; r = _tmp$7; q = _tmp$8; z = _tmp$9;
- }
- v = (y$2 = (1), y$2 < 32 ? (v << y$2) : 0) >>> 0;
- j = j + (1) >> 0;
- }
- i = y.$length - 2 >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- v = ((i < 0 || i >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i]);
- j$1 = 0;
- while (true) {
- if (!(j$1 < 32)) { break; }
- zz = zz.mul(z, z);
- _tmp$10 = z; _tmp$11 = zz; zz = _tmp$10; z = _tmp$11;
- if (!((((v & 2147483648) >>> 0) === 0))) {
- zz = zz.mul(z, x);
- _tmp$12 = z; _tmp$13 = zz; zz = _tmp$12; z = _tmp$13;
- }
- if (!((m.$length === 0))) {
- _tuple$1 = zz.div(r, z, m); zz = _tuple$1[0]; r = _tuple$1[1];
- _tmp$14 = q; _tmp$15 = z; _tmp$16 = zz; _tmp$17 = r; zz = _tmp$14; r = _tmp$15; q = _tmp$16; z = _tmp$17;
- }
- v = (y$3 = (1), y$3 < 32 ? (v << y$3) : 0) >>> 0;
- j$1 = j$1 + (1) >> 0;
- }
- i = i - (1) >> 0;
- }
- return z.norm();
- };
- $ptrType(nat).prototype.expNN = function(x, y, m) { return this.$get().expNN(x, y, m); };
- nat.prototype.expNNWindowed = function(x, y, m) {
- var $ptr, _q, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$24, _tmp$25, _tmp$26, _tmp$27, _tmp$28, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, i, i$1, j, m, p, p1, p2, powers, r, x, x$1, y, y$1, yi, z, zz;
- z = this;
- _tmp = nat.nil; _tmp$1 = nat.nil; zz = _tmp; r = _tmp$1;
- powers = $clone(arrayType$1.zero(), arrayType$1);
- powers[0] = natOne;
- powers[1] = x;
- i = 2;
- while (true) {
- if (!(i < 16)) { break; }
- _tmp$2 = $indexPtr(powers, (_q = i / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")), ptrType$2); _tmp$3 = $indexPtr(powers, i, ptrType$2); _tmp$4 = $indexPtr(powers, (i + 1 >> 0), ptrType$2); p2 = _tmp$2; p = _tmp$3; p1 = _tmp$4;
- p.$set(p.mul(p2.$get(), p2.$get()));
- _tuple = zz.div(r, p.$get(), m); zz = _tuple[0]; r = _tuple[1];
- _tmp$5 = r; _tmp$6 = p.$get(); p.$set(_tmp$5); r = _tmp$6;
- p1.$set(p1.mul(p.$get(), x));
- _tuple$1 = zz.div(r, p1.$get(), m); zz = _tuple$1[0]; r = _tuple$1[1];
- _tmp$7 = r; _tmp$8 = p1.$get(); p1.$set(_tmp$7); r = _tmp$8;
- i = i + (2) >> 0;
- }
- z = z.setWord(1);
- i$1 = y.$length - 1 >> 0;
- while (true) {
- if (!(i$1 >= 0)) { break; }
- yi = ((i$1 < 0 || i$1 >= y.$length) ? $throwRuntimeError("index out of range") : y.$array[y.$offset + i$1]);
- j = 0;
- while (true) {
- if (!(j < 32)) { break; }
- if (!((i$1 === (y.$length - 1 >> 0))) || !((j === 0))) {
- zz = zz.mul(z, z);
- _tmp$9 = z; _tmp$10 = zz; zz = _tmp$9; z = _tmp$10;
- _tuple$2 = zz.div(r, z, m); zz = _tuple$2[0]; r = _tuple$2[1];
- _tmp$11 = r; _tmp$12 = z; z = _tmp$11; r = _tmp$12;
- zz = zz.mul(z, z);
- _tmp$13 = z; _tmp$14 = zz; zz = _tmp$13; z = _tmp$14;
- _tuple$3 = zz.div(r, z, m); zz = _tuple$3[0]; r = _tuple$3[1];
- _tmp$15 = r; _tmp$16 = z; z = _tmp$15; r = _tmp$16;
- zz = zz.mul(z, z);
- _tmp$17 = z; _tmp$18 = zz; zz = _tmp$17; z = _tmp$18;
- _tuple$4 = zz.div(r, z, m); zz = _tuple$4[0]; r = _tuple$4[1];
- _tmp$19 = r; _tmp$20 = z; z = _tmp$19; r = _tmp$20;
- zz = zz.mul(z, z);
- _tmp$21 = z; _tmp$22 = zz; zz = _tmp$21; z = _tmp$22;
- _tuple$5 = zz.div(r, z, m); zz = _tuple$5[0]; r = _tuple$5[1];
- _tmp$23 = r; _tmp$24 = z; z = _tmp$23; r = _tmp$24;
- }
- zz = zz.mul(z, (x$1 = yi >>> 28 >>> 0, ((x$1 < 0 || x$1 >= powers.length) ? $throwRuntimeError("index out of range") : powers[x$1])));
- _tmp$25 = z; _tmp$26 = zz; zz = _tmp$25; z = _tmp$26;
- _tuple$6 = zz.div(r, z, m); zz = _tuple$6[0]; r = _tuple$6[1];
- _tmp$27 = r; _tmp$28 = z; z = _tmp$27; r = _tmp$28;
- yi = (y$1 = (4), y$1 < 32 ? (yi << y$1) : 0) >>> 0;
- j = j + (4) >> 0;
- }
- i$1 = i$1 - (1) >> 0;
- }
- return z.norm();
- };
- $ptrType(nat).prototype.expNNWindowed = function(x, y, m) { return this.$get().expNNWindowed(x, y, m); };
- nat.prototype.probablyPrime = function(reps) {
- var $ptr, _r, _r$1, _r$10, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tmp, _tmp$1, _tmp$2, _tuple, i, j, k, n, nm1, nm3, nm3Len, q, quotient, r, rand$1, reps, x, x$1, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tuple = $f._tuple; i = $f.i; j = $f.j; k = $f.k; n = $f.n; nm1 = $f.nm1; nm3 = $f.nm3; nm3Len = $f.nm3Len; q = $f.q; quotient = $f.quotient; r = $f.r; rand$1 = $f.rand$1; reps = $f.reps; x = $f.x; x$1 = $f.x$1; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- if (n.$length === 0) {
- return false;
- }
- if (n.$length === 1) {
- if ((0 >= n.$length ? $throwRuntimeError("index out of range") : n.$array[n.$offset + 0]) < 2) {
- return false;
- }
- if ((_r = (0 >= n.$length ? $throwRuntimeError("index out of range") : n.$array[n.$offset + 0]) % 2, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) === 0) {
- return (0 >= n.$length ? $throwRuntimeError("index out of range") : n.$array[n.$offset + 0]) === 2;
- }
- _ref = (0 >= n.$length ? $throwRuntimeError("index out of range") : n.$array[n.$offset + 0]);
- if (_ref === 3 || _ref === 5 || _ref === 7 || _ref === 11 || _ref === 13 || _ref === 17 || _ref === 19 || _ref === 23 || _ref === 29 || _ref === 31 || _ref === 37 || _ref === 41 || _ref === 43 || _ref === 47 || _ref === 53) {
- return true;
- }
- }
- r = 0;
- if (32 === 32) {
- r = n.modW(3234846615);
- } else if (32 === 64) {
- r = n.modW(820596253);
- } else {
- $panic(new $String("Unknown word size"));
- }
- if (((_r$1 = r % 3, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$2 = r % 5, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$3 = r % 7, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$4 = r % 11, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$5 = r % 13, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$6 = r % 17, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$7 = r % 19, _r$7 === _r$7 ? _r$7 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$8 = r % 23, _r$8 === _r$8 ? _r$8 : $throwRuntimeError("integer divide by zero")) === 0) || ((_r$9 = r % 29, _r$9 === _r$9 ? _r$9 : $throwRuntimeError("integer divide by zero")) === 0)) {
- return false;
- }
- nm1 = nat.nil.sub(n, natOne);
- k = nm1.trailingZeroBits();
- q = nat.nil.shr(nm1, k);
- nm3 = nat.nil.sub(nm1, natTwo);
- rand$1 = rand.New(rand.NewSource((x = (0 >= n.$length ? $throwRuntimeError("index out of range") : n.$array[n.$offset + 0]), new $Int64(0, x.constructor === Number ? x : 1))));
- _tmp = nat.nil; _tmp$1 = nat.nil; _tmp$2 = nat.nil; x$1 = _tmp; y = _tmp$1; quotient = _tmp$2;
- nm3Len = nm3.bitLen();
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < reps)) { break; } */ if(!(i < reps)) { $s = 2; continue; }
- _r$10 = x$1.random(rand$1, nm3, nm3Len); /* */ $s = 3; case 3: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- x$1 = _r$10;
- x$1 = x$1.add(x$1, natTwo);
- y = y.expNN(x$1, q, n);
- if ((y.cmp(natOne) === 0) || (y.cmp(nm1) === 0)) {
- i = i + (1) >> 0;
- /* continue; */ $s = 1; continue;
- }
- j = 1;
- while (true) {
- if (!(j < k)) { break; }
- y = y.mul(y, y);
- _tuple = quotient.div(y, y, n); quotient = _tuple[0]; y = _tuple[1];
- if (y.cmp(nm1) === 0) {
- i = i + (1) >> 0;
- /* continue NextRandom; */ $s = 1; continue s;
- }
- if (y.cmp(natOne) === 0) {
- return false;
- }
- j = j + (1) >>> 0;
- }
- return false;
- /* } */ $s = 1; continue; case 2:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: nat.prototype.probablyPrime }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tuple = _tuple; $f.i = i; $f.j = j; $f.k = k; $f.n = n; $f.nm1 = nm1; $f.nm3 = nm3; $f.nm3Len = nm3Len; $f.q = q; $f.quotient = quotient; $f.r = r; $f.rand$1 = rand$1; $f.reps = reps; $f.x = x; $f.x$1 = x$1; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(nat).prototype.probablyPrime = function(reps) { return this.$get().probablyPrime(reps); };
- nat.prototype.bytes = function(buf) {
- var $ptr, _i, _ref, buf, d, i, j, y, z;
- i = 0;
- z = this;
- i = buf.$length;
- _ref = z;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- d = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- j = 0;
- while (true) {
- if (!(j < 4)) { break; }
- i = i - (1) >> 0;
- ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = (d << 24 >>> 24));
- d = (y = (8), y < 32 ? (d >>> y) : 0) >>> 0;
- j = j + (1) >> 0;
- }
- _i++;
- }
- while (true) {
- if (!(i < buf.$length && (((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i]) === 0))) { break; }
- i = i + (1) >> 0;
- }
- return i;
- };
- $ptrType(nat).prototype.bytes = function(buf) { return this.$get().bytes(buf); };
- nat.prototype.setBytes = function(buf) {
- var $ptr, _q, buf, d, i, k, s, x, y, z;
- z = this;
- z = z.make((_q = (((buf.$length + 4 >> 0) - 1 >> 0)) / 4, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")));
- k = 0;
- s = 0;
- d = 0;
- i = buf.$length;
- while (true) {
- if (!(i > 0)) { break; }
- d = (d | (((y = s, y < 32 ? (((x = i - 1 >> 0, ((x < 0 || x >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + x])) >>> 0) << y) : 0) >>> 0))) >>> 0;
- s = s + (8) >>> 0;
- if (s === 32) {
- ((k < 0 || k >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + k] = d);
- k = k + (1) >> 0;
- s = 0;
- d = 0;
- }
- i = i - (1) >> 0;
- }
- if (k < z.$length) {
- ((k < 0 || k >= z.$length) ? $throwRuntimeError("index out of range") : z.$array[z.$offset + k] = d);
- }
- return z.norm();
- };
- $ptrType(nat).prototype.setBytes = function(buf) { return this.$get().setBytes(buf); };
- NewRat = function(a, b) {
- var $ptr, a, b;
- return new Rat.ptr().SetFrac64(a, b);
- };
- $pkg.NewRat = NewRat;
- Rat.ptr.prototype.SetFloat64 = function(f) {
- var $ptr, _ref, bits, exp, f, mantissa, shift, x, x$1, x$2, z;
- z = this;
- bits = math.Float64bits(f);
- mantissa = new $Uint64(bits.$high & 1048575, (bits.$low & 4294967295) >>> 0);
- exp = ((x = $shiftRightUint64(bits, 52), new $Uint64(x.$high & 0, (x.$low & 2047) >>> 0)).$low >> 0);
- _ref = exp;
- if (_ref === 2047) {
- return ptrType$3.nil;
- } else if (_ref === 0) {
- exp = exp - (1022) >> 0;
- } else {
- mantissa = (x$1 = new $Uint64(1048576, 0), new $Uint64(mantissa.$high | x$1.$high, (mantissa.$low | x$1.$low) >>> 0));
- exp = exp - (1023) >> 0;
- }
- shift = 52 - exp >> 0;
- while (true) {
- if (!((x$2 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$2.$high === 0 && x$2.$low === 0)) && shift > 0)) { break; }
- mantissa = $shiftRightUint64(mantissa, (1));
- shift = shift - (1) >> 0;
- }
- z.a.SetUint64(mantissa);
- z.a.neg = f < 0;
- z.b.Set(intOne);
- if (shift > 0) {
- z.b.Lsh(z.b, (shift >>> 0));
- } else {
- z.a.Lsh(z.a, (-shift >>> 0));
- }
- return z.norm();
- };
- Rat.prototype.SetFloat64 = function(f) { return this.$val.SetFloat64(f); };
- quotToFloat32 = function(a, b) {
- var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, a, a2, alen, b, b2, blen, exact, exp, f, haveRem, lostbits, mantissa, q, r, shift, shift$1, y, y$1, y$2, y$3, y$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; a = $f.a; a2 = $f.a2; alen = $f.alen; b = $f.b; b2 = $f.b2; blen = $f.blen; exact = $f.exact; exp = $f.exp; f = $f.f; haveRem = $f.haveRem; lostbits = $f.lostbits; mantissa = $f.mantissa; q = $f.q; r = $f.r; shift = $f.shift; shift$1 = $f.shift$1; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = 0;
- exact = false;
- alen = a.bitLen();
- if (alen === 0) {
- _tmp = 0; _tmp$1 = true; f = _tmp; exact = _tmp$1;
- return [f, exact];
- }
- blen = b.bitLen();
- if (blen === 0) {
- $panic(new $String("division by zero"));
- }
- exp = alen - blen >> 0;
- _tmp$2 = nat.nil; _tmp$3 = nat.nil; a2 = _tmp$2; b2 = _tmp$3;
- a2 = a2.set(a);
- b2 = b2.set(b);
- shift = 25 - exp >> 0;
- if (shift > 0) {
- a2 = a2.shl(a2, (shift >>> 0));
- } else if (shift < 0) {
- b2 = b2.shl(b2, (-shift >>> 0));
- }
- q = nat.nil;
- _tuple = q.div(a2, a2, b2); q = _tuple[0]; r = _tuple[1];
- mantissa = low32(q);
- haveRem = r.$length > 0;
- if ((mantissa >>> 25 >>> 0) === 1) {
- if (((mantissa & 1) >>> 0) === 1) {
- haveRem = true;
- }
- mantissa = (y = (1), y < 32 ? (mantissa >>> y) : 0) >>> 0;
- exp = exp + (1) >> 0;
- }
- /* */ if (!(((mantissa >>> 24 >>> 0) === 1))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(((mantissa >>> 24 >>> 0) === 1))) { */ case 1:
- _r = fmt.Sprintf("expected exactly %d bits of result", new sliceType$2([new $Int(25)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* } */ case 2:
- if (-149 <= exp && exp <= -126) {
- shift$1 = ((-126 - ((exp - 1 >> 0)) >> 0) >>> 0);
- lostbits = (mantissa & ((((y$1 = shift$1, y$1 < 32 ? (1 << y$1) : 0) >>> 0) - 1 >>> 0))) >>> 0;
- haveRem = haveRem || !((lostbits === 0));
- mantissa = (y$2 = (shift$1), y$2 < 32 ? (mantissa >>> y$2) : 0) >>> 0;
- exp = -125;
- }
- exact = !haveRem;
- if (!((((mantissa & 1) >>> 0) === 0))) {
- exact = false;
- if (haveRem || !((((mantissa & 2) >>> 0) === 0))) {
- mantissa = mantissa + (1) >>> 0;
- if (mantissa >= 33554432) {
- mantissa = (y$3 = (1), y$3 < 32 ? (mantissa >>> y$3) : 0) >>> 0;
- exp = exp + (1) >> 0;
- }
- }
- }
- mantissa = (y$4 = (1), y$4 < 32 ? (mantissa >>> y$4) : 0) >>> 0;
- f = $fround(math.Ldexp(mantissa, exp - 24 >> 0));
- if (math.IsInf(f, 0)) {
- exact = false;
- }
- return [f, exact];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: quotToFloat32 }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.a = a; $f.a2 = a2; $f.alen = alen; $f.b = b; $f.b2 = b2; $f.blen = blen; $f.exact = exact; $f.exp = exp; $f.f = f; $f.haveRem = haveRem; $f.lostbits = lostbits; $f.mantissa = mantissa; $f.q = q; $f.r = r; $f.shift = shift; $f.shift$1 = shift$1; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- quotToFloat64 = function(a, b) {
- var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, a, a2, alen, b, b2, blen, exact, exp, f, haveRem, lostbits, mantissa, q, r, shift, shift$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; a = $f.a; a2 = $f.a2; alen = $f.alen; b = $f.b; b2 = $f.b2; blen = $f.blen; exact = $f.exact; exp = $f.exp; f = $f.f; haveRem = $f.haveRem; lostbits = $f.lostbits; mantissa = $f.mantissa; q = $f.q; r = $f.r; shift = $f.shift; shift$1 = $f.shift$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = 0;
- exact = false;
- alen = a.bitLen();
- if (alen === 0) {
- _tmp = 0; _tmp$1 = true; f = _tmp; exact = _tmp$1;
- return [f, exact];
- }
- blen = b.bitLen();
- if (blen === 0) {
- $panic(new $String("division by zero"));
- }
- exp = alen - blen >> 0;
- _tmp$2 = nat.nil; _tmp$3 = nat.nil; a2 = _tmp$2; b2 = _tmp$3;
- a2 = a2.set(a);
- b2 = b2.set(b);
- shift = 54 - exp >> 0;
- if (shift > 0) {
- a2 = a2.shl(a2, (shift >>> 0));
- } else if (shift < 0) {
- b2 = b2.shl(b2, (-shift >>> 0));
- }
- q = nat.nil;
- _tuple = q.div(a2, a2, b2); q = _tuple[0]; r = _tuple[1];
- mantissa = low64(q);
- haveRem = r.$length > 0;
- if ((x = $shiftRightUint64(mantissa, 54), (x.$high === 0 && x.$low === 1))) {
- if ((x$1 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$1.$high === 0 && x$1.$low === 1))) {
- haveRem = true;
- }
- mantissa = $shiftRightUint64(mantissa, (1));
- exp = exp + (1) >> 0;
- }
- /* */ if (!((x$2 = $shiftRightUint64(mantissa, 53), (x$2.$high === 0 && x$2.$low === 1)))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((x$2 = $shiftRightUint64(mantissa, 53), (x$2.$high === 0 && x$2.$low === 1)))) { */ case 1:
- _r = fmt.Sprintf("expected exactly %d bits of result", new sliceType$2([new $Int(54)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* } */ case 2:
- if (-1074 <= exp && exp <= -1022) {
- shift$1 = ((-1022 - ((exp - 1 >> 0)) >> 0) >>> 0);
- lostbits = (x$3 = (x$4 = $shiftLeft64(new $Uint64(0, 1), shift$1), new $Uint64(x$4.$high - 0, x$4.$low - 1)), new $Uint64(mantissa.$high & x$3.$high, (mantissa.$low & x$3.$low) >>> 0));
- haveRem = haveRem || !((lostbits.$high === 0 && lostbits.$low === 0));
- mantissa = $shiftRightUint64(mantissa, (shift$1));
- exp = -1021;
- }
- exact = !haveRem;
- if (!((x$5 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 1) >>> 0), (x$5.$high === 0 && x$5.$low === 0)))) {
- exact = false;
- if (haveRem || !((x$6 = new $Uint64(mantissa.$high & 0, (mantissa.$low & 2) >>> 0), (x$6.$high === 0 && x$6.$low === 0)))) {
- mantissa = (x$7 = new $Uint64(0, 1), new $Uint64(mantissa.$high + x$7.$high, mantissa.$low + x$7.$low));
- if ((mantissa.$high > 4194304 || (mantissa.$high === 4194304 && mantissa.$low >= 0))) {
- mantissa = $shiftRightUint64(mantissa, (1));
- exp = exp + (1) >> 0;
- }
- }
- }
- mantissa = $shiftRightUint64(mantissa, (1));
- f = math.Ldexp($flatten64(mantissa), exp - 53 >> 0);
- if (math.IsInf(f, 0)) {
- exact = false;
- }
- return [f, exact];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: quotToFloat64 }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f.a = a; $f.a2 = a2; $f.alen = alen; $f.b = b; $f.b2 = b2; $f.blen = blen; $f.exact = exact; $f.exp = exp; $f.f = f; $f.haveRem = haveRem; $f.lostbits = lostbits; $f.mantissa = mantissa; $f.q = q; $f.r = r; $f.shift = shift; $f.shift$1 = shift$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rat.ptr.prototype.Float32 = function() {
- var $ptr, _r, _tuple, b, exact, f, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; b = $f.b; exact = $f.exact; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = 0;
- exact = false;
- x = this;
- b = x.b.abs;
- if (b.$length === 0) {
- b = b.set(natOne);
- }
- _r = quotToFloat32(x.a.abs, b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f = _tuple[0]; exact = _tuple[1];
- if (x.a.neg) {
- f = -f;
- }
- return [f, exact];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Float32 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.exact = exact; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rat.prototype.Float32 = function() { return this.$val.Float32(); };
- Rat.ptr.prototype.Float64 = function() {
- var $ptr, _r, _tuple, b, exact, f, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; b = $f.b; exact = $f.exact; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- f = 0;
- exact = false;
- x = this;
- b = x.b.abs;
- if (b.$length === 0) {
- b = b.set(natOne);
- }
- _r = quotToFloat64(x.a.abs, b); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f = _tuple[0]; exact = _tuple[1];
- if (x.a.neg) {
- f = -f;
- }
- return [f, exact];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Float64 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.exact = exact; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rat.prototype.Float64 = function() { return this.$val.Float64(); };
- Rat.ptr.prototype.SetFrac = function(a, b) {
- var $ptr, a, b, babs, z;
- z = this;
- z.a.neg = !(a.neg === b.neg);
- babs = b.abs;
- if (babs.$length === 0) {
- $panic(new $String("division by zero"));
- }
- if (z.a === b || alias(z.a.abs, babs)) {
- babs = nat.nil.set(babs);
- }
- z.a.abs = z.a.abs.set(a.abs);
- z.b.abs = z.b.abs.set(babs);
- return z.norm();
- };
- Rat.prototype.SetFrac = function(a, b) { return this.$val.SetFrac(a, b); };
- Rat.ptr.prototype.SetFrac64 = function(a, b) {
- var $ptr, a, b, z;
- z = this;
- z.a.SetInt64(a);
- if ((b.$high === 0 && b.$low === 0)) {
- $panic(new $String("division by zero"));
- }
- if ((b.$high < 0 || (b.$high === 0 && b.$low < 0))) {
- b = new $Int64(-b.$high, -b.$low);
- z.a.neg = !z.a.neg;
- }
- z.b.abs = z.b.abs.setUint64(new $Uint64(b.$high, b.$low));
- return z.norm();
- };
- Rat.prototype.SetFrac64 = function(a, b) { return this.$val.SetFrac64(a, b); };
- Rat.ptr.prototype.SetInt = function(x) {
- var $ptr, x, z;
- z = this;
- z.a.Set(x);
- z.b.abs = z.b.abs.make(0);
- return z;
- };
- Rat.prototype.SetInt = function(x) { return this.$val.SetInt(x); };
- Rat.ptr.prototype.SetInt64 = function(x) {
- var $ptr, x, z;
- z = this;
- z.a.SetInt64(x);
- z.b.abs = z.b.abs.make(0);
- return z;
- };
- Rat.prototype.SetInt64 = function(x) { return this.$val.SetInt64(x); };
- Rat.ptr.prototype.Set = function(x) {
- var $ptr, x, z;
- z = this;
- if (!(z === x)) {
- z.a.Set(x.a);
- z.b.Set(x.b);
- }
- return z;
- };
- Rat.prototype.Set = function(x) { return this.$val.Set(x); };
- Rat.ptr.prototype.Abs = function(x) {
- var $ptr, x, z;
- z = this;
- z.Set(x);
- z.a.neg = false;
- return z;
- };
- Rat.prototype.Abs = function(x) { return this.$val.Abs(x); };
- Rat.ptr.prototype.Neg = function(x) {
- var $ptr, x, z;
- z = this;
- z.Set(x);
- z.a.neg = z.a.abs.$length > 0 && !z.a.neg;
- return z;
- };
- Rat.prototype.Neg = function(x) { return this.$val.Neg(x); };
- Rat.ptr.prototype.Inv = function(x) {
- var $ptr, _tmp, _tmp$1, a, b, x, z;
- z = this;
- if (x.a.abs.$length === 0) {
- $panic(new $String("division by zero"));
- }
- z.Set(x);
- a = z.b.abs;
- if (a.$length === 0) {
- a = a.set(natOne);
- }
- b = z.a.abs;
- if (b.cmp(natOne) === 0) {
- b = b.make(0);
- }
- _tmp = a; _tmp$1 = b; z.a.abs = _tmp; z.b.abs = _tmp$1;
- return z;
- };
- Rat.prototype.Inv = function(x) { return this.$val.Inv(x); };
- Rat.ptr.prototype.Sign = function() {
- var $ptr, x;
- x = this;
- return x.a.Sign();
- };
- Rat.prototype.Sign = function() { return this.$val.Sign(); };
- Rat.ptr.prototype.IsInt = function() {
- var $ptr, x;
- x = this;
- return (x.b.abs.$length === 0) || (x.b.abs.cmp(natOne) === 0);
- };
- Rat.prototype.IsInt = function() { return this.$val.IsInt(); };
- Rat.ptr.prototype.Num = function() {
- var $ptr, x;
- x = this;
- return x.a;
- };
- Rat.prototype.Num = function() { return this.$val.Num(); };
- Rat.ptr.prototype.Denom = function() {
- var $ptr, x;
- x = this;
- x.b.neg = false;
- if (x.b.abs.$length === 0) {
- x.b.abs = x.b.abs.set(natOne);
- }
- return x.b;
- };
- Rat.prototype.Denom = function() { return this.$val.Denom(); };
- Rat.ptr.prototype.norm = function() {
- var $ptr, _tuple, _tuple$1, f, neg, z;
- z = this;
- if (z.a.abs.$length === 0) {
- z.a.neg = false;
- z.b.abs = z.b.abs.make(0);
- } else if (z.b.abs.$length === 0) {
- } else if (z.b.abs.cmp(natOne) === 0) {
- z.b.abs = z.b.abs.make(0);
- } else {
- neg = z.a.neg;
- z.a.neg = false;
- z.b.neg = false;
- f = NewInt(new $Int64(0, 0)).binaryGCD(z.a, z.b);
- if (!((f.Cmp(intOne) === 0))) {
- _tuple = z.a.abs.div(nat.nil, z.a.abs, f.abs); z.a.abs = _tuple[0];
- _tuple$1 = z.b.abs.div(nat.nil, z.b.abs, f.abs); z.b.abs = _tuple$1[0];
- if (z.b.abs.cmp(natOne) === 0) {
- z.b.abs = z.b.abs.make(0);
- }
- }
- z.a.neg = neg;
- }
- return z;
- };
- Rat.prototype.norm = function() { return this.$val.norm(); };
- mulDenom = function(z, x, y) {
- var $ptr, x, y, z;
- if (x.$length === 0) {
- return z.set(y);
- } else if (y.$length === 0) {
- return z.set(x);
- }
- return z.mul(x, y);
- };
- scaleDenom = function(x, f) {
- var $ptr, f, x, z;
- z = $clone(new Int.ptr(), Int);
- if (f.$length === 0) {
- return z.Set(x);
- }
- z.abs = z.abs.mul(x.abs, f);
- z.neg = x.neg;
- return z;
- };
- Rat.ptr.prototype.Cmp = function(y) {
- var $ptr, x, y;
- x = this;
- return scaleDenom(x.a, y.b.abs).Cmp(scaleDenom(y.a, x.b.abs));
- };
- Rat.prototype.Cmp = function(y) { return this.$val.Cmp(y); };
- Rat.ptr.prototype.Add = function(x, y) {
- var $ptr, a1, a2, x, y, z;
- z = this;
- a1 = scaleDenom(x.a, y.b.abs);
- a2 = scaleDenom(y.a, x.b.abs);
- z.a.Add(a1, a2);
- z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs);
- return z.norm();
- };
- Rat.prototype.Add = function(x, y) { return this.$val.Add(x, y); };
- Rat.ptr.prototype.Sub = function(x, y) {
- var $ptr, a1, a2, x, y, z;
- z = this;
- a1 = scaleDenom(x.a, y.b.abs);
- a2 = scaleDenom(y.a, x.b.abs);
- z.a.Sub(a1, a2);
- z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs);
- return z.norm();
- };
- Rat.prototype.Sub = function(x, y) { return this.$val.Sub(x, y); };
- Rat.ptr.prototype.Mul = function(x, y) {
- var $ptr, x, y, z;
- z = this;
- z.a.Mul(x.a, y.a);
- z.b.abs = mulDenom(z.b.abs, x.b.abs, y.b.abs);
- return z.norm();
- };
- Rat.prototype.Mul = function(x, y) { return this.$val.Mul(x, y); };
- Rat.ptr.prototype.Quo = function(x, y) {
- var $ptr, a, b, x, y, z;
- z = this;
- if (y.a.abs.$length === 0) {
- $panic(new $String("division by zero"));
- }
- a = scaleDenom(x.a, y.b.abs);
- b = scaleDenom(y.a, x.b.abs);
- z.a.abs = a.abs;
- z.b.abs = b.abs;
- z.a.neg = !(a.neg === b.neg);
- return z.norm();
- };
- Rat.prototype.Quo = function(x, y) { return this.$val.Quo(x, y); };
- ratTok = function(ch) {
- var $ptr, ch;
- return strings.IndexRune("+-/0123456789.eE", ch) >= 0;
- };
- Rat.ptr.prototype.Scan = function(s, ch) {
- var $ptr, _r, _r$1, _tuple, _tuple$1, ch, err, ok, s, tok, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; ch = $f.ch; err = $f.err; ok = $f.ok; s = $f.s; tok = $f.tok; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- _r = s.Token(true, ratTok); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; tok = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return err;
- }
- if (strings.IndexRune("efgEFGv", ch) < 0) {
- return errors.New("Rat.Scan: invalid verb");
- }
- _r$1 = z.SetString($bytesToString(tok)); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; ok = _tuple$1[1];
- /* */ if (!ok) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!ok) { */ case 3:
- return errors.New("Rat.Scan: invalid syntax");
- /* } */ case 4:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.Scan }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.ch = ch; $f.err = err; $f.ok = ok; $f.s = s; $f.tok = tok; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rat.prototype.Scan = function(s, ch) { return this.$val.Scan(s, ch); };
- Rat.ptr.prototype.SetString = function(s) {
- var $ptr, _r, _r$1, _r$2, _r$3, _tuple, _tuple$1, _tuple$2, _tuple$3, e, err, exp, ok, ok$1, ok$2, powTen, s, sep, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; e = $f.e; err = $f.err; exp = $f.exp; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; powTen = $f.powTen; s = $f.s; sep = $f.sep; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- exp = [exp];
- z = this;
- if (s.length === 0) {
- return [ptrType$3.nil, false];
- }
- sep = strings.Index(s, "/");
- /* */ if (sep >= 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (sep >= 0) { */ case 1:
- _r = z.a.SetString(s.substring(0, sep), 10); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; ok = _tuple[1];
- /* */ if (!ok) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!ok) { */ case 4:
- return [ptrType$3.nil, false];
- /* } */ case 5:
- s = s.substring((sep + 1 >> 0));
- err = $ifaceNil;
- _r$1 = z.b.abs.scan(strings.NewReader(s), 10); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; z.b.abs = _tuple$1[0]; err = _tuple$1[2];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 7:
- return [ptrType$3.nil, false];
- /* } */ case 8:
- if (z.b.abs.$length === 0) {
- return [ptrType$3.nil, false];
- }
- return [z.norm(), true];
- /* } */ case 2:
- sep = strings.Index(s, ".");
- e = strings.IndexAny(s, "eE");
- exp[0] = $clone(new Int.ptr(), Int);
- /* */ if (e >= 0) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (e >= 0) { */ case 9:
- if (e < sep) {
- return [ptrType$3.nil, false];
- }
- _r$2 = exp[0].SetString(s.substring((e + 1 >> 0)), 10); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$2 = _r$2; ok$1 = _tuple$2[1];
- /* */ if (!ok$1) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (!ok$1) { */ case 12:
- return [ptrType$3.nil, false];
- /* } */ case 13:
- s = s.substring(0, e);
- /* } */ case 10:
- if (sep >= 0) {
- s = s.substring(0, sep) + s.substring((sep + 1 >> 0));
- exp[0].Sub(exp[0], NewInt(new $Int64(0, (s.length - sep >> 0))));
- }
- _r$3 = z.a.SetString(s, 10); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$3 = _r$3; ok$2 = _tuple$3[1];
- /* */ if (!ok$2) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!ok$2) { */ case 15:
- return [ptrType$3.nil, false];
- /* } */ case 16:
- powTen = nat.nil.expNN(natTen, exp[0].abs, nat.nil);
- if (exp[0].neg) {
- z.b.abs = powTen;
- z.norm();
- } else {
- z.a.abs = z.a.abs.mul(z.a.abs, powTen);
- z.b.abs = z.b.abs.make(0);
- }
- return [z, true];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.SetString }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.e = e; $f.err = err; $f.exp = exp; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.powTen = powTen; $f.s = s; $f.sep = sep; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rat.prototype.SetString = function(s) { return this.$val.SetString(s); };
- Rat.ptr.prototype.String = function() {
- var $ptr, s, x;
- x = this;
- s = "/1";
- if (!((x.b.abs.$length === 0))) {
- s = "/" + x.b.abs.decimalString();
- }
- return x.a.String() + s;
- };
- Rat.prototype.String = function() { return this.$val.String(); };
- Rat.ptr.prototype.RatString = function() {
- var $ptr, x;
- x = this;
- if (x.IsInt()) {
- return x.a.String();
- }
- return x.String();
- };
- Rat.prototype.RatString = function() { return this.$val.RatString(); };
- Rat.ptr.prototype.FloatString = function(prec) {
- var $ptr, _tuple, _tuple$1, leadingZeros$1, p, prec, q, r, r2, rs, s, s$1, x;
- x = this;
- if (x.IsInt()) {
- s = x.a.String();
- if (prec > 0) {
- s = s + ("." + strings.Repeat("0", prec));
- }
- return s;
- }
- _tuple = nat.nil.div(nat.nil, x.a.abs, x.b.abs); q = _tuple[0]; r = _tuple[1];
- p = natOne;
- if (prec > 0) {
- p = nat.nil.expNN(natTen, nat.nil.setUint64(new $Uint64(0, prec)), nat.nil);
- }
- r = r.mul(r, p);
- _tuple$1 = r.div(nat.nil, r, x.b.abs); r = _tuple$1[0]; r2 = _tuple$1[1];
- r2 = r2.add(r2, r2);
- if (x.b.abs.cmp(r2) <= 0) {
- r = r.add(r, natOne);
- if (r.cmp(p) >= 0) {
- q = nat.nil.add(q, natOne);
- r = nat.nil.sub(r, p);
- }
- }
- s$1 = q.decimalString();
- if (x.a.neg) {
- s$1 = "-" + s$1;
- }
- if (prec > 0) {
- rs = r.decimalString();
- leadingZeros$1 = prec - rs.length >> 0;
- s$1 = s$1 + ("." + strings.Repeat("0", leadingZeros$1) + rs);
- }
- return s$1;
- };
- Rat.prototype.FloatString = function(prec) { return this.$val.FloatString(prec); };
- Rat.ptr.prototype.GobEncode = function() {
- var $ptr, b, buf, i, j, n, x;
- x = this;
- if (x === ptrType$3.nil) {
- return [sliceType.nil, $ifaceNil];
- }
- buf = $makeSlice(sliceType, (5 + (((x.a.abs.$length + x.b.abs.$length >> 0)) * 4 >> 0) >> 0));
- i = x.b.abs.bytes(buf);
- j = x.a.abs.bytes($subslice(buf, 0, i));
- n = i - j >> 0;
- if (!((((n >>> 0) >> 0) === n))) {
- return [sliceType.nil, errors.New("Rat.GobEncode: numerator too large")];
- }
- binary.BigEndian.PutUint32($subslice(buf, (j - 4 >> 0), j), (n >>> 0));
- j = j - (5) >> 0;
- b = 2;
- if (x.a.neg) {
- b = (b | (1)) >>> 0;
- }
- ((j < 0 || j >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + j] = b);
- return [$subslice(buf, j), $ifaceNil];
- };
- Rat.prototype.GobEncode = function() { return this.$val.GobEncode(); };
- Rat.ptr.prototype.GobDecode = function(buf) {
- var $ptr, _r, _r$1, b, buf, i, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; b = $f.b; buf = $f.buf; i = $f.i; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = this;
- if (buf.$length === 0) {
- $copy(z, new Rat.ptr(new Int.ptr(), new Int.ptr()), Rat);
- return $ifaceNil;
- }
- b = (0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]);
- /* */ if (!(((b >>> 1 << 24 >>> 24) === 1))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(((b >>> 1 << 24 >>> 24) === 1))) { */ case 1:
- _r = fmt.Sprintf("Rat.GobDecode: encoding version %d not supported", new sliceType$2([new $Uint8((b >>> 1 << 24 >>> 24))])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = errors.New(_r); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 2:
- i = 5 + binary.BigEndian.Uint32($subslice(buf, 1, 5)) >>> 0;
- z.a.neg = !((((b & 1) >>> 0) === 0));
- z.a.abs = z.a.abs.setBytes($subslice(buf, 5, i));
- z.b.abs = z.b.abs.setBytes($subslice(buf, i));
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.GobDecode }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.buf = buf; $f.i = i; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rat.prototype.GobDecode = function(buf) { return this.$val.GobDecode(buf); };
- Rat.ptr.prototype.MarshalText = function() {
- var $ptr, _tmp, _tmp$1, err, r, text;
- text = sliceType.nil;
- err = $ifaceNil;
- r = this;
- _tmp = new sliceType($stringToBytes(r.RatString())); _tmp$1 = $ifaceNil; text = _tmp; err = _tmp$1;
- return [text, err];
- };
- Rat.prototype.MarshalText = function() { return this.$val.MarshalText(); };
- Rat.ptr.prototype.UnmarshalText = function(text) {
- var $ptr, _r, _r$1, _tuple, ok, r, text, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; ok = $f.ok; r = $f.r; text = $f.text; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = this;
- _r = r.SetString($bytesToString(text)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; ok = _tuple[1];
- /* */ if (!ok) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!ok) { */ case 2:
- _r$1 = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Rat", new sliceType$2([text])); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 3:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Rat.ptr.prototype.UnmarshalText }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.ok = ok; $f.r = r; $f.text = text; $f.$s = $s; $f.$r = $r; return $f;
- };
- Rat.prototype.UnmarshalText = function(text) { return this.$val.UnmarshalText(text); };
- ptrType.methods = [{prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType], false)}, {prop: "SetUint64", name: "SetUint64", pkg: "", typ: $funcType([$Uint64], [ptrType], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Bits", name: "Bits", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "SetBits", name: "SetBits", pkg: "", typ: $funcType([sliceType$1], [ptrType], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "MulRange", name: "MulRange", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType], false)}, {prop: "Binomial", name: "Binomial", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Rem", name: "Rem", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "QuoRem", name: "QuoRem", pkg: "", typ: $funcType([ptrType, ptrType, ptrType], [ptrType, ptrType], false)}, {prop: "Div", name: "Div", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Mod", name: "Mod", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "DivMod", name: "DivMod", pkg: "", typ: $funcType([ptrType, ptrType, ptrType], [ptrType, ptrType], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType], [$Int], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Format", name: "Format", pkg: "", typ: $funcType([fmt.State, $Int32], [], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.RuneScanner, $Int], [ptrType, $Int, $error], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([], [$Uint64], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String, $Int], [ptrType, $Bool], false)}, {prop: "SetBytes", name: "SetBytes", pkg: "", typ: $funcType([sliceType], [ptrType], false)}, {prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType], false)}, {prop: "BitLen", name: "BitLen", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Exp", name: "Exp", pkg: "", typ: $funcType([ptrType, ptrType, ptrType], [ptrType], false)}, {prop: "GCD", name: "GCD", pkg: "", typ: $funcType([ptrType, ptrType, ptrType, ptrType], [ptrType], false)}, {prop: "binaryGCD", name: "binaryGCD", pkg: "math/big", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "ProbablyPrime", name: "ProbablyPrime", pkg: "", typ: $funcType([$Int], [$Bool], false)}, {prop: "Rand", name: "Rand", pkg: "", typ: $funcType([ptrType$4, ptrType], [ptrType], false)}, {prop: "ModInverse", name: "ModInverse", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Lsh", name: "Lsh", pkg: "", typ: $funcType([ptrType, $Uint], [ptrType], false)}, {prop: "Rsh", name: "Rsh", pkg: "", typ: $funcType([ptrType, $Uint], [ptrType], false)}, {prop: "Bit", name: "Bit", pkg: "", typ: $funcType([$Int], [$Uint], false)}, {prop: "SetBit", name: "SetBit", pkg: "", typ: $funcType([ptrType, $Int, $Uint], [ptrType], false)}, {prop: "And", name: "And", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "AndNot", name: "AndNot", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Or", name: "Or", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Xor", name: "Xor", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType], false)}, {prop: "Not", name: "Not", pkg: "", typ: $funcType([ptrType], [ptrType], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType], [$error], false)}, {prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType, $error], false)}, {prop: "UnmarshalJSON", name: "UnmarshalJSON", pkg: "", typ: $funcType([sliceType], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType], [$error], false)}];
- nat.methods = [{prop: "clear", name: "clear", pkg: "math/big", typ: $funcType([], [], false)}, {prop: "norm", name: "norm", pkg: "math/big", typ: $funcType([], [nat], false)}, {prop: "make", name: "make", pkg: "math/big", typ: $funcType([$Int], [nat], false)}, {prop: "setWord", name: "setWord", pkg: "math/big", typ: $funcType([Word], [nat], false)}, {prop: "setUint64", name: "setUint64", pkg: "math/big", typ: $funcType([$Uint64], [nat], false)}, {prop: "set", name: "set", pkg: "math/big", typ: $funcType([nat], [nat], false)}, {prop: "add", name: "add", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "sub", name: "sub", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "cmp", name: "cmp", pkg: "math/big", typ: $funcType([nat], [$Int], false)}, {prop: "mulAddWW", name: "mulAddWW", pkg: "math/big", typ: $funcType([nat, Word, Word], [nat], false)}, {prop: "mul", name: "mul", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "mulRange", name: "mulRange", pkg: "math/big", typ: $funcType([$Uint64, $Uint64], [nat], false)}, {prop: "divW", name: "divW", pkg: "math/big", typ: $funcType([nat, Word], [nat, Word], false)}, {prop: "div", name: "div", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat, nat], false)}, {prop: "divLarge", name: "divLarge", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat, nat], false)}, {prop: "bitLen", name: "bitLen", pkg: "math/big", typ: $funcType([], [$Int], false)}, {prop: "scan", name: "scan", pkg: "math/big", typ: $funcType([io.RuneScanner, $Int], [nat, $Int, $error], false)}, {prop: "decimalString", name: "decimalString", pkg: "math/big", typ: $funcType([], [$String], false)}, {prop: "string", name: "string", pkg: "math/big", typ: $funcType([$String], [$String], false)}, {prop: "convertWords", name: "convertWords", pkg: "math/big", typ: $funcType([sliceType, $String, Word, $Int, Word, sliceType$3], [], false)}, {prop: "expWW", name: "expWW", pkg: "math/big", typ: $funcType([Word, Word], [nat], false)}, {prop: "trailingZeroBits", name: "trailingZeroBits", pkg: "math/big", typ: $funcType([], [$Uint], false)}, {prop: "shl", name: "shl", pkg: "math/big", typ: $funcType([nat, $Uint], [nat], false)}, {prop: "shr", name: "shr", pkg: "math/big", typ: $funcType([nat, $Uint], [nat], false)}, {prop: "setBit", name: "setBit", pkg: "math/big", typ: $funcType([nat, $Uint, $Uint], [nat], false)}, {prop: "bit", name: "bit", pkg: "math/big", typ: $funcType([$Uint], [$Uint], false)}, {prop: "and", name: "and", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "andNot", name: "andNot", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "or", name: "or", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "xor", name: "xor", pkg: "math/big", typ: $funcType([nat, nat], [nat], false)}, {prop: "modW", name: "modW", pkg: "math/big", typ: $funcType([Word], [Word], false)}, {prop: "random", name: "random", pkg: "math/big", typ: $funcType([ptrType$4, nat, $Int], [nat], false)}, {prop: "expNN", name: "expNN", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "expNNWindowed", name: "expNNWindowed", pkg: "math/big", typ: $funcType([nat, nat, nat], [nat], false)}, {prop: "probablyPrime", name: "probablyPrime", pkg: "math/big", typ: $funcType([$Int], [$Bool], false)}, {prop: "bytes", name: "bytes", pkg: "math/big", typ: $funcType([sliceType], [$Int], false)}, {prop: "setBytes", name: "setBytes", pkg: "math/big", typ: $funcType([sliceType], [nat], false)}];
- ptrType$3.methods = [{prop: "SetFloat64", name: "SetFloat64", pkg: "", typ: $funcType([$Float64], [ptrType$3], false)}, {prop: "Float32", name: "Float32", pkg: "", typ: $funcType([], [$Float32, $Bool], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([], [$Float64, $Bool], false)}, {prop: "SetFrac", name: "SetFrac", pkg: "", typ: $funcType([ptrType, ptrType], [ptrType$3], false)}, {prop: "SetFrac64", name: "SetFrac64", pkg: "", typ: $funcType([$Int64, $Int64], [ptrType$3], false)}, {prop: "SetInt", name: "SetInt", pkg: "", typ: $funcType([ptrType], [ptrType$3], false)}, {prop: "SetInt64", name: "SetInt64", pkg: "", typ: $funcType([$Int64], [ptrType$3], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([ptrType$3], [ptrType$3], false)}, {prop: "Abs", name: "Abs", pkg: "", typ: $funcType([ptrType$3], [ptrType$3], false)}, {prop: "Neg", name: "Neg", pkg: "", typ: $funcType([ptrType$3], [ptrType$3], false)}, {prop: "Inv", name: "Inv", pkg: "", typ: $funcType([ptrType$3], [ptrType$3], false)}, {prop: "Sign", name: "Sign", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "IsInt", name: "IsInt", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Num", name: "Num", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "Denom", name: "Denom", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "norm", name: "norm", pkg: "math/big", typ: $funcType([], [ptrType$3], false)}, {prop: "Cmp", name: "Cmp", pkg: "", typ: $funcType([ptrType$3], [$Int], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([ptrType$3, ptrType$3], [ptrType$3], false)}, {prop: "Sub", name: "Sub", pkg: "", typ: $funcType([ptrType$3, ptrType$3], [ptrType$3], false)}, {prop: "Mul", name: "Mul", pkg: "", typ: $funcType([ptrType$3, ptrType$3], [ptrType$3], false)}, {prop: "Quo", name: "Quo", pkg: "", typ: $funcType([ptrType$3, ptrType$3], [ptrType$3], false)}, {prop: "Scan", name: "Scan", pkg: "", typ: $funcType([fmt.ScanState, $Int32], [$error], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [ptrType$3, $Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "RatString", name: "RatString", pkg: "", typ: $funcType([], [$String], false)}, {prop: "FloatString", name: "FloatString", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "GobEncode", name: "GobEncode", pkg: "", typ: $funcType([], [sliceType, $error], false)}, {prop: "GobDecode", name: "GobDecode", pkg: "", typ: $funcType([sliceType], [$error], false)}, {prop: "MarshalText", name: "MarshalText", pkg: "", typ: $funcType([], [sliceType, $error], false)}, {prop: "UnmarshalText", name: "UnmarshalText", pkg: "", typ: $funcType([sliceType], [$error], false)}];
- Int.init([{prop: "neg", name: "neg", pkg: "math/big", typ: $Bool, tag: ""}, {prop: "abs", name: "abs", pkg: "math/big", typ: nat, tag: ""}]);
- nat.init(Word);
- divisor.init([{prop: "bbb", name: "bbb", pkg: "math/big", typ: nat, tag: ""}, {prop: "nbits", name: "nbits", pkg: "math/big", typ: $Int, tag: ""}, {prop: "ndigits", name: "ndigits", pkg: "math/big", typ: $Int, tag: ""}]);
- Rat.init([{prop: "a", name: "a", pkg: "math/big", typ: Int, tag: ""}, {prop: "b", name: "b", pkg: "math/big", typ: Int, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = binary.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = nosync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = rand.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- cacheBase10 = new structType.ptr();
- natOne = new nat([1]);
- intOne = new Int.ptr(false, natOne);
- natTwo = new nat([2]);
- natTen = new nat([10]);
- karatsubaThreshold = 40;
- leafSize = 8;
- deBruijn32Lookup = new sliceType([0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9]);
- deBruijn64Lookup = new sliceType([0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4, 62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5, 63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11, 54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6]);
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["golang.org/x/tools/go/exact"] = (function() {
- var $pkg = {}, $init, fmt, token, big, strconv, Kind, Value, unknownVal, boolVal, stringVal, int64Val, intVal, floatVal, complexVal, sliceType, ptrType, ptrType$1, sliceType$1, sliceType$2, minInt64, maxInt64, int1, rat0, normInt, normFloat, normComplex, MakeUnknown, MakeBool, MakeString, MakeInt64, MakeFloat64, MakeFromLiteral, BoolVal, StringVal, Int64Val, Uint64Val, Float32Val, Float64Val, BitLen, Sign, Bytes, MakeFromBytes, Num, Denom, MakeImag, Real, Imag, is32bit, is63bit, UnaryOp, ord, match, BinaryOp, Shift, cmpZero, Compare, ratToFloat32;
- fmt = $packages["fmt"];
- token = $packages["go/token"];
- big = $packages["math/big"];
- strconv = $packages["strconv"];
- Kind = $pkg.Kind = $newType(4, $kindInt, "exact.Kind", "Kind", "golang.org/x/tools/go/exact", null);
- Value = $pkg.Value = $newType(8, $kindInterface, "exact.Value", "Value", "golang.org/x/tools/go/exact", null);
- unknownVal = $pkg.unknownVal = $newType(0, $kindStruct, "exact.unknownVal", "unknownVal", "golang.org/x/tools/go/exact", function() {
- this.$val = this;
- if (arguments.length === 0) {
- return;
- }
- });
- boolVal = $pkg.boolVal = $newType(1, $kindBool, "exact.boolVal", "boolVal", "golang.org/x/tools/go/exact", null);
- stringVal = $pkg.stringVal = $newType(8, $kindString, "exact.stringVal", "stringVal", "golang.org/x/tools/go/exact", null);
- int64Val = $pkg.int64Val = $newType(8, $kindInt64, "exact.int64Val", "int64Val", "golang.org/x/tools/go/exact", null);
- intVal = $pkg.intVal = $newType(0, $kindStruct, "exact.intVal", "intVal", "golang.org/x/tools/go/exact", function(val_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.val = ptrType$1.nil;
- return;
- }
- this.val = val_;
- });
- floatVal = $pkg.floatVal = $newType(0, $kindStruct, "exact.floatVal", "floatVal", "golang.org/x/tools/go/exact", function(val_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.val = ptrType.nil;
- return;
- }
- this.val = val_;
- });
- complexVal = $pkg.complexVal = $newType(0, $kindStruct, "exact.complexVal", "complexVal", "golang.org/x/tools/go/exact", function(re_, im_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.re = ptrType.nil;
- this.im = ptrType.nil;
- return;
- }
- this.re = re_;
- this.im = im_;
- });
- sliceType = $sliceType($emptyInterface);
- ptrType = $ptrType(big.Rat);
- ptrType$1 = $ptrType(big.Int);
- sliceType$1 = $sliceType($Uint8);
- sliceType$2 = $sliceType(big.Word);
- unknownVal.ptr.prototype.Kind = function() {
- var $ptr;
- return 0;
- };
- unknownVal.prototype.Kind = function() { return this.$val.Kind(); };
- boolVal.prototype.Kind = function() {
- var $ptr;
- return 1;
- };
- $ptrType(boolVal).prototype.Kind = function() { return new boolVal(this.$get()).Kind(); };
- stringVal.prototype.Kind = function() {
- var $ptr;
- return 2;
- };
- $ptrType(stringVal).prototype.Kind = function() { return new stringVal(this.$get()).Kind(); };
- int64Val.prototype.Kind = function() {
- var $ptr;
- return 3;
- };
- $ptrType(int64Val).prototype.Kind = function() { return this.$get().Kind(); };
- intVal.ptr.prototype.Kind = function() {
- var $ptr;
- return 3;
- };
- intVal.prototype.Kind = function() { return this.$val.Kind(); };
- floatVal.ptr.prototype.Kind = function() {
- var $ptr;
- return 4;
- };
- floatVal.prototype.Kind = function() { return this.$val.Kind(); };
- complexVal.ptr.prototype.Kind = function() {
- var $ptr;
- return 5;
- };
- complexVal.prototype.Kind = function() { return this.$val.Kind(); };
- unknownVal.ptr.prototype.String = function() {
- var $ptr;
- return "unknown";
- };
- unknownVal.prototype.String = function() { return this.$val.String(); };
- boolVal.prototype.String = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this.$val;
- _r = fmt.Sprintf("%v", new sliceType([new $Bool(x)])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: boolVal.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(boolVal).prototype.String = function() { return new boolVal(this.$get()).String(); };
- stringVal.prototype.String = function() {
- var $ptr, x;
- x = this.$val;
- return strconv.Quote(x);
- };
- $ptrType(stringVal).prototype.String = function() { return new stringVal(this.$get()).String(); };
- int64Val.prototype.String = function() {
- var $ptr, x;
- x = this;
- return strconv.FormatInt(new $Int64(x.$high, x.$low), 10);
- };
- $ptrType(int64Val).prototype.String = function() { return this.$get().String(); };
- intVal.ptr.prototype.String = function() {
- var $ptr, x;
- x = $clone(this, intVal);
- return x.val.String();
- };
- intVal.prototype.String = function() { return this.$val.String(); };
- floatVal.ptr.prototype.String = function() {
- var $ptr, x;
- x = $clone(this, floatVal);
- return x.val.String();
- };
- floatVal.prototype.String = function() { return this.$val.String(); };
- complexVal.ptr.prototype.String = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = $clone(this, complexVal);
- _r = fmt.Sprintf("(%s + %si)", new sliceType([x.re, x.im])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: complexVal.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- complexVal.prototype.String = function() { return this.$val.String(); };
- normInt = function(x) {
- var $ptr, x, x$1, x$2;
- if (minInt64.Cmp(x) <= 0 && x.Cmp(maxInt64) <= 0) {
- return (x$1 = x.Int64(), new int64Val(x$1.$high, x$1.$low));
- }
- return (x$2 = new intVal.ptr(x), new x$2.constructor.elem(x$2));
- };
- normFloat = function(x) {
- var $ptr, x, x$1;
- if (x.IsInt()) {
- return normInt(x.Num());
- }
- return (x$1 = new floatVal.ptr(x), new x$1.constructor.elem(x$1));
- };
- normComplex = function(re, im) {
- var $ptr, im, re, x;
- if (im.Sign() === 0) {
- return normFloat(re);
- }
- return (x = new complexVal.ptr(re, im), new x.constructor.elem(x));
- };
- MakeUnknown = function() {
- var $ptr, x;
- return (x = new unknownVal.ptr(), new x.constructor.elem(x));
- };
- $pkg.MakeUnknown = MakeUnknown;
- MakeBool = function(b) {
- var $ptr, b;
- return new boolVal(b);
- };
- $pkg.MakeBool = MakeBool;
- MakeString = function(s) {
- var $ptr, s;
- return new stringVal(s);
- };
- $pkg.MakeString = MakeString;
- MakeInt64 = function(x) {
- var $ptr, x;
- return new int64Val(x.$high, x.$low);
- };
- $pkg.MakeInt64 = MakeInt64;
- MakeFloat64 = function(x) {
- var $ptr, f, x, x$1;
- f = new big.Rat.ptr().SetFloat64(x);
- if (!(f === ptrType.nil)) {
- return normFloat(f);
- }
- return (x$1 = new unknownVal.ptr(), new x$1.constructor.elem(x$1));
- };
- $pkg.MakeFloat64 = MakeFloat64;
- MakeFromLiteral = function(lit, tok) {
- var $ptr, _r, _r$1, _r$2, _ref, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, code, err, err$1, err$2, im, lit, n, n$1, ok, ok$1, ok$2, s, tok, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; code = $f.code; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; im = $f.im; lit = $f.lit; n = $f.n; n$1 = $f.n$1; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; s = $f.s; tok = $f.tok; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = tok;
- /* */ if (_ref === 5) { $s = 1; continue; }
- /* */ if (_ref === 6) { $s = 2; continue; }
- /* */ if (_ref === 7) { $s = 3; continue; }
- /* */ if (_ref === 8) { $s = 4; continue; }
- /* */ if (_ref === 9) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref === 5) { */ case 1:
- _tuple = strconv.ParseInt(lit, 0, 64); x = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- return new int64Val(x.$high, x.$low);
- }
- _r = new big.Int.ptr().SetString(lit, 0); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = _r; x$1 = _tuple$1[0]; ok = _tuple$1[1];
- /* */ if (ok) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (ok) { */ case 8:
- return (x$2 = new intVal.ptr(x$1), new x$2.constructor.elem(x$2));
- /* } */ case 9:
- $s = 6; continue;
- /* } else if (_ref === 6) { */ case 2:
- _r$1 = new big.Rat.ptr().SetString(lit); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$2 = _r$1; x$3 = _tuple$2[0]; ok$1 = _tuple$2[1];
- /* */ if (ok$1) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (ok$1) { */ case 11:
- return normFloat(x$3);
- /* } */ case 12:
- $s = 6; continue;
- /* } else if (_ref === 7) { */ case 3:
- n = lit.length;
- /* */ if (n > 0 && (lit.charCodeAt((n - 1 >> 0)) === 105)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (n > 0 && (lit.charCodeAt((n - 1 >> 0)) === 105)) { */ case 13:
- _r$2 = new big.Rat.ptr().SetString(lit.substring(0, (n - 1 >> 0))); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$3 = _r$2; im = _tuple$3[0]; ok$2 = _tuple$3[1];
- /* */ if (ok$2) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (ok$2) { */ case 16:
- return normComplex(big.NewRat(new $Int64(0, 0), new $Int64(0, 1)), im);
- /* } */ case 17:
- /* } */ case 14:
- $s = 6; continue;
- /* } else if (_ref === 8) { */ case 4:
- n$1 = lit.length;
- if (n$1 >= 2) {
- _tuple$4 = strconv.UnquoteChar(lit.substring(1, (n$1 - 1 >> 0)), 39); code = _tuple$4[0]; err$1 = _tuple$4[3];
- if ($interfaceIsEqual(err$1, $ifaceNil)) {
- return new int64Val(0, code);
- }
- }
- $s = 6; continue;
- /* } else if (_ref === 9) { */ case 5:
- _tuple$5 = strconv.Unquote(lit); s = _tuple$5[0]; err$2 = _tuple$5[1];
- if ($interfaceIsEqual(err$2, $ifaceNil)) {
- return new stringVal(s);
- }
- /* } */ case 6:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: MakeFromLiteral }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.code = code; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.im = im; $f.lit = lit; $f.n = n; $f.n$1 = n$1; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.s = s; $f.tok = tok; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.MakeFromLiteral = MakeFromLiteral;
- BoolVal = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, boolVal, true)[1]) {
- x$1 = _ref.$val;
- return x$1;
- } else if ($assertType(_ref, unknownVal, true)[1]) {
- x$2 = _ref.$val;
- return false;
- }
- _r = fmt.Sprintf("%v not a Bool", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BoolVal }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.BoolVal = BoolVal;
- StringVal = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, stringVal, true)[1]) {
- x$1 = _ref.$val;
- return x$1;
- } else if ($assertType(_ref, unknownVal, true)[1]) {
- x$2 = _ref.$val;
- return "";
- }
- _r = fmt.Sprintf("%v not a String", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StringVal }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.StringVal = StringVal;
- Int64Val = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, int64Val, true)[1]) {
- x$1 = _ref.$val;
- return [new $Int64(x$1.$high, x$1.$low), true];
- } else if ($assertType(_ref, intVal, true)[1]) {
- x$2 = _ref.$val;
- return [x$2.val.Int64(), x$2.val.BitLen() <= 63];
- } else if ($assertType(_ref, unknownVal, true)[1]) {
- x$3 = _ref.$val;
- return [new $Int64(0, 0), false];
- }
- _r = fmt.Sprintf("%v not an Int", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Int64Val }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Int64Val = Int64Val;
- Uint64Val = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, int64Val, true)[1]) {
- x$1 = _ref.$val;
- return [new $Uint64(x$1.$high, x$1.$low), (x$1.$high > 0 || (x$1.$high === 0 && x$1.$low >= 0))];
- } else if ($assertType(_ref, intVal, true)[1]) {
- x$2 = _ref.$val;
- return [x$2.val.Uint64(), x$2.val.Sign() >= 0 && x$2.val.BitLen() <= 64];
- } else if ($assertType(_ref, unknownVal, true)[1]) {
- x$3 = _ref.$val;
- return [new $Uint64(0, 0), false];
- }
- _r = fmt.Sprintf("%v not an Int", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Uint64Val }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Uint64Val = Uint64Val;
- Float32Val = function(x) {
- var $ptr, _r, _r$1, _r$2, _ref, f, x, x$1, x$2, x$3, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; f = $f.f; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- /* */ if ($assertType(_ref, int64Val, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, intVal, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, floatVal, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, unknownVal, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref, int64Val, true)[1]) { */ case 1:
- x$1 = _ref.$val;
- f = $flatten64(x$1);
- return [f, (x$2 = new int64Val(0, f), (x$2.$high === x$1.$high && x$2.$low === x$1.$low))];
- $s = 5; continue;
- /* } else if ($assertType(_ref, intVal, true)[1]) { */ case 2:
- x$3 = _ref.$val;
- _r = ratToFloat32(new big.Rat.ptr().SetFrac(x$3.val, int1)); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 5; continue;
- /* } else if ($assertType(_ref, floatVal, true)[1]) { */ case 3:
- x$4 = _ref.$val;
- _r$1 = ratToFloat32(x$4.val); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 5; continue;
- /* } else if ($assertType(_ref, unknownVal, true)[1]) { */ case 4:
- x$5 = _ref.$val;
- return [0, false];
- /* } */ case 5:
- _r$2 = fmt.Sprintf("%v not a Float", new sliceType([x])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $panic(new $String(_r$2));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Float32Val }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.f = f; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Float32Val = Float32Val;
- Float64Val = function(x) {
- var $ptr, _r, _r$1, _r$2, _ref, f, x, x$1, x$2, x$3, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; f = $f.f; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- /* */ if ($assertType(_ref, int64Val, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, intVal, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, floatVal, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, unknownVal, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref, int64Val, true)[1]) { */ case 1:
- x$1 = _ref.$val;
- f = $flatten64(new $Int64(x$1.$high, x$1.$low));
- return [f, (x$2 = new int64Val(0, f), (x$2.$high === x$1.$high && x$2.$low === x$1.$low))];
- $s = 5; continue;
- /* } else if ($assertType(_ref, intVal, true)[1]) { */ case 2:
- x$3 = _ref.$val;
- _r = new big.Rat.ptr().SetFrac(x$3.val, int1).Float64(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 5; continue;
- /* } else if ($assertType(_ref, floatVal, true)[1]) { */ case 3:
- x$4 = _ref.$val;
- _r$1 = x$4.val.Float64(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 5; continue;
- /* } else if ($assertType(_ref, unknownVal, true)[1]) { */ case 4:
- x$5 = _ref.$val;
- return [0, false];
- /* } */ case 5:
- _r$2 = fmt.Sprintf("%v not a Float", new sliceType([x])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $panic(new $String(_r$2));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Float64Val }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.f = f; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Float64Val = Float64Val;
- BitLen = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, int64Val, true)[1]) {
- x$1 = _ref.$val;
- return new big.Int.ptr().SetInt64(new $Int64(x$1.$high, x$1.$low)).BitLen();
- } else if ($assertType(_ref, intVal, true)[1]) {
- x$2 = _ref.$val;
- return x$2.val.BitLen();
- } else if ($assertType(_ref, unknownVal, true)[1]) {
- x$3 = _ref.$val;
- return 0;
- }
- _r = fmt.Sprintf("%v not an Int", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BitLen }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.BitLen = BitLen;
- Sign = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, x$3, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, int64Val, true)[1]) {
- x$1 = _ref.$val;
- if ((x$1.$high < 0 || (x$1.$high === 0 && x$1.$low < 0))) {
- return -1;
- } else if ((x$1.$high > 0 || (x$1.$high === 0 && x$1.$low > 0))) {
- return 1;
- }
- return 0;
- } else if ($assertType(_ref, intVal, true)[1]) {
- x$2 = _ref.$val;
- return x$2.val.Sign();
- } else if ($assertType(_ref, floatVal, true)[1]) {
- x$3 = _ref.$val;
- return x$3.val.Sign();
- } else if ($assertType(_ref, complexVal, true)[1]) {
- x$4 = _ref.$val;
- return x$4.re.Sign() | x$4.im.Sign();
- } else if ($assertType(_ref, unknownVal, true)[1]) {
- x$5 = _ref.$val;
- return 1;
- }
- _r = fmt.Sprintf("%v not numeric", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Sign }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Sign = Sign;
- Bytes = function(x) {
- var $ptr, _i, _r, _ref, _ref$1, bytes, i, j, val, w, words, x, x$1, x$2, x$3, x$4, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; bytes = $f.bytes; i = $f.i; j = $f.j; val = $f.val; w = $f.w; words = $f.words; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- val = ptrType$1.nil;
- _ref = x;
- /* */ if ($assertType(_ref, int64Val, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, intVal, true)[1]) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($assertType(_ref, int64Val, true)[1]) { */ case 1:
- x$1 = _ref.$val;
- val = new big.Int.ptr().SetInt64(new $Int64(x$1.$high, x$1.$low));
- $s = 4; continue;
- /* } else if ($assertType(_ref, intVal, true)[1]) { */ case 2:
- x$2 = _ref.$val;
- val = x$2.val;
- $s = 4; continue;
- /* } else { */ case 3:
- x$3 = _ref;
- _r = fmt.Sprintf("%v not an Int", new sliceType([x$3])); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* } */ case 4:
- words = val.Bits();
- bytes = $makeSlice(sliceType$1, (words.$length * 4 >> 0));
- i = 0;
- _ref$1 = words;
- _i = 0;
- while (true) {
- if (!(_i < _ref$1.$length)) { break; }
- w = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- j = 0;
- while (true) {
- if (!(j < 4)) { break; }
- ((i < 0 || i >= bytes.$length) ? $throwRuntimeError("index out of range") : bytes.$array[bytes.$offset + i] = (w << 24 >>> 24));
- w = (y = (8), y < 32 ? (w >>> y) : 0) >>> 0;
- i = i + (1) >> 0;
- j = j + (1) >> 0;
- }
- _i++;
- }
- while (true) {
- if (!(i > 0 && ((x$4 = i - 1 >> 0, ((x$4 < 0 || x$4 >= bytes.$length) ? $throwRuntimeError("index out of range") : bytes.$array[bytes.$offset + x$4])) === 0))) { break; }
- i = i - (1) >> 0;
- }
- return $subslice(bytes, 0, i);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Bytes }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.bytes = bytes; $f.i = i; $f.j = j; $f.val = val; $f.w = w; $f.words = words; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Bytes = Bytes;
- MakeFromBytes = function(bytes) {
- var $ptr, _i, _q, _ref, b, bytes, i, s, w, words, x, y;
- words = $makeSlice(sliceType$2, (_q = ((bytes.$length + 3 >> 0)) / 4, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")));
- i = 0;
- w = 0;
- s = 0;
- _ref = bytes;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- w = (w | (((y = s, y < 32 ? ((b >>> 0) << y) : 0) >>> 0))) >>> 0;
- s = s + (8) >>> 0;
- if (s === 32) {
- ((i < 0 || i >= words.$length) ? $throwRuntimeError("index out of range") : words.$array[words.$offset + i] = w);
- i = i + (1) >> 0;
- w = 0;
- s = 0;
- }
- _i++;
- }
- if (i < words.$length) {
- ((i < 0 || i >= words.$length) ? $throwRuntimeError("index out of range") : words.$array[words.$offset + i] = w);
- i = i + (1) >> 0;
- }
- while (true) {
- if (!(i > 0 && ((x = i - 1 >> 0, ((x < 0 || x >= words.$length) ? $throwRuntimeError("index out of range") : words.$array[words.$offset + x])) === 0))) { break; }
- i = i - (1) >> 0;
- }
- return normInt(new big.Int.ptr().SetBits($subslice(words, 0, i)));
- };
- $pkg.MakeFromBytes = MakeFromBytes;
- Num = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, unknownVal, true)[1] || $assertType(_ref, int64Val, true)[1] || $assertType(_ref, intVal, true)[1]) {
- x$1 = _ref;
- return x$1;
- } else if ($assertType(_ref, floatVal, true)[1]) {
- x$2 = _ref.$val;
- return normInt(x$2.val.Num());
- }
- _r = fmt.Sprintf("%v not Int or Float", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Num }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Num = Num;
- Denom = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, unknownVal, true)[1]) {
- x$1 = _ref.$val;
- return new x$1.constructor.elem(x$1);
- } else if ($assertType(_ref, int64Val, true)[1] || $assertType(_ref, intVal, true)[1]) {
- x$2 = _ref;
- return new int64Val(0, 1);
- } else if ($assertType(_ref, floatVal, true)[1]) {
- x$3 = _ref.$val;
- return normInt(x$3.val.Denom());
- }
- _r = fmt.Sprintf("%v not Int or Float", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Denom }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Denom = Denom;
- MakeImag = function(x) {
- var $ptr, _r, _ref, im, x, x$1, x$2, x$3, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; im = $f.im; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- im = ptrType.nil;
- _ref = x;
- /* */ if ($assertType(_ref, unknownVal, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, int64Val, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, intVal, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, floatVal, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref, unknownVal, true)[1]) { */ case 1:
- x$1 = _ref.$val;
- return new x$1.constructor.elem(x$1);
- $s = 6; continue;
- /* } else if ($assertType(_ref, int64Val, true)[1]) { */ case 2:
- x$2 = _ref.$val;
- im = big.NewRat(new $Int64(x$2.$high, x$2.$low), new $Int64(0, 1));
- $s = 6; continue;
- /* } else if ($assertType(_ref, intVal, true)[1]) { */ case 3:
- x$3 = _ref.$val;
- im = new big.Rat.ptr().SetFrac(x$3.val, int1);
- $s = 6; continue;
- /* } else if ($assertType(_ref, floatVal, true)[1]) { */ case 4:
- x$4 = _ref.$val;
- im = x$4.val;
- $s = 6; continue;
- /* } else { */ case 5:
- x$5 = _ref;
- _r = fmt.Sprintf("%v not Int or Float", new sliceType([x$5])); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* } */ case 6:
- return normComplex(rat0, im);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: MakeImag }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.im = im; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.MakeImag = MakeImag;
- Real = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, unknownVal, true)[1] || $assertType(_ref, int64Val, true)[1] || $assertType(_ref, intVal, true)[1] || $assertType(_ref, floatVal, true)[1]) {
- x$1 = _ref;
- return x$1;
- } else if ($assertType(_ref, complexVal, true)[1]) {
- x$2 = _ref.$val;
- return normFloat(x$2.re);
- }
- _r = fmt.Sprintf("%v not numeric", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Real }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Real = Real;
- Imag = function(x) {
- var $ptr, _r, _ref, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, unknownVal, true)[1]) {
- x$1 = _ref.$val;
- return new x$1.constructor.elem(x$1);
- } else if ($assertType(_ref, int64Val, true)[1] || $assertType(_ref, intVal, true)[1] || $assertType(_ref, floatVal, true)[1]) {
- x$2 = _ref;
- return new int64Val(0, 0);
- } else if ($assertType(_ref, complexVal, true)[1]) {
- x$3 = _ref.$val;
- return normFloat(x$3.im);
- }
- _r = fmt.Sprintf("%v not numeric", new sliceType([x])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Imag }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Imag = Imag;
- is32bit = function(x) {
- var $ptr, x;
- return (-1 < x.$high || (-1 === x.$high && 2147483648 <= x.$low)) && (x.$high < 0 || (x.$high === 0 && x.$low <= 2147483647));
- };
- is63bit = function(x) {
- var $ptr, x;
- return (-1073741824 < x.$high || (-1073741824 === x.$high && 0 <= x.$low)) && (x.$high < 1073741823 || (x.$high === 1073741823 && x.$low <= 4294967295));
- };
- UnaryOp = function(op, y, size) {
- var $ptr, _r, _ref, _ref$1, _ref$2, _ref$3, _ref$4, op, s, size, y, y$1, y$10, y$11, y$2, y$3, y$4, y$5, y$6, y$7, y$8, y$9, z, z$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; op = $f.op; s = $f.s; size = $f.size; y = $f.y; y$1 = $f.y$1; y$10 = $f.y$10; y$11 = $f.y$11; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; y$5 = $f.y$5; y$6 = $f.y$6; y$7 = $f.y$7; y$8 = $f.y$8; y$9 = $f.y$9; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = [z];
- _ref = op;
- /* */ if (_ref === 12) { $s = 1; continue; }
- /* */ if (_ref === 13) { $s = 2; continue; }
- /* */ if (_ref === 19) { $s = 3; continue; }
- /* */ if (_ref === 43) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref === 12) { */ case 1:
- _ref$1 = y;
- if ($assertType(_ref$1, unknownVal, true)[1] || $assertType(_ref$1, int64Val, true)[1] || $assertType(_ref$1, intVal, true)[1] || $assertType(_ref$1, floatVal, true)[1] || $assertType(_ref$1, complexVal, true)[1]) {
- return y;
- }
- $s = 5; continue;
- /* } else if (_ref === 13) { */ case 2:
- _ref$2 = y;
- if ($assertType(_ref$2, unknownVal, true)[1]) {
- y$1 = _ref$2.$val;
- return new y$1.constructor.elem(y$1);
- } else if ($assertType(_ref$2, int64Val, true)[1]) {
- y$2 = _ref$2.$val;
- z$1 = new int64Val(-y$2.$high, -y$2.$low);
- if (!((z$1.$high === y$2.$high && z$1.$low === y$2.$low))) {
- return z$1;
- }
- return normInt(new big.Int.ptr().Neg(big.NewInt(new $Int64(y$2.$high, y$2.$low))));
- } else if ($assertType(_ref$2, intVal, true)[1]) {
- y$3 = _ref$2.$val;
- return normInt(new big.Int.ptr().Neg(y$3.val));
- } else if ($assertType(_ref$2, floatVal, true)[1]) {
- y$4 = _ref$2.$val;
- return normFloat(new big.Rat.ptr().Neg(y$4.val));
- } else if ($assertType(_ref$2, complexVal, true)[1]) {
- y$5 = _ref$2.$val;
- return normComplex(new big.Rat.ptr().Neg(y$5.re), new big.Rat.ptr().Neg(y$5.im));
- }
- $s = 5; continue;
- /* } else if (_ref === 19) { */ case 3:
- z[0] = $clone(new big.Int.ptr(), big.Int);
- _ref$3 = y;
- /* */ if ($assertType(_ref$3, unknownVal, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref$3, int64Val, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref$3, intVal, true)[1]) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($assertType(_ref$3, unknownVal, true)[1]) { */ case 6:
- y$6 = _ref$3.$val;
- return new y$6.constructor.elem(y$6);
- $s = 10; continue;
- /* } else if ($assertType(_ref$3, int64Val, true)[1]) { */ case 7:
- y$7 = _ref$3.$val;
- z[0].Not(big.NewInt(new $Int64(y$7.$high, y$7.$low)));
- $s = 10; continue;
- /* } else if ($assertType(_ref$3, intVal, true)[1]) { */ case 8:
- y$8 = _ref$3.$val;
- z[0].Not(y$8.val);
- $s = 10; continue;
- /* } else { */ case 9:
- y$9 = _ref$3;
- /* goto Error */ $s = 11; continue;
- /* } */ case 10:
- if (size >= 0) {
- s = (size >>> 0) * 8 >>> 0;
- z[0].AndNot(z[0], new big.Int.ptr().Lsh(big.NewInt(new $Int64(-1, 4294967295)), s));
- }
- return normInt(z[0]);
- $s = 5; continue;
- /* } else if (_ref === 43) { */ case 4:
- _ref$4 = y;
- if ($assertType(_ref$4, unknownVal, true)[1]) {
- y$10 = _ref$4.$val;
- return new y$10.constructor.elem(y$10);
- } else if ($assertType(_ref$4, boolVal, true)[1]) {
- y$11 = _ref$4.$val;
- return new boolVal(!y$11);
- }
- /* } */ case 5:
- /* Error: */ case 11:
- _r = fmt.Sprintf("invalid unary operation %s%v", new sliceType([new token.Token(op), y])); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: UnaryOp }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f.op = op; $f.s = s; $f.size = size; $f.y = y; $f.y$1 = y$1; $f.y$10 = y$10; $f.y$11 = y$11; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.y$5 = y$5; $f.y$6 = y$6; $f.y$7 = y$7; $f.y$8 = y$8; $f.y$9 = y$9; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.UnaryOp = UnaryOp;
- ord = function(x) {
- var $ptr, _ref, x;
- _ref = x;
- if ($assertType(_ref, boolVal, true)[1] || $assertType(_ref, stringVal, true)[1]) {
- return 1;
- } else if ($assertType(_ref, int64Val, true)[1]) {
- return 2;
- } else if ($assertType(_ref, intVal, true)[1]) {
- return 3;
- } else if ($assertType(_ref, floatVal, true)[1]) {
- return 4;
- } else if ($assertType(_ref, complexVal, true)[1]) {
- return 5;
- } else {
- return 0;
- }
- };
- match = function(x, y) {
- var $ptr, _, _$1, _ref, _ref$1, _ref$2, _ref$3, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$17, _tmp$18, _tmp$19, _tmp$2, _tmp$20, _tmp$21, _tmp$22, _tmp$23, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, y$1, y$2, y$3, y$4, y$5, y$6, y$7, y$8, y$9;
- _ = $ifaceNil;
- _$1 = $ifaceNil;
- if (ord(x) > ord(y)) {
- _tuple = match(y, x); y = _tuple[0]; x = _tuple[1];
- _tmp = x; _tmp$1 = y; _ = _tmp; _$1 = _tmp$1;
- return [_, _$1];
- }
- _ref = x;
- if ($assertType(_ref, unknownVal, true)[1]) {
- x$1 = _ref.$val;
- _tmp$2 = new x$1.constructor.elem(x$1); _tmp$3 = new x$1.constructor.elem(x$1); _ = _tmp$2; _$1 = _tmp$3;
- return [_, _$1];
- } else if ($assertType(_ref, boolVal, true)[1] || $assertType(_ref, stringVal, true)[1] || $assertType(_ref, complexVal, true)[1]) {
- x$2 = _ref;
- _tmp$4 = x$2; _tmp$5 = y; _ = _tmp$4; _$1 = _tmp$5;
- return [_, _$1];
- } else if ($assertType(_ref, int64Val, true)[1]) {
- x$3 = _ref.$val;
- _ref$1 = y;
- if ($assertType(_ref$1, int64Val, true)[1]) {
- y$1 = _ref$1.$val;
- _tmp$6 = x$3; _tmp$7 = y$1; _ = _tmp$6; _$1 = _tmp$7;
- return [_, _$1];
- } else if ($assertType(_ref$1, intVal, true)[1]) {
- y$2 = _ref$1.$val;
- _tmp$8 = (x$4 = new intVal.ptr(big.NewInt(new $Int64(x$3.$high, x$3.$low))), new x$4.constructor.elem(x$4)); _tmp$9 = new y$2.constructor.elem(y$2); _ = _tmp$8; _$1 = _tmp$9;
- return [_, _$1];
- } else if ($assertType(_ref$1, floatVal, true)[1]) {
- y$3 = _ref$1.$val;
- _tmp$10 = (x$5 = new floatVal.ptr(big.NewRat(new $Int64(x$3.$high, x$3.$low), new $Int64(0, 1))), new x$5.constructor.elem(x$5)); _tmp$11 = new y$3.constructor.elem(y$3); _ = _tmp$10; _$1 = _tmp$11;
- return [_, _$1];
- } else if ($assertType(_ref$1, complexVal, true)[1]) {
- y$4 = _ref$1.$val;
- _tmp$12 = (x$6 = new complexVal.ptr(big.NewRat(new $Int64(x$3.$high, x$3.$low), new $Int64(0, 1)), rat0), new x$6.constructor.elem(x$6)); _tmp$13 = new y$4.constructor.elem(y$4); _ = _tmp$12; _$1 = _tmp$13;
- return [_, _$1];
- }
- } else if ($assertType(_ref, intVal, true)[1]) {
- x$7 = _ref.$val;
- _ref$2 = y;
- if ($assertType(_ref$2, intVal, true)[1]) {
- y$5 = _ref$2.$val;
- _tmp$14 = new x$7.constructor.elem(x$7); _tmp$15 = new y$5.constructor.elem(y$5); _ = _tmp$14; _$1 = _tmp$15;
- return [_, _$1];
- } else if ($assertType(_ref$2, floatVal, true)[1]) {
- y$6 = _ref$2.$val;
- _tmp$16 = (x$8 = new floatVal.ptr(new big.Rat.ptr().SetFrac(x$7.val, int1)), new x$8.constructor.elem(x$8)); _tmp$17 = new y$6.constructor.elem(y$6); _ = _tmp$16; _$1 = _tmp$17;
- return [_, _$1];
- } else if ($assertType(_ref$2, complexVal, true)[1]) {
- y$7 = _ref$2.$val;
- _tmp$18 = (x$9 = new complexVal.ptr(new big.Rat.ptr().SetFrac(x$7.val, int1), rat0), new x$9.constructor.elem(x$9)); _tmp$19 = new y$7.constructor.elem(y$7); _ = _tmp$18; _$1 = _tmp$19;
- return [_, _$1];
- }
- } else if ($assertType(_ref, floatVal, true)[1]) {
- x$10 = _ref.$val;
- _ref$3 = y;
- if ($assertType(_ref$3, floatVal, true)[1]) {
- y$8 = _ref$3.$val;
- _tmp$20 = new x$10.constructor.elem(x$10); _tmp$21 = new y$8.constructor.elem(y$8); _ = _tmp$20; _$1 = _tmp$21;
- return [_, _$1];
- } else if ($assertType(_ref$3, complexVal, true)[1]) {
- y$9 = _ref$3.$val;
- _tmp$22 = (x$11 = new complexVal.ptr(x$10.val, rat0), new x$11.constructor.elem(x$11)); _tmp$23 = new y$9.constructor.elem(y$9); _ = _tmp$22; _$1 = _tmp$23;
- return [_, _$1];
- }
- }
- $panic(new $String("unreachable"));
- };
- BinaryOp = function(x, op, y) {
- var $ptr, _r, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$15, _tmp$16, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, a, a$1, a$2, a$3, ac, ac$1, ad, ad$1, b, b$1, b$2, b$3, bc, bc$1, bd, bd$1, c, c$1, c$2, c$3, cc, d, dd, im, op, re, s, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, y, y$1, y$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$10 = $f._tmp$10; _tmp$11 = $f._tmp$11; _tmp$12 = $f._tmp$12; _tmp$13 = $f._tmp$13; _tmp$14 = $f._tmp$14; _tmp$15 = $f._tmp$15; _tmp$16 = $f._tmp$16; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tmp$8 = $f._tmp$8; _tmp$9 = $f._tmp$9; _tuple = $f._tuple; a = $f.a; a$1 = $f.a$1; a$2 = $f.a$2; a$3 = $f.a$3; ac = $f.ac; ac$1 = $f.ac$1; ad = $f.ad; ad$1 = $f.ad$1; b = $f.b; b$1 = $f.b$1; b$2 = $f.b$2; b$3 = $f.b$3; bc = $f.bc; bc$1 = $f.bc$1; bd = $f.bd; bd$1 = $f.bd$1; c = $f.c; c$1 = $f.c$1; c$2 = $f.c$2; c$3 = $f.c$3; cc = $f.cc; d = $f.d; dd = $f.dd; im = $f.im; op = $f.op; re = $f.re; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- ac = [ac];
- ac$1 = [ac$1];
- ad = [ad];
- ad$1 = [ad$1];
- bc = [bc];
- bc$1 = [bc$1];
- bd = [bd];
- bd$1 = [bd$1];
- c = [c];
- c$1 = [c$1];
- cc = [cc];
- dd = [dd];
- im = [im];
- re = [re];
- s = [s];
- _tuple = match(x, y); x = _tuple[0]; y = _tuple[1];
- _ref = x;
- /* */ if ($assertType(_ref, unknownVal, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, boolVal, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, int64Val, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, intVal, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, floatVal, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, complexVal, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, stringVal, true)[1]) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if ($assertType(_ref, unknownVal, true)[1]) { */ case 1:
- x$1 = _ref.$val;
- return new x$1.constructor.elem(x$1);
- $s = 8; continue;
- /* } else if ($assertType(_ref, boolVal, true)[1]) { */ case 2:
- x$2 = _ref.$val;
- y$1 = $assertType(y, boolVal);
- _ref$1 = op;
- if (_ref$1 === 34) {
- return new boolVal(x$2 && y$1);
- } else if (_ref$1 === 35) {
- return new boolVal(x$2 || y$1);
- }
- $s = 8; continue;
- /* } else if ($assertType(_ref, int64Val, true)[1]) { */ case 3:
- x$3 = _ref.$val;
- a = new $Int64(x$3.$high, x$3.$low);
- b = (x$4 = $assertType(y, int64Val), new $Int64(x$4.$high, x$4.$low));
- c$2 = new $Int64(0, 0);
- _ref$2 = op;
- /* */ if (_ref$2 === 12) { $s = 9; continue; }
- /* */ if (_ref$2 === 13) { $s = 10; continue; }
- /* */ if (_ref$2 === 14) { $s = 11; continue; }
- /* */ if (_ref$2 === 15) { $s = 12; continue; }
- /* */ if (_ref$2 === 26) { $s = 13; continue; }
- /* */ if (_ref$2 === 16) { $s = 14; continue; }
- /* */ if (_ref$2 === 17) { $s = 15; continue; }
- /* */ if (_ref$2 === 18) { $s = 16; continue; }
- /* */ if (_ref$2 === 19) { $s = 17; continue; }
- /* */ if (_ref$2 === 22) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (_ref$2 === 12) { */ case 9:
- if (!is63bit(a) || !is63bit(b)) {
- return normInt(new big.Int.ptr().Add(big.NewInt(a), big.NewInt(b)));
- }
- c$2 = new $Int64(a.$high + b.$high, a.$low + b.$low);
- $s = 20; continue;
- /* } else if (_ref$2 === 13) { */ case 10:
- if (!is63bit(a) || !is63bit(b)) {
- return normInt(new big.Int.ptr().Sub(big.NewInt(a), big.NewInt(b)));
- }
- c$2 = new $Int64(a.$high - b.$high, a.$low - b.$low);
- $s = 20; continue;
- /* } else if (_ref$2 === 14) { */ case 11:
- if (!is32bit(a) || !is32bit(b)) {
- return normInt(new big.Int.ptr().Mul(big.NewInt(a), big.NewInt(b)));
- }
- c$2 = $mul64(a, b);
- $s = 20; continue;
- /* } else if (_ref$2 === 15) { */ case 12:
- return normFloat(new big.Rat.ptr().SetFrac(big.NewInt(a), big.NewInt(b)));
- $s = 20; continue;
- /* } else if (_ref$2 === 26) { */ case 13:
- c$2 = $div64(a, b, false);
- $s = 20; continue;
- /* } else if (_ref$2 === 16) { */ case 14:
- c$2 = $div64(a, b, true);
- $s = 20; continue;
- /* } else if (_ref$2 === 17) { */ case 15:
- c$2 = new $Int64(a.$high & b.$high, (a.$low & b.$low) >>> 0);
- $s = 20; continue;
- /* } else if (_ref$2 === 18) { */ case 16:
- c$2 = new $Int64(a.$high | b.$high, (a.$low | b.$low) >>> 0);
- $s = 20; continue;
- /* } else if (_ref$2 === 19) { */ case 17:
- c$2 = new $Int64(a.$high ^ b.$high, (a.$low ^ b.$low) >>> 0);
- $s = 20; continue;
- /* } else if (_ref$2 === 22) { */ case 18:
- c$2 = new $Int64(a.$high & ~b.$high, (a.$low & ~b.$low) >>> 0);
- $s = 20; continue;
- /* } else { */ case 19:
- /* goto Error */ $s = 21; continue;
- /* } */ case 20:
- return new int64Val(c$2.$high, c$2.$low);
- $s = 8; continue;
- /* } else if ($assertType(_ref, intVal, true)[1]) { */ case 4:
- x$5 = _ref.$val;
- a$1 = x$5.val;
- b$1 = $assertType(y, intVal).val;
- c$1[0] = $clone(new big.Int.ptr(), big.Int);
- _ref$3 = op;
- /* */ if (_ref$3 === 12) { $s = 22; continue; }
- /* */ if (_ref$3 === 13) { $s = 23; continue; }
- /* */ if (_ref$3 === 14) { $s = 24; continue; }
- /* */ if (_ref$3 === 15) { $s = 25; continue; }
- /* */ if (_ref$3 === 26) { $s = 26; continue; }
- /* */ if (_ref$3 === 16) { $s = 27; continue; }
- /* */ if (_ref$3 === 17) { $s = 28; continue; }
- /* */ if (_ref$3 === 18) { $s = 29; continue; }
- /* */ if (_ref$3 === 19) { $s = 30; continue; }
- /* */ if (_ref$3 === 22) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (_ref$3 === 12) { */ case 22:
- c$1[0].Add(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 13) { */ case 23:
- c$1[0].Sub(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 14) { */ case 24:
- c$1[0].Mul(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 15) { */ case 25:
- return normFloat(new big.Rat.ptr().SetFrac(a$1, b$1));
- $s = 33; continue;
- /* } else if (_ref$3 === 26) { */ case 26:
- c$1[0].Quo(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 16) { */ case 27:
- c$1[0].Rem(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 17) { */ case 28:
- c$1[0].And(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 18) { */ case 29:
- c$1[0].Or(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 19) { */ case 30:
- c$1[0].Xor(a$1, b$1);
- $s = 33; continue;
- /* } else if (_ref$3 === 22) { */ case 31:
- c$1[0].AndNot(a$1, b$1);
- $s = 33; continue;
- /* } else { */ case 32:
- /* goto Error */ $s = 21; continue;
- /* } */ case 33:
- return normInt(c$1[0]);
- $s = 8; continue;
- /* } else if ($assertType(_ref, floatVal, true)[1]) { */ case 5:
- x$6 = _ref.$val;
- a$2 = x$6.val;
- b$2 = $assertType(y, floatVal).val;
- c[0] = $clone(new big.Rat.ptr(), big.Rat);
- _ref$4 = op;
- /* */ if (_ref$4 === 12) { $s = 34; continue; }
- /* */ if (_ref$4 === 13) { $s = 35; continue; }
- /* */ if (_ref$4 === 14) { $s = 36; continue; }
- /* */ if (_ref$4 === 15) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (_ref$4 === 12) { */ case 34:
- c[0].Add(a$2, b$2);
- $s = 39; continue;
- /* } else if (_ref$4 === 13) { */ case 35:
- c[0].Sub(a$2, b$2);
- $s = 39; continue;
- /* } else if (_ref$4 === 14) { */ case 36:
- c[0].Mul(a$2, b$2);
- $s = 39; continue;
- /* } else if (_ref$4 === 15) { */ case 37:
- c[0].Quo(a$2, b$2);
- $s = 39; continue;
- /* } else { */ case 38:
- /* goto Error */ $s = 21; continue;
- /* } */ case 39:
- return normFloat(c[0]);
- $s = 8; continue;
- /* } else if ($assertType(_ref, complexVal, true)[1]) { */ case 6:
- x$7 = _ref.$val;
- y$2 = $clone($assertType(y, complexVal), complexVal);
- _tmp = x$7.re; _tmp$1 = x$7.im; a$3 = _tmp; b$3 = _tmp$1;
- _tmp$2 = y$2.re; _tmp$3 = y$2.im; c$3 = _tmp$2; d = _tmp$3;
- _tmp$4 = $clone(new big.Rat.ptr(), big.Rat); _tmp$5 = $clone(new big.Rat.ptr(), big.Rat); re[0] = $clone(_tmp$4, big.Rat); im[0] = $clone(_tmp$5, big.Rat);
- _ref$5 = op;
- /* */ if (_ref$5 === 12) { $s = 40; continue; }
- /* */ if (_ref$5 === 13) { $s = 41; continue; }
- /* */ if (_ref$5 === 14) { $s = 42; continue; }
- /* */ if (_ref$5 === 15) { $s = 43; continue; }
- /* */ $s = 44; continue;
- /* if (_ref$5 === 12) { */ case 40:
- re[0].Add(a$3, c$3);
- im[0].Add(b$3, d);
- $s = 45; continue;
- /* } else if (_ref$5 === 13) { */ case 41:
- re[0].Sub(a$3, c$3);
- im[0].Sub(b$3, d);
- $s = 45; continue;
- /* } else if (_ref$5 === 14) { */ case 42:
- _tmp$6 = $clone(new big.Rat.ptr(), big.Rat); _tmp$7 = $clone(new big.Rat.ptr(), big.Rat); _tmp$8 = $clone(new big.Rat.ptr(), big.Rat); _tmp$9 = $clone(new big.Rat.ptr(), big.Rat); ac$1[0] = $clone(_tmp$6, big.Rat); bd[0] = $clone(_tmp$7, big.Rat); bc[0] = $clone(_tmp$8, big.Rat); ad[0] = $clone(_tmp$9, big.Rat);
- ac$1[0].Mul(a$3, c$3);
- bd[0].Mul(b$3, d);
- bc[0].Mul(b$3, c$3);
- ad[0].Mul(a$3, d);
- re[0].Sub(ac$1[0], bd[0]);
- im[0].Add(bc[0], ad[0]);
- $s = 45; continue;
- /* } else if (_ref$5 === 15) { */ case 43:
- _tmp$10 = $clone(new big.Rat.ptr(), big.Rat); _tmp$11 = $clone(new big.Rat.ptr(), big.Rat); _tmp$12 = $clone(new big.Rat.ptr(), big.Rat); _tmp$13 = $clone(new big.Rat.ptr(), big.Rat); _tmp$14 = $clone(new big.Rat.ptr(), big.Rat); _tmp$15 = $clone(new big.Rat.ptr(), big.Rat); _tmp$16 = $clone(new big.Rat.ptr(), big.Rat); ac[0] = $clone(_tmp$10, big.Rat); bd$1[0] = $clone(_tmp$11, big.Rat); bc$1[0] = $clone(_tmp$12, big.Rat); ad$1[0] = $clone(_tmp$13, big.Rat); s[0] = $clone(_tmp$14, big.Rat); cc[0] = $clone(_tmp$15, big.Rat); dd[0] = $clone(_tmp$16, big.Rat);
- ac[0].Mul(a$3, c$3);
- bd$1[0].Mul(b$3, d);
- bc$1[0].Mul(b$3, c$3);
- ad$1[0].Mul(a$3, d);
- cc[0].Mul(c$3, c$3);
- dd[0].Mul(d, d);
- s[0].Add(cc[0], dd[0]);
- re[0].Add(ac[0], bd$1[0]);
- re[0].Quo(re[0], s[0]);
- im[0].Sub(bc$1[0], ad$1[0]);
- im[0].Quo(im[0], s[0]);
- $s = 45; continue;
- /* } else { */ case 44:
- /* goto Error */ $s = 21; continue;
- /* } */ case 45:
- return normComplex(re[0], im[0]);
- $s = 8; continue;
- /* } else if ($assertType(_ref, stringVal, true)[1]) { */ case 7:
- x$8 = _ref.$val;
- if (op === 12) {
- return new stringVal(x$8 + $assertType(y, stringVal));
- }
- /* } */ case 8:
- /* Error: */ case 21:
- _r = fmt.Sprintf("invalid binary operation %v %s %v", new sliceType([x, new token.Token(op), y])); /* */ $s = 46; case 46: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BinaryOp }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$10 = _tmp$10; $f._tmp$11 = _tmp$11; $f._tmp$12 = _tmp$12; $f._tmp$13 = _tmp$13; $f._tmp$14 = _tmp$14; $f._tmp$15 = _tmp$15; $f._tmp$16 = _tmp$16; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tmp$8 = _tmp$8; $f._tmp$9 = _tmp$9; $f._tuple = _tuple; $f.a = a; $f.a$1 = a$1; $f.a$2 = a$2; $f.a$3 = a$3; $f.ac = ac; $f.ac$1 = ac$1; $f.ad = ad; $f.ad$1 = ad$1; $f.b = b; $f.b$1 = b$1; $f.b$2 = b$2; $f.b$3 = b$3; $f.bc = bc; $f.bc$1 = bc$1; $f.bd = bd; $f.bd$1 = bd$1; $f.c = c; $f.c$1 = c$1; $f.c$2 = c$2; $f.c$3 = c$3; $f.cc = cc; $f.d = d; $f.dd = dd; $f.im = im; $f.op = op; $f.re = re; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.BinaryOp = BinaryOp;
- Shift = function(x, op, s) {
- var $ptr, _r, _ref, _ref$1, _ref$2, op, s, x, x$1, x$2, x$3, z, z$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; op = $f.op; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; z = $f.z; z$1 = $f.z$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = x;
- if ($assertType(_ref, unknownVal, true)[1]) {
- x$1 = _ref.$val;
- return new x$1.constructor.elem(x$1);
- } else if ($assertType(_ref, int64Val, true)[1]) {
- x$2 = _ref.$val;
- if (s === 0) {
- return x$2;
- }
- _ref$1 = op;
- if (_ref$1 === 20) {
- z = big.NewInt(new $Int64(x$2.$high, x$2.$low));
- return normInt(z.Lsh(z, s));
- } else if (_ref$1 === 21) {
- return $shiftRightInt64(x$2, s);
- }
- } else if ($assertType(_ref, intVal, true)[1]) {
- x$3 = _ref.$val;
- if (s === 0) {
- return new x$3.constructor.elem(x$3);
- }
- z$1 = $clone(new big.Int.ptr(), big.Int);
- _ref$2 = op;
- if (_ref$2 === 20) {
- return normInt(z$1.Lsh(x$3.val, s));
- } else if (_ref$2 === 21) {
- return normInt(z$1.Rsh(x$3.val, s));
- }
- }
- _r = fmt.Sprintf("invalid shift %v %s %d", new sliceType([x, new token.Token(op), new $Uint(s)])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Shift }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f.op = op; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.z = z; $f.z$1 = z$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Shift = Shift;
- cmpZero = function(x, op) {
- var $ptr, _ref, op, x;
- _ref = op;
- if (_ref === 39) {
- return x === 0;
- } else if (_ref === 44) {
- return !((x === 0));
- } else if (_ref === 40) {
- return x < 0;
- } else if (_ref === 45) {
- return x <= 0;
- } else if (_ref === 41) {
- return x > 0;
- } else if (_ref === 46) {
- return x >= 0;
- }
- $panic(new $String("unreachable"));
- };
- Compare = function(x, op, y) {
- var $ptr, _r, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, im, op, re, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, y, y$1, y$2, y$3, y$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; im = $f.im; op = $f.op; re = $f.re; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; y = $f.y; y$1 = $f.y$1; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tuple = match(x, y); x = _tuple[0]; y = _tuple[1];
- _ref = x;
- if ($assertType(_ref, unknownVal, true)[1]) {
- x$1 = _ref.$val;
- return false;
- } else if ($assertType(_ref, boolVal, true)[1]) {
- x$2 = _ref.$val;
- y$1 = $assertType(y, boolVal);
- _ref$1 = op;
- if (_ref$1 === 39) {
- return x$2 === y$1;
- } else if (_ref$1 === 44) {
- return !(x$2 === y$1);
- }
- } else if ($assertType(_ref, int64Val, true)[1]) {
- x$3 = _ref.$val;
- y$2 = $assertType(y, int64Val);
- _ref$2 = op;
- if (_ref$2 === 39) {
- return (x$3.$high === y$2.$high && x$3.$low === y$2.$low);
- } else if (_ref$2 === 44) {
- return !((x$3.$high === y$2.$high && x$3.$low === y$2.$low));
- } else if (_ref$2 === 40) {
- return (x$3.$high < y$2.$high || (x$3.$high === y$2.$high && x$3.$low < y$2.$low));
- } else if (_ref$2 === 45) {
- return (x$3.$high < y$2.$high || (x$3.$high === y$2.$high && x$3.$low <= y$2.$low));
- } else if (_ref$2 === 41) {
- return (x$3.$high > y$2.$high || (x$3.$high === y$2.$high && x$3.$low > y$2.$low));
- } else if (_ref$2 === 46) {
- return (x$3.$high > y$2.$high || (x$3.$high === y$2.$high && x$3.$low >= y$2.$low));
- }
- } else if ($assertType(_ref, intVal, true)[1]) {
- x$4 = _ref.$val;
- return cmpZero(x$4.val.Cmp($assertType(y, intVal).val), op);
- } else if ($assertType(_ref, floatVal, true)[1]) {
- x$5 = _ref.$val;
- return cmpZero(x$5.val.Cmp($assertType(y, floatVal).val), op);
- } else if ($assertType(_ref, complexVal, true)[1]) {
- x$6 = _ref.$val;
- y$3 = $clone($assertType(y, complexVal), complexVal);
- re = x$6.re.Cmp(y$3.re);
- im = x$6.im.Cmp(y$3.im);
- _ref$3 = op;
- if (_ref$3 === 39) {
- return (re === 0) && (im === 0);
- } else if (_ref$3 === 44) {
- return !((re === 0)) || !((im === 0));
- }
- } else if ($assertType(_ref, stringVal, true)[1]) {
- x$7 = _ref.$val;
- y$4 = $assertType(y, stringVal);
- _ref$4 = op;
- if (_ref$4 === 39) {
- return x$7 === y$4;
- } else if (_ref$4 === 44) {
- return !(x$7 === y$4);
- } else if (_ref$4 === 40) {
- return x$7 < y$4;
- } else if (_ref$4 === 45) {
- return x$7 <= y$4;
- } else if (_ref$4 === 41) {
- return x$7 > y$4;
- } else if (_ref$4 === 46) {
- return x$7 >= y$4;
- }
- }
- _r = fmt.Sprintf("invalid comparison %v %s %v", new sliceType([x, new token.Token(op), y])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $panic(new $String(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Compare }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f.im = im; $f.op = op; $f.re = re; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.y = y; $f.y$1 = y$1; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Compare = Compare;
- ratToFloat32 = function(x) {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = x.Float32(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ratToFloat32 }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- unknownVal.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}];
- boolVal.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}];
- stringVal.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}];
- int64Val.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}];
- intVal.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}];
- floatVal.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}];
- complexVal.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}];
- Value.init([{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [Kind], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "implementsValue", name: "implementsValue", pkg: "golang.org/x/tools/go/exact", typ: $funcType([], [], false)}]);
- unknownVal.init([]);
- intVal.init([{prop: "val", name: "val", pkg: "golang.org/x/tools/go/exact", typ: ptrType$1, tag: ""}]);
- floatVal.init([{prop: "val", name: "val", pkg: "golang.org/x/tools/go/exact", typ: ptrType, tag: ""}]);
- complexVal.init([{prop: "re", name: "re", pkg: "golang.org/x/tools/go/exact", typ: ptrType, tag: ""}, {prop: "im", name: "im", pkg: "golang.org/x/tools/go/exact", typ: ptrType, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = fmt.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = big.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- minInt64 = big.NewInt(new $Int64(-2147483648, 0));
- maxInt64 = big.NewInt(new $Int64(2147483647, 4294967295));
- int1 = big.NewInt(new $Int64(0, 1));
- rat0 = big.NewRat(new $Int64(0, 0), new $Int64(0, 1));
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["path"] = (function() {
- var $pkg = {}, $init, errors, strings, utf8, Base;
- errors = $packages["errors"];
- strings = $packages["strings"];
- utf8 = $packages["unicode/utf8"];
- Base = function(path) {
- var $ptr, i, path;
- if (path === "") {
- return ".";
- }
- while (true) {
- if (!(path.length > 0 && (path.charCodeAt((path.length - 1 >> 0)) === 47))) { break; }
- path = path.substring(0, (path.length - 1 >> 0));
- }
- i = strings.LastIndex(path, "/");
- if (i >= 0) {
- path = path.substring((i + 1 >> 0));
- }
- if (path === "") {
- return "/";
- }
- return path;
- };
- $pkg.Base = Base;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.ErrBadPattern = errors.New("syntax error in pattern");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["golang.org/x/tools/go/types"] = (function() {
- var $pkg = {}, $init, bytes, heap, errors, fmt, ast, parser, token, exact, io, math, path, sort, strconv, strings, unicode, Error, Importer, Config, Info, TypeAndValue, Initializer, getter, exprInfo, funcInfo, context, Checker, bailout, opPredicates, exprKind, objNode, nodeQueue, block, embeddedType, Object, object, PkgName, Const, TypeName, Var, Func, Label, Builtin, Nil, objset, operandMode, operand, inSourceOrder, Package, ifacePair, declInfo, Scope, SelectionKind, Selection, Sizes, StdSizes, stmtContext, Type, BasicKind, BasicInfo, Basic, Array, Slice, Struct, Pointer, Tuple, Signature, Interface, Map, Chan, ChanDir, Named, byUniqueTypeName, byUniqueMethodName, builtinId, ptrType, ptrType$1, ptrType$2, ptrType$3, structType, structType$1, ptrType$4, sliceType, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, arrayType, sliceType$1, ptrType$10, sliceType$2, sliceType$3, ptrType$11, ptrType$12, ptrType$13, sliceType$4, ptrType$14, sliceType$5, ptrType$15, ptrType$16, ptrType$17, sliceType$6, ptrType$18, ptrType$19, ptrType$20, ptrType$21, sliceType$7, ptrType$22, ptrType$23, sliceType$8, sliceType$9, funcType, sliceType$10, ptrType$24, ptrType$25, ptrType$26, ptrType$27, ptrType$28, sliceType$11, ptrType$29, ptrType$30, ptrType$31, ptrType$32, ptrType$33, sliceType$12, ptrType$34, ptrType$35, ptrType$36, ptrType$37, ptrType$38, ptrType$39, ptrType$40, ptrType$41, ptrType$42, ptrType$43, ptrType$44, ptrType$45, ptrType$46, ptrType$47, ptrType$48, ptrType$49, ptrType$50, ptrType$51, ptrType$52, ptrType$53, ptrType$54, sliceType$13, arrayType$1, ptrType$55, ptrType$56, sliceType$14, ptrType$57, ptrType$58, ptrType$59, ptrType$60, sliceType$15, ptrType$61, ptrType$62, ptrType$63, ptrType$64, ptrType$65, ptrType$66, ptrType$67, ptrType$68, ptrType$69, ptrType$70, sliceType$16, ptrType$71, ptrType$72, sliceType$18, ptrType$73, sliceType$19, ptrType$74, ptrType$75, ptrType$76, ptrType$77, ptrType$78, ptrType$79, ptrType$80, ptrType$81, ptrType$82, ptrType$83, ptrType$84, ptrType$85, ptrType$86, sliceType$20, sliceType$21, ptrType$87, sliceType$22, mapType, funcType$1, ptrType$88, sliceType$23, mapType$1, mapType$2, mapType$3, mapType$4, mapType$5, sliceType$24, mapType$6, ptrType$89, mapType$7, mapType$8, mapType$9, mapType$10, mapType$11, funcType$2, mapType$12, ptrType$91, mapType$13, mapType$14, ptrType$92, unaryOpPredicates, binaryOpPredicates, operandModeString, basicSizes, stdSizes, universeIota, aliases, predeclaredConsts, predeclaredFuncs, _map, _key, _map$1, _key$1, Implements, makeSig, implicitArrayDeref, unparen, unpack, NewChecker, isUintptr, isUnsafePointer, isPointer, isBytesOrRunes, underlying, assert, unreachable, isShift, isComparison, fitsFloat32, roundFloat32, fitsFloat64, roundFloat64, representableConst, ExprString, WriteExpr, writeSigExpr, writeFieldList, slice3, sliceMax, findPath, valIndex, dependencyGraph, LookupFieldOrMethod, lookupFieldOrMethod, consolidateMultiples, MissingMethod, assertableTo, deref, derefStructPtr, concat, fieldIndex, lookupMethod, ptrRecv, Id, NewPkgName, NewConst, NewTypeName, NewVar, NewParam, NewField, NewFunc, NewLabel, newBuiltin, writeObject, writePackage, ObjectString, writeFuncName, operandString, orderedSetObjects, NewPackage, isNamed, isBoolean, isInteger, isUnsigned, isFloat, isComplex, isNumeric, isString, isTyped, isUntyped, isOrdered, isConstType, IsInterface, Comparable, hasNil, Identical, identical, defaultType, validatedImportPath, hasBreak, hasBreakList, NewScope, SelectionString, align, assignOp, NewArray, NewSlice, NewStruct, NewPointer, NewTuple, NewSignature, NewInterface, NewMap, NewChan, NewNamed, TypeString, WriteType, writeType, writeTuple, WriteSignature, writeSignature, anonymousFieldIdent, defPredeclaredTypes, defPredeclaredConsts, defPredeclaredNil, defPredeclaredFuncs, init, def;
- bytes = $packages["bytes"];
- heap = $packages["container/heap"];
- errors = $packages["errors"];
- fmt = $packages["fmt"];
- ast = $packages["go/ast"];
- parser = $packages["go/parser"];
- token = $packages["go/token"];
- exact = $packages["golang.org/x/tools/go/exact"];
- io = $packages["io"];
- math = $packages["math"];
- path = $packages["path"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- unicode = $packages["unicode"];
- Error = $pkg.Error = $newType(0, $kindStruct, "types.Error", "Error", "golang.org/x/tools/go/types", function(Fset_, Pos_, Msg_, Soft_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Fset = ptrType$22.nil;
- this.Pos = 0;
- this.Msg = "";
- this.Soft = false;
- return;
- }
- this.Fset = Fset_;
- this.Pos = Pos_;
- this.Msg = Msg_;
- this.Soft = Soft_;
- });
- Importer = $pkg.Importer = $newType(4, $kindFunc, "types.Importer", "Importer", "golang.org/x/tools/go/types", null);
- Config = $pkg.Config = $newType(0, $kindStruct, "types.Config", "Config", "golang.org/x/tools/go/types", function(IgnoreFuncBodies_, FakeImportC_, Packages_, Error_, Import_, Sizes_, DisableUnusedImportCheck_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.IgnoreFuncBodies = false;
- this.FakeImportC = false;
- this.Packages = false;
- this.Error = $throwNilPointerError;
- this.Import = $throwNilPointerError;
- this.Sizes = $ifaceNil;
- this.DisableUnusedImportCheck = false;
- return;
- }
- this.IgnoreFuncBodies = IgnoreFuncBodies_;
- this.FakeImportC = FakeImportC_;
- this.Packages = Packages_;
- this.Error = Error_;
- this.Import = Import_;
- this.Sizes = Sizes_;
- this.DisableUnusedImportCheck = DisableUnusedImportCheck_;
- });
- Info = $pkg.Info = $newType(0, $kindStruct, "types.Info", "Info", "golang.org/x/tools/go/types", function(Types_, Defs_, Uses_, Implicits_, Selections_, Scopes_, InitOrder_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Types = false;
- this.Defs = false;
- this.Uses = false;
- this.Implicits = false;
- this.Selections = false;
- this.Scopes = false;
- this.InitOrder = sliceType$23.nil;
- return;
- }
- this.Types = Types_;
- this.Defs = Defs_;
- this.Uses = Uses_;
- this.Implicits = Implicits_;
- this.Selections = Selections_;
- this.Scopes = Scopes_;
- this.InitOrder = InitOrder_;
- });
- TypeAndValue = $pkg.TypeAndValue = $newType(0, $kindStruct, "types.TypeAndValue", "TypeAndValue", "golang.org/x/tools/go/types", function(mode_, Type_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.mode = 0;
- this.Type = $ifaceNil;
- this.Value = $ifaceNil;
- return;
- }
- this.mode = mode_;
- this.Type = Type_;
- this.Value = Value_;
- });
- Initializer = $pkg.Initializer = $newType(0, $kindStruct, "types.Initializer", "Initializer", "golang.org/x/tools/go/types", function(Lhs_, Rhs_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Lhs = sliceType$1.nil;
- this.Rhs = $ifaceNil;
- return;
- }
- this.Lhs = Lhs_;
- this.Rhs = Rhs_;
- });
- getter = $pkg.getter = $newType(4, $kindFunc, "types.getter", "getter", "golang.org/x/tools/go/types", null);
- exprInfo = $pkg.exprInfo = $newType(0, $kindStruct, "types.exprInfo", "exprInfo", "golang.org/x/tools/go/types", function(isLhs_, mode_, typ_, val_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.isLhs = false;
- this.mode = 0;
- this.typ = ptrType$3.nil;
- this.val = $ifaceNil;
- return;
- }
- this.isLhs = isLhs_;
- this.mode = mode_;
- this.typ = typ_;
- this.val = val_;
- });
- funcInfo = $pkg.funcInfo = $newType(0, $kindStruct, "types.funcInfo", "funcInfo", "golang.org/x/tools/go/types", function(name_, decl_, sig_, body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.name = "";
- this.decl = ptrType$21.nil;
- this.sig = ptrType$17.nil;
- this.body = ptrType$29.nil;
- return;
- }
- this.name = name_;
- this.decl = decl_;
- this.sig = sig_;
- this.body = body_;
- });
- context = $pkg.context = $newType(0, $kindStruct, "types.context", "context", "golang.org/x/tools/go/types", function(decl_, scope_, iota_, sig_, hasLabel_, hasCallOrRecv_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.decl = ptrType$21.nil;
- this.scope = ptrType.nil;
- this.iota = $ifaceNil;
- this.sig = ptrType$17.nil;
- this.hasLabel = false;
- this.hasCallOrRecv = false;
- return;
- }
- this.decl = decl_;
- this.scope = scope_;
- this.iota = iota_;
- this.sig = sig_;
- this.hasLabel = hasLabel_;
- this.hasCallOrRecv = hasCallOrRecv_;
- });
- Checker = $pkg.Checker = $newType(0, $kindStruct, "types.Checker", "Checker", "golang.org/x/tools/go/types", function(conf_, fset_, pkg_, Info_, objMap_, files_, unusedDotImports_, firstErr_, methods_, untyped_, funcs_, delayed_, context_, pos_, indent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.conf = ptrType$7.nil;
- this.fset = ptrType$22.nil;
- this.pkg = ptrType$1.nil;
- this.Info = ptrType$4.nil;
- this.objMap = false;
- this.files = sliceType$8.nil;
- this.unusedDotImports = false;
- this.firstErr = $ifaceNil;
- this.methods = false;
- this.untyped = false;
- this.funcs = sliceType$9.nil;
- this.delayed = sliceType$10.nil;
- this.context = new context.ptr();
- this.pos = 0;
- this.indent = 0;
- return;
- }
- this.conf = conf_;
- this.fset = fset_;
- this.pkg = pkg_;
- this.Info = Info_;
- this.objMap = objMap_;
- this.files = files_;
- this.unusedDotImports = unusedDotImports_;
- this.firstErr = firstErr_;
- this.methods = methods_;
- this.untyped = untyped_;
- this.funcs = funcs_;
- this.delayed = delayed_;
- this.context = context_;
- this.pos = pos_;
- this.indent = indent_;
- });
- bailout = $pkg.bailout = $newType(0, $kindStruct, "types.bailout", "bailout", "golang.org/x/tools/go/types", function() {
- this.$val = this;
- if (arguments.length === 0) {
- return;
- }
- });
- opPredicates = $pkg.opPredicates = $newType(4, $kindMap, "types.opPredicates", "opPredicates", "golang.org/x/tools/go/types", null);
- exprKind = $pkg.exprKind = $newType(4, $kindInt, "types.exprKind", "exprKind", "golang.org/x/tools/go/types", null);
- objNode = $pkg.objNode = $newType(0, $kindStruct, "types.objNode", "objNode", "golang.org/x/tools/go/types", function(obj_, in$1_, out_, index_, mark_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.obj = $ifaceNil;
- this.in$1 = 0;
- this.out = sliceType$14.nil;
- this.index = 0;
- this.mark = 0;
- return;
- }
- this.obj = obj_;
- this.in$1 = in$1_;
- this.out = out_;
- this.index = index_;
- this.mark = mark_;
- });
- nodeQueue = $pkg.nodeQueue = $newType(12, $kindSlice, "types.nodeQueue", "nodeQueue", "golang.org/x/tools/go/types", null);
- block = $pkg.block = $newType(0, $kindStruct, "types.block", "block", "golang.org/x/tools/go/types", function(parent_, lstmt_, labels_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.parent = ptrType$57.nil;
- this.lstmt = ptrType$58.nil;
- this.labels = false;
- return;
- }
- this.parent = parent_;
- this.lstmt = lstmt_;
- this.labels = labels_;
- });
- embeddedType = $pkg.embeddedType = $newType(0, $kindStruct, "types.embeddedType", "embeddedType", "golang.org/x/tools/go/types", function(typ_, index_, indirect_, multiples_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.typ = ptrType$26.nil;
- this.index = sliceType$6.nil;
- this.indirect = false;
- this.multiples = false;
- return;
- }
- this.typ = typ_;
- this.index = index_;
- this.indirect = indirect_;
- this.multiples = multiples_;
- });
- Object = $pkg.Object = $newType(8, $kindInterface, "types.Object", "Object", "golang.org/x/tools/go/types", null);
- object = $pkg.object = $newType(0, $kindStruct, "types.object", "object", "golang.org/x/tools/go/types", function(parent_, pos_, pkg_, name_, typ_, order__, scopePos__) {
- this.$val = this;
- if (arguments.length === 0) {
- this.parent = ptrType.nil;
- this.pos = 0;
- this.pkg = ptrType$1.nil;
- this.name = "";
- this.typ = $ifaceNil;
- this.order_ = 0;
- this.scopePos_ = 0;
- return;
- }
- this.parent = parent_;
- this.pos = pos_;
- this.pkg = pkg_;
- this.name = name_;
- this.typ = typ_;
- this.order_ = order__;
- this.scopePos_ = scopePos__;
- });
- PkgName = $pkg.PkgName = $newType(0, $kindStruct, "types.PkgName", "PkgName", "golang.org/x/tools/go/types", function(object_, imported_, used_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- this.imported = ptrType$1.nil;
- this.used = false;
- return;
- }
- this.object = object_;
- this.imported = imported_;
- this.used = used_;
- });
- Const = $pkg.Const = $newType(0, $kindStruct, "types.Const", "Const", "golang.org/x/tools/go/types", function(object_, val_, visited_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- this.val = $ifaceNil;
- this.visited = false;
- return;
- }
- this.object = object_;
- this.val = val_;
- this.visited = visited_;
- });
- TypeName = $pkg.TypeName = $newType(0, $kindStruct, "types.TypeName", "TypeName", "golang.org/x/tools/go/types", function(object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- return;
- }
- this.object = object_;
- });
- Var = $pkg.Var = $newType(0, $kindStruct, "types.Var", "Var", "golang.org/x/tools/go/types", function(object_, anonymous_, visited_, isField_, used_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- this.anonymous = false;
- this.visited = false;
- this.isField = false;
- this.used = false;
- return;
- }
- this.object = object_;
- this.anonymous = anonymous_;
- this.visited = visited_;
- this.isField = isField_;
- this.used = used_;
- });
- Func = $pkg.Func = $newType(0, $kindStruct, "types.Func", "Func", "golang.org/x/tools/go/types", function(object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- return;
- }
- this.object = object_;
- });
- Label = $pkg.Label = $newType(0, $kindStruct, "types.Label", "Label", "golang.org/x/tools/go/types", function(object_, used_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- this.used = false;
- return;
- }
- this.object = object_;
- this.used = used_;
- });
- Builtin = $pkg.Builtin = $newType(0, $kindStruct, "types.Builtin", "Builtin", "golang.org/x/tools/go/types", function(object_, id_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- this.id = 0;
- return;
- }
- this.object = object_;
- this.id = id_;
- });
- Nil = $pkg.Nil = $newType(0, $kindStruct, "types.Nil", "Nil", "golang.org/x/tools/go/types", function(object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.object = new object.ptr();
- return;
- }
- this.object = object_;
- });
- objset = $pkg.objset = $newType(4, $kindMap, "types.objset", "objset", "golang.org/x/tools/go/types", null);
- operandMode = $pkg.operandMode = $newType(1, $kindUint8, "types.operandMode", "operandMode", "golang.org/x/tools/go/types", null);
- operand = $pkg.operand = $newType(0, $kindStruct, "types.operand", "operand", "golang.org/x/tools/go/types", function(mode_, expr_, typ_, val_, id_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.mode = 0;
- this.expr = $ifaceNil;
- this.typ = $ifaceNil;
- this.val = $ifaceNil;
- this.id = 0;
- return;
- }
- this.mode = mode_;
- this.expr = expr_;
- this.typ = typ_;
- this.val = val_;
- this.id = id_;
- });
- inSourceOrder = $pkg.inSourceOrder = $newType(12, $kindSlice, "types.inSourceOrder", "inSourceOrder", "golang.org/x/tools/go/types", null);
- Package = $pkg.Package = $newType(0, $kindStruct, "types.Package", "Package", "golang.org/x/tools/go/types", function(path_, name_, scope_, complete_, imports_, fake_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.path = "";
- this.name = "";
- this.scope = ptrType.nil;
- this.complete = false;
- this.imports = sliceType$19.nil;
- this.fake = false;
- return;
- }
- this.path = path_;
- this.name = name_;
- this.scope = scope_;
- this.complete = complete_;
- this.imports = imports_;
- this.fake = fake_;
- });
- ifacePair = $pkg.ifacePair = $newType(0, $kindStruct, "types.ifacePair", "ifacePair", "golang.org/x/tools/go/types", function(x_, y_, prev_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.x = ptrType$53.nil;
- this.y = ptrType$53.nil;
- this.prev = ptrType$74.nil;
- return;
- }
- this.x = x_;
- this.y = y_;
- this.prev = prev_;
- });
- declInfo = $pkg.declInfo = $newType(0, $kindStruct, "types.declInfo", "declInfo", "golang.org/x/tools/go/types", function(file_, lhs_, typ_, init_, fdecl_, deps_, mark_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.file = ptrType.nil;
- this.lhs = sliceType$1.nil;
- this.typ = $ifaceNil;
- this.init = $ifaceNil;
- this.fdecl = ptrType$75.nil;
- this.deps = false;
- this.mark = 0;
- return;
- }
- this.file = file_;
- this.lhs = lhs_;
- this.typ = typ_;
- this.init = init_;
- this.fdecl = fdecl_;
- this.deps = deps_;
- this.mark = mark_;
- });
- Scope = $pkg.Scope = $newType(0, $kindStruct, "types.Scope", "Scope", "golang.org/x/tools/go/types", function(parent_, children_, elems_, pos_, end_, comment_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.parent = ptrType.nil;
- this.children = sliceType$20.nil;
- this.elems = false;
- this.pos = 0;
- this.end = 0;
- this.comment = "";
- return;
- }
- this.parent = parent_;
- this.children = children_;
- this.elems = elems_;
- this.pos = pos_;
- this.end = end_;
- this.comment = comment_;
- });
- SelectionKind = $pkg.SelectionKind = $newType(4, $kindInt, "types.SelectionKind", "SelectionKind", "golang.org/x/tools/go/types", null);
- Selection = $pkg.Selection = $newType(0, $kindStruct, "types.Selection", "Selection", "golang.org/x/tools/go/types", function(kind_, recv_, obj_, index_, indirect_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.kind = 0;
- this.recv = $ifaceNil;
- this.obj = $ifaceNil;
- this.index = sliceType$6.nil;
- this.indirect = false;
- return;
- }
- this.kind = kind_;
- this.recv = recv_;
- this.obj = obj_;
- this.index = index_;
- this.indirect = indirect_;
- });
- Sizes = $pkg.Sizes = $newType(8, $kindInterface, "types.Sizes", "Sizes", "golang.org/x/tools/go/types", null);
- StdSizes = $pkg.StdSizes = $newType(0, $kindStruct, "types.StdSizes", "StdSizes", "golang.org/x/tools/go/types", function(WordSize_, MaxAlign_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.WordSize = new $Int64(0, 0);
- this.MaxAlign = new $Int64(0, 0);
- return;
- }
- this.WordSize = WordSize_;
- this.MaxAlign = MaxAlign_;
- });
- stmtContext = $pkg.stmtContext = $newType(4, $kindUint, "types.stmtContext", "stmtContext", "golang.org/x/tools/go/types", null);
- Type = $pkg.Type = $newType(8, $kindInterface, "types.Type", "Type", "golang.org/x/tools/go/types", null);
- BasicKind = $pkg.BasicKind = $newType(4, $kindInt, "types.BasicKind", "BasicKind", "golang.org/x/tools/go/types", null);
- BasicInfo = $pkg.BasicInfo = $newType(4, $kindInt, "types.BasicInfo", "BasicInfo", "golang.org/x/tools/go/types", null);
- Basic = $pkg.Basic = $newType(0, $kindStruct, "types.Basic", "Basic", "golang.org/x/tools/go/types", function(kind_, info_, name_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.kind = 0;
- this.info = 0;
- this.name = "";
- return;
- }
- this.kind = kind_;
- this.info = info_;
- this.name = name_;
- });
- Array = $pkg.Array = $newType(0, $kindStruct, "types.Array", "Array", "golang.org/x/tools/go/types", function(len_, elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.len = new $Int64(0, 0);
- this.elem = $ifaceNil;
- return;
- }
- this.len = len_;
- this.elem = elem_;
- });
- Slice = $pkg.Slice = $newType(0, $kindStruct, "types.Slice", "Slice", "golang.org/x/tools/go/types", function(elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.elem = $ifaceNil;
- return;
- }
- this.elem = elem_;
- });
- Struct = $pkg.Struct = $newType(0, $kindStruct, "types.Struct", "Struct", "golang.org/x/tools/go/types", function(fields_, tags_, offsets_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.fields = sliceType$1.nil;
- this.tags = sliceType$21.nil;
- this.offsets = sliceType$4.nil;
- return;
- }
- this.fields = fields_;
- this.tags = tags_;
- this.offsets = offsets_;
- });
- Pointer = $pkg.Pointer = $newType(0, $kindStruct, "types.Pointer", "Pointer", "golang.org/x/tools/go/types", function(base_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.base = $ifaceNil;
- return;
- }
- this.base = base_;
- });
- Tuple = $pkg.Tuple = $newType(0, $kindStruct, "types.Tuple", "Tuple", "golang.org/x/tools/go/types", function(vars_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.vars = sliceType$1.nil;
- return;
- }
- this.vars = vars_;
- });
- Signature = $pkg.Signature = $newType(0, $kindStruct, "types.Signature", "Signature", "golang.org/x/tools/go/types", function(scope_, recv_, params_, results_, variadic_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.scope = ptrType.nil;
- this.recv = ptrType$9.nil;
- this.params = ptrType$8.nil;
- this.results = ptrType$8.nil;
- this.variadic = false;
- return;
- }
- this.scope = scope_;
- this.recv = recv_;
- this.params = params_;
- this.results = results_;
- this.variadic = variadic_;
- });
- Interface = $pkg.Interface = $newType(0, $kindStruct, "types.Interface", "Interface", "golang.org/x/tools/go/types", function(methods_, embeddeds_, allMethods_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.methods = sliceType$7.nil;
- this.embeddeds = sliceType$22.nil;
- this.allMethods = sliceType$7.nil;
- return;
- }
- this.methods = methods_;
- this.embeddeds = embeddeds_;
- this.allMethods = allMethods_;
- });
- Map = $pkg.Map = $newType(0, $kindStruct, "types.Map", "Map", "golang.org/x/tools/go/types", function(key_, elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.key = $ifaceNil;
- this.elem = $ifaceNil;
- return;
- }
- this.key = key_;
- this.elem = elem_;
- });
- Chan = $pkg.Chan = $newType(0, $kindStruct, "types.Chan", "Chan", "golang.org/x/tools/go/types", function(dir_, elem_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.dir = 0;
- this.elem = $ifaceNil;
- return;
- }
- this.dir = dir_;
- this.elem = elem_;
- });
- ChanDir = $pkg.ChanDir = $newType(4, $kindInt, "types.ChanDir", "ChanDir", "golang.org/x/tools/go/types", null);
- Named = $pkg.Named = $newType(0, $kindStruct, "types.Named", "Named", "golang.org/x/tools/go/types", function(obj_, underlying_, methods_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.obj = ptrType$19.nil;
- this.underlying = $ifaceNil;
- this.methods = sliceType$7.nil;
- return;
- }
- this.obj = obj_;
- this.underlying = underlying_;
- this.methods = methods_;
- });
- byUniqueTypeName = $pkg.byUniqueTypeName = $newType(12, $kindSlice, "types.byUniqueTypeName", "byUniqueTypeName", "golang.org/x/tools/go/types", null);
- byUniqueMethodName = $pkg.byUniqueMethodName = $newType(12, $kindSlice, "types.byUniqueMethodName", "byUniqueMethodName", "golang.org/x/tools/go/types", null);
- builtinId = $pkg.builtinId = $newType(4, $kindInt, "types.builtinId", "builtinId", "golang.org/x/tools/go/types", null);
- ptrType = $ptrType(Scope);
- ptrType$1 = $ptrType(Package);
- ptrType$2 = $ptrType(Const);
- ptrType$3 = $ptrType(Basic);
- structType = $structType([{prop: "name", name: "name", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}, {prop: "kind", name: "kind", pkg: "golang.org/x/tools/go/types", typ: BasicKind, tag: ""}, {prop: "val", name: "val", pkg: "golang.org/x/tools/go/types", typ: exact.Value, tag: ""}]);
- structType$1 = $structType([{prop: "name", name: "name", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}, {prop: "nargs", name: "nargs", pkg: "golang.org/x/tools/go/types", typ: $Int, tag: ""}, {prop: "variadic", name: "variadic", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "kind", name: "kind", pkg: "golang.org/x/tools/go/types", typ: exprKind, tag: ""}]);
- ptrType$4 = $ptrType(Info);
- sliceType = $sliceType($emptyInterface);
- ptrType$5 = $ptrType(ast.Ident);
- ptrType$6 = $ptrType(Func);
- ptrType$7 = $ptrType(Config);
- ptrType$8 = $ptrType(Tuple);
- ptrType$9 = $ptrType(Var);
- arrayType = $arrayType(Type, 2);
- sliceType$1 = $sliceType(ptrType$9);
- ptrType$10 = $ptrType(Slice);
- sliceType$2 = $sliceType(operand);
- sliceType$3 = $sliceType(Type);
- ptrType$11 = $ptrType(Array);
- ptrType$12 = $ptrType(Chan);
- ptrType$13 = $ptrType(Map);
- sliceType$4 = $sliceType($Int64);
- ptrType$14 = $ptrType(ast.SelectorExpr);
- sliceType$5 = $sliceType(ast.Expr);
- ptrType$15 = $ptrType(Pointer);
- ptrType$16 = $ptrType(ast.ParenExpr);
- ptrType$17 = $ptrType(Signature);
- sliceType$6 = $sliceType($Int);
- ptrType$18 = $ptrType(PkgName);
- ptrType$19 = $ptrType(TypeName);
- ptrType$20 = $ptrType(Builtin);
- ptrType$21 = $ptrType(declInfo);
- sliceType$7 = $sliceType(ptrType$6);
- ptrType$22 = $ptrType(token.FileSet);
- ptrType$23 = $ptrType(ast.File);
- sliceType$8 = $sliceType(ptrType$23);
- sliceType$9 = $sliceType(funcInfo);
- funcType = $funcType([], [], false);
- sliceType$10 = $sliceType(funcType);
- ptrType$24 = $ptrType($error);
- ptrType$25 = $ptrType(exact.Value);
- ptrType$26 = $ptrType(Named);
- ptrType$27 = $ptrType(Struct);
- ptrType$28 = $ptrType(objset);
- sliceType$11 = $sliceType(ptrType$19);
- ptrType$29 = $ptrType(ast.BlockStmt);
- ptrType$30 = $ptrType(ast.BadDecl);
- ptrType$31 = $ptrType(ast.GenDecl);
- ptrType$32 = $ptrType(ast.ValueSpec);
- ptrType$33 = $ptrType(ast.TypeSpec);
- sliceType$12 = $sliceType(ptrType$2);
- ptrType$34 = $ptrType(operand);
- ptrType$35 = $ptrType(ast.CompositeLit);
- ptrType$36 = $ptrType(ast.UnaryExpr);
- ptrType$37 = $ptrType(ast.BadExpr);
- ptrType$38 = $ptrType(ast.FuncLit);
- ptrType$39 = $ptrType(ast.IndexExpr);
- ptrType$40 = $ptrType(ast.SliceExpr);
- ptrType$41 = $ptrType(ast.TypeAssertExpr);
- ptrType$42 = $ptrType(ast.StarExpr);
- ptrType$43 = $ptrType(ast.KeyValueExpr);
- ptrType$44 = $ptrType(ast.ArrayType);
- ptrType$45 = $ptrType(ast.StructType);
- ptrType$46 = $ptrType(ast.FuncType);
- ptrType$47 = $ptrType(ast.InterfaceType);
- ptrType$48 = $ptrType(ast.MapType);
- ptrType$49 = $ptrType(ast.ChanType);
- ptrType$50 = $ptrType(ast.CallExpr);
- ptrType$51 = $ptrType(ast.BasicLit);
- ptrType$52 = $ptrType(ast.BinaryExpr);
- ptrType$53 = $ptrType(Interface);
- ptrType$54 = $ptrType(ast.Ellipsis);
- sliceType$13 = $sliceType($Bool);
- arrayType$1 = $arrayType($Int64, 3);
- ptrType$55 = $ptrType(nodeQueue);
- ptrType$56 = $ptrType(objNode);
- sliceType$14 = $sliceType(ptrType$56);
- ptrType$57 = $ptrType(block);
- ptrType$58 = $ptrType(ast.LabeledStmt);
- ptrType$59 = $ptrType(Label);
- ptrType$60 = $ptrType(ast.BranchStmt);
- sliceType$15 = $sliceType(ptrType$60);
- ptrType$61 = $ptrType(ast.DeclStmt);
- ptrType$62 = $ptrType(ast.AssignStmt);
- ptrType$63 = $ptrType(ast.IfStmt);
- ptrType$64 = $ptrType(ast.CaseClause);
- ptrType$65 = $ptrType(ast.SwitchStmt);
- ptrType$66 = $ptrType(ast.TypeSwitchStmt);
- ptrType$67 = $ptrType(ast.CommClause);
- ptrType$68 = $ptrType(ast.SelectStmt);
- ptrType$69 = $ptrType(ast.ForStmt);
- ptrType$70 = $ptrType(ast.RangeStmt);
- sliceType$16 = $sliceType(embeddedType);
- ptrType$71 = $ptrType(Selection);
- ptrType$72 = $ptrType(Nil);
- sliceType$18 = $sliceType(Object);
- ptrType$73 = $ptrType(sliceType$18);
- sliceType$19 = $sliceType(ptrType$1);
- ptrType$74 = $ptrType(ifacePair);
- ptrType$75 = $ptrType(ast.FuncDecl);
- ptrType$76 = $ptrType(token.File);
- ptrType$77 = $ptrType(ast.ImportSpec);
- ptrType$78 = $ptrType(ast.FieldList);
- ptrType$79 = $ptrType(ast.BadStmt);
- ptrType$80 = $ptrType(ast.EmptyStmt);
- ptrType$81 = $ptrType(ast.SendStmt);
- ptrType$82 = $ptrType(ast.IncDecStmt);
- ptrType$83 = $ptrType(ast.GoStmt);
- ptrType$84 = $ptrType(ast.DeferStmt);
- ptrType$85 = $ptrType(ast.ExprStmt);
- ptrType$86 = $ptrType(ast.ReturnStmt);
- sliceType$20 = $sliceType(ptrType);
- sliceType$21 = $sliceType($String);
- ptrType$87 = $ptrType(ast.Object);
- sliceType$22 = $sliceType(ptrType$26);
- mapType = $mapType($String, ptrType$1);
- funcType$1 = $funcType([$error], [], false);
- ptrType$88 = $ptrType(Initializer);
- sliceType$23 = $sliceType(ptrType$88);
- mapType$1 = $mapType(ast.Expr, TypeAndValue);
- mapType$2 = $mapType(ptrType$5, Object);
- mapType$3 = $mapType(ast.Node, Object);
- mapType$4 = $mapType(ptrType$14, ptrType$71);
- mapType$5 = $mapType(ast.Node, ptrType);
- sliceType$24 = $sliceType(ast.Stmt);
- mapType$6 = $mapType(Type, token.Pos);
- ptrType$89 = $ptrType(Checker);
- mapType$7 = $mapType(Object, ptrType$21);
- mapType$8 = $mapType(ptrType$1, token.Pos);
- mapType$9 = $mapType(ptrType, mapType$8);
- mapType$10 = $mapType($String, sliceType$7);
- mapType$11 = $mapType(ast.Expr, exprInfo);
- funcType$2 = $funcType([Type], [$Bool], false);
- mapType$12 = $mapType($String, ptrType$58);
- ptrType$91 = $ptrType(object);
- mapType$13 = $mapType(Object, $Bool);
- mapType$14 = $mapType($String, Object);
- ptrType$92 = $ptrType(StdSizes);
- Error.ptr.prototype.Error = function() {
- var $ptr, _arg, _arg$1, _r, _r$1, err, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; err = $f.err; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- err = $clone(this, Error);
- _r = err.Fset.Position(err.Pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg = (x = _r, new x.constructor.elem(x));
- _arg$1 = new $String(err.Msg);
- _r$1 = fmt.Sprintf("%s: %s", new sliceType([_arg, _arg$1])); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Error.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f.err = err; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Error.prototype.Error = function() { return this.$val.Error(); };
- Info.ptr.prototype.TypeOf = function(e) {
- var $ptr, _entry, _r, _tuple, _tuple$1, e, id, info, obj, ok, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; e = $f.e; id = $f.id; info = $f.info; obj = $f.obj; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- info = this;
- _tuple = (_entry = info.Types[ast.Expr.keyFor(e)], _entry !== undefined ? [_entry.v, true] : [new TypeAndValue.ptr(), false]); t = $clone(_tuple[0], TypeAndValue); ok = _tuple[1];
- if (ok) {
- return t.Type;
- }
- _tuple$1 = $assertType(e, ptrType$5, true); id = _tuple$1[0];
- /* */ if (!(id === ptrType$5.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(id === ptrType$5.nil)) { */ case 1:
- obj = info.ObjectOf(id);
- /* */ if (!($interfaceIsEqual(obj, $ifaceNil))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!($interfaceIsEqual(obj, $ifaceNil))) { */ case 3:
- _r = obj.Type(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 4:
- /* } */ case 2:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Info.ptr.prototype.TypeOf }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.e = e; $f.id = id; $f.info = info; $f.obj = obj; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Info.prototype.TypeOf = function(e) { return this.$val.TypeOf(e); };
- Info.ptr.prototype.ObjectOf = function(id) {
- var $ptr, _entry, _entry$1, _tuple, id, info, obj;
- info = this;
- _tuple = (_entry = info.Defs[ptrType$5.keyFor(id)], _entry !== undefined ? [_entry.v, true] : [$ifaceNil, false]); obj = _tuple[0];
- if (!($interfaceIsEqual(obj, $ifaceNil))) {
- return obj;
- }
- return (_entry$1 = info.Uses[ptrType$5.keyFor(id)], _entry$1 !== undefined ? _entry$1.v : $ifaceNil);
- };
- Info.prototype.ObjectOf = function(id) { return this.$val.ObjectOf(id); };
- TypeAndValue.ptr.prototype.IsVoid = function() {
- var $ptr, tv;
- tv = $clone(this, TypeAndValue);
- return tv.mode === 1;
- };
- TypeAndValue.prototype.IsVoid = function() { return this.$val.IsVoid(); };
- TypeAndValue.ptr.prototype.IsType = function() {
- var $ptr, tv;
- tv = $clone(this, TypeAndValue);
- return tv.mode === 3;
- };
- TypeAndValue.prototype.IsType = function() { return this.$val.IsType(); };
- TypeAndValue.ptr.prototype.IsBuiltin = function() {
- var $ptr, tv;
- tv = $clone(this, TypeAndValue);
- return tv.mode === 2;
- };
- TypeAndValue.prototype.IsBuiltin = function() { return this.$val.IsBuiltin(); };
- TypeAndValue.ptr.prototype.IsValue = function() {
- var $ptr, _ref, tv;
- tv = $clone(this, TypeAndValue);
- _ref = tv.mode;
- if (_ref === 4 || _ref === 5 || _ref === 6 || _ref === 7 || _ref === 8) {
- return true;
- }
- return false;
- };
- TypeAndValue.prototype.IsValue = function() { return this.$val.IsValue(); };
- TypeAndValue.ptr.prototype.IsNil = function() {
- var $ptr, tv;
- tv = $clone(this, TypeAndValue);
- return (tv.mode === 7) && $interfaceIsEqual(tv.Type, $pkg.Typ[25]);
- };
- TypeAndValue.prototype.IsNil = function() { return this.$val.IsNil(); };
- TypeAndValue.ptr.prototype.Addressable = function() {
- var $ptr, tv;
- tv = $clone(this, TypeAndValue);
- return tv.mode === 5;
- };
- TypeAndValue.prototype.Addressable = function() { return this.$val.Addressable(); };
- TypeAndValue.ptr.prototype.Assignable = function() {
- var $ptr, tv;
- tv = $clone(this, TypeAndValue);
- return (tv.mode === 5) || (tv.mode === 6);
- };
- TypeAndValue.prototype.Assignable = function() { return this.$val.Assignable(); };
- TypeAndValue.ptr.prototype.HasOk = function() {
- var $ptr, tv;
- tv = $clone(this, TypeAndValue);
- return (tv.mode === 8) || (tv.mode === 6);
- };
- TypeAndValue.prototype.HasOk = function() { return this.$val.HasOk(); };
- Initializer.ptr.prototype.String = function() {
- var $ptr, _i, _ref, buf, i, init$1, lhs;
- init$1 = this;
- buf = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _ref = init$1.Lhs;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- lhs = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (i > 0) {
- buf.WriteString(", ");
- }
- buf.WriteString(lhs.object.Name());
- _i++;
- }
- buf.WriteString(" = ");
- WriteExpr(buf, init$1.Rhs);
- return buf.String();
- };
- Initializer.prototype.String = function() { return this.$val.String(); };
- Config.ptr.prototype.Check = function(path$1, fset, files, info) {
- var $ptr, _r, _r$1, conf, files, fset, info, path$1, pkg, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; conf = $f.conf; files = $f.files; fset = $f.fset; info = $f.info; path$1 = $f.path$1; pkg = $f.pkg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- conf = this;
- _r = NewPackage(path$1, ""); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- pkg = _r;
- _r$1 = NewChecker(conf, fset, pkg, info).Files(files); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return [pkg, _r$1];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Config.ptr.prototype.Check }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.conf = conf; $f.files = files; $f.fset = fset; $f.info = info; $f.path$1 = path$1; $f.pkg = pkg; $f.$s = $s; $f.$r = $r; return $f;
- };
- Config.prototype.Check = function(path$1, fset, files, info) { return this.$val.Check(path$1, fset, files, info); };
- Implements = function(V, T) {
- var $ptr, T, V, _r, _tuple, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; V = $f.V; _r = $f._r; _tuple = $f._tuple; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = MissingMethod(V, T, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f = _tuple[0];
- return f === ptrType$6.nil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Implements }; } $f.$ptr = $ptr; $f.T = T; $f.V = V; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Implements = Implements;
- Checker.ptr.prototype.assignment = function(x, T) {
- var $ptr, T, _r, _r$1, _r$2, _r$3, _r$4, _ref, _tuple, _v, _v$1, check, t, target, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _tuple = $f._tuple; _v = $f._v; _v$1 = $f._v$1; check = $f.check; t = $f.t; target = $f.target; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _ref = x.mode;
- if (_ref === 0) {
- return true;
- } else if (_ref === 4 || _ref === 5 || _ref === 6 || _ref === 7 || _ref === 8) {
- } else {
- unreachable();
- }
- _tuple = $assertType(x.typ, ptrType$8, true); t = _tuple[0];
- /* */ if (!(t === ptrType$8.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(t === ptrType$8.nil)) { */ case 1:
- assert(t.Len() > 1);
- _r = x.pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.errorf(_r, "%d-valued expression %s used as single value", new sliceType([new $Int(t.Len()), x])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return false;
- /* } */ case 2:
- _r$1 = isUntyped(x.typ); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_r$1) { */ case 5:
- target = T;
- if ($interfaceIsEqual(T, $ifaceNil)) { _v = true; $s = 10; continue s; }
- _r$2 = IsInterface(T); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2; case 10:
- /* */ if (_v) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_v) { */ case 8:
- /* */ if ($interfaceIsEqual(T, $ifaceNil) && $interfaceIsEqual(x.typ, $pkg.Typ[25])) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ($interfaceIsEqual(T, $ifaceNil) && $interfaceIsEqual(x.typ, $pkg.Typ[25])) { */ case 12:
- _r$3 = x.pos(); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.errorf(_r$3, "use of untyped nil", new sliceType([])); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return false;
- /* } */ case 13:
- target = defaultType(x.typ);
- /* } */ case 9:
- $r = check.convertUntyped(x, target); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return false;
- }
- /* } */ case 6:
- if ($interfaceIsEqual(T, $ifaceNil)) { _v$1 = true; $s = 17; continue s; }
- _r$4 = x.assignableTo(check.conf, T); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _v$1 = _r$4; case 17:
- return _v$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.assignment }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._tuple = _tuple; $f._v = _v; $f._v$1 = _v$1; $f.check = check; $f.t = t; $f.target = target; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.assignment = function(x, T) { return this.$val.assignment(x, T); };
- Checker.ptr.prototype.initConst = function(lhs, x) {
- var $ptr, _r, _r$1, _r$2, _r$3, check, lhs, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; check = $f.check; lhs = $f.lhs; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- if ((x.mode === 0) || $interfaceIsEqual(x.typ, $pkg.Typ[0]) || $interfaceIsEqual(lhs.object.typ, $pkg.Typ[0])) {
- if ($interfaceIsEqual(lhs.object.typ, $ifaceNil)) {
- lhs.object.typ = $pkg.Typ[0];
- }
- return;
- }
- /* */ if (!((x.mode === 4))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((x.mode === 4))) { */ case 1:
- _r = x.pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.errorf(_r, "%s is not constant", new sliceType([x])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if ($interfaceIsEqual(lhs.object.typ, $ifaceNil)) {
- lhs.object.typ = $pkg.Typ[0];
- }
- return;
- /* } */ case 2:
- _r$1 = isConstType(x.typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = assert(_r$1); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if ($interfaceIsEqual(lhs.object.typ, $ifaceNil)) {
- lhs.object.typ = x.typ;
- }
- _r$2 = check.assignment(x, lhs.object.typ); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!_r$2) { */ case 7:
- /* */ if (!((x.mode === 0))) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!((x.mode === 0))) { */ case 10:
- _r$3 = x.pos(); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.errorf(_r$3, "cannot define constant %s (type %s) as %s", new sliceType([new $String(lhs.object.Name()), lhs.object.typ, x])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- return;
- /* } */ case 8:
- lhs.val = x.val;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.initConst }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.check = check; $f.lhs = lhs; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.initConst = function(lhs, x) { return this.$val.initConst(lhs, x); };
- Checker.ptr.prototype.initVar = function(lhs, x, result) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, check, lhs, result, typ, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; check = $f.check; lhs = $f.lhs; result = $f.result; typ = $f.typ; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- if ((x.mode === 0) || $interfaceIsEqual(x.typ, $pkg.Typ[0]) || $interfaceIsEqual(lhs.object.typ, $pkg.Typ[0])) {
- if ($interfaceIsEqual(lhs.object.typ, $ifaceNil)) {
- lhs.object.typ = $pkg.Typ[0];
- }
- return $ifaceNil;
- }
- /* */ if ($interfaceIsEqual(lhs.object.typ, $ifaceNil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ($interfaceIsEqual(lhs.object.typ, $ifaceNil)) { */ case 1:
- typ = x.typ;
- _r = isUntyped(typ); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_r) { */ case 3:
- /* */ if ($interfaceIsEqual(typ, $pkg.Typ[25])) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if ($interfaceIsEqual(typ, $pkg.Typ[25])) { */ case 6:
- _r$1 = x.pos(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "use of untyped nil", new sliceType([])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- lhs.object.typ = $pkg.Typ[0];
- return $ifaceNil;
- /* } */ case 7:
- typ = defaultType(typ);
- /* } */ case 4:
- lhs.object.typ = typ;
- /* } */ case 2:
- _r$2 = check.assignment(x, lhs.object.typ); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!_r$2) { */ case 10:
- /* */ if (!((x.mode === 0))) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!((x.mode === 0))) { */ case 13:
- /* */ if (result) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (result) { */ case 15:
- _r$3 = x.pos(); /* */ $s = 18; case 18: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.errorf(_r$3, "cannot return %s as value of type %s", new sliceType([x, lhs.object.typ])); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 17; continue;
- /* } else { */ case 16:
- _r$4 = x.pos(); /* */ $s = 20; case 20: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.errorf(_r$4, "cannot initialize %s with %s", new sliceType([lhs, x])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 17:
- /* } */ case 14:
- return $ifaceNil;
- /* } */ case 11:
- return x.typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.initVar }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.check = check; $f.lhs = lhs; $f.result = result; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.initVar = function(lhs, x, result) { return this.$val.initVar(lhs, x, result); };
- Checker.ptr.prototype.assignVar = function(lhs, x) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _ref, _tuple, _tuple$1, _tuple$2, check, ident, lhs, obj, v, v_used, x, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; check = $f.check; ident = $f.ident; lhs = $f.lhs; obj = $f.obj; v = $f.v; v_used = $f.v_used; x = $f.x; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- z = [z];
- check = this;
- if ((x.mode === 0) || $interfaceIsEqual(x.typ, $pkg.Typ[0])) {
- return $ifaceNil;
- }
- _tuple = $assertType(unparen(lhs), ptrType$5, true); ident = _tuple[0];
- /* */ if (!(ident === ptrType$5.nil) && ident.Name === "_") { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(ident === ptrType$5.nil) && ident.Name === "_") { */ case 1:
- check.recordDef(ident, $ifaceNil);
- _r = check.assignment(x, $ifaceNil); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!_r) { */ case 3:
- assert(x.mode === 0);
- x.typ = $ifaceNil;
- /* } */ case 4:
- return x.typ;
- /* } */ case 2:
- v = ptrType$9.nil;
- v_used = false;
- /* */ if (!(ident === ptrType$5.nil)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!(ident === ptrType$5.nil)) { */ case 6:
- _r$1 = check.context.scope.LookupParent(ident.Name, 0); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; obj = _tuple$1[1];
- /* */ if (!($interfaceIsEqual(obj, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(obj, $ifaceNil))) { */ case 9:
- _tuple$2 = $assertType(obj, ptrType$9, true); v = _tuple$2[0];
- if (!(v === ptrType$9.nil)) {
- v_used = v.used;
- }
- /* } */ case 10:
- /* } */ case 7:
- z[0] = $clone(new operand.ptr(), operand);
- $r = check.expr(z[0], lhs); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!(v === ptrType$9.nil)) {
- v.used = v_used;
- }
- if ((z[0].mode === 0) || $interfaceIsEqual(z[0].typ, $pkg.Typ[0])) {
- return $ifaceNil;
- }
- _ref = z[0].mode;
- /* */ if (_ref === 0) { $s = 12; continue; }
- /* */ if (_ref === 5 || _ref === 6) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (_ref === 0) { */ case 12:
- return $ifaceNil;
- $s = 15; continue;
- /* } else if (_ref === 5 || _ref === 6) { */ case 13:
- $s = 15; continue;
- /* } else { */ case 14:
- _r$2 = z[0].pos(); /* */ $s = 16; case 16: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.errorf(_r$2, "cannot assign to %s", new sliceType([z[0]])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return $ifaceNil;
- /* } */ case 15:
- _r$3 = check.assignment(x, z[0].typ); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!_r$3) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!_r$3) { */ case 18:
- /* */ if (!((x.mode === 0))) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (!((x.mode === 0))) { */ case 21:
- _r$4 = x.pos(); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.errorf(_r$4, "cannot assign %s to %s", new sliceType([x, z[0]])); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 22:
- return $ifaceNil;
- /* } */ case 19:
- return x.typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.assignVar }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.check = check; $f.ident = ident; $f.lhs = lhs; $f.obj = obj; $f.v = v; $f.v_used = v_used; $f.x = x; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.assignVar = function(lhs, x) { return this.$val.assignVar(lhs, x); };
- Checker.ptr.prototype.initVars = function(lhs, rhs, returnPos) {
- var $ptr, _i, _i$1, _i$2, _r, _r$1, _r$2, _r$3, _ref, _ref$1, _ref$2, _tuple, a, check, commaOk, get, i, i$1, l, lhs, lhs$1, obj, r, returnPos, rhs, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; a = $f.a; check = $f.check; commaOk = $f.commaOk; get = $f.get; i = $f.i; i$1 = $f.i$1; l = $f.l; lhs = $f.lhs; lhs$1 = $f.lhs$1; obj = $f.obj; r = $f.r; returnPos = $f.returnPos; rhs = $f.rhs; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = [check];
- rhs = [rhs];
- x = [x];
- check[0] = this;
- l = lhs.$length;
- _r = unpack((function(check, rhs, x) { return function $b(x$1, i) {
- var $ptr, i, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = check[0].expr(x$1, ((i < 0 || i >= rhs[0].$length) ? $throwRuntimeError("index out of range") : rhs[0].$array[rhs[0].$offset + i])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(check, rhs, x), rhs[0].$length, (l === 2) && !new token.Pos(returnPos).IsValid()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; get = _tuple[0]; r = _tuple[1]; commaOk = _tuple[2];
- /* */ if (get === $throwNilPointerError || !((l === r))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (get === $throwNilPointerError || !((l === r))) { */ case 2:
- _ref = lhs;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- obj = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if ($interfaceIsEqual(obj.object.typ, $ifaceNil)) {
- obj.object.typ = $pkg.Typ[0];
- }
- _i++;
- }
- if (get === $throwNilPointerError) {
- return;
- }
- $r = check[0].useGetter(get, r); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (new token.Pos(returnPos).IsValid()) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (new token.Pos(returnPos).IsValid()) { */ case 5:
- $r = check[0].errorf(returnPos, "wrong number of return values (want %d, got %d)", new sliceType([new $Int(l), new $Int(r)])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 6:
- _r$1 = (0 >= rhs[0].$length ? $throwRuntimeError("index out of range") : rhs[0].$array[rhs[0].$offset + 0]).Pos(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$1, "assignment count mismatch (%d vs %d)", new sliceType([new $Int(l), new $Int(r)])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 3:
- x[0] = $clone(new operand.ptr(), operand);
- /* */ if (commaOk) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (commaOk) { */ case 10:
- a = $clone(arrayType.zero(), arrayType);
- _ref$1 = a;
- _i$1 = 0;
- /* while (true) { */ case 12:
- /* if (!(_i$1 < 2)) { break; } */ if(!(_i$1 < 2)) { $s = 13; continue; }
- i = _i$1;
- $r = get(x[0], i); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = check[0].initVar(((i < 0 || i >= lhs.$length) ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + i]), x[0], new token.Pos(returnPos).IsValid()); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = _r$2);
- _i$1++;
- /* } */ $s = 12; continue; case 13:
- $r = check[0].recordCommaOkTypes((0 >= rhs[0].$length ? $throwRuntimeError("index out of range") : rhs[0].$array[rhs[0].$offset + 0]), a); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 11:
- _ref$2 = lhs;
- _i$2 = 0;
- /* while (true) { */ case 17:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 18; continue; }
- i$1 = _i$2;
- lhs$1 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- $r = get(x[0], i$1); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = check[0].initVar(lhs$1, x[0], new token.Pos(returnPos).IsValid()); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- _i$2++;
- /* } */ $s = 17; continue; case 18:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.initVars }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f.a = a; $f.check = check; $f.commaOk = commaOk; $f.get = get; $f.i = i; $f.i$1 = i$1; $f.l = l; $f.lhs = lhs; $f.lhs$1 = lhs$1; $f.obj = obj; $f.r = r; $f.returnPos = returnPos; $f.rhs = rhs; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.initVars = function(lhs, rhs, returnPos) { return this.$val.initVars(lhs, rhs, returnPos); };
- Checker.ptr.prototype.assignVars = function(lhs, rhs) {
- var $ptr, _i, _i$1, _r, _r$1, _r$2, _r$3, _ref, _ref$1, _tuple, a, check, commaOk, get, i, i$1, l, lhs, lhs$1, r, rhs, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; a = $f.a; check = $f.check; commaOk = $f.commaOk; get = $f.get; i = $f.i; i$1 = $f.i$1; l = $f.l; lhs = $f.lhs; lhs$1 = $f.lhs$1; r = $f.r; rhs = $f.rhs; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = [check];
- rhs = [rhs];
- x = [x];
- check[0] = this;
- l = lhs.$length;
- _r = unpack((function(check, rhs, x) { return function $b(x$1, i) {
- var $ptr, i, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = check[0].expr(x$1, ((i < 0 || i >= rhs[0].$length) ? $throwRuntimeError("index out of range") : rhs[0].$array[rhs[0].$offset + i])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(check, rhs, x), rhs[0].$length, l === 2); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; get = _tuple[0]; r = _tuple[1]; commaOk = _tuple[2];
- if (get === $throwNilPointerError) {
- return;
- }
- /* */ if (!((l === r))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((l === r))) { */ case 2:
- $r = check[0].useGetter(get, r); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = (0 >= rhs[0].$length ? $throwRuntimeError("index out of range") : rhs[0].$array[rhs[0].$offset + 0]).Pos(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$1, "assignment count mismatch (%d vs %d)", new sliceType([new $Int(l), new $Int(r)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 3:
- x[0] = $clone(new operand.ptr(), operand);
- /* */ if (commaOk) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (commaOk) { */ case 7:
- a = $clone(arrayType.zero(), arrayType);
- _ref = a;
- _i = 0;
- /* while (true) { */ case 9:
- /* if (!(_i < 2)) { break; } */ if(!(_i < 2)) { $s = 10; continue; }
- i = _i;
- $r = get(x[0], i); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = check[0].assignVar(((i < 0 || i >= lhs.$length) ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + i]), x[0]); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = _r$2);
- _i++;
- /* } */ $s = 9; continue; case 10:
- $r = check[0].recordCommaOkTypes((0 >= rhs[0].$length ? $throwRuntimeError("index out of range") : rhs[0].$array[rhs[0].$offset + 0]), a); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 8:
- _ref$1 = lhs;
- _i$1 = 0;
- /* while (true) { */ case 14:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 15; continue; }
- i$1 = _i$1;
- lhs$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- $r = get(x[0], i$1); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = check[0].assignVar(lhs$1, x[0]); /* */ $s = 17; case 17: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- _i$1++;
- /* } */ $s = 14; continue; case 15:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.assignVars }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f.a = a; $f.check = check; $f.commaOk = commaOk; $f.get = get; $f.i = i; $f.i$1 = i$1; $f.l = l; $f.lhs = lhs; $f.lhs$1 = lhs$1; $f.r = r; $f.rhs = rhs; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.assignVars = function(lhs, rhs) { return this.$val.assignVars(lhs, rhs); };
- Checker.ptr.prototype.shortVarDecl = function(pos, lhs, rhs) {
- var $ptr, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _tuple, _tuple$1, alt, alt$1, check, i, ident, lhs, lhs$1, lhsVars, name, newVars, obj, obj$1, pos, rhs, scope, scopePos, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; alt = $f.alt; alt$1 = $f.alt$1; check = $f.check; i = $f.i; ident = $f.ident; lhs = $f.lhs; lhs$1 = $f.lhs$1; lhsVars = $f.lhsVars; name = $f.name; newVars = $f.newVars; obj = $f.obj; obj$1 = $f.obj$1; pos = $f.pos; rhs = $f.rhs; scope = $f.scope; scopePos = $f.scopePos; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- scope = check.context.scope;
- newVars = sliceType$1.nil;
- lhsVars = $makeSlice(sliceType$1, lhs.$length);
- _ref = lhs;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- lhs$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- obj = ptrType$9.nil;
- _tuple = $assertType(lhs$1, ptrType$5, true); ident = _tuple[0];
- /* */ if (!(ident === ptrType$5.nil)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(ident === ptrType$5.nil)) { */ case 3:
- name = ident.Name;
- alt = scope.Lookup(name);
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil))) { */ case 6:
- _tuple$1 = $assertType(alt, ptrType$9, true); alt$1 = _tuple$1[0];
- /* */ if (!(alt$1 === ptrType$9.nil)) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!(alt$1 === ptrType$9.nil)) { */ case 9:
- obj = alt$1;
- $s = 11; continue;
- /* } else { */ case 10:
- _r = lhs$1.Pos(); /* */ $s = 12; case 12: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.errorf(_r, "cannot assign to %s", new sliceType([lhs$1])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- check.recordUse(ident, alt);
- $s = 8; continue;
- /* } else { */ case 7:
- obj = NewVar(ident.Pos(), check.pkg, name, $ifaceNil);
- if (!(name === "_")) {
- newVars = $append(newVars, obj);
- }
- check.recordDef(ident, obj);
- /* } */ case 8:
- $s = 5; continue;
- /* } else { */ case 4:
- _r$1 = lhs$1.Pos(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "cannot declare %s", new sliceType([lhs$1])); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- /* */ if (obj === ptrType$9.nil) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (obj === ptrType$9.nil) { */ case 16:
- _r$2 = lhs$1.Pos(); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = NewVar(_r$2, check.pkg, "_", $ifaceNil); /* */ $s = 19; case 19: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- obj = _r$3;
- /* } */ case 17:
- ((i < 0 || i >= lhsVars.$length) ? $throwRuntimeError("index out of range") : lhsVars.$array[lhsVars.$offset + i] = obj);
- _i++;
- /* } */ $s = 1; continue; case 2:
- $r = check.initVars(lhsVars, rhs, 0); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (newVars.$length > 0) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (newVars.$length > 0) { */ case 21:
- _r$4 = (x = rhs.$length - 1 >> 0, ((x < 0 || x >= rhs.$length) ? $throwRuntimeError("index out of range") : rhs.$array[rhs.$offset + x])).End(); /* */ $s = 24; case 24: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- scopePos = _r$4;
- _ref$1 = newVars;
- _i$1 = 0;
- /* while (true) { */ case 25:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 26; continue; }
- obj$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- $r = check.declare(scope, ptrType$5.nil, obj$1, scopePos); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 25; continue; case 26:
- $s = 23; continue;
- /* } else { */ case 22:
- $r = check.softErrorf(pos, "no new variables on left side of :=", new sliceType([])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 23:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.shortVarDecl }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.alt = alt; $f.alt$1 = alt$1; $f.check = check; $f.i = i; $f.ident = ident; $f.lhs = lhs; $f.lhs$1 = lhs$1; $f.lhsVars = lhsVars; $f.name = name; $f.newVars = newVars; $f.obj = obj; $f.obj$1 = obj$1; $f.pos = pos; $f.rhs = rhs; $f.scope = scope; $f.scopePos = scopePos; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.shortVarDecl = function(pos, lhs, rhs) { return this.$val.shortVarDecl(pos, lhs, rhs); };
- Checker.ptr.prototype.builtin = function(x, call, id) {
- var $ptr, S, T, T$1, T$2, T$3, _, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$16, _arg$17, _arg$18, _arg$19, _arg$2, _arg$20, _arg$21, _arg$22, _arg$23, _arg$24, _arg$25, _arg$26, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _i, _i$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$37, _r$38, _r$39, _r$4, _r$40, _r$41, _r$42, _r$43, _r$44, _r$45, _r$46, _r$47, _r$48, _r$49, _r$5, _r$50, _r$51, _r$52, _r$53, _r$54, _r$55, _r$56, _r$57, _r$58, _r$59, _r$6, _r$60, _r$61, _r$62, _r$63, _r$64, _r$65, _r$66, _r$67, _r$68, _r$69, _r$7, _r$70, _r$71, _r$72, _r$73, _r$74, _r$75, _r$76, _r$77, _r$78, _r$79, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _v, _v$1, alist, arg, arg$1, arg$2, arg0, arg0$1, base, bin, c, call, check, complexT, dst, i, id, index, indirect, k, m, min, mode, msg, nargs, obj, offs, ok, params, params$1, realT, s, s$1, sel, selx, sig, sig$1, sizes, src, t, t$1, t$2, t$3, t$4, t$5, t$6, t$7, typ, val, x, x$1, x$2, x$3, x$4, x$5, x$6, x1, y, y$1, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; S = $f.S; T = $f.T; T$1 = $f.T$1; T$2 = $f.T$2; T$3 = $f.T$3; _ = $f._; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$16 = $f._arg$16; _arg$17 = $f._arg$17; _arg$18 = $f._arg$18; _arg$19 = $f._arg$19; _arg$2 = $f._arg$2; _arg$20 = $f._arg$20; _arg$21 = $f._arg$21; _arg$22 = $f._arg$22; _arg$23 = $f._arg$23; _arg$24 = $f._arg$24; _arg$25 = $f._arg$25; _arg$26 = $f._arg$26; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$4 = $f._r$4; _r$40 = $f._r$40; _r$41 = $f._r$41; _r$42 = $f._r$42; _r$43 = $f._r$43; _r$44 = $f._r$44; _r$45 = $f._r$45; _r$46 = $f._r$46; _r$47 = $f._r$47; _r$48 = $f._r$48; _r$49 = $f._r$49; _r$5 = $f._r$5; _r$50 = $f._r$50; _r$51 = $f._r$51; _r$52 = $f._r$52; _r$53 = $f._r$53; _r$54 = $f._r$54; _r$55 = $f._r$55; _r$56 = $f._r$56; _r$57 = $f._r$57; _r$58 = $f._r$58; _r$59 = $f._r$59; _r$6 = $f._r$6; _r$60 = $f._r$60; _r$61 = $f._r$61; _r$62 = $f._r$62; _r$63 = $f._r$63; _r$64 = $f._r$64; _r$65 = $f._r$65; _r$66 = $f._r$66; _r$67 = $f._r$67; _r$68 = $f._r$68; _r$69 = $f._r$69; _r$7 = $f._r$7; _r$70 = $f._r$70; _r$71 = $f._r$71; _r$72 = $f._r$72; _r$73 = $f._r$73; _r$74 = $f._r$74; _r$75 = $f._r$75; _r$76 = $f._r$76; _r$77 = $f._r$77; _r$78 = $f._r$78; _r$79 = $f._r$79; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _v = $f._v; _v$1 = $f._v$1; alist = $f.alist; arg = $f.arg; arg$1 = $f.arg$1; arg$2 = $f.arg$2; arg0 = $f.arg0; arg0$1 = $f.arg0$1; base = $f.base; bin = $f.bin; c = $f.c; call = $f.call; check = $f.check; complexT = $f.complexT; dst = $f.dst; i = $f.i; id = $f.id; index = $f.index; indirect = $f.indirect; k = $f.k; m = $f.m; min = $f.min; mode = $f.mode; msg = $f.msg; nargs = $f.nargs; obj = $f.obj; offs = $f.offs; ok = $f.ok; params = $f.params; params$1 = $f.params$1; realT = $f.realT; s = $f.s; s$1 = $f.s$1; sel = $f.sel; selx = $f.selx; sig = $f.sig; sig$1 = $f.sig$1; sizes = $f.sizes; src = $f.src; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; typ = $f.typ; val = $f.val; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x1 = $f.x1; y = $f.y; y$1 = $f.y$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- alist = [alist];
- arg = [arg];
- call = [call];
- check = [check];
- t = [t];
- y = [y];
- y$1 = [y$1];
- _ = false;
- check[0] = this;
- bin = $clone(((id < 0 || id >= predeclaredFuncs.length) ? $throwRuntimeError("index out of range") : predeclaredFuncs[id]), structType$1);
- /* */ if (new token.Pos(call[0].Ellipsis).IsValid() && !((id === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (new token.Pos(call[0].Ellipsis).IsValid() && !((id === 0))) { */ case 1:
- $r = check[0].invalidOp(call[0].Ellipsis, "invalid use of ... with built-in %s", new sliceType([new $String(bin.name)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].use(call[0].Args); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 2:
- /* */ if ((id === 7) || (id === 1)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ((id === 7) || (id === 1)) { */ case 5:
- $deferred.push([(function(alist, arg, call, check, t, y, y$1) { return function(b) {
- var $ptr, b;
- check[0].context.hasCallOrRecv = b;
- }; })(alist, arg, call, check, t, y, y$1), [check[0].context.hasCallOrRecv]]);
- check[0].context.hasCallOrRecv = false;
- /* } */ case 6:
- arg[0] = $throwNilPointerError;
- nargs = call[0].Args.$length;
- _ref = id;
- /* */ if (_ref === 8 || _ref === 9 || _ref === 16 || _ref === 19) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_ref === 8 || _ref === 9 || _ref === 16 || _ref === 19) { */ case 7:
- $s = 9; continue;
- /* } else { */ case 8:
- _r = unpack((function(alist, arg, call, check, t, y, y$1) { return function $b(x$1, i) {
- var $ptr, i, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = check[0].expr(x$1, (x$2 = call[0].Args, ((i < 0 || i >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i]))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- }; })(alist, arg, call, check, t, y, y$1), nargs, false); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; arg[0] = _tuple[0]; nargs = _tuple[1];
- if (arg[0] === $throwNilPointerError) {
- return _;
- }
- /* */ if (nargs > 0) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (nargs > 0) { */ case 11:
- $r = arg[0](x, 0); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return _;
- }
- /* } */ case 12:
- /* } */ case 9:
- msg = "";
- if (nargs < bin.nargs) {
- msg = "not enough";
- } else if (!bin.variadic && nargs > bin.nargs) {
- msg = "too many";
- }
- /* */ if (!(msg === "")) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!(msg === "")) { */ case 14:
- $r = check[0].invalidOp(call[0].Rparen, "%s arguments for %s (expected %d, found %d)", new sliceType([new $String(msg), call[0], new $Int(bin.nargs), new $Int(nargs)])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 15:
- _ref$1 = id;
- /* */ if (_ref$1 === 0) { $s = 17; continue; }
- /* */ if (_ref$1 === 1 || _ref$1 === 7) { $s = 18; continue; }
- /* */ if (_ref$1 === 2) { $s = 19; continue; }
- /* */ if (_ref$1 === 3) { $s = 20; continue; }
- /* */ if (_ref$1 === 4) { $s = 21; continue; }
- /* */ if (_ref$1 === 5) { $s = 22; continue; }
- /* */ if (_ref$1 === 6 || _ref$1 === 13) { $s = 23; continue; }
- /* */ if (_ref$1 === 8) { $s = 24; continue; }
- /* */ if (_ref$1 === 9) { $s = 25; continue; }
- /* */ if (_ref$1 === 10) { $s = 26; continue; }
- /* */ if (_ref$1 === 11 || _ref$1 === 12) { $s = 27; continue; }
- /* */ if (_ref$1 === 14) { $s = 28; continue; }
- /* */ if (_ref$1 === 15) { $s = 29; continue; }
- /* */ if (_ref$1 === 16) { $s = 30; continue; }
- /* */ if (_ref$1 === 17) { $s = 31; continue; }
- /* */ if (_ref$1 === 18) { $s = 32; continue; }
- /* */ if (_ref$1 === 19) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* switch (0) { default: if (_ref$1 === 0) { */ case 17:
- S = x.typ;
- T = $ifaceNil;
- _r$1 = S.Underlying(); /* */ $s = 36; case 36: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r$1, ptrType$10, true); s = _tuple$1[0];
- /* */ if (!(s === ptrType$10.nil)) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (!(s === ptrType$10.nil)) { */ case 37:
- T = s.elem;
- $s = 39; continue;
- /* } else { */ case 38:
- _r$2 = x.pos(); /* */ $s = 40; case 40: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$2, "%s is not a slice", new sliceType([x])); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 39:
- alist[0] = new sliceType$2([$clone(x, operand)]);
- if (!((nargs === 2) && new token.Pos(call[0].Ellipsis).IsValid())) { _v = false; $s = 44; continue s; }
- _r$3 = x.assignableTo(check[0].conf, NewSlice($pkg.UniverseByte)); /* */ $s = 45; case 45: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v = _r$3; case 44:
- /* */ if (_v) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (_v) { */ case 42:
- $r = arg[0](x, 1); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return _;
- }
- _r$4 = isString(x.typ); /* */ $s = 49; case 49: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (_r$4) { $s = 47; continue; }
- /* */ $s = 48; continue;
- /* if (_r$4) { */ case 47:
- /* */ if (!(check[0].Info.Types === false)) { $s = 50; continue; }
- /* */ $s = 51; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 50:
- _r$5 = makeSig(S, new sliceType$3([S, x.typ])); /* */ $s = 52; case 52: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- sig = _r$5;
- sig.variadic = true;
- $r = check[0].recordBuiltinType(call[0].Fun, sig); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 51:
- x.mode = 7;
- x.typ = S;
- /* break; */ $s = 35; continue;
- /* } */ case 48:
- alist[0] = $append(alist[0], x);
- /* } */ case 43:
- _r$6 = makeSig(S, new sliceType$3([S, NewSlice(T)])); /* */ $s = 54; case 54: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- sig$1 = _r$6;
- sig$1.variadic = true;
- $r = check[0].arguments$(x, call[0], sig$1, (function(alist, arg, call, check, t, y, y$1) { return function $b(x$1, i) {
- var $ptr, i, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (i < alist[0].$length) {
- $copy(x$1, ((i < 0 || i >= alist[0].$length) ? $throwRuntimeError("index out of range") : alist[0].$array[alist[0].$offset + i]), operand);
- return;
- }
- $r = arg[0](x$1, i); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(alist, arg, call, check, t, y, y$1), nargs); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 7;
- x.typ = S;
- /* */ if (!(check[0].Info.Types === false)) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 56:
- $r = check[0].recordBuiltinType(call[0].Fun, sig$1); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 57:
- $s = 35; continue;
- /* } else if (_ref$1 === 1 || _ref$1 === 7) { */ case 18:
- mode = 0;
- typ = $ifaceNil;
- val = $ifaceNil;
- _r$7 = x.typ.Underlying(); /* */ $s = 59; case 59: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$8 = implicitArrayDeref(_r$7); /* */ $s = 60; case 60: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- typ = _r$8;
- _ref$2 = typ;
- /* */ if ($assertType(_ref$2, ptrType$3, true)[1]) { $s = 61; continue; }
- /* */ if ($assertType(_ref$2, ptrType$11, true)[1]) { $s = 62; continue; }
- /* */ if ($assertType(_ref$2, ptrType$10, true)[1] || $assertType(_ref$2, ptrType$12, true)[1]) { $s = 63; continue; }
- /* */ if ($assertType(_ref$2, ptrType$13, true)[1]) { $s = 64; continue; }
- /* */ $s = 65; continue;
- /* if ($assertType(_ref$2, ptrType$3, true)[1]) { */ case 61:
- t$1 = _ref$2.$val;
- _r$9 = isString(t$1); /* */ $s = 68; case 68: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- /* */ if (_r$9 && (id === 7)) { $s = 66; continue; }
- /* */ $s = 67; continue;
- /* if (_r$9 && (id === 7)) { */ case 66:
- /* */ if (x.mode === 4) { $s = 69; continue; }
- /* */ $s = 70; continue;
- /* if (x.mode === 4) { */ case 69:
- mode = 4;
- _r$10 = exact.StringVal(x.val); /* */ $s = 72; case 72: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$11 = exact.MakeInt64(new $Int64(0, _r$10.length)); /* */ $s = 73; case 73: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- val = _r$11;
- $s = 71; continue;
- /* } else { */ case 70:
- mode = 7;
- /* } */ case 71:
- /* } */ case 67:
- $s = 65; continue;
- /* } else if ($assertType(_ref$2, ptrType$11, true)[1]) { */ case 62:
- t$2 = _ref$2.$val;
- mode = 7;
- if (!check[0].context.hasCallOrRecv) {
- mode = 4;
- val = exact.MakeInt64(t$2.len);
- }
- $s = 65; continue;
- /* } else if ($assertType(_ref$2, ptrType$10, true)[1] || $assertType(_ref$2, ptrType$12, true)[1]) { */ case 63:
- t$3 = _ref$2;
- mode = 7;
- $s = 65; continue;
- /* } else if ($assertType(_ref$2, ptrType$13, true)[1]) { */ case 64:
- t$4 = _ref$2.$val;
- if (id === 7) {
- mode = 7;
- }
- /* } */ case 65:
- /* */ if (mode === 0) { $s = 74; continue; }
- /* */ $s = 75; continue;
- /* if (mode === 0) { */ case 74:
- _r$12 = x.pos(); /* */ $s = 76; case 76: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$12, "%s for %s", new sliceType([x, new $String(bin.name)])); /* */ $s = 77; case 77: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 75:
- x.mode = mode;
- x.typ = $pkg.Typ[2];
- x.val = val;
- /* */ if (!(check[0].Info.Types === false) && !((mode === 4))) { $s = 78; continue; }
- /* */ $s = 79; continue;
- /* if (!(check[0].Info.Types === false) && !((mode === 4))) { */ case 78:
- _arg = call[0].Fun;
- _r$13 = makeSig(x.typ, new sliceType$3([typ])); /* */ $s = 80; case 80: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _arg$1 = _r$13;
- $r = check[0].recordBuiltinType(_arg, _arg$1); /* */ $s = 81; case 81: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 79:
- $s = 35; continue;
- /* } else if (_ref$1 === 2) { */ case 19:
- _r$14 = x.typ.Underlying(); /* */ $s = 82; case 82: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _tuple$2 = $assertType(_r$14, ptrType$12, true); c = _tuple$2[0];
- /* */ if (c === ptrType$12.nil) { $s = 83; continue; }
- /* */ $s = 84; continue;
- /* if (c === ptrType$12.nil) { */ case 83:
- _r$15 = x.pos(); /* */ $s = 85; case 85: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$15, "%s is not a channel", new sliceType([x])); /* */ $s = 86; case 86: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 84:
- /* */ if (c.dir === 2) { $s = 87; continue; }
- /* */ $s = 88; continue;
- /* if (c.dir === 2) { */ case 87:
- _r$16 = x.pos(); /* */ $s = 89; case 89: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$16, "%s must not be a receive-only channel", new sliceType([x])); /* */ $s = 90; case 90: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 88:
- x.mode = 1;
- /* */ if (!(check[0].Info.Types === false)) { $s = 91; continue; }
- /* */ $s = 92; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 91:
- _arg$2 = call[0].Fun;
- _r$17 = makeSig($ifaceNil, new sliceType$3([c])); /* */ $s = 93; case 93: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _arg$3 = _r$17;
- $r = check[0].recordBuiltinType(_arg$2, _arg$3); /* */ $s = 94; case 94: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 92:
- $s = 35; continue;
- /* } else if (_ref$1 === 3) { */ case 20:
- _r$18 = check[0].complexArg(x); /* */ $s = 97; case 97: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- /* */ if (!_r$18) { $s = 95; continue; }
- /* */ $s = 96; continue;
- /* if (!_r$18) { */ case 95:
- return _;
- /* } */ case 96:
- y$1[0] = $clone(new operand.ptr(), operand);
- $r = arg[0](y$1[0], 1); /* */ $s = 98; case 98: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (y$1[0].mode === 0) {
- return _;
- }
- _r$19 = check[0].complexArg(y$1[0]); /* */ $s = 101; case 101: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- /* */ if (!_r$19) { $s = 99; continue; }
- /* */ $s = 100; continue;
- /* if (!_r$19) { */ case 99:
- return _;
- /* } */ case 100:
- $r = check[0].convertUntyped(x, y$1[0].typ); /* */ $s = 102; case 102: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return _;
- }
- $r = check[0].convertUntyped(y$1[0], x.typ); /* */ $s = 103; case 103: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (y$1[0].mode === 0) {
- return _;
- }
- _r$20 = Identical(x.typ, y$1[0].typ); /* */ $s = 106; case 106: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- /* */ if (!_r$20) { $s = 104; continue; }
- /* */ $s = 105; continue;
- /* if (!_r$20) { */ case 104:
- _r$21 = x.pos(); /* */ $s = 107; case 107: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$21, "mismatched types %s and %s", new sliceType([x.typ, y$1[0].typ])); /* */ $s = 108; case 108: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 105:
- /* */ if ((x.mode === 4) && (y$1[0].mode === 4)) { $s = 109; continue; }
- /* */ $s = 110; continue;
- /* if ((x.mode === 4) && (y$1[0].mode === 4)) { */ case 109:
- _arg$4 = x.val;
- _r$22 = exact.MakeImag(y$1[0].val); /* */ $s = 112; case 112: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$5 = _r$22;
- _r$23 = exact.BinaryOp(_arg$4, 12, _arg$5); /* */ $s = 113; case 113: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- x.val = _r$23;
- $s = 111; continue;
- /* } else { */ case 110:
- x.mode = 7;
- /* } */ case 111:
- realT = x.typ;
- complexT = $pkg.Typ[0];
- _r$24 = realT.Underlying(); /* */ $s = 114; case 114: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _ref$3 = $assertType(_r$24, ptrType$3).kind;
- /* */ if (_ref$3 === 13) { $s = 115; continue; }
- /* */ if (_ref$3 === 14) { $s = 116; continue; }
- /* */ if (_ref$3 === 20 || _ref$3 === 21 || _ref$3 === 22) { $s = 117; continue; }
- /* */ $s = 118; continue;
- /* if (_ref$3 === 13) { */ case 115:
- complexT = $pkg.Typ[15];
- $s = 119; continue;
- /* } else if (_ref$3 === 14) { */ case 116:
- complexT = $pkg.Typ[16];
- $s = 119; continue;
- /* } else if (_ref$3 === 20 || _ref$3 === 21 || _ref$3 === 22) { */ case 117:
- if (x.mode === 4) {
- realT = $assertType(defaultType(realT), ptrType$3);
- complexT = $pkg.Typ[23];
- } else {
- realT = $pkg.Typ[14];
- complexT = $pkg.Typ[16];
- }
- $s = 119; continue;
- /* } else { */ case 118:
- _r$25 = x.pos(); /* */ $s = 120; case 120: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$25, "float32 or float64 arguments expected", new sliceType([])); /* */ $s = 121; case 121: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 119:
- x.typ = complexT;
- /* */ if (!(check[0].Info.Types === false) && !((x.mode === 4))) { $s = 122; continue; }
- /* */ $s = 123; continue;
- /* if (!(check[0].Info.Types === false) && !((x.mode === 4))) { */ case 122:
- _arg$6 = call[0].Fun;
- _r$26 = makeSig(complexT, new sliceType$3([realT, realT])); /* */ $s = 124; case 124: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _arg$7 = _r$26;
- $r = check[0].recordBuiltinType(_arg$6, _arg$7); /* */ $s = 125; case 125: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 123:
- /* */ if (!((x.mode === 4))) { $s = 126; continue; }
- /* */ $s = 127; continue;
- /* if (!((x.mode === 4))) { */ case 126:
- $r = check[0].updateExprType(x.expr, realT, true); /* */ $s = 128; case 128: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].updateExprType(y$1[0].expr, realT, true); /* */ $s = 129; case 129: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 127:
- $s = 35; continue;
- /* } else if (_ref$1 === 4) { */ case 21:
- dst = $ifaceNil;
- _r$27 = x.typ.Underlying(); /* */ $s = 130; case 130: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _tuple$3 = $assertType(_r$27, ptrType$10, true); t$5 = _tuple$3[0];
- /* */ if (!(t$5 === ptrType$10.nil)) { $s = 131; continue; }
- /* */ $s = 132; continue;
- /* if (!(t$5 === ptrType$10.nil)) { */ case 131:
- dst = t$5.elem;
- /* } */ case 132:
- y[0] = $clone(new operand.ptr(), operand);
- $r = arg[0](y[0], 1); /* */ $s = 133; case 133: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (y[0].mode === 0) {
- return _;
- }
- src = $ifaceNil;
- _r$28 = y[0].typ.Underlying(); /* */ $s = 134; case 134: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _ref$4 = _r$28;
- /* */ if ($assertType(_ref$4, ptrType$3, true)[1]) { $s = 135; continue; }
- /* */ if ($assertType(_ref$4, ptrType$10, true)[1]) { $s = 136; continue; }
- /* */ $s = 137; continue;
- /* if ($assertType(_ref$4, ptrType$3, true)[1]) { */ case 135:
- t$6 = _ref$4.$val;
- _r$29 = isString(y[0].typ); /* */ $s = 140; case 140: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- /* */ if (_r$29) { $s = 138; continue; }
- /* */ $s = 139; continue;
- /* if (_r$29) { */ case 138:
- src = $pkg.UniverseByte;
- /* } */ case 139:
- $s = 137; continue;
- /* } else if ($assertType(_ref$4, ptrType$10, true)[1]) { */ case 136:
- t$7 = _ref$4.$val;
- src = t$7.elem;
- /* } */ case 137:
- /* */ if ($interfaceIsEqual(dst, $ifaceNil) || $interfaceIsEqual(src, $ifaceNil)) { $s = 141; continue; }
- /* */ $s = 142; continue;
- /* if ($interfaceIsEqual(dst, $ifaceNil) || $interfaceIsEqual(src, $ifaceNil)) { */ case 141:
- _r$30 = x.pos(); /* */ $s = 143; case 143: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$30, "copy expects slice arguments; found %s and %s", new sliceType([x, y[0]])); /* */ $s = 144; case 144: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 142:
- _r$31 = Identical(dst, src); /* */ $s = 147; case 147: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- /* */ if (!_r$31) { $s = 145; continue; }
- /* */ $s = 146; continue;
- /* if (!_r$31) { */ case 145:
- _r$32 = x.pos(); /* */ $s = 148; case 148: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$32, "arguments to copy %s and %s have different element types %s and %s", new sliceType([x, y[0], dst, src])); /* */ $s = 149; case 149: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 146:
- /* */ if (!(check[0].Info.Types === false)) { $s = 150; continue; }
- /* */ $s = 151; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 150:
- _arg$8 = call[0].Fun;
- _r$33 = makeSig($pkg.Typ[2], new sliceType$3([x.typ, y[0].typ])); /* */ $s = 152; case 152: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- _arg$9 = _r$33;
- $r = check[0].recordBuiltinType(_arg$8, _arg$9); /* */ $s = 153; case 153: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 151:
- x.mode = 7;
- x.typ = $pkg.Typ[2];
- $s = 35; continue;
- /* } else if (_ref$1 === 5) { */ case 22:
- _r$34 = x.typ.Underlying(); /* */ $s = 154; case 154: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _tuple$4 = $assertType(_r$34, ptrType$13, true); m = _tuple$4[0];
- /* */ if (m === ptrType$13.nil) { $s = 155; continue; }
- /* */ $s = 156; continue;
- /* if (m === ptrType$13.nil) { */ case 155:
- _r$35 = x.pos(); /* */ $s = 157; case 157: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$35, "%s is not a map", new sliceType([x])); /* */ $s = 158; case 158: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 156:
- $r = arg[0](x, 1); /* */ $s = 159; case 159: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return _;
- }
- _r$36 = x.assignableTo(check[0].conf, m.key); /* */ $s = 162; case 162: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- /* */ if (!_r$36) { $s = 160; continue; }
- /* */ $s = 161; continue;
- /* if (!_r$36) { */ case 160:
- _r$37 = x.pos(); /* */ $s = 163; case 163: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$37, "%s is not assignable to %s", new sliceType([x, m.key])); /* */ $s = 164; case 164: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 161:
- x.mode = 1;
- /* */ if (!(check[0].Info.Types === false)) { $s = 165; continue; }
- /* */ $s = 166; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 165:
- _arg$10 = call[0].Fun;
- _r$38 = makeSig($ifaceNil, new sliceType$3([m, m.key])); /* */ $s = 167; case 167: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- _arg$11 = _r$38;
- $r = check[0].recordBuiltinType(_arg$10, _arg$11); /* */ $s = 168; case 168: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 166:
- $s = 35; continue;
- /* } else if (_ref$1 === 6 || _ref$1 === 13) { */ case 23:
- _r$39 = isComplex(x.typ); /* */ $s = 171; case 171: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- /* */ if (!_r$39) { $s = 169; continue; }
- /* */ $s = 170; continue;
- /* if (!_r$39) { */ case 169:
- _r$40 = x.pos(); /* */ $s = 172; case 172: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$40, "%s must be a complex number", new sliceType([x])); /* */ $s = 173; case 173: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 170:
- /* */ if (x.mode === 4) { $s = 174; continue; }
- /* */ $s = 175; continue;
- /* if (x.mode === 4) { */ case 174:
- /* */ if (id === 13) { $s = 177; continue; }
- /* */ $s = 178; continue;
- /* if (id === 13) { */ case 177:
- _r$41 = exact.Real(x.val); /* */ $s = 180; case 180: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- x.val = _r$41;
- $s = 179; continue;
- /* } else { */ case 178:
- _r$42 = exact.Imag(x.val); /* */ $s = 181; case 181: if($c) { $c = false; _r$42 = _r$42.$blk(); } if (_r$42 && _r$42.$blk !== undefined) { break s; }
- x.val = _r$42;
- /* } */ case 179:
- $s = 176; continue;
- /* } else { */ case 175:
- x.mode = 7;
- /* } */ case 176:
- k = 0;
- _r$43 = x.typ.Underlying(); /* */ $s = 182; case 182: if($c) { $c = false; _r$43 = _r$43.$blk(); } if (_r$43 && _r$43.$blk !== undefined) { break s; }
- _ref$5 = $assertType(_r$43, ptrType$3).kind;
- /* */ if (_ref$5 === 15) { $s = 183; continue; }
- /* */ if (_ref$5 === 16) { $s = 184; continue; }
- /* */ if (_ref$5 === 23) { $s = 185; continue; }
- /* */ $s = 186; continue;
- /* if (_ref$5 === 15) { */ case 183:
- k = 13;
- $s = 187; continue;
- /* } else if (_ref$5 === 16) { */ case 184:
- k = 14;
- $s = 187; continue;
- /* } else if (_ref$5 === 23) { */ case 185:
- k = 22;
- $s = 187; continue;
- /* } else { */ case 186:
- unreachable();
- /* } */ case 187:
- /* */ if (!(check[0].Info.Types === false) && !((x.mode === 4))) { $s = 188; continue; }
- /* */ $s = 189; continue;
- /* if (!(check[0].Info.Types === false) && !((x.mode === 4))) { */ case 188:
- _arg$12 = call[0].Fun;
- _r$44 = makeSig(((k < 0 || k >= $pkg.Typ.length) ? $throwRuntimeError("index out of range") : $pkg.Typ[k]), new sliceType$3([x.typ])); /* */ $s = 190; case 190: if($c) { $c = false; _r$44 = _r$44.$blk(); } if (_r$44 && _r$44.$blk !== undefined) { break s; }
- _arg$13 = _r$44;
- $r = check[0].recordBuiltinType(_arg$12, _arg$13); /* */ $s = 191; case 191: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 189:
- x.typ = ((k < 0 || k >= $pkg.Typ.length) ? $throwRuntimeError("index out of range") : $pkg.Typ[k]);
- $s = 35; continue;
- /* } else if (_ref$1 === 8) { */ case 24:
- arg0 = (x$1 = call[0].Args, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0]));
- _r$45 = check[0].typ(arg0); /* */ $s = 192; case 192: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- T$1 = _r$45;
- if ($interfaceIsEqual(T$1, $pkg.Typ[0])) {
- return _;
- }
- min = 0;
- _r$46 = T$1.Underlying(); /* */ $s = 193; case 193: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- _ref$6 = _r$46;
- /* */ if ($assertType(_ref$6, ptrType$10, true)[1]) { $s = 194; continue; }
- /* */ if ($assertType(_ref$6, ptrType$13, true)[1] || $assertType(_ref$6, ptrType$12, true)[1]) { $s = 195; continue; }
- /* */ $s = 196; continue;
- /* if ($assertType(_ref$6, ptrType$10, true)[1]) { */ case 194:
- min = 2;
- $s = 197; continue;
- /* } else if ($assertType(_ref$6, ptrType$13, true)[1] || $assertType(_ref$6, ptrType$12, true)[1]) { */ case 195:
- min = 1;
- $s = 197; continue;
- /* } else { */ case 196:
- _r$47 = arg0.Pos(); /* */ $s = 198; case 198: if($c) { $c = false; _r$47 = _r$47.$blk(); } if (_r$47 && _r$47.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$47, "cannot make %s; type must be slice, map, or channel", new sliceType([arg0])); /* */ $s = 199; case 199: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 197:
- /* */ if (nargs < min || (min + 1 >> 0) < nargs) { $s = 200; continue; }
- /* */ $s = 201; continue;
- /* if (nargs < min || (min + 1 >> 0) < nargs) { */ case 200:
- _r$48 = call[0].Pos(); /* */ $s = 202; case 202: if($c) { $c = false; _r$48 = _r$48.$blk(); } if (_r$48 && _r$48.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$48, "%s expects %d or %d arguments; found %d", new sliceType([call[0], new $Int(min), new $Int((min + 1 >> 0)), new $Int(nargs)])); /* */ $s = 203; case 203: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 201:
- sizes = sliceType$4.nil;
- _ref$7 = $subslice(call[0].Args, 1);
- _i = 0;
- /* while (true) { */ case 204:
- /* if (!(_i < _ref$7.$length)) { break; } */ if(!(_i < _ref$7.$length)) { $s = 205; continue; }
- arg$1 = ((_i < 0 || _i >= _ref$7.$length) ? $throwRuntimeError("index out of range") : _ref$7.$array[_ref$7.$offset + _i]);
- _r$49 = check[0].index(arg$1, new $Int64(-1, 4294967295)); /* */ $s = 206; case 206: if($c) { $c = false; _r$49 = _r$49.$blk(); } if (_r$49 && _r$49.$blk !== undefined) { break s; }
- _tuple$5 = _r$49; s$1 = _tuple$5[0]; ok = _tuple$5[1];
- /* */ if (ok && (s$1.$high > 0 || (s$1.$high === 0 && s$1.$low >= 0))) { $s = 207; continue; }
- /* */ $s = 208; continue;
- /* if (ok && (s$1.$high > 0 || (s$1.$high === 0 && s$1.$low >= 0))) { */ case 207:
- sizes = $append(sizes, s$1);
- /* } */ case 208:
- _i++;
- /* } */ $s = 204; continue; case 205:
- /* */ if ((sizes.$length === 2) && (x$2 = (0 >= sizes.$length ? $throwRuntimeError("index out of range") : sizes.$array[sizes.$offset + 0]), x$3 = (1 >= sizes.$length ? $throwRuntimeError("index out of range") : sizes.$array[sizes.$offset + 1]), (x$2.$high > x$3.$high || (x$2.$high === x$3.$high && x$2.$low > x$3.$low)))) { $s = 209; continue; }
- /* */ $s = 210; continue;
- /* if ((sizes.$length === 2) && (x$2 = (0 >= sizes.$length ? $throwRuntimeError("index out of range") : sizes.$array[sizes.$offset + 0]), x$3 = (1 >= sizes.$length ? $throwRuntimeError("index out of range") : sizes.$array[sizes.$offset + 1]), (x$2.$high > x$3.$high || (x$2.$high === x$3.$high && x$2.$low > x$3.$low)))) { */ case 209:
- _r$50 = (x$4 = call[0].Args, (1 >= x$4.$length ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + 1])).Pos(); /* */ $s = 211; case 211: if($c) { $c = false; _r$50 = _r$50.$blk(); } if (_r$50 && _r$50.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$50, "length and capacity swapped", new sliceType([])); /* */ $s = 212; case 212: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 210:
- x.mode = 7;
- x.typ = T$1;
- /* */ if (!(check[0].Info.Types === false)) { $s = 213; continue; }
- /* */ $s = 214; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 213:
- params = $toNativeArray($kindInterface, [T$1, $pkg.Typ[2], $pkg.Typ[2]]);
- _arg$14 = call[0].Fun;
- _r$51 = makeSig(x.typ, $subslice(new sliceType$3(params), 0, (1 + sizes.$length >> 0))); /* */ $s = 215; case 215: if($c) { $c = false; _r$51 = _r$51.$blk(); } if (_r$51 && _r$51.$blk !== undefined) { break s; }
- _arg$15 = _r$51;
- $r = check[0].recordBuiltinType(_arg$14, _arg$15); /* */ $s = 216; case 216: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 214:
- $s = 35; continue;
- /* } else if (_ref$1 === 9) { */ case 25:
- _r$52 = check[0].typ((x$5 = call[0].Args, (0 >= x$5.$length ? $throwRuntimeError("index out of range") : x$5.$array[x$5.$offset + 0]))); /* */ $s = 217; case 217: if($c) { $c = false; _r$52 = _r$52.$blk(); } if (_r$52 && _r$52.$blk !== undefined) { break s; }
- T$2 = _r$52;
- if ($interfaceIsEqual(T$2, $pkg.Typ[0])) {
- return _;
- }
- x.mode = 7;
- x.typ = new Pointer.ptr(T$2);
- /* */ if (!(check[0].Info.Types === false)) { $s = 218; continue; }
- /* */ $s = 219; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 218:
- _arg$16 = call[0].Fun;
- _r$53 = makeSig(x.typ, new sliceType$3([T$2])); /* */ $s = 220; case 220: if($c) { $c = false; _r$53 = _r$53.$blk(); } if (_r$53 && _r$53.$blk !== undefined) { break s; }
- _arg$17 = _r$53;
- $r = check[0].recordBuiltinType(_arg$16, _arg$17); /* */ $s = 221; case 221: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 219:
- $s = 35; continue;
- /* } else if (_ref$1 === 10) { */ case 26:
- T$3 = new Interface.ptr();
- _r$54 = check[0].assignment(x, T$3); /* */ $s = 224; case 224: if($c) { $c = false; _r$54 = _r$54.$blk(); } if (_r$54 && _r$54.$blk !== undefined) { break s; }
- /* */ if (!_r$54) { $s = 222; continue; }
- /* */ $s = 223; continue;
- /* if (!_r$54) { */ case 222:
- assert(x.mode === 0);
- return _;
- /* } */ case 223:
- x.mode = 1;
- /* */ if (!(check[0].Info.Types === false)) { $s = 225; continue; }
- /* */ $s = 226; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 225:
- _arg$18 = call[0].Fun;
- _r$55 = makeSig($ifaceNil, new sliceType$3([T$3])); /* */ $s = 227; case 227: if($c) { $c = false; _r$55 = _r$55.$blk(); } if (_r$55 && _r$55.$blk !== undefined) { break s; }
- _arg$19 = _r$55;
- $r = check[0].recordBuiltinType(_arg$18, _arg$19); /* */ $s = 228; case 228: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 226:
- $s = 35; continue;
- /* } else if (_ref$1 === 11 || _ref$1 === 12) { */ case 27:
- params$1 = sliceType$3.nil;
- /* */ if (nargs > 0) { $s = 229; continue; }
- /* */ $s = 230; continue;
- /* if (nargs > 0) { */ case 229:
- params$1 = $makeSlice(sliceType$3, nargs);
- i = 0;
- /* while (true) { */ case 231:
- /* if (!(i < nargs)) { break; } */ if(!(i < nargs)) { $s = 232; continue; }
- /* */ if (i > 0) { $s = 233; continue; }
- /* */ $s = 234; continue;
- /* if (i > 0) { */ case 233:
- $r = arg[0](x, i); /* */ $s = 235; case 235: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 234:
- _r$56 = check[0].assignment(x, $ifaceNil); /* */ $s = 238; case 238: if($c) { $c = false; _r$56 = _r$56.$blk(); } if (_r$56 && _r$56.$blk !== undefined) { break s; }
- /* */ if (!_r$56) { $s = 236; continue; }
- /* */ $s = 237; continue;
- /* if (!_r$56) { */ case 236:
- assert(x.mode === 0);
- return _;
- /* } */ case 237:
- ((i < 0 || i >= params$1.$length) ? $throwRuntimeError("index out of range") : params$1.$array[params$1.$offset + i] = x.typ);
- i = i + (1) >> 0;
- /* } */ $s = 231; continue; case 232:
- /* } */ case 230:
- x.mode = 1;
- /* */ if (!(check[0].Info.Types === false)) { $s = 239; continue; }
- /* */ $s = 240; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 239:
- _arg$20 = call[0].Fun;
- _r$57 = makeSig($ifaceNil, params$1); /* */ $s = 241; case 241: if($c) { $c = false; _r$57 = _r$57.$blk(); } if (_r$57 && _r$57.$blk !== undefined) { break s; }
- _arg$21 = _r$57;
- $r = check[0].recordBuiltinType(_arg$20, _arg$21); /* */ $s = 242; case 242: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 240:
- $s = 35; continue;
- /* } else if (_ref$1 === 14) { */ case 28:
- x.mode = 7;
- x.typ = new Interface.ptr();
- /* */ if (!(check[0].Info.Types === false)) { $s = 243; continue; }
- /* */ $s = 244; continue;
- /* if (!(check[0].Info.Types === false)) { */ case 243:
- _arg$22 = call[0].Fun;
- _r$58 = makeSig(x.typ, new sliceType$3([])); /* */ $s = 245; case 245: if($c) { $c = false; _r$58 = _r$58.$blk(); } if (_r$58 && _r$58.$blk !== undefined) { break s; }
- _arg$23 = _r$58;
- $r = check[0].recordBuiltinType(_arg$22, _arg$23); /* */ $s = 246; case 246: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 244:
- $s = 35; continue;
- /* } else if (_ref$1 === 15) { */ case 29:
- _r$59 = check[0].assignment(x, $ifaceNil); /* */ $s = 249; case 249: if($c) { $c = false; _r$59 = _r$59.$blk(); } if (_r$59 && _r$59.$blk !== undefined) { break s; }
- /* */ if (!_r$59) { $s = 247; continue; }
- /* */ $s = 248; continue;
- /* if (!_r$59) { */ case 247:
- assert(x.mode === 0);
- return _;
- /* } */ case 248:
- x.mode = 4;
- _r$60 = check[0].conf.alignof(x.typ); /* */ $s = 250; case 250: if($c) { $c = false; _r$60 = _r$60.$blk(); } if (_r$60 && _r$60.$blk !== undefined) { break s; }
- _r$61 = exact.MakeInt64(_r$60); /* */ $s = 251; case 251: if($c) { $c = false; _r$61 = _r$61.$blk(); } if (_r$61 && _r$61.$blk !== undefined) { break s; }
- x.val = _r$61;
- x.typ = $pkg.Typ[12];
- $s = 35; continue;
- /* } else if (_ref$1 === 16) { */ case 30:
- arg0$1 = (x$6 = call[0].Args, (0 >= x$6.$length ? $throwRuntimeError("index out of range") : x$6.$array[x$6.$offset + 0]));
- _tuple$6 = $assertType(unparen(arg0$1), ptrType$14, true); selx = _tuple$6[0];
- /* */ if (selx === ptrType$14.nil) { $s = 252; continue; }
- /* */ $s = 253; continue;
- /* if (selx === ptrType$14.nil) { */ case 252:
- _r$62 = arg0$1.Pos(); /* */ $s = 254; case 254: if($c) { $c = false; _r$62 = _r$62.$blk(); } if (_r$62 && _r$62.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$62, "%s is not a selector expression", new sliceType([arg0$1])); /* */ $s = 255; case 255: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].use(new sliceType$5([arg0$1])); /* */ $s = 256; case 256: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 253:
- $r = check[0].expr(x, selx.X); /* */ $s = 257; case 257: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return _;
- }
- _r$63 = derefStructPtr(x.typ); /* */ $s = 258; case 258: if($c) { $c = false; _r$63 = _r$63.$blk(); } if (_r$63 && _r$63.$blk !== undefined) { break s; }
- base = _r$63;
- sel = selx.Sel.Name;
- _tuple$7 = LookupFieldOrMethod(base, false, check[0].pkg, sel); obj = _tuple$7[0]; index = _tuple$7[1]; indirect = _tuple$7[2];
- _ref$8 = obj;
- /* */ if (_ref$8 === $ifaceNil) { $s = 259; continue; }
- /* */ if ($assertType(_ref$8, ptrType$6, true)[1]) { $s = 260; continue; }
- /* */ $s = 261; continue;
- /* if (_ref$8 === $ifaceNil) { */ case 259:
- _r$64 = x.pos(); /* */ $s = 262; case 262: if($c) { $c = false; _r$64 = _r$64.$blk(); } if (_r$64 && _r$64.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$64, "%s has no single field %s", new sliceType([base, new $String(sel)])); /* */ $s = 263; case 263: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- $s = 261; continue;
- /* } else if ($assertType(_ref$8, ptrType$6, true)[1]) { */ case 260:
- _r$65 = arg0$1.Pos(); /* */ $s = 264; case 264: if($c) { $c = false; _r$65 = _r$65.$blk(); } if (_r$65 && _r$65.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$65, "%s is a method value", new sliceType([arg0$1])); /* */ $s = 265; case 265: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 261:
- /* */ if (indirect) { $s = 266; continue; }
- /* */ $s = 267; continue;
- /* if (indirect) { */ case 266:
- _r$66 = x.pos(); /* */ $s = 268; case 268: if($c) { $c = false; _r$66 = _r$66.$blk(); } if (_r$66 && _r$66.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$66, "field %s is embedded via a pointer in %s", new sliceType([new $String(sel), base])); /* */ $s = 269; case 269: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 267:
- check[0].recordSelection(selx, 0, base, obj, index, false);
- _r$67 = check[0].conf.offsetof(base, index); /* */ $s = 270; case 270: if($c) { $c = false; _r$67 = _r$67.$blk(); } if (_r$67 && _r$67.$blk !== undefined) { break s; }
- offs = _r$67;
- x.mode = 4;
- x.val = exact.MakeInt64(offs);
- x.typ = $pkg.Typ[12];
- $s = 35; continue;
- /* } else if (_ref$1 === 17) { */ case 31:
- _r$68 = check[0].assignment(x, $ifaceNil); /* */ $s = 273; case 273: if($c) { $c = false; _r$68 = _r$68.$blk(); } if (_r$68 && _r$68.$blk !== undefined) { break s; }
- /* */ if (!_r$68) { $s = 271; continue; }
- /* */ $s = 272; continue;
- /* if (!_r$68) { */ case 271:
- assert(x.mode === 0);
- return _;
- /* } */ case 272:
- x.mode = 4;
- _r$69 = check[0].conf.sizeof(x.typ); /* */ $s = 274; case 274: if($c) { $c = false; _r$69 = _r$69.$blk(); } if (_r$69 && _r$69.$blk !== undefined) { break s; }
- _r$70 = exact.MakeInt64(_r$69); /* */ $s = 275; case 275: if($c) { $c = false; _r$70 = _r$70.$blk(); } if (_r$70 && _r$70.$blk !== undefined) { break s; }
- x.val = _r$70;
- x.typ = $pkg.Typ[12];
- $s = 35; continue;
- /* } else if (_ref$1 === 18) { */ case 32:
- if (!((x.mode === 4))) { _v$1 = true; $s = 278; continue s; }
- _r$71 = isBoolean(x.typ); /* */ $s = 279; case 279: if($c) { $c = false; _r$71 = _r$71.$blk(); } if (_r$71 && _r$71.$blk !== undefined) { break s; }
- _v$1 = !_r$71; case 278:
- /* */ if (_v$1) { $s = 276; continue; }
- /* */ $s = 277; continue;
- /* if (_v$1) { */ case 276:
- _r$72 = x.pos(); /* */ $s = 280; case 280: if($c) { $c = false; _r$72 = _r$72.$blk(); } if (_r$72 && _r$72.$blk !== undefined) { break s; }
- $r = check[0].invalidArg(_r$72, "%s is not a boolean constant", new sliceType([x])); /* */ $s = 281; case 281: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 277:
- _r$73 = x.val.Kind(); /* */ $s = 284; case 284: if($c) { $c = false; _r$73 = _r$73.$blk(); } if (_r$73 && _r$73.$blk !== undefined) { break s; }
- /* */ if (!((_r$73 === 1))) { $s = 282; continue; }
- /* */ $s = 283; continue;
- /* if (!((_r$73 === 1))) { */ case 282:
- _r$74 = x.pos(); /* */ $s = 285; case 285: if($c) { $c = false; _r$74 = _r$74.$blk(); } if (_r$74 && _r$74.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$74, "internal error: value of %s should be a boolean constant", new sliceType([x])); /* */ $s = 286; case 286: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return _;
- /* } */ case 283:
- _r$75 = exact.BoolVal(x.val); /* */ $s = 289; case 289: if($c) { $c = false; _r$75 = _r$75.$blk(); } if (_r$75 && _r$75.$blk !== undefined) { break s; }
- /* */ if (!_r$75) { $s = 287; continue; }
- /* */ $s = 288; continue;
- /* if (!_r$75) { */ case 287:
- _r$76 = call[0].Pos(); /* */ $s = 290; case 290: if($c) { $c = false; _r$76 = _r$76.$blk(); } if (_r$76 && _r$76.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$76, "%s failed", new sliceType([call[0]])); /* */ $s = 291; case 291: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 288:
- $s = 35; continue;
- /* } else if (_ref$1 === 19) { */ case 33:
- /* */ if (nargs === 0) { $s = 292; continue; }
- /* */ $s = 293; continue;
- /* if (nargs === 0) { */ case 292:
- _r$77 = call[0].Pos(); /* */ $s = 294; case 294: if($c) { $c = false; _r$77 = _r$77.$blk(); } if (_r$77 && _r$77.$blk !== undefined) { break s; }
- _arg$24 = new token.Pos(_r$77);
- $r = check[0].dump("%s: trace() without arguments", new sliceType([_arg$24])); /* */ $s = 295; case 295: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 1;
- /* break; */ $s = 35; continue;
- /* } */ case 293:
- t[0] = $clone(new operand.ptr(), operand);
- x1 = x;
- _ref$9 = call[0].Args;
- _i$1 = 0;
- /* while (true) { */ case 296:
- /* if (!(_i$1 < _ref$9.$length)) { break; } */ if(!(_i$1 < _ref$9.$length)) { $s = 297; continue; }
- arg$2 = ((_i$1 < 0 || _i$1 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$1]);
- _r$78 = check[0].rawExpr(x1, arg$2, $ifaceNil); /* */ $s = 298; case 298: if($c) { $c = false; _r$78 = _r$78.$blk(); } if (_r$78 && _r$78.$blk !== undefined) { break s; }
- _r$78;
- _r$79 = x1.pos(); /* */ $s = 299; case 299: if($c) { $c = false; _r$79 = _r$79.$blk(); } if (_r$79 && _r$79.$blk !== undefined) { break s; }
- _arg$25 = new token.Pos(_r$79);
- _arg$26 = x1;
- $r = check[0].dump("%s: %s", new sliceType([_arg$25, _arg$26])); /* */ $s = 300; case 300: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x1 = t[0];
- _i$1++;
- /* } */ $s = 296; continue; case 297:
- $s = 35; continue;
- /* } else { */ case 34:
- unreachable();
- /* } } */ case 35:
- _ = true;
- return _;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return _; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.builtin }; } $f.$ptr = $ptr; $f.S = S; $f.T = T; $f.T$1 = T$1; $f.T$2 = T$2; $f.T$3 = T$3; $f._ = _; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$16 = _arg$16; $f._arg$17 = _arg$17; $f._arg$18 = _arg$18; $f._arg$19 = _arg$19; $f._arg$2 = _arg$2; $f._arg$20 = _arg$20; $f._arg$21 = _arg$21; $f._arg$22 = _arg$22; $f._arg$23 = _arg$23; $f._arg$24 = _arg$24; $f._arg$25 = _arg$25; $f._arg$26 = _arg$26; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$4 = _r$4; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._r$42 = _r$42; $f._r$43 = _r$43; $f._r$44 = _r$44; $f._r$45 = _r$45; $f._r$46 = _r$46; $f._r$47 = _r$47; $f._r$48 = _r$48; $f._r$49 = _r$49; $f._r$5 = _r$5; $f._r$50 = _r$50; $f._r$51 = _r$51; $f._r$52 = _r$52; $f._r$53 = _r$53; $f._r$54 = _r$54; $f._r$55 = _r$55; $f._r$56 = _r$56; $f._r$57 = _r$57; $f._r$58 = _r$58; $f._r$59 = _r$59; $f._r$6 = _r$6; $f._r$60 = _r$60; $f._r$61 = _r$61; $f._r$62 = _r$62; $f._r$63 = _r$63; $f._r$64 = _r$64; $f._r$65 = _r$65; $f._r$66 = _r$66; $f._r$67 = _r$67; $f._r$68 = _r$68; $f._r$69 = _r$69; $f._r$7 = _r$7; $f._r$70 = _r$70; $f._r$71 = _r$71; $f._r$72 = _r$72; $f._r$73 = _r$73; $f._r$74 = _r$74; $f._r$75 = _r$75; $f._r$76 = _r$76; $f._r$77 = _r$77; $f._r$78 = _r$78; $f._r$79 = _r$79; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._v = _v; $f._v$1 = _v$1; $f.alist = alist; $f.arg = arg; $f.arg$1 = arg$1; $f.arg$2 = arg$2; $f.arg0 = arg0; $f.arg0$1 = arg0$1; $f.base = base; $f.bin = bin; $f.c = c; $f.call = call; $f.check = check; $f.complexT = complexT; $f.dst = dst; $f.i = i; $f.id = id; $f.index = index; $f.indirect = indirect; $f.k = k; $f.m = m; $f.min = min; $f.mode = mode; $f.msg = msg; $f.nargs = nargs; $f.obj = obj; $f.offs = offs; $f.ok = ok; $f.params = params; $f.params$1 = params$1; $f.realT = realT; $f.s = s; $f.s$1 = s$1; $f.sel = sel; $f.selx = selx; $f.sig = sig; $f.sig$1 = sig$1; $f.sizes = sizes; $f.src = src; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.typ = typ; $f.val = val; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x1 = x1; $f.y = y; $f.y$1 = y$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.builtin = function(x, call, id) { return this.$val.builtin(x, call, id); };
- makeSig = function(res, args) {
- var $ptr, _i, _r, _ref, args, i, list, param, params, res, result, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; args = $f.args; i = $f.i; list = $f.list; param = $f.param; params = $f.params; res = $f.res; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- list = $makeSlice(sliceType$1, args.$length);
- _ref = args;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- param = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + i] = NewVar(0, ptrType$1.nil, "", defaultType(param)));
- _i++;
- }
- params = NewTuple(list);
- result = ptrType$8.nil;
- /* */ if (!($interfaceIsEqual(res, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(res, $ifaceNil))) { */ case 1:
- _r = isUntyped(res); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = assert(!_r); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- result = NewTuple(new sliceType$1([NewVar(0, ptrType$1.nil, "", res)]));
- /* } */ case 2:
- return new Signature.ptr(ptrType.nil, ptrType$9.nil, params, result, false);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: makeSig }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.args = args; $f.i = i; $f.list = list; $f.param = param; $f.params = params; $f.res = res; $f.result = result; $f.$s = $s; $f.$r = $r; return $f;
- };
- implicitArrayDeref = function(typ) {
- var $ptr, _r, _tuple, _tuple$1, a, ok, ok$1, p, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; ok = $f.ok; ok$1 = $f.ok$1; p = $f.p; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tuple = $assertType(typ, ptrType$15, true); p = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _r = p.base.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r, ptrType$11, true); a = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (ok$1) { */ case 4:
- return a;
- /* } */ case 5:
- /* } */ case 2:
- return typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: implicitArrayDeref }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.ok = ok; $f.ok$1 = ok$1; $f.p = p; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- unparen = function(e) {
- var $ptr, _tuple, e, ok, p;
- while (true) {
- _tuple = $assertType(e, ptrType$16, true); p = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- return e;
- }
- e = p.X;
- }
- };
- Checker.ptr.prototype.complexArg = function(x) {
- var $ptr, _r, _r$1, _tuple, check, t, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; check = $f.check; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = x.typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0];
- if (!(t === ptrType$3.nil) && (!(((t.info & 8) === 0)) || (t.kind === 20) || (t.kind === 21))) {
- return true;
- }
- _r$1 = x.pos(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.invalidArg(_r$1, "%s must be a float32, float64, or an untyped non-complex numeric constant", new sliceType([x])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.complexArg }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.check = check; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.complexArg = function(x) { return this.$val.complexArg(x); };
- Checker.ptr.prototype.call = function(x, e) {
- var $ptr, T, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _ref$2, _tuple, _tuple$1, arg, check, e, id, n, n$1, sig, x, x$1, x$2, x$3, x$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; arg = $f.arg; check = $f.check; e = $f.e; id = $f.id; n = $f.n; n$1 = $f.n$1; sig = $f.sig; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = [check];
- e = [e];
- check[0] = this;
- $r = check[0].exprOrType(x, e[0].Fun); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = x.mode;
- /* */ if (_ref === 0) { $s = 2; continue; }
- /* */ if (_ref === 3) { $s = 3; continue; }
- /* */ if (_ref === 2) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref === 0) { */ case 2:
- $r = check[0].use(e[0].Args); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- x.expr = e[0];
- return 2;
- $s = 6; continue;
- /* } else if (_ref === 3) { */ case 3:
- T = x.typ;
- x.mode = 0;
- n = e[0].Args.$length;
- _ref$1 = n;
- /* */ if (_ref$1 === 0) { $s = 8; continue; }
- /* */ if (_ref$1 === 1) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_ref$1 === 0) { */ case 8:
- $r = check[0].errorf(e[0].Rparen, "missing argument in conversion to %s", new sliceType([T])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 11; continue;
- /* } else if (_ref$1 === 1) { */ case 9:
- $r = check[0].expr(x, (x$1 = e[0].Args, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0]))); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!((x.mode === 0))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!((x.mode === 0))) { */ case 14:
- $r = check[0].conversion(x, T); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- $s = 11; continue;
- /* } else { */ case 10:
- _r = (x$2 = e[0].Args, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3])).Pos(); /* */ $s = 17; case 17: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r, "too many arguments in conversion to %s", new sliceType([T])); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- x.expr = e[0];
- return 0;
- $s = 6; continue;
- /* } else if (_ref === 2) { */ case 4:
- id = x.id;
- _r$1 = check[0].builtin(x, e[0], id); /* */ $s = 21; case 21: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!_r$1) { */ case 19:
- x.mode = 0;
- /* } */ case 20:
- x.expr = e[0];
- if (!((x.mode === 0)) && !((x.mode === 4))) {
- check[0].context.hasCallOrRecv = true;
- }
- return ((id < 0 || id >= predeclaredFuncs.length) ? $throwRuntimeError("index out of range") : predeclaredFuncs[id]).kind;
- $s = 6; continue;
- /* } else { */ case 5:
- _r$2 = x.typ.Underlying(); /* */ $s = 22; case 22: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$2, ptrType$17, true); sig = _tuple[0];
- /* */ if (sig === ptrType$17.nil) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (sig === ptrType$17.nil) { */ case 23:
- _r$3 = x.pos(); /* */ $s = 25; case 25: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check[0].invalidOp(_r$3, "cannot call non-function %s", new sliceType([x])); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- x.expr = e[0];
- return 2;
- /* } */ case 24:
- _r$4 = unpack((function(check, e) { return function $b(x$4, i) {
- var $ptr, i, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = check[0].expr(x$4, (x$5 = e[0].Args, ((i < 0 || i >= x$5.$length) ? $throwRuntimeError("index out of range") : x$5.$array[x$5.$offset + i]))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.i = i; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- }; })(check, e), e[0].Args.$length, false); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple$1 = _r$4; arg = _tuple$1[0]; n$1 = _tuple$1[1];
- if (arg === $throwNilPointerError) {
- x.mode = 0;
- x.expr = e[0];
- return 2;
- }
- $r = check[0].arguments$(x, e[0], sig, arg, n$1); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$2 = sig.results.Len();
- if (_ref$2 === 0) {
- x.mode = 1;
- } else if (_ref$2 === 1) {
- x.mode = 7;
- x.typ = (x$4 = sig.results.vars, (0 >= x$4.$length ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + 0])).object.typ;
- } else {
- x.mode = 7;
- x.typ = sig.results;
- }
- x.expr = e[0];
- check[0].context.hasCallOrRecv = true;
- return 2;
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.call }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.arg = arg; $f.check = check; $f.e = e; $f.id = id; $f.n = n; $f.n$1 = n$1; $f.sig = sig; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.call = function(x, e) { return this.$val.call(x, e); };
- Checker.ptr.prototype.use = function(arg) {
- var $ptr, _i, _r, _ref, arg, check, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; arg = $f.arg; check = $f.check; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- check = this;
- x[0] = $clone(new operand.ptr(), operand);
- _ref = arg;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- e = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = check.rawExpr(x[0], e, $ifaceNil); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.use }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.arg = arg; $f.check = check; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.use = function(arg) { return this.$val.use(arg); };
- Checker.ptr.prototype.useGetter = function(get, n) {
- var $ptr, check, get, i, n, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; check = $f.check; get = $f.get; i = $f.i; n = $f.n; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- check = this;
- x[0] = $clone(new operand.ptr(), operand);
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; }
- $r = get(x[0], i); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.useGetter }; } $f.$ptr = $ptr; $f.check = check; $f.get = get; $f.i = i; $f.n = n; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.useGetter = function(get, n) { return this.$val.useGetter(get, n); };
- unpack = function(get, n, allowCommaOk) {
- var $ptr, _tuple, a, allowCommaOk, get, n, ok, t, x0, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _tuple = $f._tuple; a = $f.a; allowCommaOk = $f.allowCommaOk; get = $f.get; n = $f.n; ok = $f.ok; t = $f.t; x0 = $f.x0; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = [a];
- t = [t];
- x0 = [x0];
- /* */ if (n === 1) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n === 1) { */ case 1:
- x0[0] = $clone(new operand.ptr(), operand);
- $r = get(x0[0], 0); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x0[0].mode === 0) {
- return [$throwNilPointerError, 0, false];
- }
- _tuple = $assertType(x0[0].typ, ptrType$8, true); t[0] = _tuple[0]; ok = _tuple[1];
- if (ok) {
- return [(function(a, t, x0) { return function(x, i) {
- var $ptr, i, x;
- x.mode = 7;
- x.expr = x0[0].expr;
- x.typ = t[0].At(i).object.typ;
- }; })(a, t, x0), t[0].Len(), false];
- }
- if ((x0[0].mode === 6) || (x0[0].mode === 8)) {
- if (allowCommaOk) {
- a[0] = $toNativeArray($kindInterface, [x0[0].typ, $pkg.Typ[19]]);
- return [(function(a, t, x0) { return function(x, i) {
- var $ptr, i, x;
- x.mode = 7;
- x.expr = x0[0].expr;
- x.typ = ((i < 0 || i >= a[0].length) ? $throwRuntimeError("index out of range") : a[0][i]);
- }; })(a, t, x0), 2, true];
- }
- x0[0].mode = 7;
- }
- return [(function(a, t, x0) { return function(x, i) {
- var $ptr, i, x;
- if (!((i === 0))) {
- unreachable();
- }
- $copy(x, x0[0], operand);
- }; })(a, t, x0), 1, false];
- /* } */ case 2:
- return [get, n, false];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: unpack }; } $f.$ptr = $ptr; $f._tuple = _tuple; $f.a = a; $f.allowCommaOk = allowCommaOk; $f.get = get; $f.n = n; $f.ok = ok; $f.t = t; $f.x0 = x0; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.ptr.prototype.arguments$ = function(x, call, sig, arg, n) {
- var $ptr, arg, call, check, ellipsis, i, n, sig, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; arg = $f.arg; call = $f.call; check = $f.check; ellipsis = $f.ellipsis; i = $f.i; n = $f.n; sig = $f.sig; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- /* */ if (new token.Pos(call.Ellipsis).IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (new token.Pos(call.Ellipsis).IsValid()) { */ case 1:
- /* */ if ((call.Args.$length === 1) && n > 1) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ((call.Args.$length === 1) && n > 1) { */ case 3:
- $r = check.errorf(call.Ellipsis, "cannot use ... with %d-valued expression %s", new sliceType([new $Int(n), (x$1 = call.Args, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0]))])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.useGetter(arg, n); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 4:
- /* */ if (!sig.variadic) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!sig.variadic) { */ case 7:
- $r = check.errorf(call.Ellipsis, "cannot use ... in call to non-variadic %s", new sliceType([call.Fun])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.useGetter(arg, n); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 8:
- /* } */ case 2:
- i = 0;
- /* while (true) { */ case 11:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 12; continue; }
- $r = arg(x, i); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!((x.mode === 0))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!((x.mode === 0))) { */ case 14:
- ellipsis = 0;
- if ((i === (n - 1 >> 0)) && new token.Pos(call.Ellipsis).IsValid()) {
- ellipsis = call.Ellipsis;
- }
- $r = check.argument(sig, i, x, ellipsis); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- i = i + (1) >> 0;
- /* } */ $s = 11; continue; case 12:
- if (sig.variadic) {
- n = n + (1) >> 0;
- }
- /* */ if (n < sig.params.Len()) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (n < sig.params.Len()) { */ case 17:
- $r = check.errorf(call.Rparen, "too few arguments in call to %s", new sliceType([call.Fun])); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.arguments$ }; } $f.$ptr = $ptr; $f.arg = arg; $f.call = call; $f.check = check; $f.ellipsis = ellipsis; $f.i = i; $f.n = n; $f.sig = sig; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.arguments$ = function(x, call, sig, arg, n) { return this.$val.arguments$(x, call, sig, arg, n); };
- Checker.ptr.prototype.argument = function(sig, i, x, ellipsis) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _ref, check, ellipsis, i, n, sig, t, t$1, t$2, typ, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; check = $f.check; ellipsis = $f.ellipsis; i = $f.i; n = $f.n; sig = $f.sig; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; typ = $f.typ; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- n = sig.params.Len();
- typ = $ifaceNil;
- /* */ if (i < n) { $s = 1; continue; }
- /* */ if (sig.variadic) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (i < n) { */ case 1:
- typ = (x$1 = sig.params.vars, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])).object.typ;
- $s = 4; continue;
- /* } else if (sig.variadic) { */ case 2:
- typ = (x$2 = sig.params.vars, x$3 = n - 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3])).object.typ;
- $s = 4; continue;
- /* } else { */ case 3:
- _r = x.pos(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.errorf(_r, "too many arguments", new sliceType([])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 4:
- /* */ if (new token.Pos(ellipsis).IsValid()) { $s = 7; continue; }
- /* */ if (sig.variadic && i >= (n - 1 >> 0)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (new token.Pos(ellipsis).IsValid()) { */ case 7:
- /* */ if (!((i === (n - 1 >> 0)))) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!((i === (n - 1 >> 0)))) { */ case 10:
- $r = check.errorf(ellipsis, "can only use ... with matching parameter", new sliceType([])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 11:
- _r$1 = x.typ.Underlying(); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _ref = _r$1;
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$8, true)[1]) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if ($assertType(_ref, ptrType$10, true)[1]) { */ case 14:
- t = _ref.$val;
- $s = 17; continue;
- /* } else if ($assertType(_ref, ptrType$8, true)[1]) { */ case 15:
- t$1 = _ref.$val;
- $r = check.errorf(ellipsis, "cannot use ... with %d-valued expression %s", new sliceType([new $Int(t$1.Len()), x])); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- $s = 17; continue;
- /* } else { */ case 16:
- t$2 = _ref;
- _r$2 = x.pos(); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.errorf(_r$2, "cannot use %s as parameter of type %s", new sliceType([x, typ])); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 17:
- $s = 9; continue;
- /* } else if (sig.variadic && i >= (n - 1 >> 0)) { */ case 8:
- typ = $assertType(typ, ptrType$10).elem;
- /* } */ case 9:
- _r$3 = check.assignment(x, typ); /* */ $s = 23; case 23: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!_r$3 && !((x.mode === 0))) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (!_r$3 && !((x.mode === 0))) { */ case 21:
- _r$4 = x.pos(); /* */ $s = 24; case 24: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.errorf(_r$4, "cannot pass argument %s to parameter of type %s", new sliceType([x, typ])); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 22:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.argument }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.check = check; $f.ellipsis = ellipsis; $f.i = i; $f.n = n; $f.sig = sig; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.typ = typ; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.argument = function(sig, i, x, ellipsis) { return this.$val.argument(sig, i, x, ellipsis); };
- Checker.ptr.prototype.selector = function(x, e) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, check, e, exp, exp$1, exp$2, exp$3, exp$4, exp$5, exp$6, ident, index, indirect, m, obj, obj$1, obj$2, obj$3, obj$4, ok, params, pkg, sel, sig, sig$1, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; check = $f.check; e = $f.e; exp = $f.exp; exp$1 = $f.exp$1; exp$2 = $f.exp$2; exp$3 = $f.exp$3; exp$4 = $f.exp$4; exp$5 = $f.exp$5; exp$6 = $f.exp$6; ident = $f.ident; index = $f.index; indirect = $f.indirect; m = $f.m; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; obj$4 = $f.obj$4; ok = $f.ok; params = $f.params; pkg = $f.pkg; sel = $f.sel; sig = $f.sig; sig$1 = $f.sig$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- sig = [sig];
- check = this;
- obj = $ifaceNil;
- index = sliceType$6.nil;
- indirect = false;
- sel = e.Sel.Name;
- _tuple = $assertType(e.X, ptrType$5, true); ident = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _r = check.context.scope.LookupParent(ident.Name, check.pos); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = _r; obj$1 = _tuple$1[1];
- _tuple$2 = $assertType(obj$1, ptrType$18, true); pkg = _tuple$2[0];
- /* */ if (!(pkg === ptrType$18.nil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(pkg === ptrType$18.nil)) { */ case 4:
- assert(pkg.object.pkg === check.pkg);
- check.recordUse(ident, pkg);
- pkg.used = true;
- exp = pkg.imported.scope.Lookup(sel);
- /* */ if ($interfaceIsEqual(exp, $ifaceNil)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if ($interfaceIsEqual(exp, $ifaceNil)) { */ case 6:
- /* */ if (!pkg.imported.fake) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!pkg.imported.fake) { */ case 8:
- _r$1 = e.Pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "%s not declared by package %s", new sliceType([new $String(sel), ident])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- /* goto Error */ $s = 12; continue;
- /* } */ case 7:
- _r$2 = exp.Exported(); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!_r$2) { */ case 13:
- _r$3 = e.Pos(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.errorf(_r$3, "%s not exported by package %s", new sliceType([new $String(sel), ident])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- check.recordUse(e.Sel, exp);
- _ref = exp;
- if ($assertType(_ref, ptrType$2, true)[1]) {
- exp$1 = _ref.$val;
- assert(!($interfaceIsEqual(exp$1.Val(), $ifaceNil)));
- x.mode = 4;
- x.typ = exp$1.object.typ;
- x.val = exp$1.val;
- } else if ($assertType(_ref, ptrType$19, true)[1]) {
- exp$2 = _ref.$val;
- x.mode = 3;
- x.typ = exp$2.object.typ;
- } else if ($assertType(_ref, ptrType$9, true)[1]) {
- exp$3 = _ref.$val;
- x.mode = 5;
- x.typ = exp$3.object.typ;
- } else if ($assertType(_ref, ptrType$6, true)[1]) {
- exp$4 = _ref.$val;
- x.mode = 7;
- x.typ = exp$4.object.typ;
- } else if ($assertType(_ref, ptrType$20, true)[1]) {
- exp$5 = _ref.$val;
- x.mode = 2;
- x.typ = exp$5.object.typ;
- x.id = exp$5.id;
- } else {
- exp$6 = _ref;
- unreachable();
- }
- x.expr = e;
- return;
- /* } */ case 5:
- /* } */ case 2:
- $r = check.exprOrType(x, e.X); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (x.mode === 0) { */ case 19:
- /* goto Error */ $s = 12; continue;
- /* } */ case 20:
- _tuple$3 = LookupFieldOrMethod(x.typ, x.mode === 5, check.pkg, sel); obj = _tuple$3[0]; index = _tuple$3[1]; indirect = _tuple$3[2];
- /* */ if ($interfaceIsEqual(obj, $ifaceNil)) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if ($interfaceIsEqual(obj, $ifaceNil)) { */ case 21:
- /* */ if (!(index === sliceType$6.nil)) { $s = 23; continue; }
- /* */ if (indirect) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (!(index === sliceType$6.nil)) { */ case 23:
- _r$4 = e.Pos(); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$4, "ambiguous selector %s", new sliceType([new $String(sel)])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if (indirect) { */ case 24:
- _r$5 = e.Pos(); /* */ $s = 29; case 29: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$5, "%s is not in method set of %s", new sliceType([new $String(sel), x.typ])); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else { */ case 25:
- _r$6 = e.Pos(); /* */ $s = 31; case 31: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$6, "%s has no field or method %s", new sliceType([x, new $String(sel)])); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 26:
- /* goto Error */ $s = 12; continue;
- /* } */ case 22:
- /* */ if (x.mode === 3) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* if (x.mode === 3) { */ case 33:
- _tuple$4 = $assertType(obj, ptrType$6, true); m = _tuple$4[0];
- /* */ if (m === ptrType$6.nil) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (m === ptrType$6.nil) { */ case 36:
- _r$7 = e.Pos(); /* */ $s = 38; case 38: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$7, "%s has no method %s", new sliceType([x, new $String(sel)])); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 12; continue;
- /* } */ case 37:
- check.recordSelection(e, 2, x.typ, m, index, indirect);
- params = sliceType$1.nil;
- sig$1 = $assertType(m.object.typ, ptrType$17);
- if (!(sig$1.params === ptrType$8.nil)) {
- params = sig$1.params.vars;
- }
- x.mode = 7;
- x.typ = new Signature.ptr(ptrType.nil, ptrType$9.nil, NewTuple($appendSlice(new sliceType$1([NewVar(0, check.pkg, "", x.typ)]), params)), sig$1.results, sig$1.variadic);
- check.addDeclDep(m);
- $s = 35; continue;
- /* } else { */ case 34:
- _ref$1 = obj;
- /* */ if ($assertType(_ref$1, ptrType$9, true)[1]) { $s = 40; continue; }
- /* */ if ($assertType(_ref$1, ptrType$6, true)[1]) { $s = 41; continue; }
- /* */ $s = 42; continue;
- /* if ($assertType(_ref$1, ptrType$9, true)[1]) { */ case 40:
- obj$2 = _ref$1.$val;
- check.recordSelection(e, 0, x.typ, obj$2, index, indirect);
- if ((x.mode === 5) || indirect) {
- x.mode = 5;
- } else {
- x.mode = 7;
- }
- x.typ = obj$2.object.typ;
- $s = 43; continue;
- /* } else if ($assertType(_ref$1, ptrType$6, true)[1]) { */ case 41:
- obj$3 = _ref$1.$val;
- check.recordSelection(e, 1, x.typ, obj$3, index, indirect);
- x.mode = 7;
- sig[0] = $clone($assertType(obj$3.object.typ, ptrType$17), Signature);
- sig[0].recv = ptrType$9.nil;
- x.typ = sig[0];
- check.addDeclDep(obj$3);
- $s = 43; continue;
- /* } else { */ case 42:
- obj$4 = _ref$1;
- unreachable();
- /* } */ case 43:
- /* } */ case 35:
- x.expr = e;
- return;
- /* Error: */ case 12:
- x.mode = 0;
- x.expr = e;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.selector }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.check = check; $f.e = e; $f.exp = exp; $f.exp$1 = exp$1; $f.exp$2 = exp$2; $f.exp$3 = exp$3; $f.exp$4 = exp$4; $f.exp$5 = exp$5; $f.exp$6 = exp$6; $f.ident = ident; $f.index = index; $f.indirect = indirect; $f.m = m; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.obj$4 = obj$4; $f.ok = ok; $f.params = params; $f.pkg = pkg; $f.sel = sel; $f.sig = sig; $f.sig$1 = sig$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.selector = function(x, e) { return this.$val.selector(x, e); };
- Checker.ptr.prototype.addUnusedDotImport = function(scope, pkg, pos) {
- var $ptr, _entry, _key$2, _key$3, check, m, mm, pkg, pos, scope;
- check = this;
- mm = check.unusedDotImports;
- if (mm === false) {
- mm = new $Map();
- check.unusedDotImports = mm;
- }
- m = (_entry = mm[ptrType.keyFor(scope)], _entry !== undefined ? _entry.v : false);
- if (m === false) {
- m = new $Map();
- _key$2 = scope; (mm || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key$2)] = { k: _key$2, v: m };
- }
- _key$3 = pkg; (m || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$3)] = { k: _key$3, v: pos };
- };
- Checker.prototype.addUnusedDotImport = function(scope, pkg, pos) { return this.$val.addUnusedDotImport(scope, pkg, pos); };
- Checker.ptr.prototype.addDeclDep = function(to) {
- var $ptr, _entry, _tuple, check, found, from, to;
- check = this;
- from = check.context.decl;
- if (from === ptrType$21.nil) {
- return;
- }
- _tuple = (_entry = check.objMap[Object.keyFor(to)], _entry !== undefined ? [_entry.v, true] : [ptrType$21.nil, false]); found = _tuple[1];
- if (!found) {
- return;
- }
- from.addDep(to);
- };
- Checker.prototype.addDeclDep = function(to) { return this.$val.addDeclDep(to); };
- Checker.ptr.prototype.assocMethod = function(tname, meth) {
- var $ptr, _entry, _key$2, check, m, meth, tname;
- check = this;
- m = check.methods;
- if (m === false) {
- m = new $Map();
- check.methods = m;
- }
- _key$2 = tname; (m || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$2)] = { k: _key$2, v: $append((_entry = m[$String.keyFor(tname)], _entry !== undefined ? _entry.v : sliceType$7.nil), meth) };
- };
- Checker.prototype.assocMethod = function(tname, meth) { return this.$val.assocMethod(tname, meth); };
- Checker.ptr.prototype.rememberUntyped = function(e, lhs, mode, typ, val) {
- var $ptr, _key$2, check, e, lhs, m, mode, typ, val;
- check = this;
- m = check.untyped;
- if (m === false) {
- m = new $Map();
- check.untyped = m;
- }
- _key$2 = e; (m || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key$2)] = { k: _key$2, v: new exprInfo.ptr(lhs, mode, typ, val) };
- };
- Checker.prototype.rememberUntyped = function(e, lhs, mode, typ, val) { return this.$val.rememberUntyped(e, lhs, mode, typ, val); };
- Checker.ptr.prototype.later = function(name, decl, sig, body) {
- var $ptr, body, check, decl, name, sig;
- check = this;
- check.funcs = $append(check.funcs, new funcInfo.ptr(name, decl, sig, body));
- };
- Checker.prototype.later = function(name, decl, sig, body) { return this.$val.later(name, decl, sig, body); };
- Checker.ptr.prototype.delay = function(f) {
- var $ptr, check, f;
- check = this;
- check.delayed = $append(check.delayed, f);
- };
- Checker.prototype.delay = function(f) { return this.$val.delay(f); };
- NewChecker = function(conf, fset, pkg, info) {
- var $ptr, conf, fset, info, pkg;
- if (conf === ptrType$7.nil) {
- conf = new Config.ptr();
- }
- if (conf.Packages === false) {
- conf.Packages = new $Map();
- }
- if (info === ptrType$4.nil) {
- info = new Info.ptr();
- }
- return new Checker.ptr(conf, fset, pkg, info, new $Map(), sliceType$8.nil, false, $ifaceNil, false, false, sliceType$9.nil, sliceType$10.nil, new context.ptr(), 0, 0);
- };
- $pkg.NewChecker = NewChecker;
- Checker.ptr.prototype.initFiles = function(files) {
- var $ptr, _i, _ref, _ref$1, check, file, files, name, pkg, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; _ref$1 = $f._ref$1; check = $f.check; file = $f.file; files = $f.files; name = $f.name; pkg = $f.pkg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- check.files = sliceType$8.nil;
- check.unusedDotImports = false;
- check.firstErr = $ifaceNil;
- check.methods = false;
- check.untyped = false;
- check.funcs = sliceType$9.nil;
- check.delayed = sliceType$10.nil;
- pkg = check.pkg;
- _ref = files;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- file = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- name = file.Name.Name;
- _ref$1 = pkg.name;
- /* */ if (_ref$1 === "") { $s = 3; continue; }
- /* */ if (_ref$1 === name) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref$1 === "") { */ case 3:
- /* */ if (!(name === "_")) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!(name === "_")) { */ case 7:
- pkg.name = name;
- $s = 9; continue;
- /* } else { */ case 8:
- $r = check.errorf(file.Name.Pos(), "invalid package name _", new sliceType([])); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- check.files = $append(check.files, file);
- $s = 6; continue;
- /* } else if (_ref$1 === name) { */ case 4:
- check.files = $append(check.files, file);
- $s = 6; continue;
- /* } else { */ case 5:
- $r = check.errorf(file.Package, "package %s; expected %s", new sliceType([new $String(name), new $String(pkg.name)])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.initFiles }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f._ref$1 = _ref$1; $f.check = check; $f.file = file; $f.files = files; $f.name = name; $f.pkg = pkg; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.initFiles = function(files) { return this.$val.initFiles(files); };
- Checker.ptr.prototype.handleBailout = function(err) {
- var $ptr, _ref, check, err, p, p$1;
- check = this;
- _ref = $recover();
- if (_ref === $ifaceNil || $assertType(_ref, bailout, true)[1]) {
- p = _ref;
- err.$set(check.firstErr);
- } else {
- p$1 = _ref;
- $panic(p$1);
- }
- };
- Checker.prototype.handleBailout = function(err) { return this.$val.handleBailout(err); };
- Checker.ptr.prototype.Files = function(files) {
- var $ptr, _i, _r, _ref, check, err, f, files, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; check = $f.check; err = $f.err; f = $f.f; files = $f.files; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- err[0] = $ifaceNil;
- check = this;
- $deferred.push([$methodVal(check, "handleBailout"), [(err.$ptr || (err.$ptr = new ptrType$24(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, err)))]]);
- $r = check.initFiles(files); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.collectObjects(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = check.resolveOrder(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.packageObjects(_r); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.functionBodies(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.initOrder(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!check.conf.DisableUnusedImportCheck) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!check.conf.DisableUnusedImportCheck) { */ case 7:
- $r = check.unusedImports(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- _ref = check.delayed;
- _i = 0;
- /* while (true) { */ case 10:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 11; continue; }
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = f(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 10; continue; case 11:
- $r = check.recordUntyped(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- check.pkg.complete = true;
- return err[0];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err[0]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.Files }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.check = check; $f.err = err; $f.f = f; $f.files = files; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.Files = function(files) { return this.$val.Files(files); };
- Checker.ptr.prototype.recordUntyped = function() {
- var $ptr, _entry, _i, _keys, _ref, check, info, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _ref = $f._ref; check = $f.check; info = $f.info; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- if (true && check.Info.Types === false) {
- return;
- }
- _ref = check.untyped;
- _i = 0;
- _keys = $keys(_ref);
- /* while (true) { */ case 1:
- /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 2; continue; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- /* continue; */ $s = 1; continue;
- }
- x = _entry.k;
- info = $clone(_entry.v, exprInfo);
- $r = check.recordTypeAndValue(x, info.mode, info.typ, info.val); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.recordUntyped }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._ref = _ref; $f.check = check; $f.info = info; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.recordUntyped = function() { return this.$val.recordUntyped(); };
- Checker.ptr.prototype.recordTypeAndValue = function(x, mode, typ, val) {
- var $ptr, _key$2, _r, _v, check, m, mode, typ, val, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key$2 = $f._key$2; _r = $f._r; _v = $f._v; check = $f.check; m = $f.m; mode = $f.mode; typ = $f.typ; val = $f.val; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- assert(!($interfaceIsEqual(x, $ifaceNil)));
- assert(!($interfaceIsEqual(typ, $ifaceNil)));
- if (mode === 0) {
- return;
- }
- assert(!($interfaceIsEqual(typ, $ifaceNil)));
- /* */ if (mode === 4) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (mode === 4) { */ case 1:
- assert(!($interfaceIsEqual(val, $ifaceNil)));
- if ($interfaceIsEqual(typ, $pkg.Typ[0])) { _v = true; $s = 3; continue s; }
- _r = isConstType(typ); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 3:
- $r = assert(_v); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- m = check.Info.Types;
- if (!(m === false)) {
- _key$2 = x; (m || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key$2)] = { k: _key$2, v: new TypeAndValue.ptr(mode, typ, val) };
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.recordTypeAndValue }; } $f.$ptr = $ptr; $f._key$2 = _key$2; $f._r = _r; $f._v = _v; $f.check = check; $f.m = m; $f.mode = mode; $f.typ = typ; $f.val = val; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.recordTypeAndValue = function(x, mode, typ, val) { return this.$val.recordTypeAndValue(x, mode, typ, val); };
- Checker.ptr.prototype.recordBuiltinType = function(f, sig) {
- var $ptr, _ref, check, f, p, p$1, p$2, sig, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; check = $f.check; f = $f.f; p = $f.p; p$1 = $f.p$1; p$2 = $f.p$2; sig = $f.sig; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- /* while (true) { */ case 1:
- $r = check.recordTypeAndValue(f, 2, sig, $ifaceNil); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = f;
- if ($assertType(_ref, ptrType$5, true)[1]) {
- p = _ref.$val;
- return;
- } else if ($assertType(_ref, ptrType$16, true)[1]) {
- p$1 = _ref.$val;
- f = p$1.X;
- } else {
- p$2 = _ref;
- unreachable();
- }
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.recordBuiltinType }; } $f.$ptr = $ptr; $f._ref = _ref; $f.check = check; $f.f = f; $f.p = p; $f.p$1 = p$1; $f.p$2 = p$2; $f.sig = sig; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.recordBuiltinType = function(f, sig) { return this.$val.recordBuiltinType(f, sig); };
- Checker.ptr.prototype.recordCommaOkTypes = function(x, a) {
- var $ptr, _entry, _key$2, _r, _r$1, _r$2, _r$3, _tuple, _v, _v$1, a, check, m, p, pos, tv, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$2 = $f._key$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _v = $f._v; _v$1 = $f._v$1; a = $f.a; check = $f.check; m = $f.m; p = $f.p; pos = $f.pos; tv = $f.tv; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- a = $clone(a, arrayType);
- assert(!($interfaceIsEqual(x, $ifaceNil)));
- if ($interfaceIsEqual(a[0], $ifaceNil) || $interfaceIsEqual(a[1], $ifaceNil)) {
- return;
- }
- _r = isTyped(a[0]); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- if (!(_r)) { _v$1 = false; $s = 2; continue s; }
- _r$1 = isTyped(a[1]); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v$1 = _r$1; case 2:
- if (!(_v$1)) { _v = false; $s = 1; continue s; }
- _r$2 = isBoolean(a[1]); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2; case 1:
- $r = assert(_v); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- m = check.Info.Types;
- /* */ if (!(m === false)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!(m === false)) { */ case 7:
- /* while (true) { */ case 9:
- tv = $clone((_entry = m[ast.Expr.keyFor(x)], _entry !== undefined ? _entry.v : new TypeAndValue.ptr()), TypeAndValue);
- assert(!($interfaceIsEqual(tv.Type, $ifaceNil)));
- _r$3 = x.Pos(); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- pos = _r$3;
- tv.Type = NewTuple(new sliceType$1([NewVar(pos, check.pkg, "", a[0]), NewVar(pos, check.pkg, "", a[1])]));
- _key$2 = x; (m || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key$2)] = { k: _key$2, v: $clone(tv, TypeAndValue) };
- _tuple = $assertType(x, ptrType$16, true); p = _tuple[0];
- if (p === ptrType$16.nil) {
- /* break; */ $s = 10; continue;
- }
- x = p.X;
- /* } */ $s = 9; continue; case 10:
- /* } */ case 8:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.recordCommaOkTypes }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$2 = _key$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._v = _v; $f._v$1 = _v$1; $f.a = a; $f.check = check; $f.m = m; $f.p = p; $f.pos = pos; $f.tv = tv; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.recordCommaOkTypes = function(x, a) { return this.$val.recordCommaOkTypes(x, a); };
- Checker.ptr.prototype.recordDef = function(id, obj) {
- var $ptr, _key$2, check, id, m, obj;
- check = this;
- assert(!(id === ptrType$5.nil));
- m = check.Info.Defs;
- if (!(m === false)) {
- _key$2 = id; (m || $throwRuntimeError("assignment to entry in nil map"))[ptrType$5.keyFor(_key$2)] = { k: _key$2, v: obj };
- }
- };
- Checker.prototype.recordDef = function(id, obj) { return this.$val.recordDef(id, obj); };
- Checker.ptr.prototype.recordUse = function(id, obj) {
- var $ptr, _key$2, check, id, m, obj;
- check = this;
- assert(!(id === ptrType$5.nil));
- assert(!($interfaceIsEqual(obj, $ifaceNil)));
- m = check.Info.Uses;
- if (!(m === false)) {
- _key$2 = id; (m || $throwRuntimeError("assignment to entry in nil map"))[ptrType$5.keyFor(_key$2)] = { k: _key$2, v: obj };
- }
- };
- Checker.prototype.recordUse = function(id, obj) { return this.$val.recordUse(id, obj); };
- Checker.ptr.prototype.recordImplicit = function(node, obj) {
- var $ptr, _key$2, check, m, node, obj;
- check = this;
- assert(!($interfaceIsEqual(node, $ifaceNil)));
- assert(!($interfaceIsEqual(obj, $ifaceNil)));
- m = check.Info.Implicits;
- if (!(m === false)) {
- _key$2 = node; (m || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$2)] = { k: _key$2, v: obj };
- }
- };
- Checker.prototype.recordImplicit = function(node, obj) { return this.$val.recordImplicit(node, obj); };
- Checker.ptr.prototype.recordSelection = function(x, kind, recv, obj, index, indirect) {
- var $ptr, _key$2, check, index, indirect, kind, m, obj, recv, x;
- check = this;
- assert(!($interfaceIsEqual(obj, $ifaceNil)) && ($interfaceIsEqual(recv, $ifaceNil) || index.$length > 0));
- check.recordUse(x.Sel, obj);
- m = check.Info.Selections;
- if (!(m === false)) {
- _key$2 = x; (m || $throwRuntimeError("assignment to entry in nil map"))[ptrType$14.keyFor(_key$2)] = { k: _key$2, v: new Selection.ptr(kind, recv, obj, index, indirect) };
- }
- };
- Checker.prototype.recordSelection = function(x, kind, recv, obj, index, indirect) { return this.$val.recordSelection(x, kind, recv, obj, index, indirect); };
- Checker.ptr.prototype.recordScope = function(node, scope) {
- var $ptr, _key$2, check, m, node, scope;
- check = this;
- assert(!($interfaceIsEqual(node, $ifaceNil)));
- assert(!(scope === ptrType.nil));
- m = check.Info.Scopes;
- if (!(m === false)) {
- _key$2 = node; (m || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$2)] = { k: _key$2, v: scope };
- }
- };
- Checker.prototype.recordScope = function(node, scope) { return this.$val.recordScope(node, scope); };
- Checker.ptr.prototype.conversion = function(x, T) {
- var $ptr, T, _r, _r$1, _r$10, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _v, _v$1, _v$2, _v$3, check, codepoint, constArg, final$1, i, ok, ok$1, t, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; check = $f.check; codepoint = $f.codepoint; constArg = $f.constArg; final$1 = $f.final$1; i = $f.i; ok = $f.ok; ok$1 = $f.ok$1; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- constArg = x.mode === 4;
- ok = false;
- if (!(constArg)) { _v = false; $s = 4; continue s; }
- _r = isConstType(T); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 4:
- /* */ if (_v) { $s = 1; continue; }
- _r$1 = x.convertibleTo(check.conf, T); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_v) { */ case 1:
- _r$2 = T.Underlying(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- t = $assertType(_r$2, ptrType$3);
- _r$3 = representableConst(x.val, check.conf, t.kind, (x.$ptr_val || (x.$ptr_val = new ptrType$25(function() { return this.$target.val; }, function($v) { this.$target.val = $v; }, x)))); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3) { $s = 8; continue; }
- _r$4 = isInteger(x.typ); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- if (!(_r$4)) { _v$1 = false; $s = 12; continue s; }
- _r$5 = isString(t); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _v$1 = _r$5; case 12:
- /* */ if (_v$1) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_r$3) { */ case 8:
- ok = true;
- $s = 10; continue;
- /* } else if (_v$1) { */ case 9:
- codepoint = new $Int64(-1, 4294967295);
- _r$6 = exact.Int64Val(x.val); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple = _r$6; i = _tuple[0]; ok$1 = _tuple[1];
- /* */ if (ok$1) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (ok$1) { */ case 16:
- codepoint = i;
- /* } */ case 17:
- x.val = exact.MakeString($encodeRune(codepoint.$low));
- ok = true;
- /* } */ case 10:
- $s = 3; continue;
- /* } else if (_r$1) { */ case 2:
- x.mode = 7;
- ok = true;
- /* } */ case 3:
- /* */ if (!ok) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!ok) { */ case 18:
- _r$7 = x.pos(); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $r = check.errorf(_r$7, "cannot convert %s to %s", new sliceType([x, T])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 19:
- final$1 = x.typ;
- _r$8 = isUntyped(x.typ); /* */ $s = 24; case 24: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- /* */ if (_r$8) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (_r$8) { */ case 22:
- final$1 = T;
- _r$9 = IsInterface(T); /* */ $s = 28; case 28: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- if (_r$9) { _v$2 = true; $s = 27; continue s; }
- if (!(constArg)) { _v$3 = false; $s = 29; continue s; }
- _r$10 = isConstType(T); /* */ $s = 30; case 30: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _v$3 = !_r$10; case 29:
- _v$2 = _v$3; case 27:
- /* */ if (_v$2) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if (_v$2) { */ case 25:
- final$1 = defaultType(x.typ);
- /* } */ case 26:
- $r = check.updateExprType(x.expr, final$1, true); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 23:
- x.typ = T;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.conversion }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f.check = check; $f.codepoint = codepoint; $f.constArg = constArg; $f.final$1 = final$1; $f.i = i; $f.ok = ok; $f.ok$1 = ok$1; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.conversion = function(x, T) { return this.$val.conversion(x, T); };
- operand.ptr.prototype.convertibleTo = function(conf, T) {
- var $ptr, T, T$1, Tu, V, V$1, Vu, _arg, _arg$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, _v, _v$1, _v$10, _v$2, _v$3, _v$4, _v$5, _v$6, _v$7, _v$8, _v$9, conf, ok, ok$1, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; T$1 = $f.T$1; Tu = $f.Tu; V = $f.V; V$1 = $f.V$1; Vu = $f.Vu; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; _v$1 = $f._v$1; _v$10 = $f._v$10; _v$2 = $f._v$2; _v$3 = $f._v$3; _v$4 = $f._v$4; _v$5 = $f._v$5; _v$6 = $f._v$6; _v$7 = $f._v$7; _v$8 = $f._v$8; _v$9 = $f._v$9; conf = $f.conf; ok = $f.ok; ok$1 = $f.ok$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = x.assignableTo(conf, T); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r) { */ case 1:
- return true;
- /* } */ case 2:
- V = x.typ;
- _r$1 = V.Underlying(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- Vu = _r$1;
- _r$2 = T.Underlying(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- Tu = _r$2;
- _r$3 = Identical(Vu, Tu); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_r$3) { */ case 6:
- return true;
- /* } */ case 7:
- _tuple = $assertType(V, ptrType$15, true); V$1 = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (ok) { */ case 9:
- _tuple$1 = $assertType(T, ptrType$15, true); T$1 = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (ok$1) { */ case 11:
- _r$4 = V$1.base.Underlying(); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg = _r$4;
- _r$5 = T$1.base.Underlying(); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$1 = _r$5;
- _r$6 = Identical(_arg, _arg$1); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- /* */ if (_r$6) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (_r$6) { */ case 13:
- return true;
- /* } */ case 14:
- /* } */ case 12:
- /* } */ case 10:
- _r$7 = isInteger(V); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- if (_r$7) { _v$1 = true; $s = 21; continue s; }
- _r$8 = isFloat(V); /* */ $s = 23; case 23: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _v$1 = _r$8; case 21:
- if (!(_v$1)) { _v = false; $s = 20; continue s; }
- _r$9 = isInteger(T); /* */ $s = 25; case 25: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- if (_r$9) { _v$2 = true; $s = 24; continue s; }
- _r$10 = isFloat(T); /* */ $s = 26; case 26: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _v$2 = _r$10; case 24:
- _v = _v$2; case 20:
- /* */ if (_v) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (_v) { */ case 18:
- return true;
- /* } */ case 19:
- _r$11 = isComplex(V); /* */ $s = 30; case 30: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- if (!(_r$11)) { _v$3 = false; $s = 29; continue s; }
- _r$12 = isComplex(T); /* */ $s = 31; case 31: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _v$3 = _r$12; case 29:
- /* */ if (_v$3) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (_v$3) { */ case 27:
- return true;
- /* } */ case 28:
- _r$13 = isInteger(V); /* */ $s = 36; case 36: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- if (_r$13) { _v$5 = true; $s = 35; continue s; }
- _r$14 = isBytesOrRunes(Vu); /* */ $s = 37; case 37: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _v$5 = _r$14; case 35:
- if (!(_v$5)) { _v$4 = false; $s = 34; continue s; }
- _r$15 = isString(T); /* */ $s = 38; case 38: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _v$4 = _r$15; case 34:
- /* */ if (_v$4) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (_v$4) { */ case 32:
- return true;
- /* } */ case 33:
- _r$16 = isString(V); /* */ $s = 42; case 42: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- if (!(_r$16)) { _v$6 = false; $s = 41; continue s; }
- _r$17 = isBytesOrRunes(Tu); /* */ $s = 43; case 43: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _v$6 = _r$17; case 41:
- /* */ if (_v$6) { $s = 39; continue; }
- /* */ $s = 40; continue;
- /* if (_v$6) { */ case 39:
- return true;
- /* } */ case 40:
- _r$18 = isPointer(Vu); /* */ $s = 48; case 48: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- if (_r$18) { _v$8 = true; $s = 47; continue s; }
- _r$19 = isUintptr(Vu); /* */ $s = 49; case 49: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- _v$8 = _r$19; case 47:
- if (!(_v$8)) { _v$7 = false; $s = 46; continue s; }
- _r$20 = isUnsafePointer(T); /* */ $s = 50; case 50: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- _v$7 = _r$20; case 46:
- /* */ if (_v$7) { $s = 44; continue; }
- /* */ $s = 45; continue;
- /* if (_v$7) { */ case 44:
- return true;
- /* } */ case 45:
- _r$21 = isUnsafePointer(V); /* */ $s = 54; case 54: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- if (!(_r$21)) { _v$9 = false; $s = 53; continue s; }
- _r$22 = isPointer(Tu); /* */ $s = 56; case 56: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- if (_r$22) { _v$10 = true; $s = 55; continue s; }
- _r$23 = isUintptr(Tu); /* */ $s = 57; case 57: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _v$10 = _r$23; case 55:
- _v$9 = _v$10; case 53:
- /* */ if (_v$9) { $s = 51; continue; }
- /* */ $s = 52; continue;
- /* if (_v$9) { */ case 51:
- return true;
- /* } */ case 52:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: operand.ptr.prototype.convertibleTo }; } $f.$ptr = $ptr; $f.T = T; $f.T$1 = T$1; $f.Tu = Tu; $f.V = V; $f.V$1 = V$1; $f.Vu = Vu; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f._v$1 = _v$1; $f._v$10 = _v$10; $f._v$2 = _v$2; $f._v$3 = _v$3; $f._v$4 = _v$4; $f._v$5 = _v$5; $f._v$6 = _v$6; $f._v$7 = _v$7; $f._v$8 = _v$8; $f._v$9 = _v$9; $f.conf = conf; $f.ok = ok; $f.ok$1 = ok$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.prototype.convertibleTo = function(conf, T) { return this.$val.convertibleTo(conf, T); };
- isUintptr = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && (t.kind === 12);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isUintptr }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isUnsafePointer = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && (t.kind === 18);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isUnsafePointer }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isPointer = function(typ) {
- var $ptr, _r, _tuple, ok, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$15, true); ok = _tuple[1];
- return ok;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isPointer }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isBytesOrRunes = function(typ) {
- var $ptr, _r, _tuple, _tuple$1, ok, ok$1, s, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; ok = $f.ok; ok$1 = $f.ok$1; s = $f.s; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tuple = $assertType(typ, ptrType$10, true); s = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _r = s.elem.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r, ptrType$3, true); t = _tuple$1[0]; ok$1 = _tuple$1[1];
- return ok$1 && ((t.kind === 8) || (t.kind === 5));
- /* } */ case 2:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isBytesOrRunes }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.ok = ok; $f.ok$1 = ok$1; $f.s = s; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.ptr.prototype.reportAltDecl = function(obj) {
- var $ptr, _arg, _arg$1, _r, _r$1, check, obj, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; check = $f.check; obj = $f.obj; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = obj.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- pos = _r;
- /* */ if (new token.Pos(pos).IsValid()) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (new token.Pos(pos).IsValid()) { */ case 2:
- _arg = pos;
- _r$1 = obj.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$1);
- $r = check.errorf(_arg, "\tother declaration of %s", new sliceType([_arg$1])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.reportAltDecl }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f.check = check; $f.obj = obj; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.reportAltDecl = function(obj) { return this.$val.reportAltDecl(obj); };
- Checker.ptr.prototype.declare = function(scope, id, obj, pos) {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$2, _r$3, alt, check, id, obj, pos, scope, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; alt = $f.alt; check = $f.check; id = $f.id; obj = $f.obj; pos = $f.pos; scope = $f.scope; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = obj.Name(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!(_r === "_")) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(_r === "_")) { */ case 1:
- _r$1 = scope.Insert(obj); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- alt = _r$1;
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil))) { */ case 5:
- _r$2 = obj.Pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg = _r$2;
- _r$3 = obj.Name(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$3);
- $r = check.errorf(_arg, "%s redeclared in this block", new sliceType([_arg$1])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.reportAltDecl(alt); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 6:
- $r = obj.setScopePos(pos); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- if (!(id === ptrType$5.nil)) {
- check.recordDef(id, obj);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.declare }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.alt = alt; $f.check = check; $f.id = id; $f.obj = obj; $f.pos = pos; $f.scope = scope; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.declare = function(scope, id, obj, pos) { return this.$val.declare(scope, id, obj, pos); };
- Checker.ptr.prototype.objDecl = function(obj, def$1, path$1) {
- var $ptr, _arg, _arg$1, _entry, _r, _r$1, _r$2, _ref, check, d, def$1, obj, obj$1, obj$2, obj$3, obj$4, obj$5, path$1, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; check = $f.check; d = $f.d; def$1 = $f.def$1; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; obj$4 = $f.obj$4; obj$5 = $f.obj$5; path$1 = $f.path$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- check = [check];
- obj = [obj];
- check[0] = this;
- _r = obj[0].Type(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(_r, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(_r, $ifaceNil))) { */ case 1:
- return;
- /* } */ case 2:
- d = (_entry = check[0].objMap[Object.keyFor(obj[0])], _entry !== undefined ? _entry.v : ptrType$21.nil);
- /* */ if (d === ptrType$21.nil) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (d === ptrType$21.nil) { */ case 4:
- _r$1 = obj[0].Pos(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg = new token.Pos(_r$1);
- _r$2 = obj[0].Name(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$2);
- $r = check[0].dump("%s: %s should have been declared", new sliceType([_arg, _arg$1])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- unreachable();
- /* } */ case 5:
- $deferred.push([(function(check, obj) { return function(ctxt) {
- var $ptr, ctxt;
- $copy(check[0].context, ctxt, context);
- }; })(check, obj), [$clone(check[0].context, context)]]);
- $copy(check[0].context, new context.ptr(ptrType$21.nil, d.file, $ifaceNil, ptrType$17.nil, false, false), context);
- _ref = obj[0];
- /* */ if ($assertType(_ref, ptrType$2, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$19, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$6, true)[1]) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ($assertType(_ref, ptrType$2, true)[1]) { */ case 9:
- obj$1 = _ref.$val;
- check[0].context.decl = d;
- $r = check[0].constDecl(obj$1, d.typ, d.init); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 10:
- obj$2 = _ref.$val;
- check[0].context.decl = d;
- $r = check[0].varDecl(obj$2, d.lhs, d.typ, d.init); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$19, true)[1]) { */ case 11:
- obj$3 = _ref.$val;
- $r = check[0].typeDecl(obj$3, d.typ, def$1, path$1); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$6, true)[1]) { */ case 12:
- obj$4 = _ref.$val;
- $r = check[0].funcDecl(obj$4, d); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else { */ case 13:
- obj$5 = _ref;
- unreachable();
- /* } */ case 14:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.objDecl }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.check = check; $f.d = d; $f.def$1 = def$1; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.obj$4 = obj$4; $f.obj$5 = obj$5; $f.path$1 = path$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.objDecl = function(obj, def$1, path$1) { return this.$val.objDecl(obj, def$1, path$1); };
- Checker.ptr.prototype.constDecl = function(obj, typ, init$1) {
- var $ptr, _r, _r$1, _r$2, check, init$1, obj, t, typ, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; check = $f.check; init$1 = $f.init$1; obj = $f.obj; t = $f.t; typ = $f.typ; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- check = [check];
- x = [x];
- check[0] = this;
- assert($interfaceIsEqual(obj.object.typ, $ifaceNil));
- if (obj.visited) {
- obj.object.typ = $pkg.Typ[0];
- return;
- }
- obj.visited = true;
- assert($interfaceIsEqual(check[0].context.iota, $ifaceNil));
- check[0].context.iota = obj.val;
- $deferred.push([(function(check, x) { return function() {
- var $ptr;
- check[0].context.iota = $ifaceNil;
- }; })(check, x), []]);
- obj.val = exact.MakeUnknown();
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 1:
- _r = check[0].typ(typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- t = _r;
- _r$1 = isConstType(t); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!_r$1) { */ case 4:
- _r$2 = typ.Pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$2, "invalid constant type %s", new sliceType([t])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- obj.object.typ = $pkg.Typ[0];
- return;
- /* } */ case 5:
- obj.object.typ = t;
- /* } */ case 2:
- x[0] = $clone(new operand.ptr(), operand);
- /* */ if (!($interfaceIsEqual(init$1, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(init$1, $ifaceNil))) { */ case 9:
- $r = check[0].expr(x[0], init$1); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- $r = check[0].initConst(obj, x[0]); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.constDecl }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.check = check; $f.init$1 = init$1; $f.obj = obj; $f.t = t; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.constDecl = function(obj, typ, init$1) { return this.$val.constDecl(obj, typ, init$1); };
- Checker.ptr.prototype.varDecl = function(obj, lhs, typ, init$1) {
- var $ptr, _r, _r$1, check, init$1, lhs, obj, typ, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; check = $f.check; init$1 = $f.init$1; lhs = $f.lhs; obj = $f.obj; typ = $f.typ; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- check = this;
- assert($interfaceIsEqual(obj.object.typ, $ifaceNil));
- if (obj.visited) {
- obj.object.typ = $pkg.Typ[0];
- return;
- }
- obj.visited = true;
- assert($interfaceIsEqual(check.context.iota, $ifaceNil));
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 1:
- _r = check.typ(typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- obj.object.typ = _r;
- /* } */ case 2:
- if ($interfaceIsEqual(init$1, $ifaceNil)) {
- if ($interfaceIsEqual(typ, $ifaceNil)) {
- obj.object.typ = $pkg.Typ[0];
- }
- return;
- }
- /* */ if (lhs === sliceType$1.nil || (lhs.$length === 1)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (lhs === sliceType$1.nil || (lhs.$length === 1)) { */ case 4:
- assert(lhs === sliceType$1.nil || (0 >= lhs.$length ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + 0]) === obj);
- x[0] = $clone(new operand.ptr(), operand);
- $r = check.expr(x[0], init$1); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = check.initVar(obj, x[0], false); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- return;
- /* } */ case 5:
- $r = check.initVars(lhs, new sliceType$5([init$1]), 0); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.varDecl }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.check = check; $f.init$1 = init$1; $f.lhs = lhs; $f.obj = obj; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.varDecl = function(obj, lhs, typ, init$1) { return this.$val.varDecl(obj, lhs, typ, init$1); };
- underlying = function(typ) {
- var $ptr, _tuple, n, typ;
- while (true) {
- _tuple = $assertType(typ, ptrType$26, true); n = _tuple[0];
- if (n === ptrType$26.nil) {
- break;
- }
- typ = n.underlying;
- }
- return typ;
- };
- Named.ptr.prototype.setUnderlying = function(typ) {
- var $ptr, n, typ;
- n = this;
- if (!(n === ptrType$26.nil)) {
- n.underlying = typ;
- }
- };
- Named.prototype.setUnderlying = function(typ) { return this.$val.setUnderlying(typ); };
- Checker.ptr.prototype.typeDecl = function(obj, typ, def$1, path$1) {
- var $ptr, _r, check, def$1, named, obj, path$1, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; check = $f.check; def$1 = $f.def$1; named = $f.named; obj = $f.obj; path$1 = $f.path$1; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- assert($interfaceIsEqual(obj.object.typ, $ifaceNil));
- assert($interfaceIsEqual(check.context.iota, $ifaceNil));
- named = new Named.ptr(obj, $ifaceNil, sliceType$7.nil);
- def$1.setUnderlying(named);
- obj.object.typ = named;
- _r = check.typExpr(typ, named, $append(path$1, obj)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- named.underlying = underlying(named.underlying);
- $r = check.addMethodDecls(obj); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.typeDecl }; } $f.$ptr = $ptr; $f._r = _r; $f.check = check; $f.def$1 = def$1; $f.named = named; $f.obj = obj; $f.path$1 = path$1; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.typeDecl = function(obj, typ, def$1, path$1) { return this.$val.typeDecl(obj, typ, def$1, path$1); };
- Checker.ptr.prototype.addMethodDecls = function(obj) {
- var $ptr, _entry, _i, _i$1, _i$2, _r, _r$1, _r$2, _ref, _ref$1, _ref$2, _ref$3, _tuple, alt, base, check, fld, m, m$1, methods, mset, nonAsciiName$1, obj, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; alt = $f.alt; base = $f.base; check = $f.check; fld = $f.fld; m = $f.m; m$1 = $f.m$1; methods = $f.methods; mset = $f.mset; nonAsciiName$1 = $f.nonAsciiName$1; obj = $f.obj; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- methods = (_entry = check.methods[$String.keyFor(obj.object.name)], _entry !== undefined ? _entry.v : sliceType$7.nil);
- if (methods.$length === 0) {
- return;
- }
- delete check.methods[$String.keyFor(obj.object.name)];
- mset = false;
- base = $assertType(obj.object.typ, ptrType$26);
- _tuple = $assertType(base.underlying, ptrType$27, true); t = _tuple[0];
- /* */ if (!(t === ptrType$27.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(t === ptrType$27.nil)) { */ case 1:
- _ref = t.fields;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- fld = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (!(fld.object.name === "_")) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!(fld.object.name === "_")) { */ case 5:
- _r = (nonAsciiName$1 || (nonAsciiName$1 = new ptrType$28(function() { return mset; }, function($v) { mset = $v; }))).insert(fld); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = assert($interfaceIsEqual(_r, $ifaceNil)); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- _i++;
- /* } */ $s = 3; continue; case 4:
- /* } */ case 2:
- _ref$1 = base.methods;
- _i$1 = 0;
- /* while (true) { */ case 9:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 10; continue; }
- m = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- assert(!(m.object.name === "_"));
- _r$1 = (nonAsciiName$1 || (nonAsciiName$1 = new ptrType$28(function() { return mset; }, function($v) { mset = $v; }))).insert(m); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = assert($interfaceIsEqual(_r$1, $ifaceNil)); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 9; continue; case 10:
- _ref$2 = methods;
- _i$2 = 0;
- /* while (true) { */ case 13:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 14; continue; }
- m$1 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- /* */ if (!(m$1.object.name === "_")) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!(m$1.object.name === "_")) { */ case 15:
- _r$2 = (nonAsciiName$1 || (nonAsciiName$1 = new ptrType$28(function() { return mset; }, function($v) { mset = $v; }))).insert(m$1); /* */ $s = 17; case 17: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- alt = _r$2;
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil))) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil))) { */ case 18:
- _ref$3 = alt;
- /* */ if ($assertType(_ref$3, ptrType$9, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref$3, ptrType$6, true)[1]) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if ($assertType(_ref$3, ptrType$9, true)[1]) { */ case 20:
- $r = check.errorf(m$1.object.pos, "field and method with the same name %s", new sliceType([new $String(m$1.object.name)])); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref$3, ptrType$6, true)[1]) { */ case 21:
- $r = check.errorf(m$1.object.pos, "method %s already declared for %s", new sliceType([new $String(m$1.object.name), base])); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else { */ case 22:
- unreachable();
- /* } */ case 23:
- $r = check.reportAltDecl(alt); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* continue; */ $s = 13; continue;
- /* } */ case 19:
- /* } */ case 16:
- $r = check.objDecl(m$1, ptrType$26.nil, sliceType$11.nil); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!(m$1.object.name === "_")) {
- base.methods = $append(base.methods, m$1);
- }
- _i$2++;
- /* } */ $s = 13; continue; case 14:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.addMethodDecls }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f.alt = alt; $f.base = base; $f.check = check; $f.fld = fld; $f.m = m; $f.m$1 = m$1; $f.methods = methods; $f.mset = mset; $f.nonAsciiName$1 = nonAsciiName$1; $f.obj = obj; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.addMethodDecls = function(obj) { return this.$val.addMethodDecls(obj); };
- Checker.ptr.prototype.funcDecl = function(obj, decl) {
- var $ptr, _r, check, decl, fdecl, obj, sig, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; check = $f.check; decl = $f.decl; fdecl = $f.fdecl; obj = $f.obj; sig = $f.sig; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- assert($interfaceIsEqual(obj.object.typ, $ifaceNil));
- assert($interfaceIsEqual(check.context.iota, $ifaceNil));
- sig = new Signature.ptr();
- obj.object.typ = sig;
- fdecl = decl.fdecl;
- $r = check.funcType(sig, fdecl.Recv, fdecl.Type); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (sig.recv === ptrType$9.nil && obj.object.name === "init" && (sig.params.Len() > 0 || sig.results.Len() > 0)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (sig.recv === ptrType$9.nil && obj.object.name === "init" && (sig.params.Len() > 0 || sig.results.Len() > 0)) { */ case 2:
- _r = fdecl.Pos(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.errorf(_r, "func init must have no arguments and no return values", new sliceType([])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- if (!check.conf.IgnoreFuncBodies && !(fdecl.Body === ptrType$29.nil)) {
- check.later(obj.object.name, decl, sig, fdecl.Body);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.funcDecl }; } $f.$ptr = $ptr; $f._r = _r; $f.check = check; $f.decl = decl; $f.fdecl = fdecl; $f.obj = obj; $f.sig = sig; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.funcDecl = function(obj, decl) { return this.$val.funcDecl(obj, decl); };
- Checker.ptr.prototype.declStmt = function(decl) {
- var $ptr, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _r, _r$1, _r$2, _r$3, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, check, d, d$1, d$2, decl, i, i$1, i$2, i$3, i$4, init$1, init$2, iota, last, lhs, lhs$1, lhs0, name, name$1, name$2, name$3, obj, obj$1, obj$2, pkg, s, s$1, s$2, scopePos, scopePos$1, scopePos$2, spec, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; check = $f.check; d = $f.d; d$1 = $f.d$1; d$2 = $f.d$2; decl = $f.decl; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; init$1 = $f.init$1; init$2 = $f.init$2; iota = $f.iota; last = $f.last; lhs = $f.lhs; lhs$1 = $f.lhs$1; lhs0 = $f.lhs0; name = $f.name; name$1 = $f.name$1; name$2 = $f.name$2; name$3 = $f.name$3; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; pkg = $f.pkg; s = $f.s; s$1 = $f.s$1; s$2 = $f.s$2; scopePos = $f.scopePos; scopePos$1 = $f.scopePos$1; scopePos$2 = $f.scopePos$2; spec = $f.spec; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- pkg = check.pkg;
- _ref = decl;
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$31, true)[1]) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($assertType(_ref, ptrType$30, true)[1]) { */ case 1:
- d = _ref.$val;
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$31, true)[1]) { */ case 2:
- d$1 = _ref.$val;
- last = ptrType$32.nil;
- _ref$1 = d$1.Specs;
- _i = 0;
- /* while (true) { */ case 5:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 6; continue; }
- iota = _i;
- spec = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- _ref$2 = spec;
- /* */ if ($assertType(_ref$2, ptrType$32, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref$2, ptrType$33, true)[1]) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($assertType(_ref$2, ptrType$32, true)[1]) { */ case 7:
- s = _ref$2.$val;
- _ref$3 = d$1.Tok;
- /* */ if (_ref$3 === 64) { $s = 11; continue; }
- /* */ if (_ref$3 === 85) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (_ref$3 === 64) { */ case 11:
- if (!($interfaceIsEqual(s.Type, $ifaceNil)) || s.Values.$length > 0) {
- last = s;
- } else if (last === ptrType$32.nil) {
- last = new ast.ValueSpec.ptr();
- }
- lhs = $makeSlice(sliceType$12, s.Names.$length);
- _ref$4 = s.Names;
- _i$1 = 0;
- /* while (true) { */ case 15:
- /* if (!(_i$1 < _ref$4.$length)) { break; } */ if(!(_i$1 < _ref$4.$length)) { $s = 16; continue; }
- i = _i$1;
- name = ((_i$1 < 0 || _i$1 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$1]);
- obj = NewConst(name.Pos(), pkg, name.Name, $ifaceNil, exact.MakeInt64(new $Int64(0, iota)));
- ((i < 0 || i >= lhs.$length) ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + i] = obj);
- init$1 = $ifaceNil;
- if (i < last.Values.$length) {
- init$1 = (x = last.Values, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- }
- $r = check.constDecl(obj, last.Type, init$1); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 15; continue; case 16:
- $r = check.arityMatch(s, last); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = s.End(); /* */ $s = 19; case 19: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- scopePos = _r;
- _ref$5 = s.Names;
- _i$2 = 0;
- /* while (true) { */ case 20:
- /* if (!(_i$2 < _ref$5.$length)) { break; } */ if(!(_i$2 < _ref$5.$length)) { $s = 21; continue; }
- i$1 = _i$2;
- name$1 = ((_i$2 < 0 || _i$2 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$2]);
- $r = check.declare(check.context.scope, name$1, ((i$1 < 0 || i$1 >= lhs.$length) ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + i$1]), scopePos); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 20; continue; case 21:
- $s = 14; continue;
- /* } else if (_ref$3 === 85) { */ case 12:
- lhs0 = $makeSlice(sliceType$1, s.Names.$length);
- _ref$6 = s.Names;
- _i$3 = 0;
- while (true) {
- if (!(_i$3 < _ref$6.$length)) { break; }
- i$2 = _i$3;
- name$2 = ((_i$3 < 0 || _i$3 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$3]);
- ((i$2 < 0 || i$2 >= lhs0.$length) ? $throwRuntimeError("index out of range") : lhs0.$array[lhs0.$offset + i$2] = NewVar(name$2.Pos(), pkg, name$2.Name, $ifaceNil));
- _i$3++;
- }
- _ref$7 = lhs0;
- _i$4 = 0;
- /* while (true) { */ case 23:
- /* if (!(_i$4 < _ref$7.$length)) { break; } */ if(!(_i$4 < _ref$7.$length)) { $s = 24; continue; }
- i$3 = _i$4;
- obj$1 = ((_i$4 < 0 || _i$4 >= _ref$7.$length) ? $throwRuntimeError("index out of range") : _ref$7.$array[_ref$7.$offset + _i$4]);
- lhs$1 = sliceType$1.nil;
- init$2 = $ifaceNil;
- _ref$8 = s.Values.$length;
- if (_ref$8 === s.Names.$length) {
- init$2 = (x$1 = s.Values, ((i$3 < 0 || i$3 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i$3]));
- } else if (_ref$8 === 1) {
- lhs$1 = lhs0;
- init$2 = (x$2 = s.Values, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0]));
- } else {
- if (i$3 < s.Values.$length) {
- init$2 = (x$3 = s.Values, ((i$3 < 0 || i$3 >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + i$3]));
- }
- }
- $r = check.varDecl(obj$1, lhs$1, s.Type, init$2); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (s.Values.$length === 1) {
- /* break; */ $s = 24; continue;
- }
- _i$4++;
- /* } */ $s = 23; continue; case 24:
- $r = check.arityMatch(s, ptrType$32.nil); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = s.End(); /* */ $s = 27; case 27: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- scopePos$1 = _r$1;
- _ref$9 = s.Names;
- _i$5 = 0;
- /* while (true) { */ case 28:
- /* if (!(_i$5 < _ref$9.$length)) { break; } */ if(!(_i$5 < _ref$9.$length)) { $s = 29; continue; }
- i$4 = _i$5;
- name$3 = ((_i$5 < 0 || _i$5 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$5]);
- $r = check.declare(check.context.scope, name$3, ((i$4 < 0 || i$4 >= lhs0.$length) ? $throwRuntimeError("index out of range") : lhs0.$array[lhs0.$offset + i$4]), scopePos$1); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$5++;
- /* } */ $s = 28; continue; case 29:
- $s = 14; continue;
- /* } else { */ case 13:
- $r = check.invalidAST(s.Pos(), "invalid token %s", new sliceType([new token.Token(d$1.Tok)])); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- $s = 10; continue;
- /* } else if ($assertType(_ref$2, ptrType$33, true)[1]) { */ case 8:
- s$1 = _ref$2.$val;
- obj$2 = NewTypeName(s$1.Name.Pos(), pkg, s$1.Name.Name, $ifaceNil);
- scopePos$2 = s$1.Name.Pos();
- $r = check.declare(check.context.scope, s$1.Name, obj$2, scopePos$2); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.typeDecl(obj$2, s$1.Type, ptrType$26.nil, sliceType$11.nil); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 10; continue;
- /* } else { */ case 9:
- s$2 = _ref$2;
- _r$2 = s$2.Pos(); /* */ $s = 34; case 34: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$2, "const, type, or var declaration expected", new sliceType([])); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- _i++;
- /* } */ $s = 5; continue; case 6:
- $s = 4; continue;
- /* } else { */ case 3:
- d$2 = _ref;
- _r$3 = d$2.Pos(); /* */ $s = 36; case 36: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$3, "unknown ast.Decl node %T", new sliceType([d$2])); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.declStmt }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f.check = check; $f.d = d; $f.d$1 = d$1; $f.d$2 = d$2; $f.decl = decl; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.init$1 = init$1; $f.init$2 = init$2; $f.iota = iota; $f.last = last; $f.lhs = lhs; $f.lhs$1 = lhs$1; $f.lhs0 = lhs0; $f.name = name; $f.name$1 = name$1; $f.name$2 = name$2; $f.name$3 = name$3; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.pkg = pkg; $f.s = s; $f.s$1 = s$1; $f.s$2 = s$2; $f.scopePos = scopePos; $f.scopePos$1 = scopePos$1; $f.scopePos$2 = scopePos$2; $f.spec = spec; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.declStmt = function(decl) { return this.$val.declStmt(decl); };
- assert = function(p) {
- var $ptr, p;
- if (!p) {
- $panic(new $String("assertion failed"));
- }
- };
- unreachable = function() {
- var $ptr;
- $panic(new $String("unreachable"));
- };
- Checker.ptr.prototype.qualifier = function(pkg) {
- var $ptr, check, pkg;
- check = this;
- if (!(pkg === check.pkg)) {
- return pkg.path;
- }
- return "";
- };
- Checker.prototype.qualifier = function(pkg) { return this.$val.qualifier(pkg); };
- Checker.ptr.prototype.sprintf = function(format, args) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, _ref$1, a, a$1, a$2, a$3, a$4, a$5, a$6, arg, args, check, format, i, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _ref$1 = $f._ref$1; a = $f.a; a$1 = $f.a$1; a$2 = $f.a$2; a$3 = $f.a$3; a$4 = $f.a$4; a$5 = $f.a$5; a$6 = $f.a$6; arg = $f.arg; args = $f.args; check = $f.check; format = $f.format; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _ref = args;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- arg = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = arg;
- /* */ if (_ref$1 === $ifaceNil) { $s = 3; continue; }
- /* */ if ($assertType(_ref$1, operand, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref$1, ptrType$34, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref$1, token.Pos, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref$1, ast.Expr, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref$1, Object, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref$1, Type, true)[1]) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_ref$1 === $ifaceNil) { */ case 3:
- a = _ref$1;
- arg = new $String("");
- $s = 10; continue;
- /* } else if ($assertType(_ref$1, operand, true)[1]) { */ case 4:
- a$1 = _ref$1.$val;
- $panic(new $String("internal error: should always pass *operand"));
- $s = 10; continue;
- /* } else if ($assertType(_ref$1, ptrType$34, true)[1]) { */ case 5:
- a$2 = _ref$1.$val;
- _r = operandString(a$2, $methodVal(check, "qualifier")); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- arg = new $String(_r);
- $s = 10; continue;
- /* } else if ($assertType(_ref$1, token.Pos, true)[1]) { */ case 6:
- a$3 = _ref$1.$val;
- _r$1 = check.fset.Position(a$3); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = _r$1.String(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- arg = new $String(_r$2);
- $s = 10; continue;
- /* } else if ($assertType(_ref$1, ast.Expr, true)[1]) { */ case 7:
- a$4 = _ref$1;
- arg = new $String(ExprString(a$4));
- $s = 10; continue;
- /* } else if ($assertType(_ref$1, Object, true)[1]) { */ case 8:
- a$5 = _ref$1;
- _r$3 = ObjectString(a$5, $methodVal(check, "qualifier")); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- arg = new $String(_r$3);
- $s = 10; continue;
- /* } else if ($assertType(_ref$1, Type, true)[1]) { */ case 9:
- a$6 = _ref$1;
- _r$4 = TypeString(a$6, $methodVal(check, "qualifier")); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- arg = new $String(_r$4);
- /* } */ case 10:
- ((i < 0 || i >= args.$length) ? $throwRuntimeError("index out of range") : args.$array[args.$offset + i] = arg);
- _i++;
- /* } */ $s = 1; continue; case 2:
- _r$5 = fmt.Sprintf(format, args); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.sprintf }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._ref$1 = _ref$1; $f.a = a; $f.a$1 = a$1; $f.a$2 = a$2; $f.a$3 = a$3; $f.a$4 = a$4; $f.a$5 = a$5; $f.a$6 = a$6; $f.arg = arg; $f.args = args; $f.check = check; $f.format = format; $f.i = i; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.sprintf = function(format, args) { return this.$val.sprintf(format, args); };
- Checker.ptr.prototype.dump = function(format, args) {
- var $ptr, _r, _r$1, args, check, format, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; args = $f.args; check = $f.check; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = check.sprintf(format, args); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = fmt.Println(new sliceType([new $String(_r)])); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.dump }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.args = args; $f.check = check; $f.format = format; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.dump = function(format, args) { return this.$val.dump(format, args); };
- Checker.ptr.prototype.err = function(pos, msg, soft) {
- var $ptr, check, err, f, msg, pos, soft, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; check = $f.check; err = $f.err; f = $f.f; msg = $f.msg; pos = $f.pos; soft = $f.soft; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- err = new Error.ptr(check.fset, pos, msg, soft);
- if ($interfaceIsEqual(check.firstErr, $ifaceNil)) {
- check.firstErr = new err.constructor.elem(err);
- }
- f = check.conf.Error;
- if (f === $throwNilPointerError) {
- $panic((x = new bailout.ptr(), new x.constructor.elem(x)));
- }
- $r = f(new err.constructor.elem(err)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.err }; } $f.$ptr = $ptr; $f.check = check; $f.err = err; $f.f = f; $f.msg = msg; $f.pos = pos; $f.soft = soft; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.err = function(pos, msg, soft) { return this.$val.err(pos, msg, soft); };
- Checker.ptr.prototype.error = function(pos, msg) {
- var $ptr, check, msg, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; check = $f.check; msg = $f.msg; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- $r = check.err(pos, msg, false); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.error }; } $f.$ptr = $ptr; $f.check = check; $f.msg = msg; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.error = function(pos, msg) { return this.$val.error(pos, msg); };
- Checker.ptr.prototype.errorf = function(pos, format, args) {
- var $ptr, _arg, _arg$1, _r, args, check, format, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; args = $f.args; check = $f.check; format = $f.format; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _arg = pos;
- _r = check.sprintf(format, args); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = _r;
- $r = check.err(_arg, _arg$1, false); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.errorf }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.args = args; $f.check = check; $f.format = format; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.errorf = function(pos, format, args) { return this.$val.errorf(pos, format, args); };
- Checker.ptr.prototype.softErrorf = function(pos, format, args) {
- var $ptr, _arg, _arg$1, _r, args, check, format, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; args = $f.args; check = $f.check; format = $f.format; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _arg = pos;
- _r = check.sprintf(format, args); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = _r;
- $r = check.err(_arg, _arg$1, true); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.softErrorf }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f.args = args; $f.check = check; $f.format = format; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.softErrorf = function(pos, format, args) { return this.$val.softErrorf(pos, format, args); };
- Checker.ptr.prototype.invalidAST = function(pos, format, args) {
- var $ptr, args, check, format, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; args = $f.args; check = $f.check; format = $f.format; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- $r = check.errorf(pos, "invalid AST: " + format, args); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.invalidAST }; } $f.$ptr = $ptr; $f.args = args; $f.check = check; $f.format = format; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.invalidAST = function(pos, format, args) { return this.$val.invalidAST(pos, format, args); };
- Checker.ptr.prototype.invalidArg = function(pos, format, args) {
- var $ptr, args, check, format, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; args = $f.args; check = $f.check; format = $f.format; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- $r = check.errorf(pos, "invalid argument: " + format, args); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.invalidArg }; } $f.$ptr = $ptr; $f.args = args; $f.check = check; $f.format = format; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.invalidArg = function(pos, format, args) { return this.$val.invalidArg(pos, format, args); };
- Checker.ptr.prototype.invalidOp = function(pos, format, args) {
- var $ptr, args, check, format, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; args = $f.args; check = $f.check; format = $f.format; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- $r = check.errorf(pos, "invalid operation: " + format, args); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.invalidOp }; } $f.$ptr = $ptr; $f.args = args; $f.check = check; $f.format = format; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.invalidOp = function(pos, format, args) { return this.$val.invalidOp(pos, format, args); };
- Checker.ptr.prototype.op = function(m, x, op) {
- var $ptr, _entry, _r, _r$1, _r$2, check, m, op, pred, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; check = $f.check; m = $f.m; op = $f.op; pred = $f.pred; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- pred = (_entry = m[token.Token.keyFor(op)], _entry !== undefined ? _entry.v : $throwNilPointerError);
- /* */ if (!(pred === $throwNilPointerError)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(pred === $throwNilPointerError)) { */ case 1:
- _r = pred(x.typ); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!_r) { */ case 4:
- _r$1 = x.pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$1, "operator %s not defined for %s", new sliceType([new token.Token(op), x])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return false;
- /* } */ case 5:
- $s = 3; continue;
- /* } else { */ case 2:
- _r$2 = x.pos(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$2, "unknown operator %s", new sliceType([new token.Token(op)])); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return false;
- /* } */ case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.op }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.check = check; $f.m = m; $f.op = op; $f.pred = pred; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.op = function(m, x, op) { return this.$val.op(m, x, op); };
- Checker.ptr.prototype.unary = function(x, e, op) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, _tuple$1, check, e, ok, ok$1, op, size, typ, typ$1, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; check = $f.check; e = $f.e; ok = $f.ok; ok$1 = $f.ok$1; op = $f.op; size = $f.size; typ = $f.typ; typ$1 = $f.typ$1; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _ref = op;
- /* */ if (_ref === 17) { $s = 1; continue; }
- /* */ if (_ref === 36) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_ref === 17) { */ case 1:
- _tuple = $assertType(unparen(x.expr), ptrType$35, true); ok = _tuple[1];
- /* */ if (!ok && !((x.mode === 5))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!ok && !((x.mode === 5))) { */ case 4:
- _r = x.pos(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r, "cannot take address of %s", new sliceType([x])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 5:
- x.mode = 7;
- x.typ = new Pointer.ptr(x.typ);
- return;
- $s = 3; continue;
- /* } else if (_ref === 36) { */ case 2:
- _r$1 = x.typ.Underlying(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r$1, ptrType$12, true); typ = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (!ok$1) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!ok$1) { */ case 9:
- _r$2 = x.pos(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$2, "cannot receive from non-channel %s", new sliceType([x])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 10:
- /* */ if (typ.dir === 1) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (typ.dir === 1) { */ case 13:
- _r$3 = x.pos(); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$3, "cannot receive from send-only channel %s", new sliceType([x])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 14:
- x.mode = 8;
- x.typ = typ.elem;
- check.context.hasCallOrRecv = true;
- return;
- /* } */ case 3:
- _r$4 = check.op(unaryOpPredicates, x, op); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (!_r$4) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (!_r$4) { */ case 17:
- x.mode = 0;
- return;
- /* } */ case 18:
- /* */ if (x.mode === 4) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (x.mode === 4) { */ case 20:
- _r$5 = x.typ.Underlying(); /* */ $s = 22; case 22: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- typ$1 = $assertType(_r$5, ptrType$3);
- size = -1;
- _r$6 = isUnsigned(typ$1); /* */ $s = 25; case 25: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- /* */ if (_r$6) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_r$6) { */ case 23:
- _r$7 = check.conf.sizeof(typ$1); /* */ $s = 26; case 26: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- size = ((x$1 = _r$7, x$1.$low + ((x$1.$high >> 31) * 4294967296)) >> 0);
- /* } */ case 24:
- _r$8 = exact.UnaryOp(op, x.val, size); /* */ $s = 27; case 27: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- x.val = _r$8;
- _r$9 = isTyped(typ$1); /* */ $s = 30; case 30: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- /* */ if (_r$9) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (_r$9) { */ case 28:
- if (!(e === ptrType$36.nil)) {
- x.expr = e;
- }
- $r = check.representable(x, typ$1); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 29:
- return;
- /* } */ case 21:
- x.mode = 7;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.unary }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.check = check; $f.e = e; $f.ok = ok; $f.ok$1 = ok$1; $f.op = op; $f.size = size; $f.typ = typ; $f.typ$1 = typ$1; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.unary = function(x, e, op) { return this.$val.unary(x, e, op); };
- isShift = function(op) {
- var $ptr, op;
- return (op === 20) || (op === 21);
- };
- isComparison = function(op) {
- var $ptr, _ref, op;
- _ref = op;
- if (_ref === 39 || _ref === 44 || _ref === 40 || _ref === 45 || _ref === 41 || _ref === 46) {
- return true;
- }
- return false;
- };
- fitsFloat32 = function(x) {
- var $ptr, _r, _tuple, f, f32, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; f32 = $f.f32; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = exact.Float32Val(x); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f32 = _tuple[0];
- f = f32;
- return !math.IsInf(f, 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: fitsFloat32 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.f32 = f32; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- roundFloat32 = function(x) {
- var $ptr, _r, _tuple, f, f32, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; f32 = $f.f32; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = exact.Float32Val(x); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f32 = _tuple[0];
- f = f32;
- if (!math.IsInf(f, 0)) {
- return exact.MakeFloat64(f);
- }
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: roundFloat32 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.f32 = f32; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- fitsFloat64 = function(x) {
- var $ptr, _r, _tuple, f, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = exact.Float64Val(x); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f = _tuple[0];
- return !math.IsInf(f, 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: fitsFloat64 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- roundFloat64 = function(x) {
- var $ptr, _r, _tuple, f, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; f = $f.f; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = exact.Float64Val(x); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; f = _tuple[0];
- if (!math.IsInf(f, 0)) {
- return exact.MakeFloat64(f);
- }
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: roundFloat64 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.f = f; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- representableConst = function(x, conf, as, rounded) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, _v, _v$1, as, conf, im, im$1, n, ok, r, r$1, r$2, r$3, re, re$1, rounded, s, s$1, s$2, x, x$1, x$2, x$3, x$4, x$5, x$6, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; _v = $f._v; _v$1 = $f._v$1; as = $f.as; conf = $f.conf; im = $f.im; im$1 = $f.im$1; n = $f.n; ok = $f.ok; r = $f.r; r$1 = $f.r$1; r$2 = $f.r$2; r$3 = $f.r$3; re = $f.re; re$1 = $f.re$1; rounded = $f.rounded; s = $f.s; s$1 = $f.s$1; s$2 = $f.s$2; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = x.Kind(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if (_ref === 0) { $s = 2; continue; }
- /* */ if (_ref === 1) { $s = 3; continue; }
- /* */ if (_ref === 3) { $s = 4; continue; }
- /* */ if (_ref === 4) { $s = 5; continue; }
- /* */ if (_ref === 5) { $s = 6; continue; }
- /* */ if (_ref === 2) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_ref === 0) { */ case 2:
- return true;
- $s = 9; continue;
- /* } else if (_ref === 1) { */ case 3:
- return (as === 1) || (as === 19);
- $s = 9; continue;
- /* } else if (_ref === 3) { */ case 4:
- _r$1 = exact.Int64Val(x); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; x$1 = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (ok) { */ case 11:
- _ref$1 = as;
- /* */ if (_ref$1 === 2) { $s = 13; continue; }
- /* */ if (_ref$1 === 3) { $s = 14; continue; }
- /* */ if (_ref$1 === 4) { $s = 15; continue; }
- /* */ if (_ref$1 === 5) { $s = 16; continue; }
- /* */ if (_ref$1 === 6) { $s = 17; continue; }
- /* */ if (_ref$1 === 7 || _ref$1 === 12) { $s = 18; continue; }
- /* */ if (_ref$1 === 8) { $s = 19; continue; }
- /* */ if (_ref$1 === 9) { $s = 20; continue; }
- /* */ if (_ref$1 === 10) { $s = 21; continue; }
- /* */ if (_ref$1 === 11) { $s = 22; continue; }
- /* */ if (_ref$1 === 13 || _ref$1 === 14 || _ref$1 === 15 || _ref$1 === 16 || _ref$1 === 20 || _ref$1 === 22 || _ref$1 === 23) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_ref$1 === 2) { */ case 13:
- _r$2 = conf.sizeof(((as < 0 || as >= $pkg.Typ.length) ? $throwRuntimeError("index out of range") : $pkg.Typ[as])); /* */ $s = 25; case 25: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- s = (_r$2.$low >>> 0) * 8 >>> 0;
- return (x$2 = $shiftLeft64(new $Int64(-1, 4294967295), ((s - 1 >>> 0))), (x$2.$high < x$1.$high || (x$2.$high === x$1.$high && x$2.$low <= x$1.$low))) && (x$3 = (x$4 = $shiftLeft64(new $Int64(0, 1), ((s - 1 >>> 0))), new $Int64(x$4.$high - 0, x$4.$low - 1)), (x$1.$high < x$3.$high || (x$1.$high === x$3.$high && x$1.$low <= x$3.$low)));
- $s = 24; continue;
- /* } else if (_ref$1 === 3) { */ case 14:
- return (-1 < x$1.$high || (-1 === x$1.$high && 4294967168 <= x$1.$low)) && (x$1.$high < 0 || (x$1.$high === 0 && x$1.$low <= 127));
- $s = 24; continue;
- /* } else if (_ref$1 === 4) { */ case 15:
- return (-1 < x$1.$high || (-1 === x$1.$high && 4294934528 <= x$1.$low)) && (x$1.$high < 0 || (x$1.$high === 0 && x$1.$low <= 32767));
- $s = 24; continue;
- /* } else if (_ref$1 === 5) { */ case 16:
- return (-1 < x$1.$high || (-1 === x$1.$high && 2147483648 <= x$1.$low)) && (x$1.$high < 0 || (x$1.$high === 0 && x$1.$low <= 2147483647));
- $s = 24; continue;
- /* } else if (_ref$1 === 6) { */ case 17:
- return true;
- $s = 24; continue;
- /* } else if (_ref$1 === 7 || _ref$1 === 12) { */ case 18:
- _r$3 = conf.sizeof(((as < 0 || as >= $pkg.Typ.length) ? $throwRuntimeError("index out of range") : $pkg.Typ[as])); /* */ $s = 26; case 26: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- s$1 = (_r$3.$low >>> 0) * 8 >>> 0;
- /* */ if (s$1 < 64) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (s$1 < 64) { */ case 27:
- return (0 < x$1.$high || (0 === x$1.$high && 0 <= x$1.$low)) && (x$5 = (x$6 = $shiftLeft64(new $Int64(0, 1), s$1), new $Int64(x$6.$high - 0, x$6.$low - 1)), (x$1.$high < x$5.$high || (x$1.$high === x$5.$high && x$1.$low <= x$5.$low)));
- /* } */ case 28:
- return (0 < x$1.$high || (0 === x$1.$high && 0 <= x$1.$low));
- $s = 24; continue;
- /* } else if (_ref$1 === 8) { */ case 19:
- return (0 < x$1.$high || (0 === x$1.$high && 0 <= x$1.$low)) && (x$1.$high < 0 || (x$1.$high === 0 && x$1.$low <= 255));
- $s = 24; continue;
- /* } else if (_ref$1 === 9) { */ case 20:
- return (0 < x$1.$high || (0 === x$1.$high && 0 <= x$1.$low)) && (x$1.$high < 0 || (x$1.$high === 0 && x$1.$low <= 65535));
- $s = 24; continue;
- /* } else if (_ref$1 === 10) { */ case 21:
- return (0 < x$1.$high || (0 === x$1.$high && 0 <= x$1.$low)) && (x$1.$high < 0 || (x$1.$high === 0 && x$1.$low <= 4294967295));
- $s = 24; continue;
- /* } else if (_ref$1 === 11) { */ case 22:
- return (0 < x$1.$high || (0 === x$1.$high && 0 <= x$1.$low));
- $s = 24; continue;
- /* } else if (_ref$1 === 13 || _ref$1 === 14 || _ref$1 === 15 || _ref$1 === 16 || _ref$1 === 20 || _ref$1 === 22 || _ref$1 === 23) { */ case 23:
- return true;
- /* } */ case 24:
- /* } */ case 12:
- _r$4 = exact.BitLen(x); /* */ $s = 29; case 29: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- n = _r$4;
- _ref$2 = as;
- /* */ if (_ref$2 === 7 || _ref$2 === 12) { $s = 30; continue; }
- /* */ if (_ref$2 === 11) { $s = 31; continue; }
- /* */ if (_ref$2 === 13 || _ref$2 === 15) { $s = 32; continue; }
- /* */ if (_ref$2 === 14 || _ref$2 === 16) { $s = 33; continue; }
- /* */ if (_ref$2 === 20 || _ref$2 === 22 || _ref$2 === 23) { $s = 34; continue; }
- /* */ $s = 35; continue;
- /* if (_ref$2 === 7 || _ref$2 === 12) { */ case 30:
- _r$5 = conf.sizeof(((as < 0 || as >= $pkg.Typ.length) ? $throwRuntimeError("index out of range") : $pkg.Typ[as])); /* */ $s = 36; case 36: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- s$2 = (_r$5.$low >>> 0) * 8 >>> 0;
- _r$6 = exact.Sign(x); /* */ $s = 37; case 37: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6 >= 0 && n <= (s$2 >> 0);
- $s = 35; continue;
- /* } else if (_ref$2 === 11) { */ case 31:
- _r$7 = exact.Sign(x); /* */ $s = 38; case 38: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7 >= 0 && n <= 64;
- $s = 35; continue;
- /* } else if (_ref$2 === 13 || _ref$2 === 15) { */ case 32:
- /* */ if (rounded === ptrType$25.nil) { $s = 39; continue; }
- /* */ $s = 40; continue;
- /* if (rounded === ptrType$25.nil) { */ case 39:
- _r$8 = fitsFloat32(x); /* */ $s = 41; case 41: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- return _r$8;
- /* } */ case 40:
- _r$9 = roundFloat32(x); /* */ $s = 42; case 42: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- r = _r$9;
- if (!($interfaceIsEqual(r, $ifaceNil))) {
- rounded.$set(r);
- return true;
- }
- $s = 35; continue;
- /* } else if (_ref$2 === 14 || _ref$2 === 16) { */ case 33:
- /* */ if (rounded === ptrType$25.nil) { $s = 43; continue; }
- /* */ $s = 44; continue;
- /* if (rounded === ptrType$25.nil) { */ case 43:
- _r$10 = fitsFloat64(x); /* */ $s = 45; case 45: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- return _r$10;
- /* } */ case 44:
- _r$11 = roundFloat64(x); /* */ $s = 46; case 46: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- r$1 = _r$11;
- if (!($interfaceIsEqual(r$1, $ifaceNil))) {
- rounded.$set(r$1);
- return true;
- }
- $s = 35; continue;
- /* } else if (_ref$2 === 20 || _ref$2 === 22 || _ref$2 === 23) { */ case 34:
- return true;
- /* } */ case 35:
- $s = 9; continue;
- /* } else if (_ref === 4) { */ case 5:
- _ref$3 = as;
- /* */ if (_ref$3 === 13 || _ref$3 === 15) { $s = 47; continue; }
- /* */ if (_ref$3 === 14 || _ref$3 === 16) { $s = 48; continue; }
- /* */ if (_ref$3 === 22 || _ref$3 === 23) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (_ref$3 === 13 || _ref$3 === 15) { */ case 47:
- /* */ if (rounded === ptrType$25.nil) { $s = 51; continue; }
- /* */ $s = 52; continue;
- /* if (rounded === ptrType$25.nil) { */ case 51:
- _r$12 = fitsFloat32(x); /* */ $s = 53; case 53: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- return _r$12;
- /* } */ case 52:
- _r$13 = roundFloat32(x); /* */ $s = 54; case 54: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- r$2 = _r$13;
- if (!($interfaceIsEqual(r$2, $ifaceNil))) {
- rounded.$set(r$2);
- return true;
- }
- $s = 50; continue;
- /* } else if (_ref$3 === 14 || _ref$3 === 16) { */ case 48:
- /* */ if (rounded === ptrType$25.nil) { $s = 55; continue; }
- /* */ $s = 56; continue;
- /* if (rounded === ptrType$25.nil) { */ case 55:
- _r$14 = fitsFloat64(x); /* */ $s = 57; case 57: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- return _r$14;
- /* } */ case 56:
- _r$15 = roundFloat64(x); /* */ $s = 58; case 58: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- r$3 = _r$15;
- if (!($interfaceIsEqual(r$3, $ifaceNil))) {
- rounded.$set(r$3);
- return true;
- }
- $s = 50; continue;
- /* } else if (_ref$3 === 22 || _ref$3 === 23) { */ case 49:
- return true;
- /* } */ case 50:
- $s = 9; continue;
- /* } else if (_ref === 5) { */ case 6:
- _ref$4 = as;
- /* */ if (_ref$4 === 15) { $s = 59; continue; }
- /* */ if (_ref$4 === 16) { $s = 60; continue; }
- /* */ if (_ref$4 === 23) { $s = 61; continue; }
- /* */ $s = 62; continue;
- /* if (_ref$4 === 15) { */ case 59:
- /* */ if (rounded === ptrType$25.nil) { $s = 63; continue; }
- /* */ $s = 64; continue;
- /* if (rounded === ptrType$25.nil) { */ case 63:
- _r$16 = exact.Real(x); /* */ $s = 66; case 66: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _r$17 = fitsFloat32(_r$16); /* */ $s = 67; case 67: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- if (!(_r$17)) { _v = false; $s = 65; continue s; }
- _r$18 = exact.Imag(x); /* */ $s = 68; case 68: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _r$19 = fitsFloat32(_r$18); /* */ $s = 69; case 69: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- _v = _r$19; case 65:
- return _v;
- /* } */ case 64:
- _r$20 = exact.Real(x); /* */ $s = 70; case 70: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- _r$21 = roundFloat32(_r$20); /* */ $s = 71; case 71: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- re = _r$21;
- _r$22 = exact.Imag(x); /* */ $s = 72; case 72: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = roundFloat32(_r$22); /* */ $s = 73; case 73: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- im = _r$23;
- /* */ if (!($interfaceIsEqual(re, $ifaceNil)) && !($interfaceIsEqual(im, $ifaceNil))) { $s = 74; continue; }
- /* */ $s = 75; continue;
- /* if (!($interfaceIsEqual(re, $ifaceNil)) && !($interfaceIsEqual(im, $ifaceNil))) { */ case 74:
- _arg = re;
- _r$24 = exact.MakeImag(im); /* */ $s = 76; case 76: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _arg$1 = _r$24;
- _r$25 = exact.BinaryOp(_arg, 12, _arg$1); /* */ $s = 77; case 77: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- rounded.$set(_r$25);
- return true;
- /* } */ case 75:
- $s = 62; continue;
- /* } else if (_ref$4 === 16) { */ case 60:
- /* */ if (rounded === ptrType$25.nil) { $s = 78; continue; }
- /* */ $s = 79; continue;
- /* if (rounded === ptrType$25.nil) { */ case 78:
- _r$26 = exact.Real(x); /* */ $s = 81; case 81: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _r$27 = fitsFloat64(_r$26); /* */ $s = 82; case 82: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- if (!(_r$27)) { _v$1 = false; $s = 80; continue s; }
- _r$28 = exact.Imag(x); /* */ $s = 83; case 83: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _r$29 = fitsFloat64(_r$28); /* */ $s = 84; case 84: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _v$1 = _r$29; case 80:
- return _v$1;
- /* } */ case 79:
- _r$30 = exact.Real(x); /* */ $s = 85; case 85: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _r$31 = roundFloat64(_r$30); /* */ $s = 86; case 86: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- re$1 = _r$31;
- _r$32 = exact.Imag(x); /* */ $s = 87; case 87: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _r$33 = roundFloat64(_r$32); /* */ $s = 88; case 88: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- im$1 = _r$33;
- /* */ if (!($interfaceIsEqual(re$1, $ifaceNil)) && !($interfaceIsEqual(im$1, $ifaceNil))) { $s = 89; continue; }
- /* */ $s = 90; continue;
- /* if (!($interfaceIsEqual(re$1, $ifaceNil)) && !($interfaceIsEqual(im$1, $ifaceNil))) { */ case 89:
- _arg$2 = re$1;
- _r$34 = exact.MakeImag(im$1); /* */ $s = 91; case 91: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _arg$3 = _r$34;
- _r$35 = exact.BinaryOp(_arg$2, 12, _arg$3); /* */ $s = 92; case 92: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- rounded.$set(_r$35);
- return true;
- /* } */ case 90:
- $s = 62; continue;
- /* } else if (_ref$4 === 23) { */ case 61:
- return true;
- /* } */ case 62:
- $s = 9; continue;
- /* } else if (_ref === 2) { */ case 7:
- return (as === 17) || (as === 24);
- $s = 9; continue;
- /* } else { */ case 8:
- unreachable();
- /* } */ case 9:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: representableConst }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f._v = _v; $f._v$1 = _v$1; $f.as = as; $f.conf = conf; $f.im = im; $f.im$1 = im$1; $f.n = n; $f.ok = ok; $f.r = r; $f.r$1 = r$1; $f.r$2 = r$2; $f.r$3 = r$3; $f.re = re; $f.re$1 = re$1; $f.rounded = rounded; $f.s = s; $f.s$1 = s$1; $f.s$2 = s$2; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.ptr.prototype.representable = function(x, typ) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _v, _v$1, check, msg, typ, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _v = $f._v; _v$1 = $f._v$1; check = $f.check; msg = $f.msg; typ = $f.typ; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- assert(x.mode === 4);
- _r = representableConst(x.val, check.conf, typ.kind, (x.$ptr_val || (x.$ptr_val = new ptrType$25(function() { return this.$target.val; }, function($v) { this.$target.val = $v; }, x)))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!_r) { */ case 1:
- msg = "";
- _r$1 = isNumeric(x.typ); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- if (!(_r$1)) { _v = false; $s = 7; continue s; }
- _r$2 = isNumeric(typ); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2; case 7:
- /* */ if (_v) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_v) { */ case 4:
- _r$3 = isInteger(x.typ); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- if (!(!_r$3)) { _v$1 = false; $s = 13; continue s; }
- _r$4 = isInteger(typ); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _v$1 = _r$4; case 13:
- /* */ if (_v$1) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_v$1) { */ case 10:
- msg = "%s truncated to %s";
- $s = 12; continue;
- /* } else { */ case 11:
- msg = "%s overflows %s";
- /* } */ case 12:
- $s = 6; continue;
- /* } else { */ case 5:
- msg = "cannot convert %s to %s";
- /* } */ case 6:
- _r$5 = x.pos(); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = check.errorf(_r$5, msg, new sliceType([x, typ])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.representable }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._v = _v; $f._v$1 = _v$1; $f.check = check; $f.msg = msg; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.representable = function(x, typ) { return this.$val.representable(x, typ); };
- Checker.ptr.prototype.updateExprType = function(x, typ, final$1) {
- var $ptr, _entry, _key$2, _r, _r$1, _r$2, _r$3, _ref, _tuple, _v, _v$1, check, final$1, found, old, typ, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$2 = $f._key$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _tuple = $f._tuple; _v = $f._v; _v$1 = $f._v$1; check = $f.check; final$1 = $f.final$1; found = $f.found; old = $f.old; typ = $f.typ; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _tuple = (_entry = check.untyped[ast.Expr.keyFor(x)], _entry !== undefined ? [_entry.v, true] : [new exprInfo.ptr(), false]); old = $clone(_tuple[0], exprInfo); found = _tuple[1];
- if (!found) {
- return;
- }
- _ref = x;
- /* */ if ($assertType(_ref, ptrType$37, true)[1] || $assertType(_ref, ptrType$38, true)[1] || $assertType(_ref, ptrType$35, true)[1] || $assertType(_ref, ptrType$39, true)[1] || $assertType(_ref, ptrType$40, true)[1] || $assertType(_ref, ptrType$41, true)[1] || $assertType(_ref, ptrType$42, true)[1] || $assertType(_ref, ptrType$43, true)[1] || $assertType(_ref, ptrType$44, true)[1] || $assertType(_ref, ptrType$45, true)[1] || $assertType(_ref, ptrType$46, true)[1] || $assertType(_ref, ptrType$47, true)[1] || $assertType(_ref, ptrType$48, true)[1] || $assertType(_ref, ptrType$49, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$50, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1] || $assertType(_ref, ptrType$51, true)[1] || $assertType(_ref, ptrType$14, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$16, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$36, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$52, true)[1]) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* switch (0) { default: if ($assertType(_ref, ptrType$37, true)[1] || $assertType(_ref, ptrType$38, true)[1] || $assertType(_ref, ptrType$35, true)[1] || $assertType(_ref, ptrType$39, true)[1] || $assertType(_ref, ptrType$40, true)[1] || $assertType(_ref, ptrType$41, true)[1] || $assertType(_ref, ptrType$42, true)[1] || $assertType(_ref, ptrType$43, true)[1] || $assertType(_ref, ptrType$44, true)[1] || $assertType(_ref, ptrType$45, true)[1] || $assertType(_ref, ptrType$46, true)[1] || $assertType(_ref, ptrType$47, true)[1] || $assertType(_ref, ptrType$48, true)[1] || $assertType(_ref, ptrType$49, true)[1]) { */ case 1:
- x$1 = _ref;
- return;
- $s = 8; continue;
- /* } else if ($assertType(_ref, ptrType$50, true)[1]) { */ case 2:
- x$2 = _ref.$val;
- $s = 8; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1] || $assertType(_ref, ptrType$51, true)[1] || $assertType(_ref, ptrType$14, true)[1]) { */ case 3:
- x$3 = _ref;
- $s = 8; continue;
- /* } else if ($assertType(_ref, ptrType$16, true)[1]) { */ case 4:
- x$4 = _ref.$val;
- $r = check.updateExprType(x$4.X, typ, final$1); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else if ($assertType(_ref, ptrType$36, true)[1]) { */ case 5:
- x$5 = _ref.$val;
- if (!($interfaceIsEqual(old.val, $ifaceNil))) {
- /* break; */ $s = 8; continue;
- }
- $r = check.updateExprType(x$5.X, typ, final$1); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else if ($assertType(_ref, ptrType$52, true)[1]) { */ case 6:
- x$6 = _ref.$val;
- if (!($interfaceIsEqual(old.val, $ifaceNil))) {
- /* break; */ $s = 8; continue;
- }
- /* */ if (isComparison(x$6.Op)) { $s = 11; continue; }
- /* */ if (isShift(x$6.Op)) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (isComparison(x$6.Op)) { */ case 11:
- $s = 14; continue;
- /* } else if (isShift(x$6.Op)) { */ case 12:
- $r = check.updateExprType(x$6.X, typ, final$1); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else { */ case 13:
- $r = check.updateExprType(x$6.X, typ, final$1); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.updateExprType(x$6.Y, typ, final$1); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- $s = 8; continue;
- /* } else { */ case 7:
- x$7 = _ref;
- unreachable();
- /* } } */ case 8:
- if (!(!final$1)) { _v = false; $s = 20; continue s; }
- _r = isUntyped(typ); /* */ $s = 21; case 21: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 20:
- /* */ if (_v) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (_v) { */ case 18:
- _r$1 = typ.Underlying(); /* */ $s = 22; case 22: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- old.typ = $assertType(_r$1, ptrType$3);
- _key$2 = x; (check.untyped || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key$2)] = { k: _key$2, v: $clone(old, exprInfo) };
- return;
- /* } */ case 19:
- delete check.untyped[ast.Expr.keyFor(x)];
- if (!(old.isLhs)) { _v$1 = false; $s = 25; continue s; }
- _r$2 = isInteger(typ); /* */ $s = 26; case 26: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v$1 = !_r$2; case 25:
- /* */ if (_v$1) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_v$1) { */ case 23:
- _r$3 = x.Pos(); /* */ $s = 27; case 27: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$3, "shifted operand %s (type %s) must be integer", new sliceType([x, typ])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 24:
- $r = check.recordTypeAndValue(x, old.mode, typ, old.val); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.updateExprType }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$2 = _key$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._tuple = _tuple; $f._v = _v; $f._v$1 = _v$1; $f.check = check; $f.final$1 = final$1; $f.found = found; $f.old = old; $f.typ = typ; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.updateExprType = function(x, typ, final$1) { return this.$val.updateExprType(x, typ, final$1); };
- Checker.ptr.prototype.updateExprVal = function(x, val) {
- var $ptr, _entry, _key$2, _tuple, check, info, ok, val, x;
- check = this;
- _tuple = (_entry = check.untyped[ast.Expr.keyFor(x)], _entry !== undefined ? [_entry.v, true] : [new exprInfo.ptr(), false]); info = $clone(_tuple[0], exprInfo); ok = _tuple[1];
- if (ok) {
- info.val = val;
- _key$2 = x; (check.untyped || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key$2)] = { k: _key$2, v: $clone(info, exprInfo) };
- }
- };
- Checker.prototype.updateExprVal = function(x, val) { return this.$val.updateExprVal(x, val); };
- Checker.ptr.prototype.convertUntyped = function(x, target) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _ref$1, _v, _v$1, check, t, t$1, t$2, t$3, target, tkind, x, xkind, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _ref$1 = $f._ref$1; _v = $f._v; _v$1 = $f._v$1; check = $f.check; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; target = $f.target; tkind = $f.tkind; x = $f.x; xkind = $f.xkind; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- if (x.mode === 0) { _v = true; $s = 3; continue s; }
- _r = isTyped(x.typ); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 3:
- /* */ if (_v || $interfaceIsEqual(target, $pkg.Typ[0])) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v || $interfaceIsEqual(target, $pkg.Typ[0])) { */ case 1:
- return;
- /* } */ case 2:
- _r$1 = isUntyped(target); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_r$1) { */ case 5:
- xkind = $assertType(x.typ, ptrType$3).kind;
- tkind = $assertType(target, ptrType$3).kind;
- _r$2 = isNumeric(x.typ); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- if (!(_r$2)) { _v$1 = false; $s = 11; continue s; }
- _r$3 = isNumeric(target); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v$1 = _r$3; case 11:
- /* */ if (_v$1) { $s = 8; continue; }
- /* */ if (!((xkind === tkind))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_v$1) { */ case 8:
- /* */ if (xkind < tkind) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (xkind < tkind) { */ case 14:
- x.typ = target;
- $r = check.updateExprType(x.expr, target, false); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- $s = 10; continue;
- /* } else if (!((xkind === tkind))) { */ case 9:
- /* goto Error */ $s = 17; continue;
- /* } */ case 10:
- return;
- /* } */ case 6:
- _r$4 = target.Underlying(); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _ref = _r$4;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref, ptrType$53, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref, ptrType$15, true)[1] || $assertType(_ref, ptrType$17, true)[1] || $assertType(_ref, ptrType$10, true)[1] || $assertType(_ref, ptrType$13, true)[1] || $assertType(_ref, ptrType$12, true)[1]) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 19:
- t = _ref.$val;
- /* */ if (x.mode === 4) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (x.mode === 4) { */ case 24:
- $r = check.representable(x, t); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return;
- }
- check.updateExprVal(x.expr, x.val);
- $s = 26; continue;
- /* } else { */ case 25:
- _ref$1 = $assertType(x.typ, ptrType$3).kind;
- /* */ if (_ref$1 === 19) { $s = 28; continue; }
- /* */ if (_ref$1 === 20 || _ref$1 === 21 || _ref$1 === 22 || _ref$1 === 23) { $s = 29; continue; }
- /* */ if (_ref$1 === 24) { $s = 30; continue; }
- /* */ if (_ref$1 === 25) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (_ref$1 === 19) { */ case 28:
- _r$5 = isBoolean(target); /* */ $s = 36; case 36: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- /* */ if (!_r$5) { $s = 34; continue; }
- /* */ $s = 35; continue;
- /* if (!_r$5) { */ case 34:
- /* goto Error */ $s = 17; continue;
- /* } */ case 35:
- $s = 33; continue;
- /* } else if (_ref$1 === 20 || _ref$1 === 21 || _ref$1 === 22 || _ref$1 === 23) { */ case 29:
- _r$6 = isNumeric(target); /* */ $s = 39; case 39: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- /* */ if (!_r$6) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (!_r$6) { */ case 37:
- /* goto Error */ $s = 17; continue;
- /* } */ case 38:
- $s = 33; continue;
- /* } else if (_ref$1 === 24) { */ case 30:
- unreachable();
- $s = 33; continue;
- /* } else if (_ref$1 === 25) { */ case 31:
- _r$7 = hasNil(target); /* */ $s = 42; case 42: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (!_r$7) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if (!_r$7) { */ case 40:
- /* goto Error */ $s = 17; continue;
- /* } */ case 41:
- $s = 33; continue;
- /* } else { */ case 32:
- /* goto Error */ $s = 17; continue;
- /* } */ case 33:
- /* } */ case 26:
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$53, true)[1]) { */ case 20:
- t$1 = _ref.$val;
- /* */ if (!x.isNil() && !t$1.Empty()) { $s = 43; continue; }
- /* */ $s = 44; continue;
- /* if (!x.isNil() && !t$1.Empty()) { */ case 43:
- /* goto Error */ $s = 17; continue;
- /* } */ case 44:
- /* */ if (x.isNil()) { $s = 45; continue; }
- /* */ $s = 46; continue;
- /* if (x.isNil()) { */ case 45:
- target = $pkg.Typ[25];
- $s = 47; continue;
- /* } else { */ case 46:
- /* */ if (!t$1.Empty()) { $s = 48; continue; }
- /* */ $s = 49; continue;
- /* if (!t$1.Empty()) { */ case 48:
- /* goto Error */ $s = 17; continue;
- /* } */ case 49:
- target = defaultType(x.typ);
- /* } */ case 47:
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$15, true)[1] || $assertType(_ref, ptrType$17, true)[1] || $assertType(_ref, ptrType$10, true)[1] || $assertType(_ref, ptrType$13, true)[1] || $assertType(_ref, ptrType$12, true)[1]) { */ case 21:
- t$2 = _ref;
- /* */ if (!x.isNil()) { $s = 50; continue; }
- /* */ $s = 51; continue;
- /* if (!x.isNil()) { */ case 50:
- /* goto Error */ $s = 17; continue;
- /* } */ case 51:
- target = $pkg.Typ[25];
- $s = 23; continue;
- /* } else { */ case 22:
- t$3 = _ref;
- /* goto Error */ $s = 17; continue;
- /* } */ case 23:
- x.typ = target;
- $r = check.updateExprType(x.expr, target, true); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* Error: */ case 17:
- _r$8 = x.pos(); /* */ $s = 53; case 53: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- $r = check.errorf(_r$8, "cannot convert %s to %s", new sliceType([x, target])); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.convertUntyped }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._ref$1 = _ref$1; $f._v = _v; $f._v$1 = _v$1; $f.check = check; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.target = target; $f.tkind = tkind; $f.x = x; $f.xkind = xkind; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.convertUntyped = function(x, target) { return this.$val.convertUntyped(x, target); };
- Checker.ptr.prototype.comparison = function(x, y, op) {
- var $ptr, _r, _r$1, _r$10, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _v, _v$1, _v$2, _v$3, _v$4, check, defined, err, op, typ, x, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; _v$4 = $f._v$4; check = $f.check; defined = $f.defined; err = $f.err; op = $f.op; typ = $f.typ; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- err = "";
- _r = x.assignableTo(check.conf, y.typ); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- if (_r) { _v = true; $s = 4; continue s; }
- _r$1 = y.assignableTo(check.conf, x.typ); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1; case 4:
- /* */ if (_v) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v) { */ case 1:
- defined = false;
- _ref = op;
- /* */ if (_ref === 39 || _ref === 44) { $s = 7; continue; }
- /* */ if (_ref === 40 || _ref === 45 || _ref === 41 || _ref === 46) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref === 39 || _ref === 44) { */ case 7:
- _r$2 = Comparable(x.typ); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- if (_r$2) { _v$2 = true; $s = 12; continue s; }
- if (!(x.isNil())) { _v$3 = false; $s = 14; continue s; }
- _r$3 = hasNil(y.typ); /* */ $s = 15; case 15: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v$3 = _r$3; case 14:
- _v$2 = _v$3; case 12:
- if (_v$2) { _v$1 = true; $s = 11; continue s; }
- if (!(y.isNil())) { _v$4 = false; $s = 16; continue s; }
- _r$4 = hasNil(x.typ); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _v$4 = _r$4; case 16:
- _v$1 = _v$4; case 11:
- defined = _v$1;
- $s = 10; continue;
- /* } else if (_ref === 40 || _ref === 45 || _ref === 41 || _ref === 46) { */ case 8:
- _r$5 = isOrdered(x.typ); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- defined = _r$5;
- $s = 10; continue;
- /* } else { */ case 9:
- unreachable();
- /* } */ case 10:
- /* */ if (!defined) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!defined) { */ case 19:
- typ = x.typ;
- if (x.isNil()) {
- typ = y.typ;
- }
- _r$6 = check.sprintf("operator %s not defined for %s", new sliceType([new token.Token(op), typ])); /* */ $s = 21; case 21: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- err = _r$6;
- /* } */ case 20:
- $s = 3; continue;
- /* } else { */ case 2:
- _r$7 = check.sprintf("mismatched types %s and %s", new sliceType([x.typ, y.typ])); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- err = _r$7;
- /* } */ case 3:
- /* */ if (!(err === "")) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (!(err === "")) { */ case 23:
- _r$8 = x.pos(); /* */ $s = 25; case 25: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- $r = check.errorf(_r$8, "cannot compare %s %s %s (%s)", new sliceType([x.expr, new token.Token(op), y.expr, new $String(err)])); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 24:
- /* */ if ((x.mode === 4) && (y.mode === 4)) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if ((x.mode === 4) && (y.mode === 4)) { */ case 27:
- _r$9 = exact.Compare(x.val, op, y.val); /* */ $s = 30; case 30: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$10 = exact.MakeBool(_r$9); /* */ $s = 31; case 31: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- x.val = _r$10;
- $s = 29; continue;
- /* } else { */ case 28:
- x.mode = 7;
- $r = check.updateExprType(x.expr, defaultType(x.typ), true); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.updateExprType(y.expr, defaultType(y.typ), true); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 29:
- x.typ = $pkg.Typ[19];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.comparison }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f._v$4 = _v$4; $f.check = check; $f.defined = defined; $f.err = err; $f.op = op; $f.typ = typ; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.comparison = function(x, y, op) { return this.$val.comparison(x, y, op); };
- Checker.ptr.prototype.shift = function(x, y, op) {
- var $ptr, _entry, _key$2, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, _v, _v$1, check, found, info, ok, op, s, untypedx, x, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$2 = $f._key$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; _v$1 = $f._v$1; check = $f.check; found = $f.found; info = $f.info; ok = $f.ok; op = $f.op; s = $f.s; untypedx = $f.untypedx; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = isUntyped(x.typ); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- untypedx = _r;
- _r$1 = x.isInteger(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!_r$1) { */ case 2:
- _r$2 = x.pos(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$2, "shifted operand %s must be integer", new sliceType([x])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 3:
- _r$3 = isInteger(y.typ); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- if (!(_r$3)) { _v = false; $s = 11; continue s; }
- _r$4 = isUnsigned(y.typ); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _v = _r$4; case 11:
- /* */ if (_v) { $s = 7; continue; }
- _r$5 = isUntyped(y.typ); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- /* */ if (_r$5) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_v) { */ case 7:
- $s = 10; continue;
- /* } else if (_r$5) { */ case 8:
- $r = check.convertUntyped(y, $pkg.Typ[20]); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (y.mode === 0) {
- x.mode = 0;
- return;
- }
- $s = 10; continue;
- /* } else { */ case 9:
- _r$6 = y.pos(); /* */ $s = 16; case 16: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$6, "shift count %s must be unsigned integer", new sliceType([y])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 10:
- /* */ if (x.mode === 4) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (x.mode === 4) { */ case 18:
- /* */ if (y.mode === 4) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (y.mode === 4) { */ case 20:
- _r$7 = y.isInteger(); /* */ $s = 24; case 24: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (!_r$7) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (!_r$7) { */ case 22:
- _r$8 = y.pos(); /* */ $s = 25; case 25: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$8, "shift count %s must be unsigned integer", new sliceType([y])); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 23:
- _r$9 = exact.Uint64Val(y.val); /* */ $s = 27; case 27: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _tuple = _r$9; s = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok || (s.$high > 0 || (s.$high === 0 && s.$low > 1074))) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (!ok || (s.$high > 0 || (s.$high === 0 && s.$low > 1074))) { */ case 28:
- _r$10 = y.pos(); /* */ $s = 30; case 30: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$10, "stupid shift count %s", new sliceType([y])); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 29:
- _r$11 = isInteger(x.typ); /* */ $s = 34; case 34: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- /* */ if (!_r$11) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (!_r$11) { */ case 32:
- x.typ = $pkg.Typ[20];
- /* } */ case 33:
- _r$12 = exact.Shift(x.val, op, (s.$low >>> 0)); /* */ $s = 35; case 35: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- x.val = _r$12;
- return;
- /* } */ case 21:
- if (untypedx) {
- _tuple$1 = (_entry = check.untyped[ast.Expr.keyFor(x.expr)], _entry !== undefined ? [_entry.v, true] : [new exprInfo.ptr(), false]); info = $clone(_tuple$1[0], exprInfo); found = _tuple$1[1];
- assert(found);
- info.isLhs = true;
- _key$2 = x.expr; (check.untyped || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key$2)] = { k: _key$2, v: $clone(info, exprInfo) };
- x.mode = 7;
- return;
- }
- /* } */ case 19:
- if (!(y.mode === 4)) { _v$1 = false; $s = 38; continue s; }
- _r$13 = exact.Sign(y.val); /* */ $s = 39; case 39: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _v$1 = _r$13 < 0; case 38:
- /* */ if (_v$1) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (_v$1) { */ case 36:
- _r$14 = y.pos(); /* */ $s = 40; case 40: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$14, "shift count %s must not be negative", new sliceType([y])); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 37:
- _r$15 = isInteger(x.typ); /* */ $s = 44; case 44: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- /* */ if (!_r$15) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (!_r$15) { */ case 42:
- _r$16 = x.pos(); /* */ $s = 45; case 45: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$16, "shifted operand %s must be integer", new sliceType([x])); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 43:
- x.mode = 7;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.shift }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$2 = _key$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f._v$1 = _v$1; $f.check = check; $f.found = found; $f.info = info; $f.ok = ok; $f.op = op; $f.s = s; $f.untypedx = untypedx; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.shift = function(x, y, op) { return this.$val.shift(x, y, op); };
- Checker.ptr.prototype.binary = function(x, e, lhs, rhs, op) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _v, _v$1, _v$2, _v$3, check, e, lhs, op, rhs, typ, x, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; check = $f.check; e = $f.e; lhs = $f.lhs; op = $f.op; rhs = $f.rhs; typ = $f.typ; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- y = [y];
- check = this;
- y[0] = $clone(new operand.ptr(), operand);
- $r = check.expr(x, lhs); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.expr(y[0], rhs); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return;
- }
- if (y[0].mode === 0) {
- x.mode = 0;
- x.expr = y[0].expr;
- return;
- }
- /* */ if (isShift(op)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (isShift(op)) { */ case 3:
- $r = check.shift(x, y[0], op); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 4:
- $r = check.convertUntyped(x, y[0].typ); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x.mode === 0) {
- return;
- }
- $r = check.convertUntyped(y[0], x.typ); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (y[0].mode === 0) {
- x.mode = 0;
- return;
- }
- /* */ if (isComparison(op)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (isComparison(op)) { */ case 8:
- $r = check.comparison(x, y[0], op); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 9:
- _r = Identical(x.typ, y[0].typ); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!_r) { */ case 11:
- /* */ if (!($interfaceIsEqual(x.typ, $pkg.Typ[0])) && !($interfaceIsEqual(y[0].typ, $pkg.Typ[0]))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!($interfaceIsEqual(x.typ, $pkg.Typ[0])) && !($interfaceIsEqual(y[0].typ, $pkg.Typ[0]))) { */ case 14:
- _r$1 = x.pos(); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$1, "mismatched types %s and %s", new sliceType([x.typ, y[0].typ])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- x.mode = 0;
- return;
- /* } */ case 12:
- _r$2 = check.op(binaryOpPredicates, x, op); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!_r$2) { */ case 18:
- x.mode = 0;
- return;
- /* } */ case 19:
- if (!((op === 15) || (op === 16))) { _v$1 = false; $s = 24; continue s; }
- if (x.mode === 4) { _v$2 = true; $s = 25; continue s; }
- _r$3 = isInteger(x.typ); /* */ $s = 26; case 26: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v$2 = _r$3; case 25:
- _v$1 = _v$2; case 24:
- if (!(_v$1 && (y[0].mode === 4))) { _v = false; $s = 23; continue s; }
- _r$4 = exact.Sign(y[0].val); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _v = _r$4 === 0; case 23:
- /* */ if (_v) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (_v) { */ case 21:
- _r$5 = y[0].pos(); /* */ $s = 28; case 28: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$5, "division by zero", new sliceType([])); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- return;
- /* } */ case 22:
- /* */ if ((x.mode === 4) && (y[0].mode === 4)) { $s = 30; continue; }
- /* */ $s = 31; continue;
- /* if ((x.mode === 4) && (y[0].mode === 4)) { */ case 30:
- _r$6 = x.typ.Underlying(); /* */ $s = 32; case 32: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- typ = $assertType(_r$6, ptrType$3);
- if (!(op === 15)) { _v$3 = false; $s = 35; continue s; }
- _r$7 = isInteger(typ); /* */ $s = 36; case 36: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _v$3 = _r$7; case 35:
- /* */ if (_v$3) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* if (_v$3) { */ case 33:
- op = 26;
- /* } */ case 34:
- _r$8 = exact.BinaryOp(x.val, op, y[0].val); /* */ $s = 37; case 37: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- x.val = _r$8;
- _r$9 = isTyped(typ); /* */ $s = 40; case 40: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- /* */ if (_r$9) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (_r$9) { */ case 38:
- if (!(e === ptrType$52.nil)) {
- x.expr = e;
- }
- $r = check.representable(x, typ); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 39:
- return;
- /* } */ case 31:
- x.mode = 7;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.binary }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f.check = check; $f.e = e; $f.lhs = lhs; $f.op = op; $f.rhs = rhs; $f.typ = typ; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.binary = function(x, e, lhs, rhs, op) { return this.$val.binary(x, e, lhs, rhs, op); };
- Checker.ptr.prototype.index = function(index, max) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, check, i, index, max, valid, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tuple = $f._tuple; check = $f.check; i = $f.i; index = $f.index; max = $f.max; valid = $f.valid; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- i = new $Int64(0, 0);
- valid = false;
- check = this;
- x[0] = $clone(new operand.ptr(), operand);
- $r = check.expr(x[0], index); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x[0].mode === 0) {
- return [i, valid];
- }
- $r = check.convertUntyped(x[0], $pkg.Typ[2]); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x[0].mode === 0) {
- return [i, valid];
- }
- _r = isInteger(x[0].typ); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!_r) { */ case 3:
- _r$1 = x[0].pos(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.invalidArg(_r$1, "index %s must be integer", new sliceType([x[0]])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [i, valid];
- /* } */ case 4:
- /* */ if (x[0].mode === 4) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (x[0].mode === 4) { */ case 8:
- _r$2 = exact.Sign(x[0].val); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2 < 0) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_r$2 < 0) { */ case 10:
- _r$3 = x[0].pos(); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.invalidArg(_r$3, "index %s must not be negative", new sliceType([x[0]])); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [i, valid];
- /* } */ case 11:
- _r$4 = exact.Int64Val(x[0].val); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; i = _tuple[0]; valid = _tuple[1];
- /* */ if (!valid || (max.$high > 0 || (max.$high === 0 && max.$low >= 0)) && (i.$high > max.$high || (i.$high === max.$high && i.$low >= max.$low))) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (!valid || (max.$high > 0 || (max.$high === 0 && max.$low >= 0)) && (i.$high > max.$high || (i.$high === max.$high && i.$low >= max.$low))) { */ case 16:
- _r$5 = x[0].pos(); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = check.errorf(_r$5, "index %s is out of bounds", new sliceType([x[0]])); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tmp = i; _tmp$1 = false; i = _tmp; valid = _tmp$1;
- return [i, valid];
- /* } */ case 17:
- _tmp$2 = i; _tmp$3 = true; i = _tmp$2; valid = _tmp$3;
- return [i, valid];
- /* } */ case 9:
- _tmp$4 = new $Int64(-1, 4294967295); _tmp$5 = true; i = _tmp$4; valid = _tmp$5;
- return [i, valid];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.index }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tuple = _tuple; $f.check = check; $f.i = i; $f.index = index; $f.max = max; $f.valid = valid; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.index = function(index, max) { return this.$val.index(index, max); };
- Checker.ptr.prototype.indexedElts = function(elts, typ, length) {
- var $ptr, _entry, _i, _key$2, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, _tmp, _tmp$1, _tuple, _tuple$1, check, e, elts, eval$1, i, index, kv, length, max, ok, typ, validIndex, visited, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _key$2 = $f._key$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; check = $f.check; e = $f.e; elts = $f.elts; eval$1 = $f.eval$1; i = $f.i; index = $f.index; kv = $f.kv; length = $f.length; max = $f.max; ok = $f.ok; typ = $f.typ; validIndex = $f.validIndex; visited = $f.visited; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- visited = new $Map();
- _tmp = new $Int64(0, 0); _tmp$1 = new $Int64(0, 0); index = _tmp; max = _tmp$1;
- _ref = elts;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- x = [x];
- e = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- validIndex = false;
- eval$1 = e;
- _tuple = $assertType(e, ptrType$43, true); kv = _tuple[0];
- /* */ if (!(kv === ptrType$43.nil)) { $s = 3; continue; }
- /* */ if ((length.$high > 0 || (length.$high === 0 && length.$low >= 0)) && (index.$high > length.$high || (index.$high === length.$high && index.$low >= length.$low))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(kv === ptrType$43.nil)) { */ case 3:
- _r = check.index(kv.Key, length); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = _r; i = _tuple$1[0]; ok = _tuple$1[1];
- /* */ if (ok) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (ok) { */ case 8:
- /* */ if ((i.$high > 0 || (i.$high === 0 && i.$low >= 0))) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if ((i.$high > 0 || (i.$high === 0 && i.$low >= 0))) { */ case 10:
- index = i;
- validIndex = true;
- $s = 12; continue;
- /* } else { */ case 11:
- _r$1 = e.Pos(); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "index %s must be integer constant", new sliceType([kv.Key])); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 12:
- /* } */ case 9:
- eval$1 = kv.Value;
- $s = 6; continue;
- /* } else if ((length.$high > 0 || (length.$high === 0 && length.$low >= 0)) && (index.$high > length.$high || (index.$high === length.$high && index.$low >= length.$low))) { */ case 4:
- _r$2 = e.Pos(); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.errorf(_r$2, "index %d is out of bounds (>= %d)", new sliceType([index, length])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else { */ case 5:
- validIndex = true;
- /* } */ case 6:
- /* */ if (validIndex) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (validIndex) { */ case 17:
- /* */ if ((_entry = visited[$Int64.keyFor(index)], _entry !== undefined ? _entry.v : false)) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if ((_entry = visited[$Int64.keyFor(index)], _entry !== undefined ? _entry.v : false)) { */ case 19:
- _r$3 = e.Pos(); /* */ $s = 21; case 21: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.errorf(_r$3, "duplicate index %d in array or slice literal", new sliceType([index])); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- _key$2 = index; (visited || $throwRuntimeError("assignment to entry in nil map"))[$Int64.keyFor(_key$2)] = { k: _key$2, v: true };
- /* } */ case 18:
- index = (x$1 = new $Int64(0, 1), new $Int64(index.$high + x$1.$high, index.$low + x$1.$low));
- if ((index.$high > max.$high || (index.$high === max.$high && index.$low > max.$low))) {
- max = index;
- }
- x[0] = $clone(new operand.ptr(), operand);
- $r = check.exprWithHint(x[0], eval$1, typ); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$4 = check.assignment(x[0], typ); /* */ $s = 26; case 26: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (!_r$4 && !((x[0].mode === 0))) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (!_r$4 && !((x[0].mode === 0))) { */ case 24:
- _r$5 = x[0].pos(); /* */ $s = 27; case 27: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = check.errorf(_r$5, "cannot use %s as %s value in array or slice literal", new sliceType([x[0], typ])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 25:
- _i++;
- /* } */ $s = 1; continue; case 2:
- return max;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.indexedElts }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._key$2 = _key$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.check = check; $f.e = e; $f.elts = elts; $f.eval$1 = eval$1; $f.i = i; $f.index = index; $f.kv = kv; $f.length = length; $f.max = max; $f.ok = ok; $f.typ = typ; $f.validIndex = validIndex; $f.visited = visited; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.indexedElts = function(elts, typ, length) { return this.$val.indexedElts(elts, typ, length); };
- Checker.ptr.prototype.rawExpr = function(x, e, hint) {
- var $ptr, _r, _r$1, _ref, check, e, hint, kind, typ, val, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; check = $f.check; e = $f.e; hint = $f.hint; kind = $f.kind; typ = $f.typ; val = $f.val; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- check = [check];
- e = [e];
- x = [x];
- check[0] = this;
- _r = check[0].exprInternal(x[0], e[0], hint); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- kind = _r;
- typ = $ifaceNil;
- val = $ifaceNil;
- _ref = x[0].mode;
- if (_ref === 0) {
- typ = $pkg.Typ[0];
- } else if (_ref === 1) {
- typ = ptrType$8.nil;
- } else if (_ref === 4) {
- typ = x[0].typ;
- val = x[0].val;
- } else {
- typ = x[0].typ;
- }
- assert(!($interfaceIsEqual(x[0].expr, $ifaceNil)) && !($interfaceIsEqual(typ, $ifaceNil)));
- _r$1 = isUntyped(typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_r$1) { */ case 2:
- check[0].rememberUntyped(x[0].expr, false, x[0].mode, $assertType(typ, ptrType$3), val);
- $s = 4; continue;
- /* } else { */ case 3:
- $r = check[0].recordTypeAndValue(e[0], x[0].mode, typ, val); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- return kind;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return 0; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.rawExpr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.check = check; $f.e = e; $f.hint = hint; $f.kind = kind; $f.typ = typ; $f.val = val; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.rawExpr = function(x, e, hint) { return this.$val.rawExpr(x, e, hint); };
- Checker.ptr.prototype.exprInternal = function(x, e, hint) {
- var $ptr, T, _arg, _arg$1, _entry, _entry$1, _entry$2, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _key$2, _key$3, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$37, _r$38, _r$39, _r$4, _r$40, _r$41, _r$42, _r$43, _r$44, _r$45, _r$46, _r$47, _r$48, _r$49, _r$5, _r$50, _r$51, _r$52, _r$53, _r$54, _r$55, _r$56, _r$57, _r$58, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$10, _ref$11, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tuple, _tuple$1, _tuple$10, _tuple$11, _tuple$12, _tuple$13, _tuple$14, _tuple$15, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, atyp, check, duplicate, e, e$1, e$10, e$11, e$12, e$13, e$14, e$15, e$16, e$17, e$18, e$19, e$2, e$20, e$21, e$3, e$4, e$5, e$6, e$7, e$8, e$9, ellip, etyp, etyp$1, expr, fields, fld, fld$1, hint, i, i$1, i$2, i$3, ind, key, key$1, kind, kv, kv$1, kv$2, length, length$1, max, n, ok, ok$1, ok$2, ok$3, ok$4, openArray, sig, t, typ, typ$1, typ$10, typ$11, typ$12, typ$13, typ$2, typ$3, typ$4, typ$5, typ$6, typ$7, typ$8, typ$9, utyp, utyp$1, utyp$2, utyp$3, utyp$4, valid, valid$1, visited, visited$1, vtyp, x, x$1, x$2, x$3, x$4, xtyp, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _key$2 = $f._key$2; _key$3 = $f._key$3; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$4 = $f._r$4; _r$40 = $f._r$40; _r$41 = $f._r$41; _r$42 = $f._r$42; _r$43 = $f._r$43; _r$44 = $f._r$44; _r$45 = $f._r$45; _r$46 = $f._r$46; _r$47 = $f._r$47; _r$48 = $f._r$48; _r$49 = $f._r$49; _r$5 = $f._r$5; _r$50 = $f._r$50; _r$51 = $f._r$51; _r$52 = $f._r$52; _r$53 = $f._r$53; _r$54 = $f._r$54; _r$55 = $f._r$55; _r$56 = $f._r$56; _r$57 = $f._r$57; _r$58 = $f._r$58; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$10 = $f._ref$10; _ref$11 = $f._ref$11; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$11 = $f._tuple$11; _tuple$12 = $f._tuple$12; _tuple$13 = $f._tuple$13; _tuple$14 = $f._tuple$14; _tuple$15 = $f._tuple$15; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; atyp = $f.atyp; check = $f.check; duplicate = $f.duplicate; e = $f.e; e$1 = $f.e$1; e$10 = $f.e$10; e$11 = $f.e$11; e$12 = $f.e$12; e$13 = $f.e$13; e$14 = $f.e$14; e$15 = $f.e$15; e$16 = $f.e$16; e$17 = $f.e$17; e$18 = $f.e$18; e$19 = $f.e$19; e$2 = $f.e$2; e$20 = $f.e$20; e$21 = $f.e$21; e$3 = $f.e$3; e$4 = $f.e$4; e$5 = $f.e$5; e$6 = $f.e$6; e$7 = $f.e$7; e$8 = $f.e$8; e$9 = $f.e$9; ellip = $f.ellip; etyp = $f.etyp; etyp$1 = $f.etyp$1; expr = $f.expr; fields = $f.fields; fld = $f.fld; fld$1 = $f.fld$1; hint = $f.hint; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; ind = $f.ind; key = $f.key; key$1 = $f.key$1; kind = $f.kind; kv = $f.kv; kv$1 = $f.kv$1; kv$2 = $f.kv$2; length = $f.length; length$1 = $f.length$1; max = $f.max; n = $f.n; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; ok$3 = $f.ok$3; ok$4 = $f.ok$4; openArray = $f.openArray; sig = $f.sig; t = $f.t; typ = $f.typ; typ$1 = $f.typ$1; typ$10 = $f.typ$10; typ$11 = $f.typ$11; typ$12 = $f.typ$12; typ$13 = $f.typ$13; typ$2 = $f.typ$2; typ$3 = $f.typ$3; typ$4 = $f.typ$4; typ$5 = $f.typ$5; typ$6 = $f.typ$6; typ$7 = $f.typ$7; typ$8 = $f.typ$8; typ$9 = $f.typ$9; utyp = $f.utyp; utyp$1 = $f.utyp$1; utyp$2 = $f.utyp$2; utyp$3 = $f.utyp$3; utyp$4 = $f.utyp$4; valid = $f.valid; valid$1 = $f.valid$1; visited = $f.visited; visited$1 = $f.visited$1; vtyp = $f.vtyp; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; xtyp = $f.xtyp; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- key = [key];
- check = this;
- x.mode = 0;
- x.typ = $pkg.Typ[0];
- _ref = e;
- /* */ if ($assertType(_ref, ptrType$37, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$54, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$51, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$38, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$35, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$16, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$14, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$39, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$40, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$41, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$50, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$42, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, ptrType$36, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$52, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$43, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, ptrType$44, true)[1] || $assertType(_ref, ptrType$45, true)[1] || $assertType(_ref, ptrType$46, true)[1] || $assertType(_ref, ptrType$47, true)[1] || $assertType(_ref, ptrType$48, true)[1] || $assertType(_ref, ptrType$49, true)[1]) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if ($assertType(_ref, ptrType$37, true)[1]) { */ case 1:
- e$1 = _ref.$val;
- /* goto Error */ $s = 20; continue;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1]) { */ case 2:
- e$2 = _ref.$val;
- $r = check.ident(x, e$2, ptrType$26.nil, sliceType$11.nil); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$54, true)[1]) { */ case 3:
- e$3 = _ref.$val;
- $r = check.error(e$3.Pos(), "invalid use of '...'"); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$51, true)[1]) { */ case 4:
- e$4 = _ref.$val;
- $r = x.setConst(e$4.Kind, e$4.Value); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (x.mode === 0) { */ case 24:
- $r = check.invalidAST(e$4.Pos(), "invalid literal %v", new sliceType([new $String(e$4.Value)])); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 25:
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$38, true)[1]) { */ case 5:
- e$5 = _ref.$val;
- _r = check.typ(e$5.Type); /* */ $s = 27; case 27: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$17, true); sig = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (ok) { */ case 28:
- $r = check.funcBody(check.context.decl, "", sig, e$5.Body); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 7;
- x.typ = sig;
- $s = 30; continue;
- /* } else { */ case 29:
- _r$1 = e$5.Pos(); /* */ $s = 32; case 32: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$1, "invalid function literal %s", new sliceType([e$5])); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 30:
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$35, true)[1]) { */ case 6:
- e$6 = _ref.$val;
- typ = hint;
- openArray = false;
- /* */ if (!($interfaceIsEqual(e$6.Type, $ifaceNil))) { $s = 34; continue; }
- /* */ $s = 35; continue;
- /* if (!($interfaceIsEqual(e$6.Type, $ifaceNil))) { */ case 34:
- typ = $ifaceNil;
- _tuple$1 = $assertType(e$6.Type, ptrType$44, true); atyp = _tuple$1[0];
- /* */ if (!(atyp === ptrType$44.nil) && !($interfaceIsEqual(atyp.Len, $ifaceNil))) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (!(atyp === ptrType$44.nil) && !($interfaceIsEqual(atyp.Len, $ifaceNil))) { */ case 36:
- _tuple$2 = $assertType(atyp.Len, ptrType$54, true); ellip = _tuple$2[0];
- /* */ if (!(ellip === ptrType$54.nil) && $interfaceIsEqual(ellip.Elt, $ifaceNil)) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (!(ellip === ptrType$54.nil) && $interfaceIsEqual(ellip.Elt, $ifaceNil)) { */ case 38:
- _r$2 = check.typ(atyp.Elt); /* */ $s = 40; case 40: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- typ = new Array.ptr(new $Int64(-1, 4294967295), _r$2);
- openArray = true;
- /* } */ case 39:
- /* } */ case 37:
- /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 41; continue; }
- /* */ $s = 42; continue;
- /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 41:
- _r$3 = check.typ(e$6.Type); /* */ $s = 43; case 43: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- typ = _r$3;
- /* } */ case 42:
- /* } */ case 35:
- /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 44; continue; }
- /* */ $s = 45; continue;
- /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 44:
- _r$4 = e$6.Pos(); /* */ $s = 46; case 46: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.error(_r$4, "missing type in composite literal"); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 45:
- _tuple$3 = deref(typ); typ$1 = _tuple$3[0];
- _r$5 = typ$1.Underlying(); /* */ $s = 48; case 48: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _ref$1 = _r$5;
- /* */ if ($assertType(_ref$1, ptrType$27, true)[1]) { $s = 49; continue; }
- /* */ if ($assertType(_ref$1, ptrType$11, true)[1]) { $s = 50; continue; }
- /* */ if ($assertType(_ref$1, ptrType$10, true)[1]) { $s = 51; continue; }
- /* */ if ($assertType(_ref$1, ptrType$13, true)[1]) { $s = 52; continue; }
- /* */ $s = 53; continue;
- /* switch (0) { default: if ($assertType(_ref$1, ptrType$27, true)[1]) { */ case 49:
- utyp = _ref$1.$val;
- if (e$6.Elts.$length === 0) {
- /* break; */ $s = 54; continue;
- }
- fields = utyp.fields;
- _tuple$4 = $assertType((x$1 = e$6.Elts, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])), ptrType$43, true); ok$1 = _tuple$4[1];
- /* */ if (ok$1) { $s = 55; continue; }
- /* */ $s = 56; continue;
- /* if (ok$1) { */ case 55:
- visited = $makeSlice(sliceType$13, fields.$length);
- _ref$2 = e$6.Elts;
- _i = 0;
- /* while (true) { */ case 58:
- /* if (!(_i < _ref$2.$length)) { break; } */ if(!(_i < _ref$2.$length)) { $s = 59; continue; }
- e$7 = ((_i < 0 || _i >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i]);
- _tuple$5 = $assertType(e$7, ptrType$43, true); kv = _tuple$5[0];
- /* */ if (kv === ptrType$43.nil) { $s = 60; continue; }
- /* */ $s = 61; continue;
- /* if (kv === ptrType$43.nil) { */ case 60:
- _r$6 = e$7.Pos(); /* */ $s = 62; case 62: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = check.error(_r$6, "mixture of field:value and value elements in struct literal"); /* */ $s = 63; case 63: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 58; continue;
- /* } */ case 61:
- _tuple$6 = $assertType(kv.Key, ptrType$5, true); key$1 = _tuple$6[0];
- /* */ if (key$1 === ptrType$5.nil) { $s = 64; continue; }
- /* */ $s = 65; continue;
- /* if (key$1 === ptrType$5.nil) { */ case 64:
- _r$7 = kv.Pos(); /* */ $s = 66; case 66: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $r = check.errorf(_r$7, "invalid field name %s in struct literal", new sliceType([kv.Key])); /* */ $s = 67; case 67: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 58; continue;
- /* } */ case 65:
- i = fieldIndex(utyp.fields, check.pkg, key$1.Name);
- /* */ if (i < 0) { $s = 68; continue; }
- /* */ $s = 69; continue;
- /* if (i < 0) { */ case 68:
- _r$8 = kv.Pos(); /* */ $s = 70; case 70: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- $r = check.errorf(_r$8, "unknown field %s in struct literal", new sliceType([new $String(key$1.Name)])); /* */ $s = 71; case 71: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 58; continue;
- /* } */ case 69:
- fld = ((i < 0 || i >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + i]);
- check.recordUse(key$1, fld);
- /* */ if (((i < 0 || i >= visited.$length) ? $throwRuntimeError("index out of range") : visited.$array[visited.$offset + i])) { $s = 72; continue; }
- /* */ $s = 73; continue;
- /* if (((i < 0 || i >= visited.$length) ? $throwRuntimeError("index out of range") : visited.$array[visited.$offset + i])) { */ case 72:
- _r$9 = kv.Pos(); /* */ $s = 74; case 74: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- $r = check.errorf(_r$9, "duplicate field name %s in struct literal", new sliceType([new $String(key$1.Name)])); /* */ $s = 75; case 75: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 58; continue;
- /* } */ case 73:
- ((i < 0 || i >= visited.$length) ? $throwRuntimeError("index out of range") : visited.$array[visited.$offset + i] = true);
- $r = check.expr(x, kv.Value); /* */ $s = 76; case 76: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- etyp = fld.object.typ;
- _r$10 = check.assignment(x, etyp); /* */ $s = 79; case 79: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- /* */ if (!_r$10) { $s = 77; continue; }
- /* */ $s = 78; continue;
- /* if (!_r$10) { */ case 77:
- /* */ if (!((x.mode === 0))) { $s = 80; continue; }
- /* */ $s = 81; continue;
- /* if (!((x.mode === 0))) { */ case 80:
- _r$11 = x.pos(); /* */ $s = 82; case 82: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- $r = check.errorf(_r$11, "cannot use %s as %s value in struct literal", new sliceType([x, etyp])); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 81:
- _i++;
- /* continue; */ $s = 58; continue;
- /* } */ case 78:
- _i++;
- /* } */ $s = 58; continue; case 59:
- $s = 57; continue;
- /* } else { */ case 56:
- _ref$3 = e$6.Elts;
- _i$1 = 0;
- /* while (true) { */ case 84:
- /* if (!(_i$1 < _ref$3.$length)) { break; } */ if(!(_i$1 < _ref$3.$length)) { $s = 85; continue; }
- i$1 = _i$1;
- e$8 = ((_i$1 < 0 || _i$1 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$1]);
- _tuple$7 = $assertType(e$8, ptrType$43, true); kv$1 = _tuple$7[0];
- /* */ if (!(kv$1 === ptrType$43.nil)) { $s = 86; continue; }
- /* */ $s = 87; continue;
- /* if (!(kv$1 === ptrType$43.nil)) { */ case 86:
- _r$12 = kv$1.Pos(); /* */ $s = 88; case 88: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- $r = check.error(_r$12, "mixture of field:value and value elements in struct literal"); /* */ $s = 89; case 89: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* continue; */ $s = 84; continue;
- /* } */ case 87:
- $r = check.expr(x, e$8); /* */ $s = 90; case 90: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (i$1 >= fields.$length) { $s = 91; continue; }
- /* */ $s = 92; continue;
- /* if (i$1 >= fields.$length) { */ case 91:
- _r$13 = x.pos(); /* */ $s = 93; case 93: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- $r = check.error(_r$13, "too many values in struct literal"); /* */ $s = 94; case 94: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* break; */ $s = 85; continue;
- /* } */ case 92:
- fld$1 = ((i$1 < 0 || i$1 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + i$1]);
- /* */ if (!fld$1.object.Exported() && !(fld$1.object.pkg === check.pkg)) { $s = 95; continue; }
- /* */ $s = 96; continue;
- /* if (!fld$1.object.Exported() && !(fld$1.object.pkg === check.pkg)) { */ case 95:
- _r$14 = x.pos(); /* */ $s = 97; case 97: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- $r = check.errorf(_r$14, "implicit assignment to unexported field %s in %s literal", new sliceType([new $String(fld$1.object.name), typ$1])); /* */ $s = 98; case 98: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* continue; */ $s = 84; continue;
- /* } */ case 96:
- etyp$1 = fld$1.object.typ;
- _r$15 = check.assignment(x, etyp$1); /* */ $s = 101; case 101: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- /* */ if (!_r$15) { $s = 99; continue; }
- /* */ $s = 100; continue;
- /* if (!_r$15) { */ case 99:
- /* */ if (!((x.mode === 0))) { $s = 102; continue; }
- /* */ $s = 103; continue;
- /* if (!((x.mode === 0))) { */ case 102:
- _r$16 = x.pos(); /* */ $s = 104; case 104: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- $r = check.errorf(_r$16, "cannot use %s as %s value in struct literal", new sliceType([x, etyp$1])); /* */ $s = 105; case 105: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 103:
- _i$1++;
- /* continue; */ $s = 84; continue;
- /* } */ case 100:
- _i$1++;
- /* } */ $s = 84; continue; case 85:
- /* */ if (e$6.Elts.$length < fields.$length) { $s = 106; continue; }
- /* */ $s = 107; continue;
- /* if (e$6.Elts.$length < fields.$length) { */ case 106:
- $r = check.error(e$6.Rbrace, "too few values in struct literal"); /* */ $s = 108; case 108: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 107:
- /* } */ case 57:
- $s = 54; continue;
- /* } else if ($assertType(_ref$1, ptrType$11, true)[1]) { */ case 50:
- utyp$1 = _ref$1.$val;
- _r$17 = check.indexedElts(e$6.Elts, utyp$1.elem, utyp$1.len); /* */ $s = 109; case 109: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- n = _r$17;
- if (openArray) {
- utyp$1.len = n;
- }
- $s = 54; continue;
- /* } else if ($assertType(_ref$1, ptrType$10, true)[1]) { */ case 51:
- utyp$2 = _ref$1.$val;
- _r$18 = check.indexedElts(e$6.Elts, utyp$2.elem, new $Int64(-1, 4294967295)); /* */ $s = 110; case 110: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _r$18;
- $s = 54; continue;
- /* } else if ($assertType(_ref$1, ptrType$13, true)[1]) { */ case 52:
- utyp$3 = _ref$1.$val;
- visited$1 = new $Map();
- _ref$4 = e$6.Elts;
- _i$2 = 0;
- /* while (true) { */ case 111:
- /* if (!(_i$2 < _ref$4.$length)) { break; } */ if(!(_i$2 < _ref$4.$length)) { $s = 112; continue; }
- e$9 = ((_i$2 < 0 || _i$2 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$2]);
- _tuple$8 = $assertType(e$9, ptrType$43, true); kv$2 = _tuple$8[0];
- /* */ if (kv$2 === ptrType$43.nil) { $s = 113; continue; }
- /* */ $s = 114; continue;
- /* if (kv$2 === ptrType$43.nil) { */ case 113:
- _r$19 = e$9.Pos(); /* */ $s = 115; case 115: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- $r = check.error(_r$19, "missing key in map literal"); /* */ $s = 116; case 116: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* continue; */ $s = 111; continue;
- /* } */ case 114:
- $r = check.exprWithHint(x, kv$2.Key, utyp$3.key); /* */ $s = 117; case 117: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$20 = check.assignment(x, utyp$3.key); /* */ $s = 120; case 120: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- /* */ if (!_r$20) { $s = 118; continue; }
- /* */ $s = 119; continue;
- /* if (!_r$20) { */ case 118:
- /* */ if (!((x.mode === 0))) { $s = 121; continue; }
- /* */ $s = 122; continue;
- /* if (!((x.mode === 0))) { */ case 121:
- _r$21 = x.pos(); /* */ $s = 123; case 123: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- $r = check.errorf(_r$21, "cannot use %s as %s key in map literal", new sliceType([x, utyp$3.key])); /* */ $s = 124; case 124: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 122:
- _i$2++;
- /* continue; */ $s = 111; continue;
- /* } */ case 119:
- /* */ if (x.mode === 4) { $s = 125; continue; }
- /* */ $s = 126; continue;
- /* if (x.mode === 4) { */ case 125:
- duplicate = false;
- _r$22 = utyp$3.key.Underlying(); /* */ $s = 127; case 127: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _tuple$9 = $assertType(_r$22, ptrType$53, true); ok$2 = _tuple$9[1];
- /* */ if (ok$2) { $s = 128; continue; }
- /* */ $s = 129; continue;
- /* if (ok$2) { */ case 128:
- _ref$5 = (_entry = visited$1[$emptyInterface.keyFor(x.val)], _entry !== undefined ? _entry.v : sliceType$3.nil);
- _i$3 = 0;
- /* while (true) { */ case 131:
- /* if (!(_i$3 < _ref$5.$length)) { break; } */ if(!(_i$3 < _ref$5.$length)) { $s = 132; continue; }
- vtyp = ((_i$3 < 0 || _i$3 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$3]);
- _r$23 = Identical(vtyp, x.typ); /* */ $s = 135; case 135: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- /* */ if (_r$23) { $s = 133; continue; }
- /* */ $s = 134; continue;
- /* if (_r$23) { */ case 133:
- duplicate = true;
- /* break; */ $s = 132; continue;
- /* } */ case 134:
- _i$3++;
- /* } */ $s = 131; continue; case 132:
- _key$2 = x.val; (visited$1 || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key$2)] = { k: _key$2, v: $append((_entry$1 = visited$1[$emptyInterface.keyFor(x.val)], _entry$1 !== undefined ? _entry$1.v : sliceType$3.nil), x.typ) };
- $s = 130; continue;
- /* } else { */ case 129:
- _tuple$10 = (_entry$2 = visited$1[$emptyInterface.keyFor(x.val)], _entry$2 !== undefined ? [_entry$2.v, true] : [sliceType$3.nil, false]); duplicate = _tuple$10[1];
- _key$3 = x.val; (visited$1 || $throwRuntimeError("assignment to entry in nil map"))[$emptyInterface.keyFor(_key$3)] = { k: _key$3, v: sliceType$3.nil };
- /* } */ case 130:
- /* */ if (duplicate) { $s = 136; continue; }
- /* */ $s = 137; continue;
- /* if (duplicate) { */ case 136:
- _r$24 = x.pos(); /* */ $s = 138; case 138: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- $r = check.errorf(_r$24, "duplicate key %s in map literal", new sliceType([x.val])); /* */ $s = 139; case 139: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* continue; */ $s = 111; continue;
- /* } */ case 137:
- /* } */ case 126:
- $r = check.exprWithHint(x, kv$2.Value, utyp$3.elem); /* */ $s = 140; case 140: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$25 = check.assignment(x, utyp$3.elem); /* */ $s = 143; case 143: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- /* */ if (!_r$25) { $s = 141; continue; }
- /* */ $s = 142; continue;
- /* if (!_r$25) { */ case 141:
- /* */ if (!((x.mode === 0))) { $s = 144; continue; }
- /* */ $s = 145; continue;
- /* if (!((x.mode === 0))) { */ case 144:
- _r$26 = x.pos(); /* */ $s = 146; case 146: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- $r = check.errorf(_r$26, "cannot use %s as %s value in map literal", new sliceType([x, utyp$3.elem])); /* */ $s = 147; case 147: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 145:
- _i$2++;
- /* continue; */ $s = 111; continue;
- /* } */ case 142:
- _i$2++;
- /* } */ $s = 111; continue; case 112:
- $s = 54; continue;
- /* } else { */ case 53:
- utyp$4 = _ref$1;
- /* */ if (!($interfaceIsEqual(utyp$4, $pkg.Typ[0]))) { $s = 148; continue; }
- /* */ $s = 149; continue;
- /* if (!($interfaceIsEqual(utyp$4, $pkg.Typ[0]))) { */ case 148:
- _r$27 = e$6.Pos(); /* */ $s = 150; case 150: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- $r = check.errorf(_r$27, "invalid composite literal type %s", new sliceType([typ$1])); /* */ $s = 151; case 151: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 149:
- /* } } */ case 54:
- x.mode = 7;
- x.typ = typ;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$16, true)[1]) { */ case 7:
- e$10 = _ref.$val;
- _r$28 = check.rawExpr(x, e$10.X, $ifaceNil); /* */ $s = 152; case 152: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- kind = _r$28;
- x.expr = e$10;
- return kind;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$14, true)[1]) { */ case 8:
- e$11 = _ref.$val;
- $r = check.selector(x, e$11); /* */ $s = 153; case 153: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$39, true)[1]) { */ case 9:
- e$12 = _ref.$val;
- $r = check.expr(x, e$12.X); /* */ $s = 154; case 154: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 155; continue; }
- /* */ $s = 156; continue;
- /* if (x.mode === 0) { */ case 155:
- /* goto Error */ $s = 20; continue;
- /* } */ case 156:
- valid = false;
- length = new $Int64(-1, 4294967295);
- _r$29 = x.typ.Underlying(); /* */ $s = 157; case 157: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _ref$6 = _r$29;
- /* */ if ($assertType(_ref$6, ptrType$3, true)[1]) { $s = 158; continue; }
- /* */ if ($assertType(_ref$6, ptrType$11, true)[1]) { $s = 159; continue; }
- /* */ if ($assertType(_ref$6, ptrType$15, true)[1]) { $s = 160; continue; }
- /* */ if ($assertType(_ref$6, ptrType$10, true)[1]) { $s = 161; continue; }
- /* */ if ($assertType(_ref$6, ptrType$13, true)[1]) { $s = 162; continue; }
- /* */ $s = 163; continue;
- /* if ($assertType(_ref$6, ptrType$3, true)[1]) { */ case 158:
- typ$2 = _ref$6.$val;
- _r$30 = isString(typ$2); /* */ $s = 166; case 166: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- /* */ if (_r$30) { $s = 164; continue; }
- /* */ $s = 165; continue;
- /* if (_r$30) { */ case 164:
- valid = true;
- /* */ if (x.mode === 4) { $s = 167; continue; }
- /* */ $s = 168; continue;
- /* if (x.mode === 4) { */ case 167:
- _r$31 = exact.StringVal(x.val); /* */ $s = 169; case 169: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- length = new $Int64(0, _r$31.length);
- /* } */ case 168:
- x.mode = 7;
- x.typ = $pkg.UniverseByte;
- /* } */ case 165:
- $s = 163; continue;
- /* } else if ($assertType(_ref$6, ptrType$11, true)[1]) { */ case 159:
- typ$3 = _ref$6.$val;
- valid = true;
- length = typ$3.len;
- if (!((x.mode === 5))) {
- x.mode = 7;
- }
- x.typ = typ$3.elem;
- $s = 163; continue;
- /* } else if ($assertType(_ref$6, ptrType$15, true)[1]) { */ case 160:
- typ$4 = _ref$6.$val;
- _r$32 = typ$4.base.Underlying(); /* */ $s = 170; case 170: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _tuple$11 = $assertType(_r$32, ptrType$11, true); typ$5 = _tuple$11[0];
- /* */ if (!(typ$5 === ptrType$11.nil)) { $s = 171; continue; }
- /* */ $s = 172; continue;
- /* if (!(typ$5 === ptrType$11.nil)) { */ case 171:
- valid = true;
- length = typ$5.len;
- x.mode = 5;
- x.typ = typ$5.elem;
- /* } */ case 172:
- $s = 163; continue;
- /* } else if ($assertType(_ref$6, ptrType$10, true)[1]) { */ case 161:
- typ$6 = _ref$6.$val;
- valid = true;
- x.mode = 5;
- x.typ = typ$6.elem;
- $s = 163; continue;
- /* } else if ($assertType(_ref$6, ptrType$13, true)[1]) { */ case 162:
- typ$7 = _ref$6.$val;
- key[0] = $clone(new operand.ptr(), operand);
- $r = check.expr(key[0], e$12.Index); /* */ $s = 173; case 173: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$33 = check.assignment(key[0], typ$7.key); /* */ $s = 176; case 176: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- /* */ if (!_r$33) { $s = 174; continue; }
- /* */ $s = 175; continue;
- /* if (!_r$33) { */ case 174:
- /* */ if (!((key[0].mode === 0))) { $s = 177; continue; }
- /* */ $s = 178; continue;
- /* if (!((key[0].mode === 0))) { */ case 177:
- _r$34 = key[0].pos(); /* */ $s = 179; case 179: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$34, "cannot use %s as map index of type %s", new sliceType([key[0], typ$7.key])); /* */ $s = 180; case 180: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 178:
- /* goto Error */ $s = 20; continue;
- /* } */ case 175:
- x.mode = 6;
- x.typ = typ$7.elem;
- x.expr = e$12;
- return 1;
- /* } */ case 163:
- /* */ if (!valid) { $s = 181; continue; }
- /* */ $s = 182; continue;
- /* if (!valid) { */ case 181:
- _r$35 = x.pos(); /* */ $s = 183; case 183: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$35, "cannot index %s", new sliceType([x])); /* */ $s = 184; case 184: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 182:
- /* */ if ($interfaceIsEqual(e$12.Index, $ifaceNil)) { $s = 185; continue; }
- /* */ $s = 186; continue;
- /* if ($interfaceIsEqual(e$12.Index, $ifaceNil)) { */ case 185:
- _r$36 = e$12.Pos(); /* */ $s = 187; case 187: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$36, "missing index for %s", new sliceType([x])); /* */ $s = 188; case 188: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 186:
- _r$37 = check.index(e$12.Index, length); /* */ $s = 189; case 189: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- _r$37;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$40, true)[1]) { */ case 10:
- e$13 = _ref.$val;
- $r = check.expr(x, e$13.X); /* */ $s = 190; case 190: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 191; continue; }
- /* */ $s = 192; continue;
- /* if (x.mode === 0) { */ case 191:
- /* goto Error */ $s = 20; continue;
- /* } */ case 192:
- valid$1 = false;
- length$1 = new $Int64(-1, 4294967295);
- _r$38 = x.typ.Underlying(); /* */ $s = 193; case 193: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- _ref$7 = _r$38;
- /* */ if ($assertType(_ref$7, ptrType$3, true)[1]) { $s = 194; continue; }
- /* */ if ($assertType(_ref$7, ptrType$11, true)[1]) { $s = 195; continue; }
- /* */ if ($assertType(_ref$7, ptrType$15, true)[1]) { $s = 196; continue; }
- /* */ if ($assertType(_ref$7, ptrType$10, true)[1]) { $s = 197; continue; }
- /* */ $s = 198; continue;
- /* if ($assertType(_ref$7, ptrType$3, true)[1]) { */ case 194:
- typ$8 = _ref$7.$val;
- _r$39 = isString(typ$8); /* */ $s = 201; case 201: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- /* */ if (_r$39) { $s = 199; continue; }
- /* */ $s = 200; continue;
- /* if (_r$39) { */ case 199:
- /* */ if (slice3(e$13)) { $s = 202; continue; }
- /* */ $s = 203; continue;
- /* if (slice3(e$13)) { */ case 202:
- _r$40 = x.pos(); /* */ $s = 204; case 204: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$40, "3-index slice of string", new sliceType([])); /* */ $s = 205; case 205: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 203:
- valid$1 = true;
- /* */ if (x.mode === 4) { $s = 206; continue; }
- /* */ $s = 207; continue;
- /* if (x.mode === 4) { */ case 206:
- _r$41 = exact.StringVal(x.val); /* */ $s = 208; case 208: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- length$1 = new $Int64(0, _r$41.length);
- /* } */ case 207:
- if (typ$8.kind === 24) {
- x.typ = $pkg.Typ[17];
- }
- /* } */ case 200:
- $s = 198; continue;
- /* } else if ($assertType(_ref$7, ptrType$11, true)[1]) { */ case 195:
- typ$9 = _ref$7.$val;
- valid$1 = true;
- length$1 = typ$9.len;
- /* */ if (!((x.mode === 5))) { $s = 209; continue; }
- /* */ $s = 210; continue;
- /* if (!((x.mode === 5))) { */ case 209:
- _r$42 = x.pos(); /* */ $s = 211; case 211: if($c) { $c = false; _r$42 = _r$42.$blk(); } if (_r$42 && _r$42.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$42, "cannot slice %s (value not addressable)", new sliceType([x])); /* */ $s = 212; case 212: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 210:
- x.typ = new Slice.ptr(typ$9.elem);
- $s = 198; continue;
- /* } else if ($assertType(_ref$7, ptrType$15, true)[1]) { */ case 196:
- typ$10 = _ref$7.$val;
- _r$43 = typ$10.base.Underlying(); /* */ $s = 213; case 213: if($c) { $c = false; _r$43 = _r$43.$blk(); } if (_r$43 && _r$43.$blk !== undefined) { break s; }
- _tuple$12 = $assertType(_r$43, ptrType$11, true); typ$11 = _tuple$12[0];
- /* */ if (!(typ$11 === ptrType$11.nil)) { $s = 214; continue; }
- /* */ $s = 215; continue;
- /* if (!(typ$11 === ptrType$11.nil)) { */ case 214:
- valid$1 = true;
- length$1 = typ$11.len;
- x.typ = new Slice.ptr(typ$11.elem);
- /* } */ case 215:
- $s = 198; continue;
- /* } else if ($assertType(_ref$7, ptrType$10, true)[1]) { */ case 197:
- typ$12 = _ref$7.$val;
- valid$1 = true;
- /* } */ case 198:
- /* */ if (!valid$1) { $s = 216; continue; }
- /* */ $s = 217; continue;
- /* if (!valid$1) { */ case 216:
- _r$44 = x.pos(); /* */ $s = 218; case 218: if($c) { $c = false; _r$44 = _r$44.$blk(); } if (_r$44 && _r$44.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$44, "cannot slice %s", new sliceType([x])); /* */ $s = 219; case 219: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 217:
- x.mode = 7;
- /* */ if (slice3(e$13) && ($interfaceIsEqual(e$13.High, $ifaceNil) || $interfaceIsEqual(sliceMax(e$13), $ifaceNil))) { $s = 220; continue; }
- /* */ $s = 221; continue;
- /* if (slice3(e$13) && ($interfaceIsEqual(e$13.High, $ifaceNil) || $interfaceIsEqual(sliceMax(e$13), $ifaceNil))) { */ case 220:
- $r = check.error(e$13.Rbrack, "2nd and 3rd index required in 3-index slice"); /* */ $s = 222; case 222: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 221:
- ind = $clone(arrayType$1.zero(), arrayType$1);
- _ref$8 = new sliceType$5([e$13.Low, e$13.High, sliceMax(e$13)]);
- _i$4 = 0;
- /* while (true) { */ case 223:
- /* if (!(_i$4 < _ref$8.$length)) { break; } */ if(!(_i$4 < _ref$8.$length)) { $s = 224; continue; }
- i$2 = _i$4;
- expr = ((_i$4 < 0 || _i$4 >= _ref$8.$length) ? $throwRuntimeError("index out of range") : _ref$8.$array[_ref$8.$offset + _i$4]);
- x$2 = new $Int64(-1, 4294967295);
- /* */ if (!($interfaceIsEqual(expr, $ifaceNil))) { $s = 225; continue; }
- /* */ if (i$2 === 0) { $s = 226; continue; }
- /* */ if ((length$1.$high > 0 || (length$1.$high === 0 && length$1.$low >= 0))) { $s = 227; continue; }
- /* */ $s = 228; continue;
- /* if (!($interfaceIsEqual(expr, $ifaceNil))) { */ case 225:
- max = new $Int64(-1, 4294967295);
- if ((length$1.$high > 0 || (length$1.$high === 0 && length$1.$low >= 0))) {
- max = new $Int64(length$1.$high + 0, length$1.$low + 1);
- }
- _r$45 = check.index(expr, max); /* */ $s = 229; case 229: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- _tuple$13 = _r$45; t = _tuple$13[0]; ok$3 = _tuple$13[1];
- /* */ if (ok$3 && (t.$high > 0 || (t.$high === 0 && t.$low >= 0))) { $s = 230; continue; }
- /* */ $s = 231; continue;
- /* if (ok$3 && (t.$high > 0 || (t.$high === 0 && t.$low >= 0))) { */ case 230:
- x$2 = t;
- /* } */ case 231:
- $s = 228; continue;
- /* } else if (i$2 === 0) { */ case 226:
- x$2 = new $Int64(0, 0);
- $s = 228; continue;
- /* } else if ((length$1.$high > 0 || (length$1.$high === 0 && length$1.$low >= 0))) { */ case 227:
- x$2 = length$1;
- /* } */ case 228:
- ((i$2 < 0 || i$2 >= ind.length) ? $throwRuntimeError("index out of range") : ind[i$2] = x$2);
- _i$4++;
- /* } */ $s = 223; continue; case 224:
- _ref$9 = $subslice(new sliceType$4(ind), 0, 2);
- _i$5 = 0;
- /* while (true) { */ case 232:
- /* if (!(_i$5 < _ref$9.$length)) { break; } */ if(!(_i$5 < _ref$9.$length)) { $s = 233; continue; }
- i$3 = _i$5;
- x$3 = ((_i$5 < 0 || _i$5 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$5]);
- /* */ if ((x$3.$high > 0 || (x$3.$high === 0 && x$3.$low > 0))) { $s = 234; continue; }
- /* */ $s = 235; continue;
- /* if ((x$3.$high > 0 || (x$3.$high === 0 && x$3.$low > 0))) { */ case 234:
- _ref$10 = $subslice(new sliceType$4(ind), (i$3 + 1 >> 0));
- _i$6 = 0;
- /* while (true) { */ case 236:
- /* if (!(_i$6 < _ref$10.$length)) { break; } */ if(!(_i$6 < _ref$10.$length)) { $s = 237; continue; }
- y = ((_i$6 < 0 || _i$6 >= _ref$10.$length) ? $throwRuntimeError("index out of range") : _ref$10.$array[_ref$10.$offset + _i$6]);
- /* */ if ((y.$high > 0 || (y.$high === 0 && y.$low >= 0)) && (x$3.$high > y.$high || (x$3.$high === y.$high && x$3.$low > y.$low))) { $s = 238; continue; }
- /* */ $s = 239; continue;
- /* if ((y.$high > 0 || (y.$high === 0 && y.$low >= 0)) && (x$3.$high > y.$high || (x$3.$high === y.$high && x$3.$low > y.$low))) { */ case 238:
- $r = check.errorf(e$13.Rbrack, "invalid slice indices: %d > %d", new sliceType([x$3, y])); /* */ $s = 240; case 240: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* break L; */ $s = 233; continue s;
- /* } */ case 239:
- _i$6++;
- /* } */ $s = 236; continue; case 237:
- /* } */ case 235:
- _i$5++;
- /* } */ $s = 232; continue; case 233:
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$41, true)[1]) { */ case 11:
- e$14 = _ref.$val;
- $r = check.expr(x, e$14.X); /* */ $s = 241; case 241: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 242; continue; }
- /* */ $s = 243; continue;
- /* if (x.mode === 0) { */ case 242:
- /* goto Error */ $s = 20; continue;
- /* } */ case 243:
- _r$46 = x.typ.Underlying(); /* */ $s = 244; case 244: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- _tuple$14 = $assertType(_r$46, ptrType$53, true); xtyp = _tuple$14[0];
- /* */ if (xtyp === ptrType$53.nil) { $s = 245; continue; }
- /* */ $s = 246; continue;
- /* if (xtyp === ptrType$53.nil) { */ case 245:
- _r$47 = x.pos(); /* */ $s = 247; case 247: if($c) { $c = false; _r$47 = _r$47.$blk(); } if (_r$47 && _r$47.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$47, "%s is not an interface", new sliceType([x])); /* */ $s = 248; case 248: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 246:
- /* */ if ($interfaceIsEqual(e$14.Type, $ifaceNil)) { $s = 249; continue; }
- /* */ $s = 250; continue;
- /* if ($interfaceIsEqual(e$14.Type, $ifaceNil)) { */ case 249:
- _r$48 = e$14.Pos(); /* */ $s = 251; case 251: if($c) { $c = false; _r$48 = _r$48.$blk(); } if (_r$48 && _r$48.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$48, "use of .(type) outside type switch", new sliceType([])); /* */ $s = 252; case 252: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 250:
- _r$49 = check.typ(e$14.Type); /* */ $s = 253; case 253: if($c) { $c = false; _r$49 = _r$49.$blk(); } if (_r$49 && _r$49.$blk !== undefined) { break s; }
- T = _r$49;
- /* */ if ($interfaceIsEqual(T, $pkg.Typ[0])) { $s = 254; continue; }
- /* */ $s = 255; continue;
- /* if ($interfaceIsEqual(T, $pkg.Typ[0])) { */ case 254:
- /* goto Error */ $s = 20; continue;
- /* } */ case 255:
- _r$50 = x.pos(); /* */ $s = 256; case 256: if($c) { $c = false; _r$50 = _r$50.$blk(); } if (_r$50 && _r$50.$blk !== undefined) { break s; }
- $r = check.typeAssertion(_r$50, x, xtyp, T); /* */ $s = 257; case 257: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 8;
- x.typ = T;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$50, true)[1]) { */ case 12:
- e$15 = _ref.$val;
- _r$51 = check.call(x, e$15); /* */ $s = 258; case 258: if($c) { $c = false; _r$51 = _r$51.$blk(); } if (_r$51 && _r$51.$blk !== undefined) { break s; }
- return _r$51;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$42, true)[1]) { */ case 13:
- e$16 = _ref.$val;
- $r = check.exprOrType(x, e$16.X); /* */ $s = 259; case 259: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$11 = x.mode;
- /* */ if (_ref$11 === 0) { $s = 260; continue; }
- /* */ if (_ref$11 === 3) { $s = 261; continue; }
- /* */ $s = 262; continue;
- /* if (_ref$11 === 0) { */ case 260:
- /* goto Error */ $s = 20; continue;
- $s = 263; continue;
- /* } else if (_ref$11 === 3) { */ case 261:
- x.typ = new Pointer.ptr(x.typ);
- $s = 263; continue;
- /* } else { */ case 262:
- _r$52 = x.typ.Underlying(); /* */ $s = 264; case 264: if($c) { $c = false; _r$52 = _r$52.$blk(); } if (_r$52 && _r$52.$blk !== undefined) { break s; }
- _tuple$15 = $assertType(_r$52, ptrType$15, true); typ$13 = _tuple$15[0]; ok$4 = _tuple$15[1];
- /* */ if (ok$4) { $s = 265; continue; }
- /* */ $s = 266; continue;
- /* if (ok$4) { */ case 265:
- x.mode = 5;
- x.typ = typ$13.base;
- $s = 267; continue;
- /* } else { */ case 266:
- _r$53 = x.pos(); /* */ $s = 268; case 268: if($c) { $c = false; _r$53 = _r$53.$blk(); } if (_r$53 && _r$53.$blk !== undefined) { break s; }
- $r = check.invalidOp(_r$53, "cannot indirect %s", new sliceType([x])); /* */ $s = 269; case 269: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- /* } */ case 267:
- /* } */ case 263:
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$36, true)[1]) { */ case 14:
- e$17 = _ref.$val;
- $r = check.expr(x, e$17.X); /* */ $s = 270; case 270: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 271; continue; }
- /* */ $s = 272; continue;
- /* if (x.mode === 0) { */ case 271:
- /* goto Error */ $s = 20; continue;
- /* } */ case 272:
- $r = check.unary(x, e$17, e$17.Op); /* */ $s = 273; case 273: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 274; continue; }
- /* */ $s = 275; continue;
- /* if (x.mode === 0) { */ case 274:
- /* goto Error */ $s = 20; continue;
- /* } */ case 275:
- if (e$17.Op === 36) {
- x.expr = e$17;
- return 2;
- }
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$52, true)[1]) { */ case 15:
- e$18 = _ref.$val;
- $r = check.binary(x, e$18, e$18.X, e$18.Y, e$18.Op); /* */ $s = 276; case 276: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x.mode === 0) { $s = 277; continue; }
- /* */ $s = 278; continue;
- /* if (x.mode === 0) { */ case 277:
- /* goto Error */ $s = 20; continue;
- /* } */ case 278:
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$43, true)[1]) { */ case 16:
- e$19 = _ref.$val;
- _r$54 = e$19.Pos(); /* */ $s = 279; case 279: if($c) { $c = false; _r$54 = _r$54.$blk(); } if (_r$54 && _r$54.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$54, "no key:value expected", new sliceType([])); /* */ $s = 280; case 280: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* goto Error */ $s = 20; continue;
- $s = 19; continue;
- /* } else if ($assertType(_ref, ptrType$44, true)[1] || $assertType(_ref, ptrType$45, true)[1] || $assertType(_ref, ptrType$46, true)[1] || $assertType(_ref, ptrType$47, true)[1] || $assertType(_ref, ptrType$48, true)[1] || $assertType(_ref, ptrType$49, true)[1]) { */ case 17:
- e$20 = _ref;
- x.mode = 3;
- _r$55 = check.typ(e$20); /* */ $s = 281; case 281: if($c) { $c = false; _r$55 = _r$55.$blk(); } if (_r$55 && _r$55.$blk !== undefined) { break s; }
- x.typ = _r$55;
- $s = 19; continue;
- /* } else { */ case 18:
- e$21 = _ref;
- _r$56 = e$21.Pos(); /* */ $s = 282; case 282: if($c) { $c = false; _r$56 = _r$56.$blk(); } if (_r$56 && _r$56.$blk !== undefined) { break s; }
- _r$57 = check.fset.Position(_r$56); /* */ $s = 283; case 283: if($c) { $c = false; _r$57 = _r$57.$blk(); } if (_r$57 && _r$57.$blk !== undefined) { break s; }
- _arg = (x$4 = _r$57, new x$4.constructor.elem(x$4));
- _arg$1 = e$21;
- _r$58 = fmt.Sprintf("%s: unknown expression type %T", new sliceType([_arg, _arg$1])); /* */ $s = 284; case 284: if($c) { $c = false; _r$58 = _r$58.$blk(); } if (_r$58 && _r$58.$blk !== undefined) { break s; }
- $panic(new $String(_r$58));
- /* } */ case 19:
- x.expr = e;
- return 1;
- /* Error: */ case 20:
- x.mode = 0;
- x.expr = e;
- return 2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.exprInternal }; } $f.$ptr = $ptr; $f.T = T; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$4 = _r$4; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._r$42 = _r$42; $f._r$43 = _r$43; $f._r$44 = _r$44; $f._r$45 = _r$45; $f._r$46 = _r$46; $f._r$47 = _r$47; $f._r$48 = _r$48; $f._r$49 = _r$49; $f._r$5 = _r$5; $f._r$50 = _r$50; $f._r$51 = _r$51; $f._r$52 = _r$52; $f._r$53 = _r$53; $f._r$54 = _r$54; $f._r$55 = _r$55; $f._r$56 = _r$56; $f._r$57 = _r$57; $f._r$58 = _r$58; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$10 = _ref$10; $f._ref$11 = _ref$11; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$11 = _tuple$11; $f._tuple$12 = _tuple$12; $f._tuple$13 = _tuple$13; $f._tuple$14 = _tuple$14; $f._tuple$15 = _tuple$15; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.atyp = atyp; $f.check = check; $f.duplicate = duplicate; $f.e = e; $f.e$1 = e$1; $f.e$10 = e$10; $f.e$11 = e$11; $f.e$12 = e$12; $f.e$13 = e$13; $f.e$14 = e$14; $f.e$15 = e$15; $f.e$16 = e$16; $f.e$17 = e$17; $f.e$18 = e$18; $f.e$19 = e$19; $f.e$2 = e$2; $f.e$20 = e$20; $f.e$21 = e$21; $f.e$3 = e$3; $f.e$4 = e$4; $f.e$5 = e$5; $f.e$6 = e$6; $f.e$7 = e$7; $f.e$8 = e$8; $f.e$9 = e$9; $f.ellip = ellip; $f.etyp = etyp; $f.etyp$1 = etyp$1; $f.expr = expr; $f.fields = fields; $f.fld = fld; $f.fld$1 = fld$1; $f.hint = hint; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.ind = ind; $f.key = key; $f.key$1 = key$1; $f.kind = kind; $f.kv = kv; $f.kv$1 = kv$1; $f.kv$2 = kv$2; $f.length = length; $f.length$1 = length$1; $f.max = max; $f.n = n; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.ok$3 = ok$3; $f.ok$4 = ok$4; $f.openArray = openArray; $f.sig = sig; $f.t = t; $f.typ = typ; $f.typ$1 = typ$1; $f.typ$10 = typ$10; $f.typ$11 = typ$11; $f.typ$12 = typ$12; $f.typ$13 = typ$13; $f.typ$2 = typ$2; $f.typ$3 = typ$3; $f.typ$4 = typ$4; $f.typ$5 = typ$5; $f.typ$6 = typ$6; $f.typ$7 = typ$7; $f.typ$8 = typ$8; $f.typ$9 = typ$9; $f.utyp = utyp; $f.utyp$1 = utyp$1; $f.utyp$2 = utyp$2; $f.utyp$3 = utyp$3; $f.utyp$4 = utyp$4; $f.valid = valid; $f.valid$1 = valid$1; $f.visited = visited; $f.visited$1 = visited$1; $f.vtyp = vtyp; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.xtyp = xtyp; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.exprInternal = function(x, e, hint) { return this.$val.exprInternal(x, e, hint); };
- Checker.ptr.prototype.typeAssertion = function(pos, x, xtyp, T) {
- var $ptr, T, _r, _tuple, check, method, msg, pos, wrongType, x, xtyp, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _tuple = $f._tuple; check = $f.check; method = $f.method; msg = $f.msg; pos = $f.pos; wrongType = $f.wrongType; x = $f.x; xtyp = $f.xtyp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = assertableTo(xtyp, T); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; method = _tuple[0]; wrongType = _tuple[1];
- if (method === ptrType$6.nil) {
- return;
- }
- msg = "";
- if (wrongType) {
- msg = "wrong type for method";
- } else {
- msg = "missing method";
- }
- $r = check.errorf(pos, "%s cannot have dynamic type %s (%s %s)", new sliceType([x, T, new $String(msg), new $String(method.object.name)])); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.typeAssertion }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._tuple = _tuple; $f.check = check; $f.method = method; $f.msg = msg; $f.pos = pos; $f.wrongType = wrongType; $f.x = x; $f.xtyp = xtyp; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.typeAssertion = function(pos, x, xtyp, T) { return this.$val.typeAssertion(pos, x, xtyp, T); };
- Checker.ptr.prototype.expr = function(x, e) {
- var $ptr, _r, _r$1, _ref, check, e, msg, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; check = $f.check; e = $f.e; msg = $f.msg; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = check.rawExpr(x, e, $ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- msg = "";
- _ref = x.mode;
- if (_ref === 1) {
- msg = "used as value";
- } else if (_ref === 2) {
- msg = "must be called";
- } else if (_ref === 3) {
- msg = "is not an expression";
- } else {
- return;
- }
- _r$1 = x.pos(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "%s %s", new sliceType([x, new $String(msg)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.expr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.check = check; $f.e = e; $f.msg = msg; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.expr = function(x, e) { return this.$val.expr(x, e); };
- Checker.ptr.prototype.exprWithHint = function(x, e, hint) {
- var $ptr, _r, _r$1, _ref, check, e, hint, msg, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; check = $f.check; e = $f.e; hint = $f.hint; msg = $f.msg; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- assert(!($interfaceIsEqual(hint, $ifaceNil)));
- _r = check.rawExpr(x, e, hint); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- msg = "";
- _ref = x.mode;
- if (_ref === 1) {
- msg = "used as value";
- } else if (_ref === 2) {
- msg = "must be called";
- } else if (_ref === 3) {
- msg = "is not an expression";
- } else {
- return;
- }
- _r$1 = x.pos(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "%s %s", new sliceType([x, new $String(msg)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.exprWithHint }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.check = check; $f.e = e; $f.hint = hint; $f.msg = msg; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.exprWithHint = function(x, e, hint) { return this.$val.exprWithHint(x, e, hint); };
- Checker.ptr.prototype.exprOrType = function(x, e) {
- var $ptr, _r, _r$1, check, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; check = $f.check; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = check.rawExpr(x, e, $ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- /* */ if (x.mode === 1) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (x.mode === 1) { */ case 2:
- _r$1 = x.pos(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "%s used as value or type", new sliceType([x])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x.mode = 0;
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.exprOrType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.check = check; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.exprOrType = function(x, e) { return this.$val.exprOrType(x, e); };
- ExprString = function(x) {
- var $ptr, buf, x;
- buf = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- WriteExpr(buf, x);
- return buf.String();
- };
- $pkg.ExprString = ExprString;
- WriteExpr = function(buf, x) {
- var $ptr, _i, _ref, _ref$1, _ref$2, arg, buf, i, s, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$3, x$4, x$5, x$6, x$7, x$8, x$9;
- _ref = x;
- if ($assertType(_ref, ptrType$5, true)[1]) {
- x$1 = _ref.$val;
- buf.WriteString(x$1.Name);
- } else if ($assertType(_ref, ptrType$54, true)[1]) {
- x$2 = _ref.$val;
- buf.WriteString("...");
- if (!($interfaceIsEqual(x$2.Elt, $ifaceNil))) {
- WriteExpr(buf, x$2.Elt);
- }
- } else if ($assertType(_ref, ptrType$51, true)[1]) {
- x$3 = _ref.$val;
- buf.WriteString(x$3.Value);
- } else if ($assertType(_ref, ptrType$38, true)[1]) {
- x$4 = _ref.$val;
- buf.WriteByte(40);
- WriteExpr(buf, x$4.Type);
- buf.WriteString(" literal)");
- } else if ($assertType(_ref, ptrType$35, true)[1]) {
- x$5 = _ref.$val;
- buf.WriteByte(40);
- WriteExpr(buf, x$5.Type);
- buf.WriteString(" literal)");
- } else if ($assertType(_ref, ptrType$16, true)[1]) {
- x$6 = _ref.$val;
- buf.WriteByte(40);
- WriteExpr(buf, x$6.X);
- buf.WriteByte(41);
- } else if ($assertType(_ref, ptrType$14, true)[1]) {
- x$7 = _ref.$val;
- WriteExpr(buf, x$7.X);
- buf.WriteByte(46);
- buf.WriteString(x$7.Sel.Name);
- } else if ($assertType(_ref, ptrType$39, true)[1]) {
- x$8 = _ref.$val;
- WriteExpr(buf, x$8.X);
- buf.WriteByte(91);
- WriteExpr(buf, x$8.Index);
- buf.WriteByte(93);
- } else if ($assertType(_ref, ptrType$40, true)[1]) {
- x$9 = _ref.$val;
- WriteExpr(buf, x$9.X);
- buf.WriteByte(91);
- if (!($interfaceIsEqual(x$9.Low, $ifaceNil))) {
- WriteExpr(buf, x$9.Low);
- }
- buf.WriteByte(58);
- if (!($interfaceIsEqual(x$9.High, $ifaceNil))) {
- WriteExpr(buf, x$9.High);
- }
- if (x$9.Slice3) {
- buf.WriteByte(58);
- if (!($interfaceIsEqual(x$9.Max, $ifaceNil))) {
- WriteExpr(buf, x$9.Max);
- }
- }
- buf.WriteByte(93);
- } else if ($assertType(_ref, ptrType$41, true)[1]) {
- x$10 = _ref.$val;
- WriteExpr(buf, x$10.X);
- buf.WriteString(".(");
- WriteExpr(buf, x$10.Type);
- buf.WriteByte(41);
- } else if ($assertType(_ref, ptrType$50, true)[1]) {
- x$11 = _ref.$val;
- WriteExpr(buf, x$11.Fun);
- buf.WriteByte(40);
- _ref$1 = x$11.Args;
- _i = 0;
- while (true) {
- if (!(_i < _ref$1.$length)) { break; }
- i = _i;
- arg = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- if (i > 0) {
- buf.WriteString(", ");
- }
- WriteExpr(buf, arg);
- _i++;
- }
- if (new token.Pos(x$11.Ellipsis).IsValid()) {
- buf.WriteString("...");
- }
- buf.WriteByte(41);
- } else if ($assertType(_ref, ptrType$42, true)[1]) {
- x$12 = _ref.$val;
- buf.WriteByte(42);
- WriteExpr(buf, x$12.X);
- } else if ($assertType(_ref, ptrType$36, true)[1]) {
- x$13 = _ref.$val;
- buf.WriteString(new token.Token(x$13.Op).String());
- WriteExpr(buf, x$13.X);
- } else if ($assertType(_ref, ptrType$52, true)[1]) {
- x$14 = _ref.$val;
- WriteExpr(buf, x$14.X);
- buf.WriteByte(32);
- buf.WriteString(new token.Token(x$14.Op).String());
- buf.WriteByte(32);
- WriteExpr(buf, x$14.Y);
- } else if ($assertType(_ref, ptrType$44, true)[1]) {
- x$15 = _ref.$val;
- buf.WriteByte(91);
- if (!($interfaceIsEqual(x$15.Len, $ifaceNil))) {
- WriteExpr(buf, x$15.Len);
- }
- buf.WriteByte(93);
- WriteExpr(buf, x$15.Elt);
- } else if ($assertType(_ref, ptrType$45, true)[1]) {
- x$16 = _ref.$val;
- buf.WriteString("struct{");
- writeFieldList(buf, x$16.Fields, "; ", false);
- buf.WriteByte(125);
- } else if ($assertType(_ref, ptrType$46, true)[1]) {
- x$17 = _ref.$val;
- buf.WriteString("func");
- writeSigExpr(buf, x$17);
- } else if ($assertType(_ref, ptrType$47, true)[1]) {
- x$18 = _ref.$val;
- buf.WriteString("interface{");
- writeFieldList(buf, x$18.Methods, "; ", true);
- buf.WriteByte(125);
- } else if ($assertType(_ref, ptrType$48, true)[1]) {
- x$19 = _ref.$val;
- buf.WriteString("map[");
- WriteExpr(buf, x$19.Key);
- buf.WriteByte(93);
- WriteExpr(buf, x$19.Value);
- } else if ($assertType(_ref, ptrType$49, true)[1]) {
- x$20 = _ref.$val;
- s = "";
- _ref$2 = x$20.Dir;
- if (_ref$2 === 1) {
- s = "chan<- ";
- } else if (_ref$2 === 2) {
- s = "<-chan ";
- } else {
- s = "chan ";
- }
- buf.WriteString(s);
- WriteExpr(buf, x$20.Value);
- } else {
- x$21 = _ref;
- buf.WriteString("(bad expr)");
- }
- };
- $pkg.WriteExpr = WriteExpr;
- writeSigExpr = function(buf, sig) {
- var $ptr, buf, n, res, sig, x, x$1;
- buf.WriteByte(40);
- writeFieldList(buf, sig.Params, ", ", false);
- buf.WriteByte(41);
- res = sig.Results;
- n = res.NumFields();
- if (n === 0) {
- return;
- }
- buf.WriteByte(32);
- if ((n === 1) && ((x = res.List, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Names.$length === 0)) {
- WriteExpr(buf, (x$1 = res.List, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])).Type);
- return;
- }
- buf.WriteByte(40);
- writeFieldList(buf, res, ", ", false);
- buf.WriteByte(41);
- };
- writeFieldList = function(buf, fields, sep, iface) {
- var $ptr, _i, _i$1, _ref, _ref$1, _tuple, buf, f, fields, i, i$1, iface, name, sep, sig;
- _ref = fields.List;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (i > 0) {
- buf.WriteString(sep);
- }
- _ref$1 = f.Names;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- i$1 = _i$1;
- name = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- if (i$1 > 0) {
- buf.WriteString(", ");
- }
- buf.WriteString(name.Name);
- _i$1++;
- }
- _tuple = $assertType(f.Type, ptrType$46, true); sig = _tuple[0];
- if (!(sig === ptrType$46.nil) && iface) {
- writeSigExpr(buf, sig);
- _i++;
- continue;
- }
- if (f.Names.$length > 0) {
- buf.WriteByte(32);
- }
- WriteExpr(buf, f.Type);
- _i++;
- }
- };
- slice3 = function(x) {
- var $ptr, x;
- return x.Slice3;
- };
- sliceMax = function(x) {
- var $ptr, x;
- return x.Max;
- };
- Checker.ptr.prototype.initOrder = function() {
- var $ptr, _entry, _entry$1, _i, _key$2, _r, _ref, _tuple, check, cycle, emitted, i, info, infoLhs, init$1, mark, n, out, pq, v, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _key$2 = $f._key$2; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; check = $f.check; cycle = $f.cycle; emitted = $f.emitted; i = $f.i; info = $f.info; infoLhs = $f.infoLhs; init$1 = $f.init$1; mark = $f.mark; n = $f.n; out = $f.out; pq = $f.pq; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pq = [pq];
- check = this;
- check.Info.InitOrder = $subslice(check.Info.InitOrder, 0, 0);
- pq[0] = (x = dependencyGraph(check.objMap), $subslice(new nodeQueue(x.$array), x.$offset, x.$offset + x.$length));
- $r = heap.Init((pq.$ptr || (pq.$ptr = new ptrType$55(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, pq)))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- mark = 0;
- emitted = new $Map();
- /* while (true) { */ case 2:
- /* if (!(pq[0].$length > 0)) { break; } */ if(!(pq[0].$length > 0)) { $s = 3; continue; }
- _r = heap.Pop((pq.$ptr || (pq.$ptr = new ptrType$55(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, pq)))); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n = $assertType(_r, ptrType$56);
- /* */ if (n.in$1 > 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (n.in$1 > 0) { */ case 5:
- mark = mark + (1) >> 0;
- cycle = findPath(n, n, mark);
- i = valIndex(cycle);
- /* */ if (i >= 0) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (i >= 0) { */ case 7:
- $r = check.reportCycle(cycle, i); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* } */ case 6:
- _ref = n.out;
- _i = 0;
- /* while (true) { */ case 10:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 11; continue; }
- out = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- out.in$1 = out.in$1 - (1) >> 0;
- $r = heap.Fix((pq.$ptr || (pq.$ptr = new ptrType$55(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, pq))), out.index); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 10; continue; case 11:
- _tuple = $assertType(n.obj, ptrType$9, true); v = _tuple[0];
- info = (_entry = check.objMap[Object.keyFor(v)], _entry !== undefined ? _entry.v : ptrType$21.nil);
- /* */ if (v === ptrType$9.nil || !info.hasInitializer()) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (v === ptrType$9.nil || !info.hasInitializer()) { */ case 13:
- /* continue; */ $s = 2; continue;
- /* } */ case 14:
- /* */ if ((_entry$1 = emitted[ptrType$21.keyFor(info)], _entry$1 !== undefined ? _entry$1.v : false)) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if ((_entry$1 = emitted[ptrType$21.keyFor(info)], _entry$1 !== undefined ? _entry$1.v : false)) { */ case 15:
- /* continue; */ $s = 2; continue;
- /* } */ case 16:
- _key$2 = info; (emitted || $throwRuntimeError("assignment to entry in nil map"))[ptrType$21.keyFor(_key$2)] = { k: _key$2, v: true };
- infoLhs = info.lhs;
- if (infoLhs === sliceType$1.nil) {
- infoLhs = new sliceType$1([v]);
- }
- init$1 = new Initializer.ptr(infoLhs, info.init);
- check.Info.InitOrder = $append(check.Info.InitOrder, init$1);
- /* } */ $s = 2; continue; case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.initOrder }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._key$2 = _key$2; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.check = check; $f.cycle = cycle; $f.emitted = emitted; $f.i = i; $f.info = info; $f.infoLhs = infoLhs; $f.init$1 = init$1; $f.mark = mark; $f.n = n; $f.out = out; $f.pq = pq; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.initOrder = function() { return this.$val.initOrder(); };
- findPath = function(a, z, mark) {
- var $ptr, P, _i, _ref, a, mark, n, z;
- if (a.mark === mark) {
- return sliceType$14.nil;
- }
- a.mark = mark;
- _ref = a.out;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- n = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (n === z) {
- return new sliceType$14([z]);
- }
- P = findPath(n, z, mark);
- if (!(P === sliceType$14.nil)) {
- return $append(P, n);
- }
- _i++;
- }
- return sliceType$14.nil;
- };
- valIndex = function(a) {
- var $ptr, _i, _ref, _ref$1, a, i, n;
- _ref = a;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- n = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = n.obj;
- if ($assertType(_ref$1, ptrType$2, true)[1] || $assertType(_ref$1, ptrType$9, true)[1]) {
- return i;
- }
- _i++;
- }
- return -1;
- };
- Checker.ptr.prototype.reportCycle = function(cycle, i) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, check, cycle, i, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; check = $f.check; cycle = $f.cycle; i = $f.i; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- obj = ((i < 0 || i >= cycle.$length) ? $throwRuntimeError("index out of range") : cycle.$array[cycle.$offset + i]).obj;
- _r = obj.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg = _r;
- _r$1 = obj.Name(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$1);
- $r = check.errorf(_arg, "initialization cycle for %s", new sliceType([_arg$1])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = cycle;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- _r$2 = obj.Pos(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$2 = _r$2;
- _r$3 = obj.Name(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$3 = new $String(_r$3);
- $r = check.errorf(_arg$2, "\t%s refers to", new sliceType([_arg$3])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- if (i >= cycle.$length) {
- i = 0;
- }
- obj = ((i < 0 || i >= cycle.$length) ? $throwRuntimeError("index out of range") : cycle.$array[cycle.$offset + i]).obj;
- _i++;
- /* } */ $s = 4; continue; case 5:
- _r$4 = obj.Pos(); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$4 = _r$4;
- _r$5 = obj.Name(); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$5 = new $String(_r$5);
- $r = check.errorf(_arg$4, "\t%s", new sliceType([_arg$5])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.reportCycle }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.check = check; $f.cycle = cycle; $f.i = i; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.reportCycle = function(cycle, i) { return this.$val.reportCycle(cycle, i); };
- dependencyGraph = function(objMap) {
- var $ptr, G, M, _entry, _entry$1, _entry$2, _entry$3, _entry$4, _i, _i$1, _i$2, _key$2, _keys, _keys$1, _keys$2, _ref, _ref$1, _ref$2, d, d$1, deps, i, n, obj, obj$1, objMap;
- M = new $Map();
- _ref = objMap;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- obj = _entry.k;
- _key$2 = obj; (M || $throwRuntimeError("assignment to entry in nil map"))[Object.keyFor(_key$2)] = { k: _key$2, v: new objNode.ptr(obj, 0, sliceType$14.nil, 0, 0) };
- _i++;
- }
- G = $makeSlice(sliceType$14, $keys(M).length);
- i = 0;
- _ref$1 = M;
- _i$1 = 0;
- _keys$1 = $keys(_ref$1);
- while (true) {
- if (!(_i$1 < _keys$1.length)) { break; }
- _entry$1 = _ref$1[_keys$1[_i$1]];
- if (_entry$1 === undefined) {
- _i$1++;
- continue;
- }
- obj$1 = _entry$1.k;
- n = _entry$1.v;
- deps = (_entry$2 = objMap[Object.keyFor(obj$1)], _entry$2 !== undefined ? _entry$2.v : ptrType$21.nil).deps;
- n.in$1 = $keys(deps).length;
- _ref$2 = deps;
- _i$2 = 0;
- _keys$2 = $keys(_ref$2);
- while (true) {
- if (!(_i$2 < _keys$2.length)) { break; }
- _entry$3 = _ref$2[_keys$2[_i$2]];
- if (_entry$3 === undefined) {
- _i$2++;
- continue;
- }
- d = _entry$3.k;
- d$1 = (_entry$4 = M[Object.keyFor(d)], _entry$4 !== undefined ? _entry$4.v : ptrType$56.nil);
- d$1.out = $append(d$1.out, n);
- _i$2++;
- }
- ((i < 0 || i >= G.$length) ? $throwRuntimeError("index out of range") : G.$array[G.$offset + i] = n);
- n.index = i;
- i = i + (1) >> 0;
- _i$1++;
- }
- return G;
- };
- nodeQueue.prototype.Len = function() {
- var $ptr, a;
- a = this;
- return a.$length;
- };
- $ptrType(nodeQueue).prototype.Len = function() { return this.$get().Len(); };
- nodeQueue.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, a, i, j, x, y;
- a = this;
- _tmp = ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]); _tmp$1 = ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]); x = _tmp; y = _tmp$1;
- _tmp$2 = y; _tmp$3 = x; ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = _tmp$2); ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j] = _tmp$3);
- _tmp$4 = j; _tmp$5 = i; x.index = _tmp$4; y.index = _tmp$5;
- };
- $ptrType(nodeQueue).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- nodeQueue.prototype.Less = function(i, j) {
- var $ptr, _r, _r$1, _tmp, _tmp$1, _v, _v$1, a, i, j, x, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _v = $f._v; _v$1 = $f._v$1; a = $f.a; i = $f.i; j = $f.j; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = this;
- _tmp = ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]); _tmp$1 = ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]); x = _tmp; y = _tmp$1;
- if (x.in$1 < y.in$1) { _v = true; $s = 1; continue s; }
- if (!(x.in$1 === y.in$1)) { _v$1 = false; $s = 2; continue s; }
- _r = x.obj.order(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = y.obj.order(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v$1 = _r < _r$1; case 2:
- _v = _v$1; case 1:
- return _v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: nodeQueue.prototype.Less }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._v = _v; $f._v$1 = _v$1; $f.a = a; $f.i = i; $f.j = j; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(nodeQueue).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- $ptrType(nodeQueue).prototype.Push = function(x) {
- var $ptr, a, x;
- a = this;
- $panic(new $String("unreachable"));
- };
- $ptrType(nodeQueue).prototype.Pop = function() {
- var $ptr, a, n, x, x$1, x$2;
- a = this;
- n = a.$get().$length;
- x$2 = (x = a.$get(), x$1 = n - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- x$2.index = -1;
- a.$set($subslice((a.$get()), 0, (n - 1 >> 0)));
- return x$2;
- };
- Checker.ptr.prototype.labels = function(body) {
- var $ptr, _entry, _i, _i$1, _keys, _r, _ref, _ref$1, all, alt, body, check, fwdJumps, jmp, lbl, msg, name, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _keys = $f._keys; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; all = $f.all; alt = $f.alt; body = $f.body; check = $f.check; fwdJumps = $f.fwdJumps; jmp = $f.jmp; lbl = $f.lbl; msg = $f.msg; name = $f.name; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- all = NewScope(ptrType.nil, body.Pos(), body.End(), "label");
- _r = check.blockBranches(all, ptrType$57.nil, ptrType$58.nil, body.List); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- fwdJumps = _r;
- _ref = fwdJumps;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- jmp = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- msg = "";
- name = jmp.Label.Name;
- alt = all.Lookup(name);
- if (!($interfaceIsEqual(alt, $ifaceNil))) {
- msg = "goto %s jumps into block";
- $assertType(alt, ptrType$59).used = true;
- } else {
- msg = "label %s not declared";
- }
- $r = check.errorf(jmp.Label.Pos(), msg, new sliceType([new $String(name)])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 2; continue; case 3:
- _ref$1 = all.elems;
- _i$1 = 0;
- _keys = $keys(_ref$1);
- /* while (true) { */ case 5:
- /* if (!(_i$1 < _keys.length)) { break; } */ if(!(_i$1 < _keys.length)) { $s = 6; continue; }
- _entry = _ref$1[_keys[_i$1]];
- if (_entry === undefined) {
- _i$1++;
- /* continue; */ $s = 5; continue;
- }
- obj = _entry.v;
- lbl = $assertType(obj, ptrType$59);
- /* */ if (!lbl.used) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!lbl.used) { */ case 7:
- $r = check.softErrorf(lbl.object.pos, "label %s declared but not used", new sliceType([new $String(lbl.object.name)])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- _i$1++;
- /* } */ $s = 5; continue; case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.labels }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._keys = _keys; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.all = all; $f.alt = alt; $f.body = body; $f.check = check; $f.fwdJumps = fwdJumps; $f.jmp = jmp; $f.lbl = lbl; $f.msg = msg; $f.name = name; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.labels = function(body) { return this.$val.labels(body); };
- block.ptr.prototype.insert = function(s) {
- var $ptr, _key$2, b, labels, name, s;
- b = this;
- name = s.Label.Name;
- labels = b.labels;
- if (labels === false) {
- labels = new $Map();
- b.labels = labels;
- }
- _key$2 = name; (labels || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$2)] = { k: _key$2, v: s };
- };
- block.prototype.insert = function(s) { return this.$val.insert(s); };
- block.ptr.prototype.gotoTarget = function(name) {
- var $ptr, _entry, b, name, s, t;
- b = this;
- s = b;
- while (true) {
- if (!(!(s === ptrType$57.nil))) { break; }
- t = (_entry = s.labels[$String.keyFor(name)], _entry !== undefined ? _entry.v : ptrType$58.nil);
- if (!(t === ptrType$58.nil)) {
- return t;
- }
- s = s.parent;
- }
- return ptrType$58.nil;
- };
- block.prototype.gotoTarget = function(name) { return this.$val.gotoTarget(name); };
- block.ptr.prototype.enclosingTarget = function(name) {
- var $ptr, b, name, s, t;
- b = this;
- s = b;
- while (true) {
- if (!(!(s === ptrType$57.nil))) { break; }
- t = s.lstmt;
- if (!(t === ptrType$58.nil) && t.Label.Name === name) {
- return t;
- }
- s = s.parent;
- }
- return ptrType$58.nil;
- };
- block.prototype.enclosingTarget = function(name) { return this.$val.enclosingTarget(name); };
- Checker.ptr.prototype.blockBranches = function(all, parent, lstmt, list) {
- var $ptr, _i, _ref, _tmp, _tmp$1, all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, list, lstmt, parent, recordVarDecl, s, stmtBranches, varDeclPos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; all = $f.all; b = $f.b; badJumps = $f.badJumps; blockBranches = $f.blockBranches; check = $f.check; fwdJumps = $f.fwdJumps; jumpsOverVarDecl = $f.jumpsOverVarDecl; list = $f.list; lstmt = $f.lstmt; parent = $f.parent; recordVarDecl = $f.recordVarDecl; s = $f.s; stmtBranches = $f.stmtBranches; varDeclPos = $f.varDeclPos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- all = [all];
- b = [b];
- badJumps = [badJumps];
- blockBranches = [blockBranches];
- check = [check];
- fwdJumps = [fwdJumps];
- jumpsOverVarDecl = [jumpsOverVarDecl];
- lstmt = [lstmt];
- recordVarDecl = [recordVarDecl];
- stmtBranches = [stmtBranches];
- varDeclPos = [varDeclPos];
- check[0] = this;
- b[0] = new block.ptr(parent, lstmt[0], false);
- varDeclPos[0] = 0;
- _tmp = sliceType$15.nil; _tmp$1 = sliceType$15.nil; fwdJumps[0] = _tmp; badJumps[0] = _tmp$1;
- recordVarDecl[0] = (function(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos) { return function(pos) {
- var $ptr, pos;
- varDeclPos[0] = pos;
- badJumps[0] = $appendSlice($subslice(badJumps[0], 0, 0), fwdJumps[0]);
- }; })(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos);
- jumpsOverVarDecl[0] = (function(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos) { return function(jmp) {
- var $ptr, _i, _ref, bad, jmp;
- if (new token.Pos(varDeclPos[0]).IsValid()) {
- _ref = badJumps[0];
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- bad = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (jmp === bad) {
- return true;
- }
- _i++;
- }
- }
- return false;
- }; })(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos);
- blockBranches[0] = (function(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos) { return function $b(lstmt$1, list$1) {
- var $ptr, _r, list$1, lstmt$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; list$1 = $f.list$1; lstmt$1 = $f.lstmt$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = check[0].blockBranches(all[0], b[0], lstmt$1, list$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- fwdJumps[0] = $appendSlice(fwdJumps[0], _r);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f.list$1 = list$1; $f.lstmt$1 = lstmt$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos);
- stmtBranches[0] = $throwNilPointerError;
- stmtBranches[0] = (function(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos) { return function $b(s) {
- var $ptr, _arg, _arg$1, _arg$2, _i, _r, _r$1, _r$2, _r$3, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, alt, d, i, jmp, lbl, name, name$1, obj, s, s$1, s$10, s$11, s$12, s$13, s$2, s$3, s$4, s$5, s$6, s$7, s$8, s$9, t, t$1, valid, valid$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; alt = $f.alt; d = $f.d; i = $f.i; jmp = $f.jmp; lbl = $f.lbl; name = $f.name; name$1 = $f.name$1; obj = $f.obj; s = $f.s; s$1 = $f.s$1; s$10 = $f.s$10; s$11 = $f.s$11; s$12 = $f.s$12; s$13 = $f.s$13; s$2 = $f.s$2; s$3 = $f.s$3; s$4 = $f.s$4; s$5 = $f.s$5; s$6 = $f.s$6; s$7 = $f.s$7; s$8 = $f.s$8; s$9 = $f.s$9; t = $f.t; t$1 = $f.t$1; valid = $f.valid; valid$1 = $f.valid$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = s;
- /* */ if ($assertType(_ref, ptrType$61, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$58, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$60, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$62, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$29, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$63, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$64, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$65, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$66, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$67, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$68, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$69, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$70, true)[1]) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if ($assertType(_ref, ptrType$61, true)[1]) { */ case 1:
- s$1 = _ref.$val;
- _tuple = $assertType(s$1.Decl, ptrType$31, true); d = _tuple[0];
- /* */ if (!(d === ptrType$31.nil) && (d.Tok === 85)) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!(d === ptrType$31.nil) && (d.Tok === 85)) { */ case 15:
- $r = recordVarDecl[0](d.Pos()); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 16:
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$58, true)[1]) { */ case 2:
- s$2 = _ref.$val;
- name = s$2.Label.Name;
- /* */ if (!(name === "_")) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!(name === "_")) { */ case 18:
- lbl = NewLabel(s$2.Label.Pos(), check[0].pkg, name);
- _r = all[0].Insert(lbl); /* */ $s = 20; case 20: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- alt = _r;
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil))) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil))) { */ case 21:
- $r = check[0].softErrorf(lbl.object.pos, "label %s already declared", new sliceType([new $String(name)])); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].reportAltDecl(alt); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else { */ case 22:
- b[0].insert(s$2);
- check[0].recordDef(s$2.Label, lbl);
- /* } */ case 23:
- i = 0;
- _ref$1 = fwdJumps[0];
- _i = 0;
- /* while (true) { */ case 26:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 27; continue; }
- jmp = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- /* */ if (jmp.Label.Name === name) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (jmp.Label.Name === name) { */ case 28:
- lbl.used = true;
- check[0].recordUse(jmp.Label, lbl);
- _r$1 = jumpsOverVarDecl[0](jmp); /* */ $s = 33; case 33: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (_r$1) { */ case 31:
- _arg = jmp.Label.Pos();
- _arg$1 = new $String(name);
- _r$2 = check[0].fset.Position(varDeclPos[0]); /* */ $s = 34; case 34: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$2 = new $Int(_r$2.Line);
- $r = check[0].softErrorf(_arg, "goto %s jumps over variable declaration at line %d", new sliceType([_arg$1, _arg$2])); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 32:
- $s = 30; continue;
- /* } else { */ case 29:
- ((i < 0 || i >= fwdJumps[0].$length) ? $throwRuntimeError("index out of range") : fwdJumps[0].$array[fwdJumps[0].$offset + i] = jmp);
- i = i + (1) >> 0;
- /* } */ case 30:
- _i++;
- /* } */ $s = 26; continue; case 27:
- fwdJumps[0] = $subslice(fwdJumps[0], 0, i);
- lstmt[0] = s$2;
- /* } */ case 19:
- $r = stmtBranches[0](s$2.Stmt); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$60, true)[1]) { */ case 3:
- s$3 = _ref.$val;
- if (s$3.Label === ptrType$5.nil) {
- return;
- }
- name$1 = s$3.Label.Name;
- _ref$2 = s$3.Tok;
- /* */ if (_ref$2 === 61) { $s = 37; continue; }
- /* */ if (_ref$2 === 65) { $s = 38; continue; }
- /* */ if (_ref$2 === 73) { $s = 39; continue; }
- /* */ $s = 40; continue;
- /* if (_ref$2 === 61) { */ case 37:
- valid = false;
- t = b[0].enclosingTarget(name$1);
- if (!(t === ptrType$58.nil)) {
- _ref$3 = t.Stmt;
- if ($assertType(_ref$3, ptrType$65, true)[1] || $assertType(_ref$3, ptrType$66, true)[1] || $assertType(_ref$3, ptrType$68, true)[1] || $assertType(_ref$3, ptrType$69, true)[1] || $assertType(_ref$3, ptrType$70, true)[1]) {
- valid = true;
- }
- }
- /* */ if (!valid) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (!valid) { */ case 42:
- $r = check[0].errorf(s$3.Label.Pos(), "invalid break label %s", new sliceType([new $String(name$1)])); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 43:
- $s = 41; continue;
- /* } else if (_ref$2 === 65) { */ case 38:
- valid$1 = false;
- t$1 = b[0].enclosingTarget(name$1);
- if (!(t$1 === ptrType$58.nil)) {
- _ref$4 = t$1.Stmt;
- if ($assertType(_ref$4, ptrType$69, true)[1] || $assertType(_ref$4, ptrType$70, true)[1]) {
- valid$1 = true;
- }
- }
- /* */ if (!valid$1) { $s = 45; continue; }
- /* */ $s = 46; continue;
- /* if (!valid$1) { */ case 45:
- $r = check[0].errorf(s$3.Label.Pos(), "invalid continue label %s", new sliceType([new $String(name$1)])); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 46:
- $s = 41; continue;
- /* } else if (_ref$2 === 73) { */ case 39:
- if (b[0].gotoTarget(name$1) === ptrType$58.nil) {
- fwdJumps[0] = $append(fwdJumps[0], s$3);
- return;
- }
- $s = 41; continue;
- /* } else { */ case 40:
- $r = check[0].invalidAST(s$3.Pos(), "branch statement: %s %s", new sliceType([new token.Token(s$3.Tok), new $String(name$1)])); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 41:
- obj = all[0].Lookup(name$1);
- $assertType(obj, ptrType$59).used = true;
- check[0].recordUse(s$3.Label, obj);
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$62, true)[1]) { */ case 4:
- s$4 = _ref.$val;
- /* */ if (s$4.Tok === 47) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (s$4.Tok === 47) { */ case 49:
- _r$3 = s$4.Pos(); /* */ $s = 51; case 51: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = recordVarDecl[0](_r$3); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 50:
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$29, true)[1]) { */ case 5:
- s$5 = _ref.$val;
- $r = blockBranches[0](lstmt[0], s$5.List); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$63, true)[1]) { */ case 6:
- s$6 = _ref.$val;
- $r = stmtBranches[0](s$6.Body); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$6.Else, $ifaceNil))) { $s = 55; continue; }
- /* */ $s = 56; continue;
- /* if (!($interfaceIsEqual(s$6.Else, $ifaceNil))) { */ case 55:
- $r = stmtBranches[0](s$6.Else); /* */ $s = 57; case 57: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 56:
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$64, true)[1]) { */ case 7:
- s$7 = _ref.$val;
- $r = blockBranches[0](ptrType$58.nil, s$7.Body); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$65, true)[1]) { */ case 8:
- s$8 = _ref.$val;
- $r = stmtBranches[0](s$8.Body); /* */ $s = 59; case 59: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$66, true)[1]) { */ case 9:
- s$9 = _ref.$val;
- $r = stmtBranches[0](s$9.Body); /* */ $s = 60; case 60: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$67, true)[1]) { */ case 10:
- s$10 = _ref.$val;
- $r = blockBranches[0](ptrType$58.nil, s$10.Body); /* */ $s = 61; case 61: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$68, true)[1]) { */ case 11:
- s$11 = _ref.$val;
- $r = stmtBranches[0](s$11.Body); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$69, true)[1]) { */ case 12:
- s$12 = _ref.$val;
- $r = stmtBranches[0](s$12.Body); /* */ $s = 63; case 63: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$70, true)[1]) { */ case 13:
- s$13 = _ref.$val;
- $r = stmtBranches[0](s$13.Body); /* */ $s = 64; case 64: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f.alt = alt; $f.d = d; $f.i = i; $f.jmp = jmp; $f.lbl = lbl; $f.name = name; $f.name$1 = name$1; $f.obj = obj; $f.s = s; $f.s$1 = s$1; $f.s$10 = s$10; $f.s$11 = s$11; $f.s$12 = s$12; $f.s$13 = s$13; $f.s$2 = s$2; $f.s$3 = s$3; $f.s$4 = s$4; $f.s$5 = s$5; $f.s$6 = s$6; $f.s$7 = s$7; $f.s$8 = s$8; $f.s$9 = s$9; $f.t = t; $f.t$1 = t$1; $f.valid = valid; $f.valid$1 = valid$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(all, b, badJumps, blockBranches, check, fwdJumps, jumpsOverVarDecl, lstmt, recordVarDecl, stmtBranches, varDeclPos);
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = stmtBranches[0](s); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- return fwdJumps[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.blockBranches }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.all = all; $f.b = b; $f.badJumps = badJumps; $f.blockBranches = blockBranches; $f.check = check; $f.fwdJumps = fwdJumps; $f.jumpsOverVarDecl = jumpsOverVarDecl; $f.list = list; $f.lstmt = lstmt; $f.parent = parent; $f.recordVarDecl = recordVarDecl; $f.s = s; $f.stmtBranches = stmtBranches; $f.varDeclPos = varDeclPos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.blockBranches = function(all, parent, lstmt, list) { return this.$val.blockBranches(all, parent, lstmt, list); };
- LookupFieldOrMethod = function(T, addressable, pkg, name) {
- var $ptr, T, _tmp, _tmp$1, _tmp$2, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, addressable, index, indirect, name, obj, ok, p, pkg, t;
- obj = $ifaceNil;
- index = sliceType$6.nil;
- indirect = false;
- _tuple = $assertType(T, ptrType$26, true); t = _tuple[0];
- if (!(t === ptrType$26.nil)) {
- _tuple$1 = $assertType(t.underlying, ptrType$15, true); p = _tuple$1[0];
- if (!(p === ptrType$15.nil)) {
- _tuple$2 = lookupFieldOrMethod(p, false, pkg, name); obj = _tuple$2[0]; index = _tuple$2[1]; indirect = _tuple$2[2];
- _tuple$3 = $assertType(obj, ptrType$6, true); ok = _tuple$3[1];
- if (ok) {
- _tmp = $ifaceNil; _tmp$1 = sliceType$6.nil; _tmp$2 = false; obj = _tmp; index = _tmp$1; indirect = _tmp$2;
- return [obj, index, indirect];
- }
- return [obj, index, indirect];
- }
- }
- _tuple$4 = lookupFieldOrMethod(T, addressable, pkg, name); obj = _tuple$4[0]; index = _tuple$4[1]; indirect = _tuple$4[2];
- return [obj, index, indirect];
- };
- $pkg.LookupFieldOrMethod = LookupFieldOrMethod;
- lookupFieldOrMethod = function(T, addressable, pkg, name) {
- var $ptr, T, _entry, _i, _i$1, _key$2, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tmp$10, _tmp$11, _tmp$12, _tmp$13, _tmp$14, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, addressable, current, e, f, f$1, i, i$1, i$2, index, indirect, isPtr, isPtr$1, m, m$1, name, named, next, obj, ok, pkg, seen, t, t$1, t$2, typ, typ$1, utyp;
- obj = $ifaceNil;
- index = sliceType$6.nil;
- indirect = false;
- if (name === "_") {
- return [obj, index, indirect];
- }
- _tuple = deref(T); typ = _tuple[0]; isPtr = _tuple[1];
- _tuple$1 = $assertType(typ, ptrType$26, true); named = _tuple$1[0];
- if (isPtr) {
- utyp = typ;
- if (!(named === ptrType$26.nil)) {
- utyp = named.underlying;
- }
- _tuple$2 = $assertType(utyp, ptrType$53, true); ok = _tuple$2[1];
- if (ok) {
- return [obj, index, indirect];
- }
- }
- current = new sliceType$16([new embeddedType.ptr(named, sliceType$6.nil, isPtr, false)]);
- seen = false;
- while (true) {
- if (!(current.$length > 0)) { break; }
- next = sliceType$16.nil;
- _ref = current;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- e = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), embeddedType);
- if (!(e.typ === ptrType$26.nil)) {
- if ((_entry = seen[ptrType$26.keyFor(e.typ)], _entry !== undefined ? _entry.v : false)) {
- _i++;
- continue;
- }
- if (seen === false) {
- seen = new $Map();
- }
- _key$2 = e.typ; (seen || $throwRuntimeError("assignment to entry in nil map"))[ptrType$26.keyFor(_key$2)] = { k: _key$2, v: true };
- _tuple$3 = lookupMethod(e.typ.methods, pkg, name); i = _tuple$3[0]; m = _tuple$3[1];
- if (!(m === ptrType$6.nil)) {
- assert(!($interfaceIsEqual(m.object.typ, $ifaceNil)));
- index = concat(e.index, i);
- if (!($interfaceIsEqual(obj, $ifaceNil)) || e.multiples) {
- _tmp = $ifaceNil; _tmp$1 = index; _tmp$2 = false; obj = _tmp; index = _tmp$1; indirect = _tmp$2;
- return [obj, index, indirect];
- }
- obj = m;
- indirect = e.indirect;
- _i++;
- continue;
- }
- typ = e.typ.underlying;
- }
- _ref$1 = typ;
- if ($assertType(_ref$1, ptrType$27, true)[1]) {
- t = _ref$1.$val;
- _ref$2 = t.fields;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$2.$length)) { break; }
- i$1 = _i$1;
- f = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- if (f.object.sameId(pkg, name)) {
- assert(!($interfaceIsEqual(f.object.typ, $ifaceNil)));
- index = concat(e.index, i$1);
- if (!($interfaceIsEqual(obj, $ifaceNil)) || e.multiples) {
- _tmp$3 = $ifaceNil; _tmp$4 = index; _tmp$5 = false; obj = _tmp$3; index = _tmp$4; indirect = _tmp$5;
- return [obj, index, indirect];
- }
- obj = f;
- indirect = e.indirect;
- _i$1++;
- continue;
- }
- if ($interfaceIsEqual(obj, $ifaceNil) && f.anonymous) {
- _tuple$4 = deref(f.object.typ); typ$1 = _tuple$4[0]; isPtr$1 = _tuple$4[1];
- _tuple$5 = $assertType(typ$1, ptrType$26, true); t$1 = _tuple$5[0];
- if (!(t$1 === ptrType$26.nil)) {
- next = $append(next, new embeddedType.ptr(t$1, concat(e.index, i$1), e.indirect || isPtr$1, e.multiples));
- }
- }
- _i$1++;
- }
- } else if ($assertType(_ref$1, ptrType$53, true)[1]) {
- t$2 = _ref$1.$val;
- _tuple$6 = lookupMethod(t$2.allMethods, pkg, name); i$2 = _tuple$6[0]; m$1 = _tuple$6[1];
- if (!(m$1 === ptrType$6.nil)) {
- assert(!($interfaceIsEqual(m$1.object.typ, $ifaceNil)));
- index = concat(e.index, i$2);
- if (!($interfaceIsEqual(obj, $ifaceNil)) || e.multiples) {
- _tmp$6 = $ifaceNil; _tmp$7 = index; _tmp$8 = false; obj = _tmp$6; index = _tmp$7; indirect = _tmp$8;
- return [obj, index, indirect];
- }
- obj = m$1;
- indirect = e.indirect;
- }
- }
- _i++;
- }
- if (!($interfaceIsEqual(obj, $ifaceNil))) {
- _tuple$7 = $assertType(obj, ptrType$6, true); f$1 = _tuple$7[0];
- if (!(f$1 === ptrType$6.nil) && ptrRecv(f$1) && !indirect && !addressable) {
- _tmp$9 = $ifaceNil; _tmp$10 = sliceType$6.nil; _tmp$11 = true; obj = _tmp$9; index = _tmp$10; indirect = _tmp$11;
- return [obj, index, indirect];
- }
- return [obj, index, indirect];
- }
- current = consolidateMultiples(next);
- }
- _tmp$12 = $ifaceNil; _tmp$13 = sliceType$6.nil; _tmp$14 = false; obj = _tmp$12; index = _tmp$13; indirect = _tmp$14;
- return [obj, index, indirect];
- };
- consolidateMultiples = function(list) {
- var $ptr, _entry, _i, _key$2, _ref, _tuple, e, found, i, list, n, prev;
- if (list.$length <= 1) {
- return list;
- }
- n = 0;
- prev = new $Map();
- _ref = list;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- e = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), embeddedType);
- _tuple = (_entry = prev[ptrType$26.keyFor(e.typ)], _entry !== undefined ? [_entry.v, true] : [0, false]); i = _tuple[0]; found = _tuple[1];
- if (found) {
- ((i < 0 || i >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + i]).multiples = true;
- } else {
- _key$2 = e.typ; (prev || $throwRuntimeError("assignment to entry in nil map"))[ptrType$26.keyFor(_key$2)] = { k: _key$2, v: n };
- $copy(((n < 0 || n >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + n]), e, embeddedType);
- n = n + (1) >> 0;
- }
- _i++;
- }
- return $subslice(list, 0, n);
- };
- MissingMethod = function(V, T, static$1) {
- var $ptr, T, V, _i, _i$1, _r, _r$1, _r$2, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, _tuple$2, _tuple$3, f, ityp, m, m$1, method, obj, obj$1, static$1, wrongType, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; V = $f.V; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; _tmp$5 = $f._tmp$5; _tmp$6 = $f._tmp$6; _tmp$7 = $f._tmp$7; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; f = $f.f; ityp = $f.ityp; m = $f.m; m$1 = $f.m$1; method = $f.method; obj = $f.obj; obj$1 = $f.obj$1; static$1 = $f.static$1; wrongType = $f.wrongType; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- method = ptrType$6.nil;
- wrongType = false;
- if (T.Empty()) {
- return [method, wrongType];
- }
- _r = V.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$53, true); ityp = _tuple[0];
- /* */ if (!(ityp === ptrType$53.nil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!(ityp === ptrType$53.nil)) { */ case 2:
- _ref = T.allMethods;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- m = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple$1 = lookupMethod(ityp.allMethods, m.object.pkg, m.object.name); obj = _tuple$1[1];
- /* */ if (obj === ptrType$6.nil) { $s = 6; continue; }
- _r$1 = Identical(obj.object.Type(), m.object.typ); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (obj === ptrType$6.nil) { */ case 6:
- if (static$1) {
- _tmp = m; _tmp$1 = false; method = _tmp; wrongType = _tmp$1;
- return [method, wrongType];
- }
- $s = 8; continue;
- /* } else if (!_r$1) { */ case 7:
- _tmp$2 = m; _tmp$3 = true; method = _tmp$2; wrongType = _tmp$3;
- return [method, wrongType];
- /* } */ case 8:
- _i++;
- /* } */ $s = 4; continue; case 5:
- return [method, wrongType];
- /* } */ case 3:
- _ref$1 = T.allMethods;
- _i$1 = 0;
- /* while (true) { */ case 10:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 11; continue; }
- m$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _tuple$2 = lookupFieldOrMethod(V, false, m$1.object.pkg, m$1.object.name); obj$1 = _tuple$2[0];
- _tuple$3 = $assertType(obj$1, ptrType$6, true); f = _tuple$3[0];
- if (f === ptrType$6.nil) {
- _tmp$4 = m$1; _tmp$5 = false; method = _tmp$4; wrongType = _tmp$5;
- return [method, wrongType];
- }
- _r$2 = Identical(f.object.typ, m$1.object.typ); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (!_r$2) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (!_r$2) { */ case 12:
- _tmp$6 = m$1; _tmp$7 = true; method = _tmp$6; wrongType = _tmp$7;
- return [method, wrongType];
- /* } */ case 13:
- _i$1++;
- /* } */ $s = 10; continue; case 11:
- return [method, wrongType];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: MissingMethod }; } $f.$ptr = $ptr; $f.T = T; $f.V = V; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f._tmp$5 = _tmp$5; $f._tmp$6 = _tmp$6; $f._tmp$7 = _tmp$7; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.f = f; $f.ityp = ityp; $f.m = m; $f.m$1 = m$1; $f.method = method; $f.obj = obj; $f.obj$1 = obj$1; $f.static$1 = static$1; $f.wrongType = wrongType; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.MissingMethod = MissingMethod;
- assertableTo = function(V, T) {
- var $ptr, T, V, _r, _r$1, _tuple, _tuple$1, method, ok, wrongType, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; V = $f.V; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; method = $f.method; ok = $f.ok; wrongType = $f.wrongType; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- method = ptrType$6.nil;
- wrongType = false;
- _r = T.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$53, true); ok = _tuple[1];
- /* */ if (ok && true) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (ok && true) { */ case 2:
- return [method, wrongType];
- /* } */ case 3:
- _r$1 = MissingMethod(T, V, false); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; method = _tuple$1[0]; wrongType = _tuple$1[1];
- return [method, wrongType];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: assertableTo }; } $f.$ptr = $ptr; $f.T = T; $f.V = V; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.method = method; $f.ok = ok; $f.wrongType = wrongType; $f.$s = $s; $f.$r = $r; return $f;
- };
- deref = function(typ) {
- var $ptr, _tuple, p, typ;
- _tuple = $assertType(typ, ptrType$15, true); p = _tuple[0];
- if (!(p === ptrType$15.nil)) {
- return [p.base, true];
- }
- return [typ, false];
- };
- derefStructPtr = function(typ) {
- var $ptr, _r, _r$1, _tuple, _tuple$1, ok, p, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; ok = $f.ok; p = $f.p; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$15, true); p = _tuple[0];
- /* */ if (!(p === ptrType$15.nil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!(p === ptrType$15.nil)) { */ case 2:
- _r$1 = p.base.Underlying(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r$1, ptrType$27, true); ok = _tuple$1[1];
- /* */ if (ok) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (ok) { */ case 5:
- return p.base;
- /* } */ case 6:
- /* } */ case 3:
- return typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: derefStructPtr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.ok = ok; $f.p = p; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- concat = function(list, i) {
- var $ptr, i, list, t;
- t = sliceType$6.nil;
- t = $appendSlice(t, list);
- return $append(t, i);
- };
- fieldIndex = function(fields, pkg, name) {
- var $ptr, _i, _ref, f, fields, i, name, pkg;
- if (!(name === "_")) {
- _ref = fields;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (f.object.sameId(pkg, name)) {
- return i;
- }
- _i++;
- }
- }
- return -1;
- };
- lookupMethod = function(methods, pkg, name) {
- var $ptr, _i, _ref, i, m, methods, name, pkg;
- if (!(name === "_")) {
- _ref = methods;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- m = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (m.object.sameId(pkg, name)) {
- return [i, m];
- }
- _i++;
- }
- }
- return [-1, ptrType$6.nil];
- };
- ptrRecv = function(f) {
- var $ptr, _tuple, f, isPtr;
- _tuple = deref($assertType(f.object.typ, ptrType$17).recv.object.typ); isPtr = _tuple[1];
- return isPtr;
- };
- Id = function(pkg, name) {
- var $ptr, name, path$1, pkg;
- if (ast.IsExported(name)) {
- return name;
- }
- path$1 = "_";
- if (!(pkg === ptrType$1.nil)) {
- path$1 = pkg.path;
- if (path$1 === "") {
- path$1 = "_";
- }
- }
- return path$1 + "." + name;
- };
- $pkg.Id = Id;
- object.ptr.prototype.Parent = function() {
- var $ptr, obj;
- obj = this;
- return obj.parent;
- };
- object.prototype.Parent = function() { return this.$val.Parent(); };
- object.ptr.prototype.Pos = function() {
- var $ptr, obj;
- obj = this;
- return obj.pos;
- };
- object.prototype.Pos = function() { return this.$val.Pos(); };
- object.ptr.prototype.Pkg = function() {
- var $ptr, obj;
- obj = this;
- return obj.pkg;
- };
- object.prototype.Pkg = function() { return this.$val.Pkg(); };
- object.ptr.prototype.Name = function() {
- var $ptr, obj;
- obj = this;
- return obj.name;
- };
- object.prototype.Name = function() { return this.$val.Name(); };
- object.ptr.prototype.Type = function() {
- var $ptr, obj;
- obj = this;
- return obj.typ;
- };
- object.prototype.Type = function() { return this.$val.Type(); };
- object.ptr.prototype.Exported = function() {
- var $ptr, obj;
- obj = this;
- return ast.IsExported(obj.name);
- };
- object.prototype.Exported = function() { return this.$val.Exported(); };
- object.ptr.prototype.Id = function() {
- var $ptr, obj;
- obj = this;
- return Id(obj.pkg, obj.name);
- };
- object.prototype.Id = function() { return this.$val.Id(); };
- object.ptr.prototype.String = function() {
- var $ptr, obj;
- obj = this;
- $panic(new $String("abstract"));
- };
- object.prototype.String = function() { return this.$val.String(); };
- object.ptr.prototype.order = function() {
- var $ptr, obj;
- obj = this;
- return obj.order_;
- };
- object.prototype.order = function() { return this.$val.order(); };
- object.ptr.prototype.scopePos = function() {
- var $ptr, obj;
- obj = this;
- return obj.scopePos_;
- };
- object.prototype.scopePos = function() { return this.$val.scopePos(); };
- object.ptr.prototype.setParent = function(parent) {
- var $ptr, obj, parent;
- obj = this;
- obj.parent = parent;
- };
- object.prototype.setParent = function(parent) { return this.$val.setParent(parent); };
- object.ptr.prototype.setOrder = function(order) {
- var $ptr, obj, order;
- obj = this;
- assert(order > 0);
- obj.order_ = order;
- };
- object.prototype.setOrder = function(order) { return this.$val.setOrder(order); };
- object.ptr.prototype.setScopePos = function(pos) {
- var $ptr, obj, pos;
- obj = this;
- obj.scopePos_ = pos;
- };
- object.prototype.setScopePos = function(pos) { return this.$val.setScopePos(pos); };
- object.ptr.prototype.sameId = function(pkg, name) {
- var $ptr, name, obj, pkg;
- obj = this;
- if (!(name === obj.name)) {
- return false;
- }
- if (obj.Exported()) {
- return true;
- }
- if (pkg === ptrType$1.nil || obj.pkg === ptrType$1.nil) {
- return pkg === obj.pkg;
- }
- return pkg.path === obj.pkg.path;
- };
- object.prototype.sameId = function(pkg, name) { return this.$val.sameId(pkg, name); };
- NewPkgName = function(pos, pkg, name, imported) {
- var $ptr, imported, name, pkg, pos;
- return new PkgName.ptr(new object.ptr(ptrType.nil, pos, pkg, name, $pkg.Typ[0], 0, 0), imported, false);
- };
- $pkg.NewPkgName = NewPkgName;
- PkgName.ptr.prototype.Imported = function() {
- var $ptr, obj;
- obj = this;
- return obj.imported;
- };
- PkgName.prototype.Imported = function() { return this.$val.Imported(); };
- NewConst = function(pos, pkg, name, typ, val) {
- var $ptr, name, pkg, pos, typ, val;
- return new Const.ptr(new object.ptr(ptrType.nil, pos, pkg, name, typ, 0, 0), val, false);
- };
- $pkg.NewConst = NewConst;
- Const.ptr.prototype.Val = function() {
- var $ptr, obj;
- obj = this;
- return obj.val;
- };
- Const.prototype.Val = function() { return this.$val.Val(); };
- NewTypeName = function(pos, pkg, name, typ) {
- var $ptr, name, pkg, pos, typ;
- return new TypeName.ptr(new object.ptr(ptrType.nil, pos, pkg, name, typ, 0, 0));
- };
- $pkg.NewTypeName = NewTypeName;
- NewVar = function(pos, pkg, name, typ) {
- var $ptr, name, pkg, pos, typ;
- return new Var.ptr(new object.ptr(ptrType.nil, pos, pkg, name, typ, 0, 0), false, false, false, false);
- };
- $pkg.NewVar = NewVar;
- NewParam = function(pos, pkg, name, typ) {
- var $ptr, name, pkg, pos, typ;
- return new Var.ptr(new object.ptr(ptrType.nil, pos, pkg, name, typ, 0, 0), false, false, false, true);
- };
- $pkg.NewParam = NewParam;
- NewField = function(pos, pkg, name, typ, anonymous) {
- var $ptr, anonymous, name, pkg, pos, typ;
- return new Var.ptr(new object.ptr(ptrType.nil, pos, pkg, name, typ, 0, 0), anonymous, false, true, false);
- };
- $pkg.NewField = NewField;
- Var.ptr.prototype.Anonymous = function() {
- var $ptr, obj;
- obj = this;
- return obj.anonymous;
- };
- Var.prototype.Anonymous = function() { return this.$val.Anonymous(); };
- Var.ptr.prototype.IsField = function() {
- var $ptr, obj;
- obj = this;
- return obj.isField;
- };
- Var.prototype.IsField = function() { return this.$val.IsField(); };
- NewFunc = function(pos, pkg, name, sig) {
- var $ptr, name, pkg, pos, sig, typ;
- typ = $ifaceNil;
- if (!(sig === ptrType$17.nil)) {
- typ = sig;
- }
- return new Func.ptr(new object.ptr(ptrType.nil, pos, pkg, name, typ, 0, 0));
- };
- $pkg.NewFunc = NewFunc;
- Func.ptr.prototype.FullName = function() {
- var $ptr, buf, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; buf = $f.buf; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- obj = this;
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- $r = writeFuncName(buf[0], obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Func.ptr.prototype.FullName }; } $f.$ptr = $ptr; $f.buf = buf; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Func.prototype.FullName = function() { return this.$val.FullName(); };
- Func.ptr.prototype.Scope = function() {
- var $ptr, obj;
- obj = this;
- return $assertType(obj.object.typ, ptrType$17).scope;
- };
- Func.prototype.Scope = function() { return this.$val.Scope(); };
- NewLabel = function(pos, pkg, name) {
- var $ptr, name, pkg, pos;
- return new Label.ptr(new object.ptr(ptrType.nil, pos, pkg, name, $pkg.Typ[0], 0, 0), false);
- };
- $pkg.NewLabel = NewLabel;
- newBuiltin = function(id) {
- var $ptr, id;
- return new Builtin.ptr(new object.ptr(ptrType.nil, 0, ptrType$1.nil, ((id < 0 || id >= predeclaredFuncs.length) ? $throwRuntimeError("index out of range") : predeclaredFuncs[id]).name, $pkg.Typ[0], 0, 0), id);
- };
- writeObject = function(buf, obj, qf) {
- var $ptr, _arg, _arg$1, _arg$2, _r, _r$1, _r$10, _r$11, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _v, buf, obj, obj$1, obj$2, obj$3, obj$4, obj$5, obj$6, obj$7, obj$8, obj$9, path$1, qf, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _v = $f._v; buf = $f.buf; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; obj$4 = $f.obj$4; obj$5 = $f.obj$5; obj$6 = $f.obj$6; obj$7 = $f.obj$7; obj$8 = $f.obj$8; obj$9 = $f.obj$9; path$1 = $f.path$1; qf = $f.qf; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = obj.Type(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ = _r;
- _ref = obj;
- /* */ if ($assertType(_ref, ptrType$18, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$2, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$19, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$6, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$59, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$72, true)[1]) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if ($assertType(_ref, ptrType$18, true)[1]) { */ case 2:
- obj$1 = _ref.$val;
- _r$1 = fmt.Fprintf(buf, "package %s", new sliceType([new $String(obj$1.object.Name())])); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- path$1 = obj$1.imported.path;
- /* */ if (!(path$1 === "") && !(path$1 === obj$1.object.name)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!(path$1 === "") && !(path$1 === obj$1.object.name)) { */ case 13:
- _r$2 = fmt.Fprintf(buf, " (%q)", new sliceType([new $String(path$1)])); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* } */ case 14:
- return;
- $s = 11; continue;
- /* } else if ($assertType(_ref, ptrType$2, true)[1]) { */ case 3:
- obj$2 = _ref.$val;
- buf.WriteString("const");
- $s = 11; continue;
- /* } else if ($assertType(_ref, ptrType$19, true)[1]) { */ case 4:
- obj$3 = _ref.$val;
- buf.WriteString("type");
- _r$3 = typ.Underlying(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- typ = _r$3;
- $s = 11; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 5:
- obj$4 = _ref.$val;
- if (obj$4.isField) {
- buf.WriteString("field");
- } else {
- buf.WriteString("var");
- }
- $s = 11; continue;
- /* } else if ($assertType(_ref, ptrType$6, true)[1]) { */ case 6:
- obj$5 = _ref.$val;
- buf.WriteString("func ");
- $r = writeFuncName(buf, obj$5, qf); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 18:
- $r = WriteSignature(buf, $assertType(typ, ptrType$17), qf); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 19:
- return;
- $s = 11; continue;
- /* } else if ($assertType(_ref, ptrType$59, true)[1]) { */ case 7:
- obj$6 = _ref.$val;
- buf.WriteString("label");
- typ = $ifaceNil;
- $s = 11; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1]) { */ case 8:
- obj$7 = _ref.$val;
- buf.WriteString("builtin");
- typ = $ifaceNil;
- $s = 11; continue;
- /* } else if ($assertType(_ref, ptrType$72, true)[1]) { */ case 9:
- obj$8 = _ref.$val;
- buf.WriteString("nil");
- return;
- $s = 11; continue;
- /* } else { */ case 10:
- obj$9 = _ref;
- _r$4 = fmt.Sprintf("writeObject(%T)", new sliceType([obj$9])); /* */ $s = 21; case 21: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $panic(new $String(_r$4));
- /* } */ case 11:
- buf.WriteByte(32);
- _r$5 = obj.Pkg(); /* */ $s = 25; case 25: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- if (!(!(_r$5 === ptrType$1.nil))) { _v = false; $s = 24; continue s; }
- _r$6 = obj.Pkg(); /* */ $s = 26; case 26: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = obj.Name(); /* */ $s = 27; case 27: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$8 = _r$6.scope.Lookup(_r$7); /* */ $s = 28; case 28: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _v = $interfaceIsEqual(_r$8, obj); case 24:
- /* */ if (_v) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (_v) { */ case 22:
- _arg = buf;
- _r$9 = obj.Pkg(); /* */ $s = 29; case 29: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$1 = _r$9;
- _arg$2 = qf;
- $r = writePackage(_arg, _arg$1, _arg$2); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 23:
- _r$10 = obj.Name(); /* */ $s = 31; case 31: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$11 = buf.WriteString(_r$10); /* */ $s = 32; case 32: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$11;
- /* */ if (!($interfaceIsEqual(typ, $ifaceNil))) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* if (!($interfaceIsEqual(typ, $ifaceNil))) { */ case 33:
- buf.WriteByte(32);
- $r = WriteType(buf, typ, qf); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 34:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: writeObject }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._v = _v; $f.buf = buf; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.obj$4 = obj$4; $f.obj$5 = obj$5; $f.obj$6 = obj$6; $f.obj$7 = obj$7; $f.obj$8 = obj$8; $f.obj$9 = obj$9; $f.path$1 = path$1; $f.qf = qf; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- writePackage = function(buf, pkg, qf) {
- var $ptr, _r, buf, pkg, qf, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; buf = $f.buf; pkg = $f.pkg; qf = $f.qf; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (pkg === ptrType$1.nil) {
- return;
- }
- s = "";
- /* */ if (!(qf === $throwNilPointerError)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(qf === $throwNilPointerError)) { */ case 1:
- _r = qf(pkg); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- s = _r;
- $s = 3; continue;
- /* } else { */ case 2:
- s = pkg.Path();
- /* } */ case 3:
- if (!(s === "")) {
- buf.WriteString(s);
- buf.WriteByte(46);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: writePackage }; } $f.$ptr = $ptr; $f._r = _r; $f.buf = buf; $f.pkg = pkg; $f.qf = qf; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- ObjectString = function(obj, qf) {
- var $ptr, buf, obj, qf, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; buf = $f.buf; obj = $f.obj; qf = $f.qf; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- $r = writeObject(buf[0], obj, qf); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ObjectString }; } $f.$ptr = $ptr; $f.buf = buf; $f.obj = obj; $f.qf = qf; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ObjectString = ObjectString;
- PkgName.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: PkgName.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- PkgName.prototype.String = function() { return this.$val.String(); };
- Const.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Const.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Const.prototype.String = function() { return this.$val.String(); };
- TypeName.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TypeName.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- TypeName.prototype.String = function() { return this.$val.String(); };
- Var.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Var.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Var.prototype.String = function() { return this.$val.String(); };
- Func.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Func.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Func.prototype.String = function() { return this.$val.String(); };
- Label.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Label.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Label.prototype.String = function() { return this.$val.String(); };
- Builtin.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Builtin.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Builtin.prototype.String = function() { return this.$val.String(); };
- Nil.ptr.prototype.String = function() {
- var $ptr, _r, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- obj = this;
- _r = ObjectString(obj, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Nil.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Nil.prototype.String = function() { return this.$val.String(); };
- writeFuncName = function(buf, f, qf) {
- var $ptr, _tuple, buf, f, ok, qf, recv, sig, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _tuple = $f._tuple; buf = $f.buf; f = $f.f; ok = $f.ok; qf = $f.qf; recv = $f.recv; sig = $f.sig; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!($interfaceIsEqual(f.object.typ, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(f.object.typ, $ifaceNil))) { */ case 1:
- sig = $assertType(f.object.typ, ptrType$17);
- recv = sig.Recv();
- /* */ if (!(recv === ptrType$9.nil)) { $s = 3; continue; }
- /* */ if (!(f.object.pkg === ptrType$1.nil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(recv === ptrType$9.nil)) { */ case 3:
- buf.WriteByte(40);
- _tuple = $assertType(recv.object.Type(), ptrType$53, true); ok = _tuple[1];
- /* */ if (ok) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (ok) { */ case 6:
- buf.WriteString("interface");
- $s = 8; continue;
- /* } else { */ case 7:
- $r = WriteType(buf, recv.object.Type(), qf); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- buf.WriteByte(41);
- buf.WriteByte(46);
- $s = 5; continue;
- /* } else if (!(f.object.pkg === ptrType$1.nil)) { */ case 4:
- $r = writePackage(buf, f.object.pkg, qf); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- /* } */ case 2:
- buf.WriteString(f.object.name);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: writeFuncName }; } $f.$ptr = $ptr; $f._tuple = _tuple; $f.buf = buf; $f.f = f; $f.ok = ok; $f.qf = qf; $f.recv = recv; $f.sig = sig; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(objset).prototype.insert = function(obj) {
- var $ptr, _entry, _key$2, _r, alt, id, obj, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$2 = $f._key$2; _r = $f._r; alt = $f.alt; id = $f.id; obj = $f.obj; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = obj.Id(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- id = _r;
- alt = (_entry = (s.$get())[$String.keyFor(id)], _entry !== undefined ? _entry.v : $ifaceNil);
- if (!($interfaceIsEqual(alt, $ifaceNil))) {
- return alt;
- }
- if (s.$get() === false) {
- s.$set(new $Map());
- }
- _key$2 = id; (s.$get() || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$2)] = { k: _key$2, v: obj };
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $ptrType(objset).prototype.insert }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$2 = _key$2; $f._r = _r; $f.alt = alt; $f.id = id; $f.obj = obj; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.ptr.prototype.pos = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- if ($interfaceIsEqual(x.expr, $ifaceNil)) {
- return 0;
- }
- _r = x.expr.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: operand.ptr.prototype.pos }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.prototype.pos = function() { return this.$val.pos(); };
- operandString = function(x, qf) {
- var $ptr, _r, _r$1, _r$2, _r$3, _ref, _ref$1, buf, expr, hasType, qf, s, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; buf = $f.buf; expr = $f.expr; hasType = $f.hasType; qf = $f.qf; s = $f.s; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- expr = "";
- /* */ if (!($interfaceIsEqual(x.expr, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(x.expr, $ifaceNil))) { */ case 1:
- expr = ExprString(x.expr);
- $s = 3; continue;
- /* } else { */ case 2:
- _ref = x.mode;
- /* */ if (_ref === 2) { $s = 4; continue; }
- /* */ if (_ref === 3) { $s = 5; continue; }
- /* */ if (_ref === 4) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 2) { */ case 4:
- expr = (x$1 = x.id, ((x$1 < 0 || x$1 >= predeclaredFuncs.length) ? $throwRuntimeError("index out of range") : predeclaredFuncs[x$1])).name;
- $s = 7; continue;
- /* } else if (_ref === 3) { */ case 5:
- _r = TypeString(x.typ, qf); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- expr = _r;
- $s = 7; continue;
- /* } else if (_ref === 4) { */ case 6:
- _r$1 = x.val.String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- expr = _r$1;
- /* } */ case 7:
- /* } */ case 3:
- if (!(expr === "")) {
- buf[0].WriteString(expr);
- buf[0].WriteString(" (");
- }
- hasType = false;
- _ref$1 = x.mode;
- /* */ if (_ref$1 === 0 || _ref$1 === 1 || _ref$1 === 2 || _ref$1 === 3) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* switch (0) { default: if (_ref$1 === 0 || _ref$1 === 1 || _ref$1 === 2 || _ref$1 === 3) { */ case 10:
- $s = 12; continue;
- /* } else { */ case 11:
- _r$2 = isUntyped(x.typ); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (_r$2) { */ case 13:
- buf[0].WriteString($assertType(x.typ, ptrType$3).name);
- buf[0].WriteByte(32);
- /* break; */ $s = 12; continue;
- /* } */ case 14:
- hasType = true;
- /* } } */ case 12:
- buf[0].WriteString((x$2 = x.mode, ((x$2 < 0 || x$2 >= operandModeString.length) ? $throwRuntimeError("index out of range") : operandModeString[x$2])));
- /* */ if (x.mode === 4) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (x.mode === 4) { */ case 16:
- _r$3 = x.val.String(); /* */ $s = 18; case 18: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- s = _r$3;
- /* */ if (!(s === expr)) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!(s === expr)) { */ case 19:
- buf[0].WriteByte(32);
- buf[0].WriteString(s);
- /* } */ case 20:
- /* } */ case 17:
- /* */ if (hasType) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (hasType) { */ case 21:
- /* */ if (!($interfaceIsEqual(x.typ, $pkg.Typ[0]))) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (!($interfaceIsEqual(x.typ, $pkg.Typ[0]))) { */ case 23:
- buf[0].WriteString(" of type ");
- $r = WriteType(buf[0], x.typ, qf); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else { */ case 24:
- buf[0].WriteString(" with invalid type");
- /* } */ case 25:
- /* } */ case 22:
- if (!(expr === "")) {
- buf[0].WriteByte(41);
- }
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: operandString }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.buf = buf; $f.expr = expr; $f.hasType = hasType; $f.qf = qf; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.ptr.prototype.String = function() {
- var $ptr, _r, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = operandString(x, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: operand.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.prototype.String = function() { return this.$val.String(); };
- operand.ptr.prototype.setConst = function(tok, lit) {
- var $ptr, _r, _ref, kind, lit, tok, val, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; kind = $f.kind; lit = $f.lit; tok = $f.tok; val = $f.val; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- _r = exact.MakeFromLiteral(lit, tok); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- val = _r;
- if ($interfaceIsEqual(val, $ifaceNil)) {
- x.mode = 0;
- return;
- }
- kind = 0;
- _ref = tok;
- if (_ref === 5) {
- kind = 20;
- } else if (_ref === 6) {
- kind = 22;
- } else if (_ref === 7) {
- kind = 23;
- } else if (_ref === 8) {
- kind = 21;
- } else if (_ref === 9) {
- kind = 24;
- }
- x.mode = 4;
- x.typ = ((kind < 0 || kind >= $pkg.Typ.length) ? $throwRuntimeError("index out of range") : $pkg.Typ[kind]);
- x.val = val;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: operand.ptr.prototype.setConst }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.kind = kind; $f.lit = lit; $f.tok = tok; $f.val = val; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.prototype.setConst = function(tok, lit) { return this.$val.setConst(tok, lit); };
- operand.ptr.prototype.isNil = function() {
- var $ptr, x;
- x = this;
- return (x.mode === 7) && $interfaceIsEqual(x.typ, $pkg.Typ[25]);
- };
- operand.prototype.isNil = function() { return this.$val.isNil(); };
- operand.ptr.prototype.assignableTo = function(conf, T) {
- var $ptr, T, Tc, Ti, Tu, V, Vb, Vc, Vu, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _v, _v$1, conf, ok, ok$1, ok$2, t, t$1, t$2, t$3, t$4, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; Tc = $f.Tc; Ti = $f.Ti; Tu = $f.Tu; V = $f.V; Vb = $f.Vb; Vc = $f.Vc; Vu = $f.Vu; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _v = $f._v; _v$1 = $f._v$1; conf = $f.conf; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- if ((x.mode === 0) || $interfaceIsEqual(T, $pkg.Typ[0])) {
- return true;
- }
- V = x.typ;
- _r = Identical(V, T); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r) { */ case 1:
- return true;
- /* } */ case 2:
- _r$1 = V.Underlying(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- Vu = _r$1;
- _r$2 = T.Underlying(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- Tu = _r$2;
- _tuple = $assertType(Tu, ptrType$53, true); Ti = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (ok) { */ case 6:
- _r$3 = Implements(x.typ, Ti); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_r$3) { */ case 8:
- return true;
- /* } */ case 9:
- /* } */ case 7:
- _r$4 = Identical(Vu, Tu); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (_r$4 && (!isNamed(V) || !isNamed(T))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_r$4 && (!isNamed(V) || !isNamed(T))) { */ case 11:
- return true;
- /* } */ case 12:
- _tuple$1 = $assertType(Vu, ptrType$12, true); Vc = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1 && (Vc.dir === 0)) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (ok$1 && (Vc.dir === 0)) { */ case 14:
- _tuple$2 = $assertType(Tu, ptrType$12, true); Tc = _tuple$2[0]; ok$2 = _tuple$2[1];
- if (!(ok$2)) { _v = false; $s = 18; continue s; }
- _r$5 = Identical(Vc.elem, Tc.elem); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _v = _r$5; case 18:
- /* */ if (_v) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (_v) { */ case 16:
- return !isNamed(V) || !isNamed(T);
- /* } */ case 17:
- /* } */ case 15:
- if (x.isNil()) {
- _ref = Tu;
- if ($assertType(_ref, ptrType$3, true)[1]) {
- t = _ref.$val;
- if (t.kind === 18) {
- return true;
- }
- } else if ($assertType(_ref, ptrType$15, true)[1] || $assertType(_ref, ptrType$17, true)[1] || $assertType(_ref, ptrType$10, true)[1] || $assertType(_ref, ptrType$13, true)[1] || $assertType(_ref, ptrType$12, true)[1] || $assertType(_ref, ptrType$53, true)[1]) {
- t$1 = _ref;
- return true;
- }
- return false;
- }
- _r$6 = isUntyped(Vu); /* */ $s = 22; case 22: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- /* */ if (_r$6) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (_r$6) { */ case 20:
- _ref$1 = Tu;
- /* */ if ($assertType(_ref$1, ptrType$3, true)[1]) { $s = 23; continue; }
- /* */ if ($assertType(_ref$1, ptrType$53, true)[1]) { $s = 24; continue; }
- /* */ if ($assertType(_ref$1, ptrType$15, true)[1] || $assertType(_ref$1, ptrType$17, true)[1] || $assertType(_ref$1, ptrType$10, true)[1] || $assertType(_ref$1, ptrType$13, true)[1] || $assertType(_ref$1, ptrType$12, true)[1]) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if ($assertType(_ref$1, ptrType$3, true)[1]) { */ case 23:
- t$2 = _ref$1.$val;
- /* */ if (x.mode === 4) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (x.mode === 4) { */ case 27:
- _r$7 = representableConst(x.val, conf, t$2.kind, ptrType$25.nil); /* */ $s = 29; case 29: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7;
- /* } */ case 28:
- _tuple$3 = $assertType(Vu, ptrType$3, true); Vb = _tuple$3[0];
- /* */ if (!(Vb === ptrType$3.nil)) { $s = 30; continue; }
- /* */ $s = 31; continue;
- /* if (!(Vb === ptrType$3.nil)) { */ case 30:
- if (!(Vb.kind === 19)) { _v$1 = false; $s = 32; continue s; }
- _r$8 = isBoolean(Tu); /* */ $s = 33; case 33: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _v$1 = _r$8; case 32:
- return _v$1;
- /* } */ case 31:
- $s = 26; continue;
- /* } else if ($assertType(_ref$1, ptrType$53, true)[1]) { */ case 24:
- t$3 = _ref$1.$val;
- return x.isNil() || t$3.Empty();
- $s = 26; continue;
- /* } else if ($assertType(_ref$1, ptrType$15, true)[1] || $assertType(_ref$1, ptrType$17, true)[1] || $assertType(_ref$1, ptrType$10, true)[1] || $assertType(_ref$1, ptrType$13, true)[1] || $assertType(_ref$1, ptrType$12, true)[1]) { */ case 25:
- t$4 = _ref$1;
- return x.isNil();
- /* } */ case 26:
- /* } */ case 21:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: operand.ptr.prototype.assignableTo }; } $f.$ptr = $ptr; $f.T = T; $f.Tc = Tc; $f.Ti = Ti; $f.Tu = Tu; $f.V = V; $f.Vb = Vb; $f.Vc = Vc; $f.Vu = Vu; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._v = _v; $f._v$1 = _v$1; $f.conf = conf; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.prototype.assignableTo = function(conf, T) { return this.$val.assignableTo(conf, T); };
- operand.ptr.prototype.isInteger = function() {
- var $ptr, _r, _r$1, _v, _v$1, _v$2, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = this;
- if (x.mode === 0) { _v$1 = true; $s = 2; continue s; }
- _r = isInteger(x.typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v$1 = _r; case 2:
- if (_v$1) { _v = true; $s = 1; continue s; }
- if (!(x.mode === 4)) { _v$2 = false; $s = 4; continue s; }
- _r$1 = representableConst(x.val, ptrType$7.nil, 20, ptrType$25.nil); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v$2 = _r$1; case 4:
- _v = _v$2; case 1:
- return _v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: operand.ptr.prototype.isInteger }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- operand.prototype.isInteger = function() { return this.$val.isInteger(); };
- Checker.ptr.prototype.resolveOrder = function() {
- var $ptr, _entry, _entry$1, _i, _i$1, _i$2, _keys, _r, _r$1, _ref, _ref$1, _ref$2, _tmp, _tmp$1, _tuple, check, embedded, f, ident, ifaces, ityp, obj, obj$1, order, others, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _keys = $f._keys; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; check = $f.check; embedded = $f.embedded; f = $f.f; ident = $f.ident; ifaces = $f.ifaces; ityp = $f.ityp; obj = $f.obj; obj$1 = $f.obj$1; order = $f.order; others = $f.others; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- order = [order];
- check = this;
- _tmp = sliceType$18.nil; _tmp$1 = sliceType$18.nil; ifaces = _tmp; others = _tmp$1;
- _ref = check.objMap;
- _i = 0;
- _keys = $keys(_ref);
- /* while (true) { */ case 1:
- /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 2; continue; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- /* continue; */ $s = 1; continue;
- }
- obj = _entry.k;
- _r = check.interfaceFor(obj); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- ityp = _r;
- /* */ if (!(ityp === ptrType$47.nil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(ityp === ptrType$47.nil)) { */ case 4:
- ifaces = $append(ifaces, obj);
- _ref$1 = ityp.Methods.List;
- _i$1 = 0;
- /* while (true) { */ case 7:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 8; continue; }
- f = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- /* */ if (f.Names.$length === 0) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (f.Names.$length === 0) { */ case 9:
- _tuple = $assertType(f.Type, ptrType$5, true); ident = _tuple[0];
- /* */ if (!(ident === ptrType$5.nil)) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!(ident === ptrType$5.nil)) { */ case 11:
- embedded = check.pkg.scope.Lookup(ident.Name);
- _r$1 = check.interfaceFor(embedded); /* */ $s = 15; case 15: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!(_r$1 === ptrType$47.nil)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!(_r$1 === ptrType$47.nil)) { */ case 13:
- (_entry$1 = check.objMap[Object.keyFor(obj)], _entry$1 !== undefined ? _entry$1.v : ptrType$21.nil).addDep(embedded);
- /* } */ case 14:
- /* } */ case 12:
- /* } */ case 10:
- _i$1++;
- /* } */ $s = 7; continue; case 8:
- $s = 6; continue;
- /* } else { */ case 5:
- others = $append(others, obj);
- /* } */ case 6:
- _i++;
- /* } */ $s = 1; continue; case 2:
- order[0] = sliceType$18.nil;
- $r = sort.Sort($subslice(new inSourceOrder(ifaces.$array), ifaces.$offset, ifaces.$offset + ifaces.$length)); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$2 = ifaces;
- _i$2 = 0;
- /* while (true) { */ case 17:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 18; continue; }
- obj$1 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- $r = check.appendInPostOrder((order.$ptr || (order.$ptr = new ptrType$73(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, order))), obj$1); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 17; continue; case 18:
- $r = sort.Sort($subslice(new inSourceOrder(others.$array), others.$offset, others.$offset + others.$length)); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return $appendSlice(order[0], others);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.resolveOrder }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._keys = _keys; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.check = check; $f.embedded = embedded; $f.f = f; $f.ident = ident; $f.ifaces = ifaces; $f.ityp = ityp; $f.obj = obj; $f.obj$1 = obj$1; $f.order = order; $f.others = others; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.resolveOrder = function() { return this.$val.resolveOrder(); };
- Checker.ptr.prototype.interfaceFor = function(obj) {
- var $ptr, _arg, _arg$1, _entry, _r, _r$1, _tuple, _tuple$1, check, d, ityp, obj, tname, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; check = $f.check; d = $f.d; ityp = $f.ityp; obj = $f.obj; tname = $f.tname; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _tuple = $assertType(obj, ptrType$19, true); tname = _tuple[0];
- if (tname === ptrType$19.nil) {
- return ptrType$47.nil;
- }
- d = (_entry = check.objMap[Object.keyFor(obj)], _entry !== undefined ? _entry.v : ptrType$21.nil);
- /* */ if (d === ptrType$21.nil) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (d === ptrType$21.nil) { */ case 1:
- _r = obj.Pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg = new token.Pos(_r);
- _r$1 = obj.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$1);
- $r = check.dump("%s: %s should have been declared", new sliceType([_arg, _arg$1])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- unreachable();
- /* } */ case 2:
- if ($interfaceIsEqual(d.typ, $ifaceNil)) {
- return ptrType$47.nil;
- }
- _tuple$1 = $assertType(d.typ, ptrType$47, true); ityp = _tuple$1[0];
- return ityp;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.interfaceFor }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.check = check; $f.d = d; $f.ityp = ityp; $f.obj = obj; $f.tname = tname; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.interfaceFor = function(obj) { return this.$val.interfaceFor(obj); };
- Checker.ptr.prototype.appendInPostOrder = function(order, obj) {
- var $ptr, _entry, _i, _r, _ref, check, d, obj, obj$1, order, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _r = $f._r; _ref = $f._ref; check = $f.check; d = $f.d; obj = $f.obj; obj$1 = $f.obj$1; order = $f.order; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- d = (_entry = check.objMap[Object.keyFor(obj)], _entry !== undefined ? _entry.v : ptrType$21.nil);
- if (!((d.mark === 0))) {
- return;
- }
- d.mark = 1;
- _r = orderedSetObjects(d.deps); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- obj$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = check.appendInPostOrder(order, obj$1); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 2; continue; case 3:
- order.$set($append(order.$get(), obj));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.appendInPostOrder }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.check = check; $f.d = d; $f.obj = obj; $f.obj$1 = obj$1; $f.order = order; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.appendInPostOrder = function(order, obj) { return this.$val.appendInPostOrder(order, obj); };
- orderedSetObjects = function(set) {
- var $ptr, _entry, _i, _keys, _ref, i, list, obj, set, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _ref = $f._ref; i = $f.i; list = $f.list; obj = $f.obj; set = $f.set; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- list = $makeSlice(sliceType$18, $keys(set).length);
- i = 0;
- _ref = set;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- obj = _entry.k;
- ((i < 0 || i >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + i] = obj);
- i = i + (1) >> 0;
- _i++;
- }
- $r = sort.Sort($subslice(new inSourceOrder(list.$array), list.$offset, list.$offset + list.$length)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return list;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: orderedSetObjects }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._ref = _ref; $f.i = i; $f.list = list; $f.obj = obj; $f.set = set; $f.$s = $s; $f.$r = $r; return $f;
- };
- inSourceOrder.prototype.Len = function() {
- var $ptr, a;
- a = this;
- return a.$length;
- };
- $ptrType(inSourceOrder).prototype.Len = function() { return this.$get().Len(); };
- inSourceOrder.prototype.Less = function(i, j) {
- var $ptr, _r, _r$1, a, i, j, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; a = $f.a; i = $f.i; j = $f.j; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = this;
- _r = ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]).order(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]).order(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r < _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: inSourceOrder.prototype.Less }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.i = i; $f.j = j; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(inSourceOrder).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- inSourceOrder.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, a, i, j;
- a = this;
- _tmp = ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]); _tmp$1 = ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]); ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = _tmp); ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j] = _tmp$1);
- };
- $ptrType(inSourceOrder).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- NewPackage = function(path$1, name) {
- var $ptr, _arg, _arg$1, _r, _r$1, name, path$1, scope, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; name = $f.name; path$1 = $f.path$1; scope = $f.scope; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (name === "_") {
- $panic(new $String("invalid package name _"));
- }
- _arg = $pkg.Universe;
- _r = fmt.Sprintf("package %q", new sliceType([new $String(path$1)])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = _r;
- _r$1 = NewScope(_arg, 0, 0, _arg$1); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- scope = _r$1;
- return new Package.ptr(path$1, name, scope, false, sliceType$19.nil, false);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: NewPackage }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f.name = name; $f.path$1 = path$1; $f.scope = scope; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.NewPackage = NewPackage;
- Package.ptr.prototype.Path = function() {
- var $ptr, pkg;
- pkg = this;
- return pkg.path;
- };
- Package.prototype.Path = function() { return this.$val.Path(); };
- Package.ptr.prototype.Name = function() {
- var $ptr, pkg;
- pkg = this;
- return pkg.name;
- };
- Package.prototype.Name = function() { return this.$val.Name(); };
- Package.ptr.prototype.Scope = function() {
- var $ptr, pkg;
- pkg = this;
- return pkg.scope;
- };
- Package.prototype.Scope = function() { return this.$val.Scope(); };
- Package.ptr.prototype.Complete = function() {
- var $ptr, pkg;
- pkg = this;
- return pkg.complete;
- };
- Package.prototype.Complete = function() { return this.$val.Complete(); };
- Package.ptr.prototype.MarkComplete = function() {
- var $ptr, pkg;
- pkg = this;
- pkg.complete = true;
- };
- Package.prototype.MarkComplete = function() { return this.$val.MarkComplete(); };
- Package.ptr.prototype.Imports = function() {
- var $ptr, pkg;
- pkg = this;
- return pkg.imports;
- };
- Package.prototype.Imports = function() { return this.$val.Imports(); };
- Package.ptr.prototype.SetImports = function(list) {
- var $ptr, list, pkg;
- pkg = this;
- pkg.imports = list;
- };
- Package.prototype.SetImports = function(list) { return this.$val.SetImports(list); };
- Package.ptr.prototype.String = function() {
- var $ptr, _r, pkg, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; pkg = $f.pkg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pkg = this;
- _r = fmt.Sprintf("package %s (%q)", new sliceType([new $String(pkg.name), new $String(pkg.path)])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Package.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.pkg = pkg; $f.$s = $s; $f.$r = $r; return $f;
- };
- Package.prototype.String = function() { return this.$val.String(); };
- isNamed = function(typ) {
- var $ptr, _tuple, _tuple$1, ok, ok$1, typ;
- _tuple = $assertType(typ, ptrType$3, true); ok = _tuple[1];
- if (ok) {
- return ok;
- }
- _tuple$1 = $assertType(typ, ptrType$26, true); ok$1 = _tuple$1[1];
- return ok$1;
- };
- isBoolean = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 1) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isBoolean }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isInteger = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 2) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isInteger }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isUnsigned = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 4) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isUnsigned }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isFloat = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 8) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isFloat }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isComplex = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 16) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isComplex }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isNumeric = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 26) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isNumeric }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isString = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 32) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isString }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isTyped = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return !ok || ((t.info & 64) === 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isTyped }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isUntyped = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 64) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isUntyped }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isOrdered = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 42) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isOrdered }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- isConstType = function(typ) {
- var $ptr, _r, _tuple, ok, t, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; t = $f.t; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- return ok && !(((t.info & 59) === 0));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isConstType }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.t = t; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- IsInterface = function(typ) {
- var $ptr, _r, _tuple, ok, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; ok = $f.ok; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = $assertType(_r, ptrType$53, true); ok = _tuple[1];
- return ok;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: IsInterface }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.ok = ok; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.IsInterface = IsInterface;
- Comparable = function(T) {
- var $ptr, T, _i, _r, _r$1, _r$2, _ref, _ref$1, f, t, t$1, t$2, t$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; f = $f.f; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = T.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$15, true)[1] || $assertType(_ref, ptrType$53, true)[1] || $assertType(_ref, ptrType$12, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$27, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- t = _ref.$val;
- return !((t.kind === 25));
- $s = 6; continue;
- /* } else if ($assertType(_ref, ptrType$15, true)[1] || $assertType(_ref, ptrType$53, true)[1] || $assertType(_ref, ptrType$12, true)[1]) { */ case 3:
- t$1 = _ref;
- return true;
- $s = 6; continue;
- /* } else if ($assertType(_ref, ptrType$27, true)[1]) { */ case 4:
- t$2 = _ref.$val;
- _ref$1 = t$2.fields;
- _i = 0;
- /* while (true) { */ case 7:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 8; continue; }
- f = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- _r$1 = Comparable(f.object.typ); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!_r$1) { */ case 9:
- return false;
- /* } */ case 10:
- _i++;
- /* } */ $s = 7; continue; case 8:
- return true;
- $s = 6; continue;
- /* } else if ($assertType(_ref, ptrType$11, true)[1]) { */ case 5:
- t$3 = _ref.$val;
- _r$2 = Comparable(t$3.elem); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* } */ case 6:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Comparable }; } $f.$ptr = $ptr; $f.T = T; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f.f = f; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Comparable = Comparable;
- hasNil = function(typ) {
- var $ptr, _r, _ref, t, t$1, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; t = $f.t; t$1 = $f.t$1; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = typ.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1] || $assertType(_ref, ptrType$15, true)[1] || $assertType(_ref, ptrType$17, true)[1] || $assertType(_ref, ptrType$53, true)[1] || $assertType(_ref, ptrType$13, true)[1] || $assertType(_ref, ptrType$12, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- t = _ref.$val;
- return t.kind === 18;
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1] || $assertType(_ref, ptrType$15, true)[1] || $assertType(_ref, ptrType$17, true)[1] || $assertType(_ref, ptrType$53, true)[1] || $assertType(_ref, ptrType$13, true)[1] || $assertType(_ref, ptrType$12, true)[1]) { */ case 3:
- t$1 = _ref;
- return true;
- /* } */ case 4:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: hasNil }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.t = t; $f.t$1 = t$1; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- Identical = function(x, y) {
- var $ptr, _r, x, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = identical(x, y, ptrType$74.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Identical }; } $f.$ptr = $ptr; $f._r = _r; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Identical = Identical;
- ifacePair.ptr.prototype.identical = function(q) {
- var $ptr, p, q;
- p = this;
- return p.x === q.x && p.y === q.y || p.x === q.y && p.y === q.x;
- };
- ifacePair.prototype.identical = function(q) { return this.$val.identical(q); };
- identical = function(x, y, p) {
- var $ptr, _i, _i$1, _i$2, _r, _r$1, _r$10, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _tuple, _tuple$1, _tuple$10, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, _v, _v$1, _v$2, _v$3, _v$4, _v$5, _v$6, a, b, f, f$1, g, g$1, i, i$1, i$2, ok, ok$1, ok$10, ok$2, ok$3, ok$4, ok$5, ok$6, ok$7, ok$8, ok$9, p, q, v, w, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, y$1, y$10, y$11, y$2, y$3, y$4, y$5, y$6, y$7, y$8, y$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; _v$4 = $f._v$4; _v$5 = $f._v$5; _v$6 = $f._v$6; a = $f.a; b = $f.b; f = $f.f; f$1 = $f.f$1; g = $f.g; g$1 = $f.g$1; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; ok = $f.ok; ok$1 = $f.ok$1; ok$10 = $f.ok$10; ok$2 = $f.ok$2; ok$3 = $f.ok$3; ok$4 = $f.ok$4; ok$5 = $f.ok$5; ok$6 = $f.ok$6; ok$7 = $f.ok$7; ok$8 = $f.ok$8; ok$9 = $f.ok$9; p = $f.p; q = $f.q; v = $f.v; w = $f.w; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; y = $f.y; y$1 = $f.y$1; y$10 = $f.y$10; y$11 = $f.y$11; y$2 = $f.y$2; y$3 = $f.y$3; y$4 = $f.y$4; y$5 = $f.y$5; y$6 = $f.y$6; y$7 = $f.y$7; y$8 = $f.y$8; y$9 = $f.y$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if ($interfaceIsEqual(x, y)) {
- return true;
- }
- _ref = x;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$27, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$15, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$8, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$17, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$53, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$13, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$12, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$26, true)[1]) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 1:
- x$1 = _ref.$val;
- _tuple = $assertType(y, ptrType$3, true); y$1 = _tuple[0]; ok = _tuple[1];
- if (ok) {
- return x$1.kind === y$1.kind;
- }
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$11, true)[1]) { */ case 2:
- x$2 = _ref.$val;
- _tuple$1 = $assertType(y, ptrType$11, true); y$2 = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (ok$1) { */ case 14:
- if (!((x$3 = x$2.len, x$4 = y$2.len, (x$3.$high === x$4.$high && x$3.$low === x$4.$low)))) { _v = false; $s = 16; continue s; }
- _r = identical(x$2.elem, y$2.elem, p); /* */ $s = 17; case 17: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 16:
- return _v;
- /* } */ case 15:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1]) { */ case 3:
- x$5 = _ref.$val;
- _tuple$2 = $assertType(y, ptrType$10, true); y$3 = _tuple$2[0]; ok$2 = _tuple$2[1];
- /* */ if (ok$2) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (ok$2) { */ case 18:
- _r$1 = identical(x$5.elem, y$3.elem, p); /* */ $s = 20; case 20: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 19:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$27, true)[1]) { */ case 4:
- x$6 = _ref.$val;
- _tuple$3 = $assertType(y, ptrType$27, true); y$4 = _tuple$3[0]; ok$3 = _tuple$3[1];
- /* */ if (ok$3) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (ok$3) { */ case 21:
- /* */ if (x$6.NumFields() === y$4.NumFields()) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (x$6.NumFields() === y$4.NumFields()) { */ case 23:
- _ref$1 = x$6.fields;
- _i = 0;
- /* while (true) { */ case 25:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 26; continue; }
- i = _i;
- f = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- g = (x$7 = y$4.fields, ((i < 0 || i >= x$7.$length) ? $throwRuntimeError("index out of range") : x$7.$array[x$7.$offset + i]));
- if (!(f.anonymous === g.anonymous) || !(x$6.Tag(i) === y$4.Tag(i)) || !f.object.sameId(g.object.pkg, g.object.name)) { _v$1 = true; $s = 29; continue s; }
- _r$2 = identical(f.object.typ, g.object.typ, p); /* */ $s = 30; case 30: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v$1 = !_r$2; case 29:
- /* */ if (_v$1) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (_v$1) { */ case 27:
- return false;
- /* } */ case 28:
- _i++;
- /* } */ $s = 25; continue; case 26:
- return true;
- /* } */ case 24:
- /* } */ case 22:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$15, true)[1]) { */ case 5:
- x$8 = _ref.$val;
- _tuple$4 = $assertType(y, ptrType$15, true); y$5 = _tuple$4[0]; ok$4 = _tuple$4[1];
- /* */ if (ok$4) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (ok$4) { */ case 31:
- _r$3 = identical(x$8.base, y$5.base, p); /* */ $s = 33; case 33: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- /* } */ case 32:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$8, true)[1]) { */ case 6:
- x$9 = _ref.$val;
- _tuple$5 = $assertType(y, ptrType$8, true); y$6 = _tuple$5[0]; ok$5 = _tuple$5[1];
- /* */ if (ok$5) { $s = 34; continue; }
- /* */ $s = 35; continue;
- /* if (ok$5) { */ case 34:
- /* */ if (x$9.Len() === y$6.Len()) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (x$9.Len() === y$6.Len()) { */ case 36:
- /* */ if (!(x$9 === ptrType$8.nil)) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (!(x$9 === ptrType$8.nil)) { */ case 38:
- _ref$2 = x$9.vars;
- _i$1 = 0;
- /* while (true) { */ case 40:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 41; continue; }
- i$1 = _i$1;
- v = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- w = (x$10 = y$6.vars, ((i$1 < 0 || i$1 >= x$10.$length) ? $throwRuntimeError("index out of range") : x$10.$array[x$10.$offset + i$1]));
- _r$4 = identical(v.object.typ, w.object.typ, p); /* */ $s = 44; case 44: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- /* */ if (!_r$4) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (!_r$4) { */ case 42:
- return false;
- /* } */ case 43:
- _i$1++;
- /* } */ $s = 40; continue; case 41:
- /* } */ case 39:
- return true;
- /* } */ case 37:
- /* } */ case 35:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$17, true)[1]) { */ case 7:
- x$11 = _ref.$val;
- _tuple$6 = $assertType(y, ptrType$17, true); y$7 = _tuple$6[0]; ok$6 = _tuple$6[1];
- /* */ if (ok$6) { $s = 45; continue; }
- /* */ $s = 46; continue;
- /* if (ok$6) { */ case 45:
- if (!(x$11.variadic === y$7.variadic)) { _v$3 = false; $s = 48; continue s; }
- _r$5 = identical(x$11.params, y$7.params, p); /* */ $s = 49; case 49: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _v$3 = _r$5; case 48:
- if (!(_v$3)) { _v$2 = false; $s = 47; continue s; }
- _r$6 = identical(x$11.results, y$7.results, p); /* */ $s = 50; case 50: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _v$2 = _r$6; case 47:
- return _v$2;
- /* } */ case 46:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$53, true)[1]) { */ case 8:
- x$12 = _ref.$val;
- _tuple$7 = $assertType(y, ptrType$53, true); y$8 = _tuple$7[0]; ok$7 = _tuple$7[1];
- /* */ if (ok$7) { $s = 51; continue; }
- /* */ $s = 52; continue;
- /* if (ok$7) { */ case 51:
- a = x$12.allMethods;
- b = y$8.allMethods;
- /* */ if (a.$length === b.$length) { $s = 53; continue; }
- /* */ $s = 54; continue;
- /* if (a.$length === b.$length) { */ case 53:
- q = new ifacePair.ptr(x$12, y$8, p);
- while (true) {
- if (!(!(p === ptrType$74.nil))) { break; }
- if (p.identical(q)) {
- return true;
- }
- p = p.prev;
- }
- _ref$3 = a;
- _i$2 = 0;
- /* while (true) { */ case 55:
- /* if (!(_i$2 < _ref$3.$length)) { break; } */ if(!(_i$2 < _ref$3.$length)) { $s = 56; continue; }
- i$2 = _i$2;
- f$1 = ((_i$2 < 0 || _i$2 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$2]);
- g$1 = ((i$2 < 0 || i$2 >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + i$2]);
- if (!(f$1.object.Id() === g$1.object.Id())) { _v$4 = true; $s = 59; continue s; }
- _r$7 = identical(f$1.object.typ, g$1.object.typ, q); /* */ $s = 60; case 60: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _v$4 = !_r$7; case 59:
- /* */ if (_v$4) { $s = 57; continue; }
- /* */ $s = 58; continue;
- /* if (_v$4) { */ case 57:
- return false;
- /* } */ case 58:
- _i$2++;
- /* } */ $s = 55; continue; case 56:
- return true;
- /* } */ case 54:
- /* } */ case 52:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$13, true)[1]) { */ case 9:
- x$13 = _ref.$val;
- _tuple$8 = $assertType(y, ptrType$13, true); y$9 = _tuple$8[0]; ok$8 = _tuple$8[1];
- /* */ if (ok$8) { $s = 61; continue; }
- /* */ $s = 62; continue;
- /* if (ok$8) { */ case 61:
- _r$8 = identical(x$13.key, y$9.key, p); /* */ $s = 64; case 64: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- if (!(_r$8)) { _v$5 = false; $s = 63; continue s; }
- _r$9 = identical(x$13.elem, y$9.elem, p); /* */ $s = 65; case 65: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _v$5 = _r$9; case 63:
- return _v$5;
- /* } */ case 62:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$12, true)[1]) { */ case 10:
- x$14 = _ref.$val;
- _tuple$9 = $assertType(y, ptrType$12, true); y$10 = _tuple$9[0]; ok$9 = _tuple$9[1];
- /* */ if (ok$9) { $s = 66; continue; }
- /* */ $s = 67; continue;
- /* if (ok$9) { */ case 66:
- if (!(x$14.dir === y$10.dir)) { _v$6 = false; $s = 68; continue s; }
- _r$10 = identical(x$14.elem, y$10.elem, p); /* */ $s = 69; case 69: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _v$6 = _r$10; case 68:
- return _v$6;
- /* } */ case 67:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$26, true)[1]) { */ case 11:
- x$15 = _ref.$val;
- _tuple$10 = $assertType(y, ptrType$26, true); y$11 = _tuple$10[0]; ok$10 = _tuple$10[1];
- if (ok$10) {
- return x$15.obj === y$11.obj;
- }
- $s = 13; continue;
- /* } else { */ case 12:
- x$16 = _ref;
- unreachable();
- /* } */ case 13:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: identical }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f._v$4 = _v$4; $f._v$5 = _v$5; $f._v$6 = _v$6; $f.a = a; $f.b = b; $f.f = f; $f.f$1 = f$1; $f.g = g; $f.g$1 = g$1; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$10 = ok$10; $f.ok$2 = ok$2; $f.ok$3 = ok$3; $f.ok$4 = ok$4; $f.ok$5 = ok$5; $f.ok$6 = ok$6; $f.ok$7 = ok$7; $f.ok$8 = ok$8; $f.ok$9 = ok$9; $f.p = p; $f.q = q; $f.v = v; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.y = y; $f.y$1 = y$1; $f.y$10 = y$10; $f.y$11 = y$11; $f.y$2 = y$2; $f.y$3 = y$3; $f.y$4 = y$4; $f.y$5 = y$5; $f.y$6 = y$6; $f.y$7 = y$7; $f.y$8 = y$8; $f.y$9 = y$9; $f.$s = $s; $f.$r = $r; return $f;
- };
- defaultType = function(typ) {
- var $ptr, _ref, _tuple, ok, t, typ;
- _tuple = $assertType(typ, ptrType$3, true); t = _tuple[0]; ok = _tuple[1];
- if (ok) {
- _ref = t.kind;
- if (_ref === 19) {
- return $pkg.Typ[1];
- } else if (_ref === 20) {
- return $pkg.Typ[2];
- } else if (_ref === 21) {
- return $pkg.UniverseRune;
- } else if (_ref === 22) {
- return $pkg.Typ[14];
- } else if (_ref === 23) {
- return $pkg.Typ[16];
- } else if (_ref === 24) {
- return $pkg.Typ[17];
- }
- }
- return typ;
- };
- declInfo.ptr.prototype.hasInitializer = function() {
- var $ptr, d;
- d = this;
- return !($interfaceIsEqual(d.init, $ifaceNil)) || !(d.fdecl === ptrType$75.nil) && !(d.fdecl.Body === ptrType$29.nil);
- };
- declInfo.prototype.hasInitializer = function() { return this.$val.hasInitializer(); };
- declInfo.ptr.prototype.addDep = function(obj) {
- var $ptr, _key$2, d, m, obj;
- d = this;
- m = d.deps;
- if (m === false) {
- m = new $Map();
- d.deps = m;
- }
- _key$2 = obj; (m || $throwRuntimeError("assignment to entry in nil map"))[Object.keyFor(_key$2)] = { k: _key$2, v: true };
- };
- declInfo.prototype.addDep = function(obj) { return this.$val.addDep(obj); };
- Checker.ptr.prototype.arityMatch = function(s, init$1) {
- var $ptr, _r, check, init$1, l, n, n$1, r, s, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; check = $f.check; init$1 = $f.init$1; l = $f.l; n = $f.n; n$1 = $f.n$1; r = $f.r; s = $f.s; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- l = s.Names.$length;
- r = s.Values.$length;
- if (!(init$1 === ptrType$32.nil)) {
- r = init$1.Values.$length;
- }
- /* */ if (init$1 === ptrType$32.nil && (r === 0)) { $s = 1; continue; }
- /* */ if (l < r) { $s = 2; continue; }
- /* */ if (l > r && (!(init$1 === ptrType$32.nil) || !((r === 1)))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (init$1 === ptrType$32.nil && (r === 0)) { */ case 1:
- /* */ if ($interfaceIsEqual(s.Type, $ifaceNil)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if ($interfaceIsEqual(s.Type, $ifaceNil)) { */ case 5:
- $r = check.errorf(s.Pos(), "missing type or init expr", new sliceType([])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- $s = 4; continue;
- /* } else if (l < r) { */ case 2:
- /* */ if (l < s.Values.$length) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (l < s.Values.$length) { */ case 8:
- n = (x = s.Values, ((l < 0 || l >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + l]));
- _r = n.Pos(); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.errorf(_r, "extra init expr %s", new sliceType([n])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 10; continue;
- /* } else { */ case 9:
- $r = check.errorf(s.Pos(), "extra init expr at %s", new sliceType([new token.Pos(init$1.Pos())])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- $s = 4; continue;
- /* } else if (l > r && (!(init$1 === ptrType$32.nil) || !((r === 1)))) { */ case 3:
- n$1 = (x$1 = s.Names, ((r < 0 || r >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + r]));
- $r = check.errorf(n$1.Pos(), "missing init expr for %s", new sliceType([n$1])); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.arityMatch }; } $f.$ptr = $ptr; $f._r = _r; $f.check = check; $f.init$1 = init$1; $f.l = l; $f.n = n; $f.n$1 = n$1; $f.r = r; $f.s = s; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.arityMatch = function(s, init$1) { return this.$val.arityMatch(s, init$1); };
- validatedImportPath = function(path$1) {
- var $ptr, _i, _r, _r$1, _ref, _rune, _tuple, err, path$1, r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _rune = $f._rune; _tuple = $f._tuple; err = $f.err; path$1 = $f.path$1; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tuple = strconv.Unquote(path$1); s = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return ["", err];
- }
- /* */ if (s === "") { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (s === "") { */ case 1:
- _r = fmt.Errorf("empty string", new sliceType([])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return ["", _r];
- /* } */ case 2:
- _ref = s;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.length)) { break; } */ if(!(_i < _ref.length)) { $s = 5; continue; }
- _rune = $decodeRune(_ref, _i);
- r = _rune[0];
- /* */ if (!unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune("!\"#$%&'()*,:;<=>?[\\]^{|}`\xEF\xBF\xBD", r)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune("!\"#$%&'()*,:;<=>?[\\]^{|}`\xEF\xBF\xBD", r)) { */ case 6:
- _r$1 = fmt.Errorf("invalid character %#U", new sliceType([new $Int32(r)])); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return [s, _r$1];
- /* } */ case 7:
- _i += _rune[1];
- /* } */ $s = 4; continue; case 5:
- return [s, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: validatedImportPath }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._rune = _rune; $f._tuple = _tuple; $f.err = err; $f.path$1 = path$1; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.ptr.prototype.declarePkgObj = function(ident, obj, d) {
- var $ptr, _key$2, _r, check, d, ident, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key$2 = $f._key$2; _r = $f._r; check = $f.check; d = $f.d; ident = $f.ident; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = obj.Name(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = assert(ident.Name === _r); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (ident.Name === "init") { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (ident.Name === "init") { */ case 3:
- $r = check.errorf(ident.Pos(), "cannot declare init - must be func", new sliceType([])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 4:
- $r = check.declare(check.pkg.scope, ident, obj, 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _key$2 = obj; (check.objMap || $throwRuntimeError("assignment to entry in nil map"))[Object.keyFor(_key$2)] = { k: _key$2, v: d };
- $r = obj.setOrder(($keys(check.objMap).length >>> 0)); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.declarePkgObj }; } $f.$ptr = $ptr; $f._key$2 = _key$2; $f._r = _r; $f.check = check; $f.d = d; $f.ident = ident; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.declarePkgObj = function(ident, obj, d) { return this.$val.declarePkgObj(ident, obj, d); };
- Checker.ptr.prototype.filename = function(fileNo) {
- var $ptr, _r, _r$1, _r$2, check, file, fileNo, pos, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; check = $f.check; file = $f.file; fileNo = $f.fileNo; pos = $f.pos; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- file = (x = check.files, ((fileNo < 0 || fileNo >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + fileNo]));
- pos = file.Pos();
- /* */ if (new token.Pos(pos).IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (new token.Pos(pos).IsValid()) { */ case 1:
- _r = check.fset.File(pos); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 2:
- _r$2 = fmt.Sprintf("file[%d]", new sliceType([new $Int(fileNo)])); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.filename }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.check = check; $f.file = file; $f.fileNo = fileNo; $f.pos = pos; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.filename = function(fileNo) { return this.$val.filename(fileNo); };
- Checker.ptr.prototype.collectObjects = function() {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _entry, _entry$1, _entry$2, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _i$7, _i$8, _key$2, _key$3, _key$4, _keys, _keys$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$10, _ref$11, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, alt, base, check, d, d$1, d$2, d$3, d$4, d$5, d1, decl, end, err, err$1, f, file, fileNo, fileScope, i, i$1, imp, imp$1, importer, info, init$1, init$2, iota, last, lhs, list, name, name$1, name$2, name$3, obj, obj$1, obj$2, obj$3, obj$4, obj$5, obj$6, ok, path$1, pkg, pkg$1, pkgImports, pos, ptr, s, s$1, s$2, s$3, scope, spec, typ, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _i$7 = $f._i$7; _i$8 = $f._i$8; _key$2 = $f._key$2; _key$3 = $f._key$3; _key$4 = $f._key$4; _keys = $f._keys; _keys$1 = $f._keys$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$10 = $f._ref$10; _ref$11 = $f._ref$11; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; alt = $f.alt; base = $f.base; check = $f.check; d = $f.d; d$1 = $f.d$1; d$2 = $f.d$2; d$3 = $f.d$3; d$4 = $f.d$4; d$5 = $f.d$5; d1 = $f.d1; decl = $f.decl; end = $f.end; err = $f.err; err$1 = $f.err$1; f = $f.f; file = $f.file; fileNo = $f.fileNo; fileScope = $f.fileScope; i = $f.i; i$1 = $f.i$1; imp = $f.imp; imp$1 = $f.imp$1; importer = $f.importer; info = $f.info; init$1 = $f.init$1; init$2 = $f.init$2; iota = $f.iota; last = $f.last; lhs = $f.lhs; list = $f.list; name = $f.name; name$1 = $f.name$1; name$2 = $f.name$2; name$3 = $f.name$3; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; obj$4 = $f.obj$4; obj$5 = $f.obj$5; obj$6 = $f.obj$6; ok = $f.ok; path$1 = $f.path$1; pkg = $f.pkg; pkg$1 = $f.pkg$1; pkgImports = $f.pkgImports; pos = $f.pos; ptr = $f.ptr; s = $f.s; s$1 = $f.s$1; s$2 = $f.s$2; s$3 = $f.s$3; scope = $f.scope; spec = $f.spec; typ = $f.typ; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- pkg = check.pkg;
- importer = check.conf.Import;
- /* */ if (importer === $throwNilPointerError) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (importer === $throwNilPointerError) { */ case 1:
- if (!($pkg.DefaultImport === $throwNilPointerError)) {
- importer = $pkg.DefaultImport;
- } else {
- importer = (function(param, param$1) {
- var $ptr, param, param$1;
- $panic(new $String("no Config.Import or DefaultImport (missing import _ \"golang.org/x/tools/go/gcimporter\"?)"));
- });
- }
- /* } */ case 2:
- pkgImports = new $Map();
- _ref = pkg.imports;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- imp = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _key$2 = imp; (pkgImports || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$2)] = { k: _key$2, v: true };
- _i++;
- }
- _ref$1 = check.files;
- _i$1 = 0;
- /* while (true) { */ case 3:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 4; continue; }
- fileNo = _i$1;
- file = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- check.recordDef(file.Name, $ifaceNil);
- _r = file.End(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tmp = file.Pos(); _tmp$1 = _r; pos = _tmp; end = _tmp$1;
- _r$1 = check.fset.File(file.Pos()); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- f = _r$1;
- /* */ if (!(f === ptrType$76.nil)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!(f === ptrType$76.nil)) { */ case 7:
- _tmp$2 = (f.Base() >> 0); _tmp$3 = ((f.Base() + f.Size() >> 0) >> 0); pos = _tmp$2; end = _tmp$3;
- /* } */ case 8:
- _arg = check.pkg.scope;
- _arg$1 = pos;
- _arg$2 = end;
- _r$2 = check.filename(fileNo); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$3 = _r$2;
- _r$3 = NewScope(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- fileScope = _r$3;
- check.recordScope(file, fileScope);
- _ref$2 = file.Decls;
- _i$2 = 0;
- /* while (true) { */ case 11:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 12; continue; }
- decl = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- _ref$3 = decl;
- /* */ if ($assertType(_ref$3, ptrType$30, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref$3, ptrType$31, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref$3, ptrType$75, true)[1]) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if ($assertType(_ref$3, ptrType$30, true)[1]) { */ case 13:
- d = _ref$3.$val;
- $s = 17; continue;
- /* } else if ($assertType(_ref$3, ptrType$31, true)[1]) { */ case 14:
- d$1 = _ref$3.$val;
- last = ptrType$32.nil;
- _ref$4 = d$1.Specs;
- _i$3 = 0;
- /* while (true) { */ case 18:
- /* if (!(_i$3 < _ref$4.$length)) { break; } */ if(!(_i$3 < _ref$4.$length)) { $s = 19; continue; }
- iota = _i$3;
- spec = ((_i$3 < 0 || _i$3 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$3]);
- _ref$5 = spec;
- /* */ if ($assertType(_ref$5, ptrType$77, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref$5, ptrType$32, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref$5, ptrType$33, true)[1]) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if ($assertType(_ref$5, ptrType$77, true)[1]) { */ case 20:
- s = _ref$5.$val;
- imp$1 = ptrType$1.nil;
- _r$4 = validatedImportPath(s.Path.Value); /* */ $s = 25; case 25: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; path$1 = _tuple[0]; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 26:
- $r = check.errorf(s.Path.Pos(), "invalid import path (%s)", new sliceType([err])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* continue; */ $s = 18; continue;
- /* } */ case 27:
- /* */ if (path$1 === "C" && check.conf.FakeImportC) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (path$1 === "C" && check.conf.FakeImportC) { */ case 29:
- _r$5 = NewPackage("C", "C"); /* */ $s = 32; case 32: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- imp$1 = _r$5;
- imp$1.fake = true;
- $s = 31; continue;
- /* } else { */ case 30:
- err$1 = $ifaceNil;
- _r$6 = importer(check.conf.Packages, path$1); /* */ $s = 33; case 33: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$1 = _r$6; imp$1 = _tuple$1[0]; err$1 = _tuple$1[1];
- if (imp$1 === ptrType$1.nil && $interfaceIsEqual(err$1, $ifaceNil)) {
- err$1 = errors.New("Config.Import returned nil but no error");
- }
- /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 34; continue; }
- /* */ $s = 35; continue;
- /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 34:
- $r = check.errorf(s.Path.Pos(), "could not import %s (%s)", new sliceType([new $String(path$1), err$1])); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* continue; */ $s = 18; continue;
- /* } */ case 35:
- /* } */ case 31:
- if (!(_entry = pkgImports[ptrType$1.keyFor(imp$1)], _entry !== undefined ? _entry.v : false)) {
- _key$3 = imp$1; (pkgImports || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$3)] = { k: _key$3, v: true };
- if (!(imp$1 === $pkg.Unsafe)) {
- pkg.imports = $append(pkg.imports, imp$1);
- }
- }
- name = imp$1.name;
- /* */ if (!(s.Name === ptrType$5.nil)) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (!(s.Name === ptrType$5.nil)) { */ case 37:
- name = s.Name.Name;
- /* */ if (name === "init") { $s = 39; continue; }
- /* */ $s = 40; continue;
- /* if (name === "init") { */ case 39:
- $r = check.errorf(s.Name.Pos(), "cannot declare init - must be func", new sliceType([])); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* continue; */ $s = 18; continue;
- /* } */ case 40:
- /* } */ case 38:
- obj = NewPkgName(s.Pos(), pkg, name, imp$1);
- if (!(s.Name === ptrType$5.nil)) {
- check.recordDef(s.Name, obj);
- } else {
- check.recordImplicit(s, obj);
- }
- /* */ if (name === ".") { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (name === ".") { */ case 42:
- _ref$6 = imp$1.scope.elems;
- _i$4 = 0;
- _keys = $keys(_ref$6);
- /* while (true) { */ case 45:
- /* if (!(_i$4 < _keys.length)) { break; } */ if(!(_i$4 < _keys.length)) { $s = 46; continue; }
- _entry$1 = _ref$6[_keys[_i$4]];
- if (_entry$1 === undefined) {
- _i$4++;
- /* continue; */ $s = 45; continue;
- }
- obj$1 = _entry$1.v;
- _r$7 = obj$1.Exported(); /* */ $s = 49; case 49: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (_r$7) { $s = 47; continue; }
- /* */ $s = 48; continue;
- /* if (_r$7) { */ case 47:
- $r = check.declare(fileScope, ptrType$5.nil, obj$1, 0); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- check.recordImplicit(s, obj$1);
- /* } */ case 48:
- _i$4++;
- /* } */ $s = 45; continue; case 46:
- check.addUnusedDotImport(fileScope, imp$1, s.Pos());
- $s = 44; continue;
- /* } else { */ case 43:
- $r = check.declare(fileScope, ptrType$5.nil, obj, 0); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 44:
- $s = 24; continue;
- /* } else if ($assertType(_ref$5, ptrType$32, true)[1]) { */ case 21:
- s$1 = _ref$5.$val;
- _ref$7 = d$1.Tok;
- /* */ if (_ref$7 === 64) { $s = 52; continue; }
- /* */ if (_ref$7 === 85) { $s = 53; continue; }
- /* */ $s = 54; continue;
- /* if (_ref$7 === 64) { */ case 52:
- if (!($interfaceIsEqual(s$1.Type, $ifaceNil)) || s$1.Values.$length > 0) {
- last = s$1;
- } else if (last === ptrType$32.nil) {
- last = new ast.ValueSpec.ptr();
- }
- _ref$8 = s$1.Names;
- _i$5 = 0;
- /* while (true) { */ case 56:
- /* if (!(_i$5 < _ref$8.$length)) { break; } */ if(!(_i$5 < _ref$8.$length)) { $s = 57; continue; }
- i = _i$5;
- name$1 = ((_i$5 < 0 || _i$5 >= _ref$8.$length) ? $throwRuntimeError("index out of range") : _ref$8.$array[_ref$8.$offset + _i$5]);
- obj$2 = NewConst(name$1.Pos(), pkg, name$1.Name, $ifaceNil, exact.MakeInt64(new $Int64(0, iota)));
- init$1 = $ifaceNil;
- if (i < last.Values.$length) {
- init$1 = (x = last.Values, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- }
- d$2 = new declInfo.ptr(fileScope, sliceType$1.nil, last.Type, init$1, ptrType$75.nil, false, 0);
- $r = check.declarePkgObj(name$1, obj$2, d$2); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$5++;
- /* } */ $s = 56; continue; case 57:
- $r = check.arityMatch(s$1, last); /* */ $s = 59; case 59: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 55; continue;
- /* } else if (_ref$7 === 85) { */ case 53:
- lhs = $makeSlice(sliceType$1, s$1.Names.$length);
- d1 = ptrType$21.nil;
- if (s$1.Values.$length === 1) {
- d1 = new declInfo.ptr(fileScope, lhs, s$1.Type, (x$1 = s$1.Values, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])), ptrType$75.nil, false, 0);
- }
- _ref$9 = s$1.Names;
- _i$6 = 0;
- /* while (true) { */ case 60:
- /* if (!(_i$6 < _ref$9.$length)) { break; } */ if(!(_i$6 < _ref$9.$length)) { $s = 61; continue; }
- i$1 = _i$6;
- name$2 = ((_i$6 < 0 || _i$6 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$6]);
- obj$3 = NewVar(name$2.Pos(), pkg, name$2.Name, $ifaceNil);
- ((i$1 < 0 || i$1 >= lhs.$length) ? $throwRuntimeError("index out of range") : lhs.$array[lhs.$offset + i$1] = obj$3);
- d$3 = d1;
- if (d$3 === ptrType$21.nil) {
- init$2 = $ifaceNil;
- if (i$1 < s$1.Values.$length) {
- init$2 = (x$2 = s$1.Values, ((i$1 < 0 || i$1 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$1]));
- }
- d$3 = new declInfo.ptr(fileScope, sliceType$1.nil, s$1.Type, init$2, ptrType$75.nil, false, 0);
- }
- $r = check.declarePkgObj(name$2, obj$3, d$3); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$6++;
- /* } */ $s = 60; continue; case 61:
- $r = check.arityMatch(s$1, ptrType$32.nil); /* */ $s = 63; case 63: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 55; continue;
- /* } else { */ case 54:
- $r = check.invalidAST(s$1.Pos(), "invalid token %s", new sliceType([new token.Token(d$1.Tok)])); /* */ $s = 64; case 64: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 55:
- $s = 24; continue;
- /* } else if ($assertType(_ref$5, ptrType$33, true)[1]) { */ case 22:
- s$2 = _ref$5.$val;
- obj$4 = NewTypeName(s$2.Name.Pos(), pkg, s$2.Name.Name, $ifaceNil);
- $r = check.declarePkgObj(s$2.Name, obj$4, new declInfo.ptr(fileScope, sliceType$1.nil, s$2.Type, $ifaceNil, ptrType$75.nil, false, 0)); /* */ $s = 65; case 65: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 24; continue;
- /* } else { */ case 23:
- s$3 = _ref$5;
- _r$8 = s$3.Pos(); /* */ $s = 66; case 66: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$8, "unknown ast.Spec node %T", new sliceType([s$3])); /* */ $s = 67; case 67: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 24:
- _i$3++;
- /* } */ $s = 18; continue; case 19:
- $s = 17; continue;
- /* } else if ($assertType(_ref$3, ptrType$75, true)[1]) { */ case 15:
- d$4 = _ref$3.$val;
- name$3 = d$4.Name.Name;
- obj$5 = NewFunc(d$4.Name.Pos(), pkg, name$3, ptrType$17.nil);
- /* */ if (d$4.Recv === ptrType$78.nil) { $s = 68; continue; }
- /* */ $s = 69; continue;
- /* if (d$4.Recv === ptrType$78.nil) { */ case 68:
- /* */ if (name$3 === "init") { $s = 71; continue; }
- /* */ $s = 72; continue;
- /* if (name$3 === "init") { */ case 71:
- obj$5.object.parent = pkg.scope;
- check.recordDef(d$4.Name, obj$5);
- /* */ if (d$4.Body === ptrType$29.nil) { $s = 74; continue; }
- /* */ $s = 75; continue;
- /* if (d$4.Body === ptrType$29.nil) { */ case 74:
- $r = check.softErrorf(obj$5.object.pos, "missing function body", new sliceType([])); /* */ $s = 76; case 76: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 75:
- $s = 73; continue;
- /* } else { */ case 72:
- $r = check.declare(pkg.scope, d$4.Name, obj$5, 0); /* */ $s = 77; case 77: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 73:
- $s = 70; continue;
- /* } else { */ case 69:
- check.recordDef(d$4.Name, obj$5);
- list = d$4.Recv.List;
- if (list.$length > 0) {
- typ = (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]).Type;
- _tuple$2 = $assertType(typ, ptrType$42, true); ptr = _tuple$2[0];
- if (!(ptr === ptrType$42.nil)) {
- typ = ptr.X;
- }
- _tuple$3 = $assertType(typ, ptrType$5, true); base = _tuple$3[0];
- if (!(base === ptrType$5.nil) && !(base.Name === "_")) {
- check.assocMethod(base.Name, obj$5);
- }
- }
- /* } */ case 70:
- info = new declInfo.ptr(fileScope, sliceType$1.nil, $ifaceNil, $ifaceNil, d$4, false, 0);
- _key$4 = obj$5; (check.objMap || $throwRuntimeError("assignment to entry in nil map"))[Object.keyFor(_key$4)] = { k: _key$4, v: info };
- obj$5.object.setOrder(($keys(check.objMap).length >>> 0));
- $s = 17; continue;
- /* } else { */ case 16:
- d$5 = _ref$3;
- _r$9 = d$5.Pos(); /* */ $s = 78; case 78: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$9, "unknown ast.Decl node %T", new sliceType([d$5])); /* */ $s = 79; case 79: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 17:
- _i$2++;
- /* } */ $s = 11; continue; case 12:
- _i$1++;
- /* } */ $s = 3; continue; case 4:
- _ref$10 = check.pkg.scope.children;
- _i$7 = 0;
- /* while (true) { */ case 80:
- /* if (!(_i$7 < _ref$10.$length)) { break; } */ if(!(_i$7 < _ref$10.$length)) { $s = 81; continue; }
- scope = ((_i$7 < 0 || _i$7 >= _ref$10.$length) ? $throwRuntimeError("index out of range") : _ref$10.$array[_ref$10.$offset + _i$7]);
- _ref$11 = scope.elems;
- _i$8 = 0;
- _keys$1 = $keys(_ref$11);
- /* while (true) { */ case 82:
- /* if (!(_i$8 < _keys$1.length)) { break; } */ if(!(_i$8 < _keys$1.length)) { $s = 83; continue; }
- _entry$2 = _ref$11[_keys$1[_i$8]];
- if (_entry$2 === undefined) {
- _i$8++;
- /* continue; */ $s = 82; continue;
- }
- obj$6 = _entry$2.v;
- _r$10 = obj$6.Name(); /* */ $s = 84; case 84: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$11 = pkg.scope.Lookup(_r$10); /* */ $s = 85; case 85: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- alt = _r$11;
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil))) { $s = 86; continue; }
- /* */ $s = 87; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil))) { */ case 86:
- _tuple$4 = $assertType(obj$6, ptrType$18, true); pkg$1 = _tuple$4[0]; ok = _tuple$4[1];
- /* */ if (ok) { $s = 88; continue; }
- /* */ $s = 89; continue;
- /* if (ok) { */ case 88:
- _r$12 = alt.Pos(); /* */ $s = 91; case 91: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _arg$4 = _r$12;
- _r$13 = alt.Name(); /* */ $s = 92; case 92: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _arg$5 = new $String(_r$13);
- _arg$6 = pkg$1.Imported();
- $r = check.errorf(_arg$4, "%s already declared through import of %s", new sliceType([_arg$5, _arg$6])); /* */ $s = 93; case 93: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.reportAltDecl(pkg$1); /* */ $s = 94; case 94: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 90; continue;
- /* } else { */ case 89:
- _r$14 = alt.Pos(); /* */ $s = 95; case 95: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _arg$7 = _r$14;
- _r$15 = alt.Name(); /* */ $s = 96; case 96: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _arg$8 = new $String(_r$15);
- _r$16 = obj$6.Pkg(); /* */ $s = 97; case 97: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _arg$9 = _r$16;
- $r = check.errorf(_arg$7, "%s already declared through dot-import of %s", new sliceType([_arg$8, _arg$9])); /* */ $s = 98; case 98: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.reportAltDecl(obj$6); /* */ $s = 99; case 99: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 90:
- /* } */ case 87:
- _i$8++;
- /* } */ $s = 82; continue; case 83:
- _i$7++;
- /* } */ $s = 80; continue; case 81:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.collectObjects }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._i$7 = _i$7; $f._i$8 = _i$8; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._key$4 = _key$4; $f._keys = _keys; $f._keys$1 = _keys$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$10 = _ref$10; $f._ref$11 = _ref$11; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.alt = alt; $f.base = base; $f.check = check; $f.d = d; $f.d$1 = d$1; $f.d$2 = d$2; $f.d$3 = d$3; $f.d$4 = d$4; $f.d$5 = d$5; $f.d1 = d1; $f.decl = decl; $f.end = end; $f.err = err; $f.err$1 = err$1; $f.f = f; $f.file = file; $f.fileNo = fileNo; $f.fileScope = fileScope; $f.i = i; $f.i$1 = i$1; $f.imp = imp; $f.imp$1 = imp$1; $f.importer = importer; $f.info = info; $f.init$1 = init$1; $f.init$2 = init$2; $f.iota = iota; $f.last = last; $f.lhs = lhs; $f.list = list; $f.name = name; $f.name$1 = name$1; $f.name$2 = name$2; $f.name$3 = name$3; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.obj$4 = obj$4; $f.obj$5 = obj$5; $f.obj$6 = obj$6; $f.ok = ok; $f.path$1 = path$1; $f.pkg = pkg; $f.pkg$1 = pkg$1; $f.pkgImports = pkgImports; $f.pos = pos; $f.ptr = ptr; $f.s = s; $f.s$1 = s$1; $f.s$2 = s$2; $f.s$3 = s$3; $f.scope = scope; $f.spec = spec; $f.typ = typ; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.collectObjects = function() { return this.$val.collectObjects(); };
- Checker.ptr.prototype.packageObjects = function(objList) {
- var $ptr, _i, _i$1, _ref, _ref$1, _tuple, check, obj, obj$1, obj$2, objList, typePath, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; check = $f.check; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; objList = $f.objList; typePath = $f.typePath; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _ref = objList;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- obj = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple = $assertType(obj, ptrType$19, true); obj$1 = _tuple[0];
- /* */ if (!(obj$1 === ptrType$19.nil) && !($interfaceIsEqual(obj$1.object.typ, $ifaceNil))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(obj$1 === ptrType$19.nil) && !($interfaceIsEqual(obj$1.object.typ, $ifaceNil))) { */ case 3:
- $r = check.addMethodDecls(obj$1); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- typePath = $makeSlice(sliceType$11, 0, 8);
- _ref$1 = objList;
- _i$1 = 0;
- /* while (true) { */ case 6:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 7; continue; }
- obj$2 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- $r = check.objDecl(obj$2, ptrType$26.nil, typePath); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 6; continue; case 7:
- check.methods = false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.packageObjects }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f.check = check; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.objList = objList; $f.typePath = typePath; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.packageObjects = function(objList) { return this.$val.packageObjects(objList); };
- Checker.ptr.prototype.functionBodies = function() {
- var $ptr, _i, _ref, check, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; check = $f.check; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _ref = check.funcs;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), funcInfo);
- $r = check.funcBody(f.decl, f.name, f.sig, f.body); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.functionBodies }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.check = check; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.functionBodies = function() { return this.$val.functionBodies(); };
- Checker.ptr.prototype.unusedImports = function() {
- var $ptr, _entry, _entry$1, _entry$2, _i, _i$1, _i$2, _i$3, _keys, _keys$1, _keys$2, _ref, _ref$1, _ref$2, _ref$3, _tuple, base, check, obj, obj$1, ok, path$1, pkg, pos, scope, unusedDotImports, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _keys = $f._keys; _keys$1 = $f._keys$1; _keys$2 = $f._keys$2; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; base = $f.base; check = $f.check; obj = $f.obj; obj$1 = $f.obj$1; ok = $f.ok; path$1 = $f.path$1; pkg = $f.pkg; pos = $f.pos; scope = $f.scope; unusedDotImports = $f.unusedDotImports; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- if (check.conf.IgnoreFuncBodies) {
- return;
- }
- _ref = check.pkg.scope.children;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- scope = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = scope.elems;
- _i$1 = 0;
- _keys = $keys(_ref$1);
- /* while (true) { */ case 3:
- /* if (!(_i$1 < _keys.length)) { break; } */ if(!(_i$1 < _keys.length)) { $s = 4; continue; }
- _entry = _ref$1[_keys[_i$1]];
- if (_entry === undefined) {
- _i$1++;
- /* continue; */ $s = 3; continue;
- }
- obj = _entry.v;
- _tuple = $assertType(obj, ptrType$18, true); obj$1 = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (ok) { */ case 5:
- /* */ if (!obj$1.used) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!obj$1.used) { */ case 7:
- path$1 = obj$1.imported.path;
- base = path.Base(path$1);
- /* */ if (obj$1.object.name === base) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (obj$1.object.name === base) { */ case 9:
- $r = check.softErrorf(obj$1.object.pos, "%q imported but not used", new sliceType([new $String(path$1)])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 11; continue;
- /* } else { */ case 10:
- $r = check.softErrorf(obj$1.object.pos, "%q imported but not used as %s", new sliceType([new $String(path$1), new $String(obj$1.object.name)])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- /* } */ case 8:
- /* } */ case 6:
- _i$1++;
- /* } */ $s = 3; continue; case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- _ref$2 = check.unusedDotImports;
- _i$2 = 0;
- _keys$1 = $keys(_ref$2);
- /* while (true) { */ case 14:
- /* if (!(_i$2 < _keys$1.length)) { break; } */ if(!(_i$2 < _keys$1.length)) { $s = 15; continue; }
- _entry$1 = _ref$2[_keys$1[_i$2]];
- if (_entry$1 === undefined) {
- _i$2++;
- /* continue; */ $s = 14; continue;
- }
- unusedDotImports = _entry$1.v;
- _ref$3 = unusedDotImports;
- _i$3 = 0;
- _keys$2 = $keys(_ref$3);
- /* while (true) { */ case 16:
- /* if (!(_i$3 < _keys$2.length)) { break; } */ if(!(_i$3 < _keys$2.length)) { $s = 17; continue; }
- _entry$2 = _ref$3[_keys$2[_i$3]];
- if (_entry$2 === undefined) {
- _i$3++;
- /* continue; */ $s = 16; continue;
- }
- pkg = _entry$2.k;
- pos = _entry$2.v;
- $r = check.softErrorf(pos, "%q imported but not used", new sliceType([new $String(pkg.path)])); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* } */ $s = 16; continue; case 17:
- _i$2++;
- /* } */ $s = 14; continue; case 15:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.unusedImports }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._keys = _keys; $f._keys$1 = _keys$1; $f._keys$2 = _keys$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f.base = base; $f.check = check; $f.obj = obj; $f.obj$1 = obj$1; $f.ok = ok; $f.path$1 = path$1; $f.pkg = pkg; $f.pos = pos; $f.scope = scope; $f.unusedDotImports = unusedDotImports; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.unusedImports = function() { return this.$val.unusedImports(); };
- Checker.ptr.prototype.isTerminating = function(s, label) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _v, _v$1, b, call, cc, check, id, label, obj, s, s$1, s$10, s$11, s$12, s$13, s$2, s$3, s$4, s$5, s$6, s$7, s$8, s$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _v = $f._v; _v$1 = $f._v$1; b = $f.b; call = $f.call; cc = $f.cc; check = $f.check; id = $f.id; label = $f.label; obj = $f.obj; s = $f.s; s$1 = $f.s$1; s$10 = $f.s$10; s$11 = $f.s$11; s$12 = $f.s$12; s$13 = $f.s$13; s$2 = $f.s$2; s$3 = $f.s$3; s$4 = $f.s$4; s$5 = $f.s$5; s$6 = $f.s$6; s$7 = $f.s$7; s$8 = $f.s$8; s$9 = $f.s$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _ref = s;
- /* */ if ($assertType(_ref, ptrType$79, true)[1] || $assertType(_ref, ptrType$61, true)[1] || $assertType(_ref, ptrType$80, true)[1] || $assertType(_ref, ptrType$81, true)[1] || $assertType(_ref, ptrType$82, true)[1] || $assertType(_ref, ptrType$62, true)[1] || $assertType(_ref, ptrType$83, true)[1] || $assertType(_ref, ptrType$84, true)[1] || $assertType(_ref, ptrType$70, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$58, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$85, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$86, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$60, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$29, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$63, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$65, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$66, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$68, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$69, true)[1]) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ($assertType(_ref, ptrType$79, true)[1] || $assertType(_ref, ptrType$61, true)[1] || $assertType(_ref, ptrType$80, true)[1] || $assertType(_ref, ptrType$81, true)[1] || $assertType(_ref, ptrType$82, true)[1] || $assertType(_ref, ptrType$62, true)[1] || $assertType(_ref, ptrType$83, true)[1] || $assertType(_ref, ptrType$84, true)[1] || $assertType(_ref, ptrType$70, true)[1]) { */ case 1:
- s$1 = _ref;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$58, true)[1]) { */ case 2:
- s$2 = _ref.$val;
- _r = check.isTerminating(s$2.Stmt, s$2.Label.Name); /* */ $s = 14; case 14: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$85, true)[1]) { */ case 3:
- s$3 = _ref.$val;
- _tuple = $assertType(unparen(s$3.X), ptrType$50, true); call = _tuple[0];
- /* */ if (!(call === ptrType$50.nil)) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!(call === ptrType$50.nil)) { */ case 15:
- _tuple$1 = $assertType(call.Fun, ptrType$5, true); id = _tuple$1[0];
- /* */ if (!(id === ptrType$5.nil)) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (!(id === ptrType$5.nil)) { */ case 17:
- _r$1 = check.context.scope.LookupParent(id.Name, 0); /* */ $s = 19; case 19: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$2 = _r$1; obj = _tuple$2[1];
- /* */ if (!($interfaceIsEqual(obj, $ifaceNil))) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (!($interfaceIsEqual(obj, $ifaceNil))) { */ case 20:
- _tuple$3 = $assertType(obj, ptrType$20, true); b = _tuple$3[0];
- if (!(b === ptrType$20.nil) && (b.id === 10)) {
- return true;
- }
- /* } */ case 21:
- /* } */ case 18:
- /* } */ case 16:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$86, true)[1]) { */ case 4:
- s$4 = _ref.$val;
- return true;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$60, true)[1]) { */ case 5:
- s$5 = _ref.$val;
- if ((s$5.Tok === 73) || (s$5.Tok === 69)) {
- return true;
- }
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$29, true)[1]) { */ case 6:
- s$6 = _ref.$val;
- _r$2 = check.isTerminatingList(s$6.List, ""); /* */ $s = 22; case 22: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$63, true)[1]) { */ case 7:
- s$7 = _ref.$val;
- if (!(!($interfaceIsEqual(s$7.Else, $ifaceNil)))) { _v$1 = false; $s = 26; continue s; }
- _r$3 = check.isTerminating(s$7.Body, ""); /* */ $s = 27; case 27: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v$1 = _r$3; case 26:
- if (!(_v$1)) { _v = false; $s = 25; continue s; }
- _r$4 = check.isTerminating(s$7.Else, ""); /* */ $s = 28; case 28: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _v = _r$4; case 25:
- /* */ if (_v) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_v) { */ case 23:
- return true;
- /* } */ case 24:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$65, true)[1]) { */ case 8:
- s$8 = _ref.$val;
- _r$5 = check.isTerminatingSwitch(s$8.Body, label); /* */ $s = 29; case 29: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$66, true)[1]) { */ case 9:
- s$9 = _ref.$val;
- _r$6 = check.isTerminatingSwitch(s$9.Body, label); /* */ $s = 30; case 30: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$68, true)[1]) { */ case 10:
- s$10 = _ref.$val;
- _ref$1 = s$10.Body.List;
- _i = 0;
- /* while (true) { */ case 31:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 32; continue; }
- s$11 = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- cc = $assertType(s$11, ptrType$67);
- _r$7 = check.isTerminatingList(cc.Body, ""); /* */ $s = 35; case 35: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (!_r$7 || hasBreakList(cc.Body, label, true)) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* if (!_r$7 || hasBreakList(cc.Body, label, true)) { */ case 33:
- return false;
- /* } */ case 34:
- _i++;
- /* } */ $s = 31; continue; case 32:
- return true;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$69, true)[1]) { */ case 11:
- s$12 = _ref.$val;
- if ($interfaceIsEqual(s$12.Cond, $ifaceNil) && !hasBreak(s$12.Body, label, true)) {
- return true;
- }
- $s = 13; continue;
- /* } else { */ case 12:
- s$13 = _ref;
- unreachable();
- /* } */ case 13:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.isTerminating }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._v = _v; $f._v$1 = _v$1; $f.b = b; $f.call = call; $f.cc = cc; $f.check = check; $f.id = id; $f.label = label; $f.obj = obj; $f.s = s; $f.s$1 = s$1; $f.s$10 = s$10; $f.s$11 = s$11; $f.s$12 = s$12; $f.s$13 = s$13; $f.s$2 = s$2; $f.s$3 = s$3; $f.s$4 = s$4; $f.s$5 = s$5; $f.s$6 = s$6; $f.s$7 = s$7; $f.s$8 = s$8; $f.s$9 = s$9; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.isTerminating = function(s, label) { return this.$val.isTerminating(s, label); };
- Checker.ptr.prototype.isTerminatingList = function(list, label) {
- var $ptr, _r, _v, check, label, list, n, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _v = $f._v; check = $f.check; label = $f.label; list = $f.list; n = $f.n; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- n = list.$length;
- if (!(n > 0)) { _v = false; $s = 1; continue s; }
- _r = check.isTerminating((x = n - 1 >> 0, ((x < 0 || x >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + x])), label); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 1:
- return _v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.isTerminatingList }; } $f.$ptr = $ptr; $f._r = _r; $f._v = _v; $f.check = check; $f.label = label; $f.list = list; $f.n = n; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.isTerminatingList = function(list, label) { return this.$val.isTerminatingList(list, label); };
- Checker.ptr.prototype.isTerminatingSwitch = function(body, label) {
- var $ptr, _i, _r, _ref, body, cc, check, hasDefault, label, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; body = $f.body; cc = $f.cc; check = $f.check; hasDefault = $f.hasDefault; label = $f.label; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- hasDefault = false;
- _ref = body.List;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- cc = $assertType(s, ptrType$64);
- if (cc.List === sliceType$5.nil) {
- hasDefault = true;
- }
- _r = check.isTerminatingList(cc.Body, ""); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r || hasBreakList(cc.Body, label, true)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!_r || hasBreakList(cc.Body, label, true)) { */ case 3:
- return false;
- /* } */ case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- return hasDefault;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.isTerminatingSwitch }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.body = body; $f.cc = cc; $f.check = check; $f.hasDefault = hasDefault; $f.label = label; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.isTerminatingSwitch = function(body, label) { return this.$val.isTerminatingSwitch(body, label); };
- hasBreak = function(s, label, implicit) {
- var $ptr, _ref, implicit, label, s, s$1, s$10, s$11, s$12, s$13, s$2, s$3, s$4, s$5, s$6, s$7, s$8, s$9;
- _ref = s;
- if ($assertType(_ref, ptrType$79, true)[1] || $assertType(_ref, ptrType$61, true)[1] || $assertType(_ref, ptrType$80, true)[1] || $assertType(_ref, ptrType$85, true)[1] || $assertType(_ref, ptrType$81, true)[1] || $assertType(_ref, ptrType$82, true)[1] || $assertType(_ref, ptrType$62, true)[1] || $assertType(_ref, ptrType$83, true)[1] || $assertType(_ref, ptrType$84, true)[1] || $assertType(_ref, ptrType$86, true)[1]) {
- s$1 = _ref;
- } else if ($assertType(_ref, ptrType$58, true)[1]) {
- s$2 = _ref.$val;
- return hasBreak(s$2.Stmt, label, implicit);
- } else if ($assertType(_ref, ptrType$60, true)[1]) {
- s$3 = _ref.$val;
- if (s$3.Tok === 61) {
- if (s$3.Label === ptrType$5.nil) {
- return implicit;
- }
- if (s$3.Label.Name === label) {
- return true;
- }
- }
- } else if ($assertType(_ref, ptrType$29, true)[1]) {
- s$4 = _ref.$val;
- return hasBreakList(s$4.List, label, implicit);
- } else if ($assertType(_ref, ptrType$63, true)[1]) {
- s$5 = _ref.$val;
- if (hasBreak(s$5.Body, label, implicit) || !($interfaceIsEqual(s$5.Else, $ifaceNil)) && hasBreak(s$5.Else, label, implicit)) {
- return true;
- }
- } else if ($assertType(_ref, ptrType$64, true)[1]) {
- s$6 = _ref.$val;
- return hasBreakList(s$6.Body, label, implicit);
- } else if ($assertType(_ref, ptrType$65, true)[1]) {
- s$7 = _ref.$val;
- if (!(label === "") && hasBreak(s$7.Body, label, false)) {
- return true;
- }
- } else if ($assertType(_ref, ptrType$66, true)[1]) {
- s$8 = _ref.$val;
- if (!(label === "") && hasBreak(s$8.Body, label, false)) {
- return true;
- }
- } else if ($assertType(_ref, ptrType$67, true)[1]) {
- s$9 = _ref.$val;
- return hasBreakList(s$9.Body, label, implicit);
- } else if ($assertType(_ref, ptrType$68, true)[1]) {
- s$10 = _ref.$val;
- if (!(label === "") && hasBreak(s$10.Body, label, false)) {
- return true;
- }
- } else if ($assertType(_ref, ptrType$69, true)[1]) {
- s$11 = _ref.$val;
- if (!(label === "") && hasBreak(s$11.Body, label, false)) {
- return true;
- }
- } else if ($assertType(_ref, ptrType$70, true)[1]) {
- s$12 = _ref.$val;
- if (!(label === "") && hasBreak(s$12.Body, label, false)) {
- return true;
- }
- } else {
- s$13 = _ref;
- unreachable();
- }
- return false;
- };
- hasBreakList = function(list, label, implicit) {
- var $ptr, _i, _ref, implicit, label, list, s;
- _ref = list;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (hasBreak(s, label, implicit)) {
- return true;
- }
- _i++;
- }
- return false;
- };
- NewScope = function(parent, pos, end, comment) {
- var $ptr, comment, end, parent, pos, s;
- s = new Scope.ptr(parent, sliceType$20.nil, false, pos, end, comment);
- if (!(parent === ptrType.nil) && !(parent === $pkg.Universe)) {
- parent.children = $append(parent.children, s);
- }
- return s;
- };
- $pkg.NewScope = NewScope;
- Scope.ptr.prototype.Parent = function() {
- var $ptr, s;
- s = this;
- return s.parent;
- };
- Scope.prototype.Parent = function() { return this.$val.Parent(); };
- Scope.ptr.prototype.Len = function() {
- var $ptr, s;
- s = this;
- return $keys(s.elems).length;
- };
- Scope.prototype.Len = function() { return this.$val.Len(); };
- Scope.ptr.prototype.Names = function() {
- var $ptr, _entry, _i, _keys, _ref, i, name, names, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _keys = $f._keys; _ref = $f._ref; i = $f.i; name = $f.name; names = $f.names; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- names = $makeSlice(sliceType$21, $keys(s.elems).length);
- i = 0;
- _ref = s.elems;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- name = _entry.k;
- ((i < 0 || i >= names.$length) ? $throwRuntimeError("index out of range") : names.$array[names.$offset + i] = name);
- i = i + (1) >> 0;
- _i++;
- }
- $r = sort.Strings(names); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return names;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scope.ptr.prototype.Names }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._keys = _keys; $f._ref = _ref; $f.i = i; $f.name = name; $f.names = names; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scope.prototype.Names = function() { return this.$val.Names(); };
- Scope.ptr.prototype.NumChildren = function() {
- var $ptr, s;
- s = this;
- return s.children.$length;
- };
- Scope.prototype.NumChildren = function() { return this.$val.NumChildren(); };
- Scope.ptr.prototype.Child = function(i) {
- var $ptr, i, s, x;
- s = this;
- return (x = s.children, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- };
- Scope.prototype.Child = function(i) { return this.$val.Child(i); };
- Scope.ptr.prototype.Lookup = function(name) {
- var $ptr, _entry, name, s;
- s = this;
- return (_entry = s.elems[$String.keyFor(name)], _entry !== undefined ? _entry.v : $ifaceNil);
- };
- Scope.prototype.Lookup = function(name) { return this.$val.Lookup(name); };
- Scope.ptr.prototype.LookupParent = function(name, pos) {
- var $ptr, _entry, _r, _v, _v$1, name, obj, pos, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; _v = $f._v; _v$1 = $f._v$1; name = $f.name; obj = $f.obj; pos = $f.pos; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- /* while (true) { */ case 1:
- /* if (!(!(s === ptrType.nil))) { break; } */ if(!(!(s === ptrType.nil))) { $s = 2; continue; }
- obj = (_entry = s.elems[$String.keyFor(name)], _entry !== undefined ? _entry.v : $ifaceNil);
- if (!(!($interfaceIsEqual(obj, $ifaceNil)))) { _v = false; $s = 5; continue s; }
- if (!new token.Pos(pos).IsValid()) { _v$1 = true; $s = 6; continue s; }
- _r = obj.scopePos(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v$1 = _r <= pos; case 6:
- _v = _v$1; case 5:
- /* */ if (_v) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_v) { */ case 3:
- return [s, obj];
- /* } */ case 4:
- s = s.parent;
- /* } */ $s = 1; continue; case 2:
- return [ptrType.nil, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scope.ptr.prototype.LookupParent }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f._v = _v; $f._v$1 = _v$1; $f.name = name; $f.obj = obj; $f.pos = pos; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scope.prototype.LookupParent = function(name, pos) { return this.$val.LookupParent(name, pos); };
- Scope.ptr.prototype.Insert = function(obj) {
- var $ptr, _entry, _key$2, _r, _r$1, alt, name, obj, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key$2 = $f._key$2; _r = $f._r; _r$1 = $f._r$1; alt = $f.alt; name = $f.name; obj = $f.obj; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = obj.Name(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- name = _r;
- alt = (_entry = s.elems[$String.keyFor(name)], _entry !== undefined ? _entry.v : $ifaceNil);
- if (!($interfaceIsEqual(alt, $ifaceNil))) {
- return alt;
- }
- if (s.elems === false) {
- s.elems = new $Map();
- }
- _key$2 = name; (s.elems || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$2)] = { k: _key$2, v: obj };
- _r$1 = obj.Parent(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1 === ptrType.nil) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_r$1 === ptrType.nil) { */ case 2:
- $r = obj.setParent(s); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scope.ptr.prototype.Insert }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key$2 = _key$2; $f._r = _r; $f._r$1 = _r$1; $f.alt = alt; $f.name = name; $f.obj = obj; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scope.prototype.Insert = function(obj) { return this.$val.Insert(obj); };
- Scope.ptr.prototype.Pos = function() {
- var $ptr, s;
- s = this;
- return s.pos;
- };
- Scope.prototype.Pos = function() { return this.$val.Pos(); };
- Scope.ptr.prototype.End = function() {
- var $ptr, s;
- s = this;
- return s.end;
- };
- Scope.prototype.End = function() { return this.$val.End(); };
- Scope.ptr.prototype.Contains = function(pos) {
- var $ptr, pos, s;
- s = this;
- return s.pos <= pos && pos < s.end;
- };
- Scope.prototype.Contains = function(pos) { return this.$val.Contains(pos); };
- Scope.ptr.prototype.Innermost = function(pos) {
- var $ptr, _i, _i$1, _ref, _ref$1, inner, pos, s, s$1, s$2;
- s = this;
- if (s.parent === $pkg.Universe) {
- _ref = s.children;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- s$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- inner = s$1.Innermost(pos);
- if (!(inner === ptrType.nil)) {
- return inner;
- }
- _i++;
- }
- }
- if (s.Contains(pos)) {
- _ref$1 = s.children;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- s$2 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- if (s$2.Contains(pos)) {
- return s$2.Innermost(pos);
- }
- _i$1++;
- }
- return s;
- }
- return ptrType.nil;
- };
- Scope.prototype.Innermost = function(pos) { return this.$val.Innermost(pos); };
- Scope.ptr.prototype.WriteTo = function(w, n, recurse) {
- var $ptr, _entry, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, indn, indn1, n, name, recurse, s, s$1, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; indn = $f.indn; indn1 = $f.indn1; n = $f.n; name = $f.name; recurse = $f.recurse; s = $f.s; s$1 = $f.s$1; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- indn = strings.Repeat(". ", n);
- _r = fmt.Fprintf(w, "%s%s scope %p {", new sliceType([new $String(indn), new $String(s.comment), s])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- /* */ if ($keys(s.elems).length === 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($keys(s.elems).length === 0) { */ case 2:
- _r$1 = fmt.Fprintf(w, "}\n", new sliceType([])); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- return;
- /* } */ case 3:
- _r$2 = fmt.Fprintln(w, new sliceType([])); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- indn1 = indn + ". ";
- _r$3 = s.Names(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _ref = _r$3;
- _i = 0;
- /* while (true) { */ case 7:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 8; continue; }
- name = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$4 = fmt.Fprintf(w, "%s%s\n", new sliceType([new $String(indn1), (_entry = s.elems[$String.keyFor(name)], _entry !== undefined ? _entry.v : $ifaceNil)])); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- _i++;
- /* } */ $s = 7; continue; case 8:
- /* */ if (recurse) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (recurse) { */ case 10:
- _ref$1 = s.children;
- _i$1 = 0;
- /* while (true) { */ case 12:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 13; continue; }
- s$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _r$5 = fmt.Fprintln(w, new sliceType([])); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$5;
- $r = s$1.WriteTo(w, n + 1 >> 0, recurse); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 12; continue; case 13:
- /* } */ case 11:
- _r$6 = fmt.Fprintf(w, "%s}", new sliceType([new $String(indn)])); /* */ $s = 16; case 16: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scope.ptr.prototype.WriteTo }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f.indn = indn; $f.indn1 = indn1; $f.n = n; $f.name = name; $f.recurse = recurse; $f.s = s; $f.s$1 = s$1; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scope.prototype.WriteTo = function(w, n, recurse) { return this.$val.WriteTo(w, n, recurse); };
- Scope.ptr.prototype.String = function() {
- var $ptr, buf, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; buf = $f.buf; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- s = this;
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- $r = s.WriteTo(buf[0], 0, false); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Scope.ptr.prototype.String }; } $f.$ptr = $ptr; $f.buf = buf; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Scope.prototype.String = function() { return this.$val.String(); };
- Selection.ptr.prototype.Kind = function() {
- var $ptr, s;
- s = this;
- return s.kind;
- };
- Selection.prototype.Kind = function() { return this.$val.Kind(); };
- Selection.ptr.prototype.Recv = function() {
- var $ptr, s;
- s = this;
- return s.recv;
- };
- Selection.prototype.Recv = function() { return this.$val.Recv(); };
- Selection.ptr.prototype.Obj = function() {
- var $ptr, s;
- s = this;
- return s.obj;
- };
- Selection.prototype.Obj = function() { return this.$val.Obj(); };
- Selection.ptr.prototype.Type = function() {
- var $ptr, _r, _ref, arg0, params, recv, s, sig, sig$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _ref = $f._ref; arg0 = $f.arg0; params = $f.params; recv = $f.recv; s = $f.s; sig = $f.sig; sig$1 = $f.sig$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- arg0 = [arg0];
- recv = [recv];
- sig = [sig];
- sig$1 = [sig$1];
- s = this;
- _ref = s.kind;
- if (_ref === 1) {
- sig$1[0] = $clone($assertType($assertType(s.obj, ptrType$6).object.typ, ptrType$17), Signature);
- recv[0] = $clone(sig$1[0].recv, Var);
- recv[0].object.typ = s.recv;
- sig$1[0].recv = recv[0];
- return sig$1[0];
- } else if (_ref === 2) {
- sig[0] = $clone($assertType($assertType(s.obj, ptrType$6).object.typ, ptrType$17), Signature);
- arg0[0] = $clone(sig[0].recv, Var);
- sig[0].recv = ptrType$9.nil;
- arg0[0].object.typ = s.recv;
- params = sliceType$1.nil;
- if (!(sig[0].params === ptrType$8.nil)) {
- params = sig[0].params.vars;
- }
- sig[0].params = NewTuple($appendSlice(new sliceType$1([arg0[0]]), params));
- return sig[0];
- }
- _r = s.obj.Type(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Selection.ptr.prototype.Type }; } $f.$ptr = $ptr; $f._r = _r; $f._ref = _ref; $f.arg0 = arg0; $f.params = params; $f.recv = recv; $f.s = s; $f.sig = sig; $f.sig$1 = sig$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Selection.prototype.Type = function() { return this.$val.Type(); };
- Selection.ptr.prototype.Index = function() {
- var $ptr, s;
- s = this;
- return s.index;
- };
- Selection.prototype.Index = function() { return this.$val.Index(); };
- Selection.ptr.prototype.Indirect = function() {
- var $ptr, s;
- s = this;
- return s.indirect;
- };
- Selection.prototype.Indirect = function() { return this.$val.Indirect(); };
- Selection.ptr.prototype.String = function() {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = SelectionString(s, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Selection.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Selection.prototype.String = function() { return this.$val.String(); };
- SelectionString = function(s, qf) {
- var $ptr, T, _arg, _arg$1, _r, _r$1, _r$2, _ref, buf, k, qf, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; buf = $f.buf; k = $f.k; qf = $f.qf; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- k = "";
- _ref = s.kind;
- if (_ref === 0) {
- k = "field ";
- } else if (_ref === 1) {
- k = "method ";
- } else if (_ref === 2) {
- k = "method expr ";
- } else {
- unreachable();
- }
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- buf[0].WriteString(k);
- buf[0].WriteByte(40);
- $r = WriteType(buf[0], s.Recv(), qf); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _arg = buf[0];
- _r = s.obj.Name(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r);
- _r$1 = fmt.Fprintf(_arg, ") %s", new sliceType([_arg$1])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- _r$2 = s.Type(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- T = _r$2;
- /* */ if (s.kind === 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (s.kind === 0) { */ case 5:
- buf[0].WriteByte(32);
- $r = WriteType(buf[0], T, qf); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 7; continue;
- /* } else { */ case 6:
- $r = WriteSignature(buf[0], $assertType(T, ptrType$17), qf); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SelectionString }; } $f.$ptr = $ptr; $f.T = T; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.buf = buf; $f.k = k; $f.qf = qf; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.SelectionString = SelectionString;
- StdSizes.ptr.prototype.Alignof = function(T) {
- var $ptr, T, _i, _r, _r$1, _r$2, _r$3, _ref, _ref$1, a, a$1, f, max, s, t, t$1, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; a = $f.a; a$1 = $f.a$1; f = $f.f; max = $f.max; s = $f.s; t = $f.t; t$1 = $f.t$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = T.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$27, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref, ptrType$11, true)[1]) { */ case 2:
- t = _ref.$val;
- _r$1 = s.Alignof(t.elem); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$27, true)[1]) { */ case 3:
- t$1 = _ref.$val;
- max = new $Int64(0, 1);
- _ref$1 = t$1.fields;
- _i = 0;
- /* while (true) { */ case 6:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 7; continue; }
- f = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- _r$2 = s.Alignof(f.object.typ); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- a = _r$2;
- /* */ if ((a.$high > max.$high || (a.$high === max.$high && a.$low > max.$low))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if ((a.$high > max.$high || (a.$high === max.$high && a.$low > max.$low))) { */ case 9:
- max = a;
- /* } */ case 10:
- _i++;
- /* } */ $s = 6; continue; case 7:
- return max;
- /* } */ case 4:
- _r$3 = s.Sizeof(T); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- a$1 = _r$3;
- if ((a$1.$high < 0 || (a$1.$high === 0 && a$1.$low < 1))) {
- return new $Int64(0, 1);
- }
- if ((x = s.MaxAlign, (a$1.$high > x.$high || (a$1.$high === x.$high && a$1.$low > x.$low)))) {
- return s.MaxAlign;
- }
- return a$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StdSizes.ptr.prototype.Alignof }; } $f.$ptr = $ptr; $f.T = T; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.a = a; $f.a$1 = a$1; $f.f = f; $f.max = max; $f.s = s; $f.t = t; $f.t$1 = t$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- StdSizes.prototype.Alignof = function(T) { return this.$val.Alignof(T); };
- StdSizes.ptr.prototype.Offsetsof = function(fields) {
- var $ptr, _i, _r, _r$1, _ref, a, f, fields, i, o, offsets, s, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; a = $f.a; f = $f.f; fields = $f.fields; i = $f.i; o = $f.o; offsets = $f.offsets; s = $f.s; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- offsets = $makeSlice(sliceType$4, fields.$length);
- o = new $Int64(0, 0);
- _ref = fields;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = s.Alignof(f.object.typ); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- a = _r;
- o = align(o, a);
- ((i < 0 || i >= offsets.$length) ? $throwRuntimeError("index out of range") : offsets.$array[offsets.$offset + i] = o);
- _r$1 = s.Sizeof(f.object.typ); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- o = (x = _r$1, new $Int64(o.$high + x.$high, o.$low + x.$low));
- _i++;
- /* } */ $s = 1; continue; case 2:
- return offsets;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StdSizes.ptr.prototype.Offsetsof }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.a = a; $f.f = f; $f.fields = fields; $f.i = i; $f.o = o; $f.offsets = offsets; $f.s = s; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- StdSizes.prototype.Offsetsof = function(fields) { return this.$val.Offsetsof(fields); };
- StdSizes.ptr.prototype.Sizeof = function(T) {
- var $ptr, T, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, a, k, n, n$1, offsets, s, s$1, t, t$1, t$2, t$3, t$4, x, x$1, x$2, x$3, x$4, x$5, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; a = $f.a; k = $f.k; n = $f.n; n$1 = $f.n$1; offsets = $f.offsets; s = $f.s; s$1 = $f.s$1; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = this;
- _r = T.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$27, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$53, true)[1]) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- t = _ref.$val;
- _r$1 = isTyped(T); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = assert(_r$1); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- k = t.kind;
- if ((k >> 0) < 17) {
- s$1 = ((k < 0 || k >= basicSizes.length) ? $throwRuntimeError("index out of range") : basicSizes[k]);
- if (s$1 > 0) {
- return new $Int64(0, s$1);
- }
- }
- if (k === 17) {
- return $mul64(s.WordSize, new $Int64(0, 2));
- }
- $s = 7; continue;
- /* } else if ($assertType(_ref, ptrType$11, true)[1]) { */ case 3:
- t$1 = _ref.$val;
- n = t$1.len;
- if ((n.$high === 0 && n.$low === 0)) {
- return new $Int64(0, 0);
- }
- _r$2 = s.Alignof(t$1.elem); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- a = _r$2;
- _r$3 = s.Sizeof(t$1.elem); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- z = _r$3;
- return (x = $mul64(align(z, a), (new $Int64(n.$high - 0, n.$low - 1))), new $Int64(x.$high + z.$high, x.$low + z.$low));
- $s = 7; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1]) { */ case 4:
- t$2 = _ref.$val;
- return $mul64(s.WordSize, new $Int64(0, 3));
- $s = 7; continue;
- /* } else if ($assertType(_ref, ptrType$27, true)[1]) { */ case 5:
- t$3 = _ref.$val;
- n$1 = t$3.NumFields();
- if (n$1 === 0) {
- return new $Int64(0, 0);
- }
- offsets = t$3.offsets;
- /* */ if (t$3.offsets === sliceType$4.nil) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (t$3.offsets === sliceType$4.nil) { */ case 12:
- _r$4 = s.Offsetsof(t$3.fields); /* */ $s = 14; case 14: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- offsets = _r$4;
- t$3.offsets = offsets;
- /* } */ case 13:
- _r$5 = s.Sizeof((x$4 = t$3.fields, x$5 = n$1 - 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + x$5])).object.typ); /* */ $s = 15; case 15: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return (x$1 = (x$2 = n$1 - 1 >> 0, ((x$2 < 0 || x$2 >= offsets.$length) ? $throwRuntimeError("index out of range") : offsets.$array[offsets.$offset + x$2])), x$3 = _r$5, new $Int64(x$1.$high + x$3.$high, x$1.$low + x$3.$low));
- $s = 7; continue;
- /* } else if ($assertType(_ref, ptrType$53, true)[1]) { */ case 6:
- t$4 = _ref.$val;
- return $mul64(s.WordSize, new $Int64(0, 2));
- /* } */ case 7:
- return s.WordSize;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: StdSizes.ptr.prototype.Sizeof }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.a = a; $f.k = k; $f.n = n; $f.n$1 = n$1; $f.offsets = offsets; $f.s = s; $f.s$1 = s$1; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- StdSizes.prototype.Sizeof = function(T) { return this.$val.Sizeof(T); };
- Config.ptr.prototype.alignof = function(T) {
- var $ptr, T, _r, _r$1, a, conf, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; a = $f.a; conf = $f.conf; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- conf = this;
- s = conf.Sizes;
- /* */ if (!($interfaceIsEqual(s, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(s, $ifaceNil))) { */ case 1:
- _r = s.Alignof(T); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- a = _r;
- /* */ if ((a.$high > 0 || (a.$high === 0 && a.$low >= 1))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ((a.$high > 0 || (a.$high === 0 && a.$low >= 1))) { */ case 4:
- return a;
- /* } */ case 5:
- $panic(new $String("Config.Sizes.Alignof returned an alignment < 1"));
- /* } */ case 2:
- _r$1 = stdSizes.Alignof(T); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Config.ptr.prototype.alignof }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.conf = conf; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Config.prototype.alignof = function(T) { return this.$val.alignof(T); };
- Config.ptr.prototype.offsetsof = function(T) {
- var $ptr, T, _i, _r, _r$1, _ref, conf, o, offsets, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; conf = $f.conf; o = $f.o; offsets = $f.offsets; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- conf = this;
- offsets = T.offsets;
- /* */ if (offsets === sliceType$4.nil && T.NumFields() > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (offsets === sliceType$4.nil && T.NumFields() > 0) { */ case 1:
- s = conf.Sizes;
- /* */ if (!($interfaceIsEqual(s, $ifaceNil))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!($interfaceIsEqual(s, $ifaceNil))) { */ case 3:
- _r = s.Offsetsof(T.fields); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- offsets = _r;
- if (!((offsets.$length === T.NumFields()))) {
- $panic(new $String("Config.Sizes.Offsetsof returned the wrong number of offsets"));
- }
- _ref = offsets;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- o = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if ((o.$high < 0 || (o.$high === 0 && o.$low < 0))) {
- $panic(new $String("Config.Sizes.Offsetsof returned an offset < 0"));
- }
- _i++;
- }
- $s = 5; continue;
- /* } else { */ case 4:
- _r$1 = stdSizes.Offsetsof(T.fields); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- offsets = _r$1;
- /* } */ case 5:
- T.offsets = offsets;
- /* } */ case 2:
- return offsets;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Config.ptr.prototype.offsetsof }; } $f.$ptr = $ptr; $f.T = T; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.conf = conf; $f.o = o; $f.offsets = offsets; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Config.prototype.offsetsof = function(T) { return this.$val.offsetsof(T); };
- Config.ptr.prototype.offsetof = function(typ, index) {
- var $ptr, _i, _r, _r$1, _ref, conf, i, index, o, s, typ, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; conf = $f.conf; i = $f.i; index = $f.index; o = $f.o; s = $f.s; typ = $f.typ; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- conf = this;
- o = new $Int64(0, 0);
- _ref = index;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = typ.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- s = $assertType(_r, ptrType$27);
- _r$1 = conf.offsetsof(s); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- o = (x = (x$1 = _r$1, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])), new $Int64(o.$high + x.$high, o.$low + x.$low));
- typ = (x$2 = s.fields, ((i < 0 || i >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i])).object.typ;
- _i++;
- /* } */ $s = 1; continue; case 2:
- return o;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Config.ptr.prototype.offsetof }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.conf = conf; $f.i = i; $f.index = index; $f.o = o; $f.s = s; $f.typ = typ; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Config.prototype.offsetof = function(typ, index) { return this.$val.offsetof(typ, index); };
- Config.ptr.prototype.sizeof = function(T) {
- var $ptr, T, _r, _r$1, conf, s, z, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; conf = $f.conf; s = $f.s; z = $f.z; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- conf = this;
- s = conf.Sizes;
- /* */ if (!($interfaceIsEqual(s, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(s, $ifaceNil))) { */ case 1:
- _r = s.Sizeof(T); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- z = _r;
- /* */ if ((z.$high > 0 || (z.$high === 0 && z.$low >= 0))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ((z.$high > 0 || (z.$high === 0 && z.$low >= 0))) { */ case 4:
- return z;
- /* } */ case 5:
- $panic(new $String("Config.Sizes.Sizeof returned a size < 0"));
- /* } */ case 2:
- _r$1 = stdSizes.Sizeof(T); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Config.ptr.prototype.sizeof }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f.conf = conf; $f.s = s; $f.z = z; $f.$s = $s; $f.$r = $r; return $f;
- };
- Config.prototype.sizeof = function(T) { return this.$val.sizeof(T); };
- align = function(x, a) {
- var $ptr, a, x, x$1, x$2, y;
- y = (x$1 = new $Int64(x.$high + a.$high, x.$low + a.$low), new $Int64(x$1.$high - 0, x$1.$low - 1));
- return (x$2 = $div64(y, a, true), new $Int64(y.$high - x$2.$high, y.$low - x$2.$low));
- };
- Checker.ptr.prototype.funcBody = function(decl, name, sig, body) {
- var $ptr, _r, _v, body, check, decl, name, sig, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _v = $f._v; body = $f.body; check = $f.check; decl = $f.decl; name = $f.name; sig = $f.sig; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- check = [check];
- check[0] = this;
- sig.scope.pos = body.Pos();
- sig.scope.end = body.End();
- $deferred.push([(function(check) { return function(ctxt, indent) {
- var $ptr, ctxt, indent;
- $copy(check[0].context, ctxt, context);
- check[0].indent = indent;
- }; })(check), [$clone(check[0].context, context), check[0].indent]]);
- $copy(check[0].context, new context.ptr(decl, sig.scope, $ifaceNil, sig, false, false), context);
- check[0].indent = 0;
- $r = check[0].stmtList(0, body.List); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (check[0].context.hasLabel) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (check[0].context.hasLabel) { */ case 2:
- $r = check[0].labels(body); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- if (!(sig.results.Len() > 0)) { _v = false; $s = 7; continue s; }
- _r = check[0].isTerminating(body, ""); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = !_r; case 7:
- /* */ if (_v) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_v) { */ case 5:
- $r = check[0].error(body.Rbrace, "missing return"); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- $r = check[0].usage(sig.scope); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.funcBody }; } $f.$ptr = $ptr; $f._r = _r; $f._v = _v; $f.body = body; $f.check = check; $f.decl = decl; $f.name = name; $f.sig = sig; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.funcBody = function(decl, name, sig, body) { return this.$val.funcBody(decl, name, sig, body); };
- Checker.ptr.prototype.usage = function(scope) {
- var $ptr, _entry, _i, _i$1, _keys, _ref, _ref$1, _tuple, check, obj, scope, scope$1, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _keys = $f._keys; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; check = $f.check; obj = $f.obj; scope = $f.scope; scope$1 = $f.scope$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _ref = scope.elems;
- _i = 0;
- _keys = $keys(_ref);
- /* while (true) { */ case 1:
- /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 2; continue; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- /* continue; */ $s = 1; continue;
- }
- obj = _entry.v;
- _tuple = $assertType(obj, ptrType$9, true); v = _tuple[0];
- /* */ if (!(v === ptrType$9.nil) && !v.used) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(v === ptrType$9.nil) && !v.used) { */ case 3:
- $r = check.softErrorf(v.object.pos, "%s declared but not used", new sliceType([new $String(v.object.name)])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- _ref$1 = scope.children;
- _i$1 = 0;
- /* while (true) { */ case 6:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 7; continue; }
- scope$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- $r = check.usage(scope$1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 6; continue; case 7:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.usage }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._keys = _keys; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f.check = check; $f.obj = obj; $f.scope = scope; $f.scope$1 = scope$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.usage = function(scope) { return this.$val.usage(scope); };
- Checker.ptr.prototype.simpleStmt = function(s) {
- var $ptr, check, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; check = $f.check; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- /* */ if (!($interfaceIsEqual(s, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(s, $ifaceNil))) { */ case 1:
- $r = check.stmt(0, s); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.simpleStmt }; } $f.$ptr = $ptr; $f.check = check; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.simpleStmt = function(s) { return this.$val.simpleStmt(s); };
- Checker.ptr.prototype.stmtList = function(ctxt, list) {
- var $ptr, _i, _ref, check, ctxt, i, inner, inner$1, list, ok, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; check = $f.check; ctxt = $f.ctxt; i = $f.i; inner = $f.inner; inner$1 = $f.inner$1; list = $f.list; ok = $f.ok; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- ok = !((((ctxt & 4) >>> 0) === 0));
- inner = (ctxt & ~4) >>> 0;
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- inner$1 = inner;
- if (ok && ((i + 1 >> 0) === list.$length)) {
- inner$1 = (inner$1 | (4)) >>> 0;
- }
- $r = check.stmt(inner$1, s); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.stmtList }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.check = check; $f.ctxt = ctxt; $f.i = i; $f.inner = inner; $f.inner$1 = inner$1; $f.list = list; $f.ok = ok; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.stmtList = function(ctxt, list) { return this.$val.stmtList(ctxt, list); };
- Checker.ptr.prototype.multipleDefaults = function(list) {
- var $ptr, _arg, _arg$1, _i, _r, _r$1, _r$2, _ref, _ref$1, c, c$1, c$2, check, d, first, list, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; c = $f.c; c$1 = $f.c$1; c$2 = $f.c$2; check = $f.check; d = $f.d; first = $f.first; list = $f.list; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- first = $ifaceNil;
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- d = $ifaceNil;
- _ref$1 = s;
- /* */ if ($assertType(_ref$1, ptrType$64, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref$1, ptrType$67, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref$1, ptrType$64, true)[1]) { */ case 3:
- c = _ref$1.$val;
- if (c.List.$length === 0) {
- d = s;
- }
- $s = 6; continue;
- /* } else if ($assertType(_ref$1, ptrType$67, true)[1]) { */ case 4:
- c$1 = _ref$1.$val;
- if ($interfaceIsEqual(c$1.Comm, $ifaceNil)) {
- d = s;
- }
- $s = 6; continue;
- /* } else { */ case 5:
- c$2 = _ref$1;
- _r = s.Pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r, "case/communication clause expected", new sliceType([])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- /* */ if (!($interfaceIsEqual(d, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(d, $ifaceNil))) { */ case 9:
- /* */ if (!($interfaceIsEqual(first, $ifaceNil))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!($interfaceIsEqual(first, $ifaceNil))) { */ case 11:
- _r$1 = d.Pos(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg = _r$1;
- _r$2 = first.Pos(); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = new token.Pos(_r$2);
- $r = check.errorf(_arg, "multiple defaults (first at %s)", new sliceType([_arg$1])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 13; continue;
- /* } else { */ case 12:
- first = d;
- /* } */ case 13:
- /* } */ case 10:
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.multipleDefaults }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f.c = c; $f.c$1 = c$1; $f.c$2 = c$2; $f.check = check; $f.d = d; $f.first = first; $f.list = list; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.multipleDefaults = function(list) { return this.$val.multipleDefaults(list); };
- Checker.ptr.prototype.openScope = function(s, comment) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r, _r$1, _r$2, check, comment, s, scope, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; check = $f.check; comment = $f.comment; s = $f.s; scope = $f.scope; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _arg = check.context.scope;
- _r = s.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = _r;
- _r$1 = s.End(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$2 = _r$1;
- _arg$3 = comment;
- _r$2 = NewScope(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- scope = _r$2;
- check.recordScope(s, scope);
- check.context.scope = scope;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.openScope }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.check = check; $f.comment = comment; $f.s = s; $f.scope = scope; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.openScope = function(s, comment) { return this.$val.openScope(s, comment); };
- Checker.ptr.prototype.closeScope = function() {
- var $ptr, check;
- check = this;
- check.context.scope = check.context.scope.Parent();
- };
- Checker.prototype.closeScope = function() { return this.$val.closeScope(); };
- assignOp = function(op) {
- var $ptr, op;
- if (23 <= op && op <= 33) {
- return op + -11 >> 0;
- }
- return 0;
- };
- Checker.ptr.prototype.suspendedCall = function(keyword, call) {
- var $ptr, _r, _r$1, _ref, call, check, keyword, msg, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; call = $f.call; check = $f.check; keyword = $f.keyword; msg = $f.msg; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- check = this;
- x[0] = $clone(new operand.ptr(), operand);
- msg = "";
- _r = check.rawExpr(x[0], call, $ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if (_ref === 0) { $s = 2; continue; }
- /* */ if (_ref === 1) { $s = 3; continue; }
- /* */ if (_ref === 2) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref === 0) { */ case 2:
- msg = "requires function call, not conversion";
- $s = 6; continue;
- /* } else if (_ref === 1) { */ case 3:
- msg = "discards result of";
- $s = 6; continue;
- /* } else if (_ref === 2) { */ case 4:
- return;
- $s = 6; continue;
- /* } else { */ case 5:
- unreachable();
- /* } */ case 6:
- _r$1 = x[0].pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "%s %s %s", new sliceType([new $String(keyword), new $String(msg), x[0]])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.suspendedCall }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.call = call; $f.check = check; $f.keyword = keyword; $f.msg = msg; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.suspendedCall = function(keyword, call) { return this.$val.suspendedCall(keyword, call); };
- Checker.ptr.prototype.caseValues = function(x, values) {
- var $ptr, _i, _ref, check, e, values, x, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; check = $f.check; e = $f.e; values = $f.values; x = $f.x; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- check = this;
- x[0] = $clone(x[0], operand);
- _ref = values;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- y = [y];
- e = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- y[0] = $clone(new operand.ptr(), operand);
- $r = check.expr(y[0], e); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (y[0].mode === 0) {
- return;
- }
- $r = check.convertUntyped(y[0], x[0].typ); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (y[0].mode === 0) {
- return;
- }
- $r = check.convertUntyped(x[0], y[0].typ); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x[0].mode === 0) {
- return;
- }
- $r = check.comparison(y[0], x[0], 39); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.caseValues }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.check = check; $f.e = e; $f.values = values; $f.x = x; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.caseValues = function(x, values) { return this.$val.caseValues(x, values); };
- Checker.ptr.prototype.caseTypes = function(x, xtyp, types, seen) {
- var $ptr, T, _entry, _i, _i$1, _key$2, _keys, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _v, _v$1, check, e, pos, seen, t, types, x, xtyp, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _key$2 = $f._key$2; _keys = $f._keys; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _v = $f._v; _v$1 = $f._v$1; check = $f.check; e = $f.e; pos = $f.pos; seen = $f.seen; t = $f.t; types = $f.types; x = $f.x; xtyp = $f.xtyp; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- T = $ifaceNil;
- check = this;
- _ref = types;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- e = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = check.typOrNil(e); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- T = _r;
- /* */ if ($interfaceIsEqual(T, $pkg.Typ[0])) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($interfaceIsEqual(T, $pkg.Typ[0])) { */ case 4:
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 5:
- _ref$1 = seen;
- _i$1 = 0;
- _keys = $keys(_ref$1);
- /* while (true) { */ case 6:
- /* if (!(_i$1 < _keys.length)) { break; } */ if(!(_i$1 < _keys.length)) { $s = 7; continue; }
- _entry = _ref$1[_keys[_i$1]];
- if (_entry === undefined) {
- _i$1++;
- /* continue; */ $s = 6; continue;
- }
- t = _entry.k;
- pos = _entry.v;
- if ($interfaceIsEqual(T, $ifaceNil) && $interfaceIsEqual(t, $ifaceNil)) { _v = true; $s = 10; continue s; }
- if (!(!($interfaceIsEqual(T, $ifaceNil)) && !($interfaceIsEqual(t, $ifaceNil)))) { _v$1 = false; $s = 11; continue s; }
- _r$1 = Identical(T, t); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v$1 = _r$1; case 11:
- _v = _v$1; case 10:
- /* */ if (_v) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_v) { */ case 8:
- _r$2 = e.Pos(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.error(_r$2, "duplicate case in type switch"); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.errorf(pos, "\tprevious case %s", new sliceType([T])); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue L; */ $s = 1; continue s;
- /* } */ case 9:
- _i$1++;
- /* } */ $s = 6; continue; case 7:
- _r$3 = e.Pos(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _key$2 = T; (seen || $throwRuntimeError("assignment to entry in nil map"))[Type.keyFor(_key$2)] = { k: _key$2, v: _r$3 };
- /* */ if (!($interfaceIsEqual(T, $ifaceNil))) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (!($interfaceIsEqual(T, $ifaceNil))) { */ case 17:
- _r$4 = e.Pos(); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.typeAssertion(_r$4, x, xtyp, T); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- _i++;
- /* } */ $s = 1; continue; case 2:
- return T;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.caseTypes }; } $f.$ptr = $ptr; $f.T = T; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._key$2 = _key$2; $f._keys = _keys; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._v = _v; $f._v$1 = _v$1; $f.check = check; $f.e = e; $f.pos = pos; $f.seen = seen; $f.t = t; $f.types = types; $f.x = x; $f.xtyp = xtyp; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.caseTypes = function(x, xtyp, types, seen) { return this.$val.caseTypes(x, xtyp, types, seen); };
- Checker.ptr.prototype.stmt = function(ctxt, s) {
- var $ptr, T, Y, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _i$7, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$10, _ref$11, _ref$12, _ref$13, _ref$14, _ref$15, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, _tuple$10, _tuple$11, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, _v, _v$1, _v$2, alt, c, ch, check, clause, clause$1, clause$2, ctxt, expr, guard, guard$1, guard$2, i, i$1, i$2, ident, inner, inner$1, key, kind, lhs, lhs$1, lhs$2, lhs$3, lhsVars, msg, name, obj, obj$1, obj$2, obj$3, ok, op, op$1, res, rhs, rhs$1, rhs$2, s, s$1, s$10, s$11, s$12, s$13, s$14, s$15, s$16, s$17, s$18, s$19, s$2, s$20, s$21, s$22, s$23, s$24, s$25, s$3, s$4, s$5, s$6, s$7, s$8, s$9, scopePos, scopePos$1, seen, tch, typ, typ$1, typ$2, typ$3, typ$4, typ$5, typ$6, typ$7, typ$8, used, v, val, valid, vars, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, xtyp, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; Y = $f.Y; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _i$7 = $f._i$7; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$10 = $f._ref$10; _ref$11 = $f._ref$11; _ref$12 = $f._ref$12; _ref$13 = $f._ref$13; _ref$14 = $f._ref$14; _ref$15 = $f._ref$15; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$11 = $f._tuple$11; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; alt = $f.alt; c = $f.c; ch = $f.ch; check = $f.check; clause = $f.clause; clause$1 = $f.clause$1; clause$2 = $f.clause$2; ctxt = $f.ctxt; expr = $f.expr; guard = $f.guard; guard$1 = $f.guard$1; guard$2 = $f.guard$2; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; ident = $f.ident; inner = $f.inner; inner$1 = $f.inner$1; key = $f.key; kind = $f.kind; lhs = $f.lhs; lhs$1 = $f.lhs$1; lhs$2 = $f.lhs$2; lhs$3 = $f.lhs$3; lhsVars = $f.lhsVars; msg = $f.msg; name = $f.name; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; ok = $f.ok; op = $f.op; op$1 = $f.op$1; res = $f.res; rhs = $f.rhs; rhs$1 = $f.rhs$1; rhs$2 = $f.rhs$2; s = $f.s; s$1 = $f.s$1; s$10 = $f.s$10; s$11 = $f.s$11; s$12 = $f.s$12; s$13 = $f.s$13; s$14 = $f.s$14; s$15 = $f.s$15; s$16 = $f.s$16; s$17 = $f.s$17; s$18 = $f.s$18; s$19 = $f.s$19; s$2 = $f.s$2; s$20 = $f.s$20; s$21 = $f.s$21; s$22 = $f.s$22; s$23 = $f.s$23; s$24 = $f.s$24; s$25 = $f.s$25; s$3 = $f.s$3; s$4 = $f.s$4; s$5 = $f.s$5; s$6 = $f.s$6; s$7 = $f.s$7; s$8 = $f.s$8; s$9 = $f.s$9; scopePos = $f.scopePos; scopePos$1 = $f.scopePos$1; seen = $f.seen; tch = $f.tch; typ = $f.typ; typ$1 = $f.typ$1; typ$2 = $f.typ$2; typ$3 = $f.typ$3; typ$4 = $f.typ$4; typ$5 = $f.typ$5; typ$6 = $f.typ$6; typ$7 = $f.typ$7; typ$8 = $f.typ$8; used = $f.used; v = $f.v; val = $f.val; valid = $f.valid; vars = $f.vars; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$17 = $f.x$17; x$18 = $f.x$18; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; xtyp = $f.xtyp; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- ch = [ch];
- check = [check];
- x = [x];
- x$1 = [x$1];
- x$2 = [x$2];
- x$3 = [x$3];
- x$4 = [x$4];
- x$5 = [x$5];
- x$6 = [x$6];
- x$7 = [x$7];
- x$8 = [x$8];
- check[0] = this;
- assert($interfaceIsEqual(check[0].context.iota, $ifaceNil));
- inner = (ctxt & ~4) >>> 0;
- _ref = s;
- /* */ if ($assertType(_ref, ptrType$79, true)[1] || $assertType(_ref, ptrType$80, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$61, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$58, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$85, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$81, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$82, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$62, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$83, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$84, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$86, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$60, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$29, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$63, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, ptrType$65, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$66, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$68, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, ptrType$69, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref, ptrType$70, true)[1]) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if ($assertType(_ref, ptrType$79, true)[1] || $assertType(_ref, ptrType$80, true)[1]) { */ case 1:
- s$1 = _ref;
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$61, true)[1]) { */ case 2:
- s$2 = _ref.$val;
- $r = check[0].declStmt(s$2.Decl); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$58, true)[1]) { */ case 3:
- s$3 = _ref.$val;
- check[0].context.hasLabel = true;
- $r = check[0].stmt(ctxt, s$3.Stmt); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$85, true)[1]) { */ case 4:
- s$4 = _ref.$val;
- x$5[0] = $clone(new operand.ptr(), operand);
- _r = check[0].rawExpr(x$5[0], s$4.X, $ifaceNil); /* */ $s = 23; case 23: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- kind = _r;
- msg = "";
- _ref$1 = x$5[0].mode;
- if (_ref$1 === 2) {
- msg = "must be called";
- } else if (_ref$1 === 3) {
- msg = "is not an expression";
- } else {
- if (kind === 2) {
- return;
- }
- msg = "is not used";
- }
- _r$1 = x$5[0].pos(); /* */ $s = 24; case 24: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$1, "%s %s", new sliceType([x$5[0], new $String(msg)])); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$81, true)[1]) { */ case 5:
- s$5 = _ref.$val;
- _tmp = $clone(new operand.ptr(), operand); _tmp$1 = $clone(new operand.ptr(), operand); ch[0] = $clone(_tmp, operand); x[0] = $clone(_tmp$1, operand);
- $r = check[0].expr(ch[0], s$5.Chan); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].expr(x[0], s$5.Value); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if ((ch[0].mode === 0) || (x[0].mode === 0)) {
- return;
- }
- _r$2 = ch[0].typ.Underlying(); /* */ $s = 28; case 28: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$2, ptrType$12, true); tch = _tuple[0]; ok = _tuple[1];
- if (!ok || (tch.dir === 2)) { _v = true; $s = 31; continue s; }
- _r$3 = check[0].assignment(x[0], tch.elem); /* */ $s = 32; case 32: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v = !_r$3; case 31:
- /* */ if (_v) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (_v) { */ case 29:
- /* */ if (!((x[0].mode === 0))) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* if (!((x[0].mode === 0))) { */ case 33:
- _r$4 = ch[0].pos(); /* */ $s = 35; case 35: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check[0].invalidOp(_r$4, "cannot send %s to channel %s", new sliceType([x[0], ch[0]])); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 34:
- /* } */ case 30:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$82, true)[1]) { */ case 6:
- s$6 = _ref.$val;
- op = 0;
- _ref$2 = s$6.Tok;
- /* */ if (_ref$2 === 37) { $s = 37; continue; }
- /* */ if (_ref$2 === 38) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (_ref$2 === 37) { */ case 37:
- op = 12;
- $s = 40; continue;
- /* } else if (_ref$2 === 38) { */ case 38:
- op = 13;
- $s = 40; continue;
- /* } else { */ case 39:
- $r = check[0].invalidAST(s$6.TokPos, "unknown inc/dec operation %s", new sliceType([new token.Token(s$6.Tok)])); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 40:
- x$6[0] = $clone(new operand.ptr(), operand);
- _r$5 = s$6.X.Pos(); /* */ $s = 42; case 42: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- Y = new ast.BasicLit.ptr(_r$5, 5, "1");
- $r = check[0].binary(x$6[0], ptrType$52.nil, s$6.X, Y, op); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x$6[0].mode === 0) {
- return;
- }
- _r$6 = check[0].assignVar(s$6.X, x$6[0]); /* */ $s = 44; case 44: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$62, true)[1]) { */ case 7:
- s$7 = _ref.$val;
- _ref$3 = s$7.Tok;
- /* */ if (_ref$3 === 42 || _ref$3 === 47) { $s = 45; continue; }
- /* */ $s = 46; continue;
- /* if (_ref$3 === 42 || _ref$3 === 47) { */ case 45:
- /* */ if (s$7.Lhs.$length === 0) { $s = 48; continue; }
- /* */ $s = 49; continue;
- /* if (s$7.Lhs.$length === 0) { */ case 48:
- _r$7 = s$7.Pos(); /* */ $s = 50; case 50: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $r = check[0].invalidAST(_r$7, "missing lhs in assignment", new sliceType([])); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 49:
- /* */ if (s$7.Tok === 47) { $s = 52; continue; }
- /* */ $s = 53; continue;
- /* if (s$7.Tok === 47) { */ case 52:
- $r = check[0].shortVarDecl(s$7.TokPos, s$7.Lhs, s$7.Rhs); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 54; continue;
- /* } else { */ case 53:
- $r = check[0].assignVars(s$7.Lhs, s$7.Rhs); /* */ $s = 56; case 56: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 54:
- $s = 47; continue;
- /* } else { */ case 46:
- /* */ if (!((s$7.Lhs.$length === 1)) || !((s$7.Rhs.$length === 1))) { $s = 57; continue; }
- /* */ $s = 58; continue;
- /* if (!((s$7.Lhs.$length === 1)) || !((s$7.Rhs.$length === 1))) { */ case 57:
- $r = check[0].errorf(s$7.TokPos, "assignment operation %s requires single-valued expressions", new sliceType([new token.Token(s$7.Tok)])); /* */ $s = 59; case 59: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 58:
- op$1 = assignOp(s$7.Tok);
- /* */ if (op$1 === 0) { $s = 60; continue; }
- /* */ $s = 61; continue;
- /* if (op$1 === 0) { */ case 60:
- $r = check[0].invalidAST(s$7.TokPos, "unknown assignment operation %s", new sliceType([new token.Token(s$7.Tok)])); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 61:
- x$1[0] = $clone(new operand.ptr(), operand);
- $r = check[0].binary(x$1[0], ptrType$52.nil, (x$9 = s$7.Lhs, (0 >= x$9.$length ? $throwRuntimeError("index out of range") : x$9.$array[x$9.$offset + 0])), (x$10 = s$7.Rhs, (0 >= x$10.$length ? $throwRuntimeError("index out of range") : x$10.$array[x$10.$offset + 0])), op$1); /* */ $s = 63; case 63: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x$1[0].mode === 0) {
- return;
- }
- _r$8 = check[0].assignVar((x$11 = s$7.Lhs, (0 >= x$11.$length ? $throwRuntimeError("index out of range") : x$11.$array[x$11.$offset + 0])), x$1[0]); /* */ $s = 64; case 64: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$8;
- /* } */ case 47:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$83, true)[1]) { */ case 8:
- s$8 = _ref.$val;
- $r = check[0].suspendedCall("go", s$8.Call); /* */ $s = 65; case 65: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$84, true)[1]) { */ case 9:
- s$9 = _ref.$val;
- $r = check[0].suspendedCall("defer", s$9.Call); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$86, true)[1]) { */ case 10:
- s$10 = _ref.$val;
- res = check[0].context.sig.results;
- /* */ if (res.Len() > 0) { $s = 67; continue; }
- /* */ if (s$10.Results.$length > 0) { $s = 68; continue; }
- /* */ $s = 69; continue;
- /* if (res.Len() > 0) { */ case 67:
- /* */ if ((s$10.Results.$length === 0) && !((x$12 = res.vars, (0 >= x$12.$length ? $throwRuntimeError("index out of range") : x$12.$array[x$12.$offset + 0])).object.name === "")) { $s = 70; continue; }
- /* */ $s = 71; continue;
- /* if ((s$10.Results.$length === 0) && !((x$12 = res.vars, (0 >= x$12.$length ? $throwRuntimeError("index out of range") : x$12.$array[x$12.$offset + 0])).object.name === "")) { */ case 70:
- _ref$4 = res.vars;
- _i = 0;
- /* while (true) { */ case 73:
- /* if (!(_i < _ref$4.$length)) { break; } */ if(!(_i < _ref$4.$length)) { $s = 74; continue; }
- obj = ((_i < 0 || _i >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i]);
- _r$9 = check[0].context.scope.LookupParent(obj.object.name, check[0].pos); /* */ $s = 75; case 75: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _tuple$1 = _r$9; alt = _tuple$1[1];
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil)) && !($interfaceIsEqual(alt, obj))) { $s = 76; continue; }
- /* */ $s = 77; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil)) && !($interfaceIsEqual(alt, obj))) { */ case 76:
- $r = check[0].errorf(s$10.Pos(), "result parameter %s not in scope at return", new sliceType([new $String(obj.object.name)])); /* */ $s = 78; case 78: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$10 = alt.Pos(); /* */ $s = 79; case 79: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$10, "\tinner declaration of %s", new sliceType([obj])); /* */ $s = 80; case 80: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 77:
- _i++;
- /* } */ $s = 73; continue; case 74:
- $s = 72; continue;
- /* } else { */ case 71:
- $r = check[0].initVars(res.vars, s$10.Results, s$10.Return); /* */ $s = 81; case 81: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 72:
- $s = 69; continue;
- /* } else if (s$10.Results.$length > 0) { */ case 68:
- _r$11 = (x$13 = s$10.Results, (0 >= x$13.$length ? $throwRuntimeError("index out of range") : x$13.$array[x$13.$offset + 0])).Pos(); /* */ $s = 82; case 82: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- $r = check[0].error(_r$11, "no result values expected"); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].use(s$10.Results); /* */ $s = 84; case 84: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 69:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$60, true)[1]) { */ case 11:
- s$11 = _ref.$val;
- if (!(s$11.Label === ptrType$5.nil)) {
- check[0].context.hasLabel = true;
- return;
- }
- _ref$5 = s$11.Tok;
- /* */ if (_ref$5 === 61) { $s = 85; continue; }
- /* */ if (_ref$5 === 65) { $s = 86; continue; }
- /* */ if (_ref$5 === 69) { $s = 87; continue; }
- /* */ $s = 88; continue;
- /* if (_ref$5 === 61) { */ case 85:
- /* */ if (((ctxt & 1) >>> 0) === 0) { $s = 90; continue; }
- /* */ $s = 91; continue;
- /* if (((ctxt & 1) >>> 0) === 0) { */ case 90:
- $r = check[0].error(s$11.Pos(), "break not in for, switch, or select statement"); /* */ $s = 92; case 92: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 91:
- $s = 89; continue;
- /* } else if (_ref$5 === 65) { */ case 86:
- /* */ if (((ctxt & 2) >>> 0) === 0) { $s = 93; continue; }
- /* */ $s = 94; continue;
- /* if (((ctxt & 2) >>> 0) === 0) { */ case 93:
- $r = check[0].error(s$11.Pos(), "continue not in for statement"); /* */ $s = 95; case 95: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 94:
- $s = 89; continue;
- /* } else if (_ref$5 === 69) { */ case 87:
- /* */ if (((ctxt & 4) >>> 0) === 0) { $s = 96; continue; }
- /* */ $s = 97; continue;
- /* if (((ctxt & 4) >>> 0) === 0) { */ case 96:
- $r = check[0].error(s$11.Pos(), "fallthrough statement out of place"); /* */ $s = 98; case 98: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 97:
- $s = 89; continue;
- /* } else { */ case 88:
- $r = check[0].invalidAST(s$11.Pos(), "branch statement: %s", new sliceType([new token.Token(s$11.Tok)])); /* */ $s = 99; case 99: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 89:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$29, true)[1]) { */ case 12:
- s$12 = _ref.$val;
- $r = check[0].openScope(s$12, "block"); /* */ $s = 100; case 100: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(check[0], "closeScope"), []]);
- $r = check[0].stmtList(inner, s$12.List); /* */ $s = 101; case 101: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$63, true)[1]) { */ case 13:
- s$13 = _ref.$val;
- $r = check[0].openScope(s$13, "if"); /* */ $s = 102; case 102: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(check[0], "closeScope"), []]);
- $r = check[0].simpleStmt(s$13.Init); /* */ $s = 103; case 103: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x$2[0] = $clone(new operand.ptr(), operand);
- $r = check[0].expr(x$2[0], s$13.Cond); /* */ $s = 104; case 104: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!(!((x$2[0].mode === 0)))) { _v$1 = false; $s = 107; continue s; }
- _r$12 = isBoolean(x$2[0].typ); /* */ $s = 108; case 108: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _v$1 = !_r$12; case 107:
- /* */ if (_v$1) { $s = 105; continue; }
- /* */ $s = 106; continue;
- /* if (_v$1) { */ case 105:
- _r$13 = s$13.Cond.Pos(); /* */ $s = 109; case 109: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- $r = check[0].error(_r$13, "non-boolean condition in if statement"); /* */ $s = 110; case 110: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 106:
- $r = check[0].stmt(inner, s$13.Body); /* */ $s = 111; case 111: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$13.Else, $ifaceNil))) { $s = 112; continue; }
- /* */ $s = 113; continue;
- /* if (!($interfaceIsEqual(s$13.Else, $ifaceNil))) { */ case 112:
- $r = check[0].stmt(inner, s$13.Else); /* */ $s = 114; case 114: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 113:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$65, true)[1]) { */ case 14:
- s$14 = _ref.$val;
- inner = (inner | (1)) >>> 0;
- $r = check[0].openScope(s$14, "switch"); /* */ $s = 115; case 115: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(check[0], "closeScope"), []]);
- $r = check[0].simpleStmt(s$14.Init); /* */ $s = 116; case 116: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- x$7[0] = $clone(new operand.ptr(), operand);
- /* */ if (!($interfaceIsEqual(s$14.Tag, $ifaceNil))) { $s = 117; continue; }
- /* */ $s = 118; continue;
- /* if (!($interfaceIsEqual(s$14.Tag, $ifaceNil))) { */ case 117:
- $r = check[0].expr(x$7[0], s$14.Tag); /* */ $s = 120; case 120: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 119; continue;
- /* } else { */ case 118:
- x$7[0].mode = 4;
- x$7[0].typ = $pkg.Typ[1];
- x$7[0].val = exact.MakeBool(true);
- x$7[0].expr = new ast.Ident.ptr(s$14.Body.Lbrace, "true", ptrType$87.nil);
- /* } */ case 119:
- $r = check[0].multipleDefaults(s$14.Body.List); /* */ $s = 121; case 121: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$6 = s$14.Body.List;
- _i$1 = 0;
- /* while (true) { */ case 122:
- /* if (!(_i$1 < _ref$6.$length)) { break; } */ if(!(_i$1 < _ref$6.$length)) { $s = 123; continue; }
- i = _i$1;
- c = ((_i$1 < 0 || _i$1 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$1]);
- _tuple$2 = $assertType(c, ptrType$64, true); clause = _tuple$2[0];
- /* */ if (clause === ptrType$64.nil) { $s = 124; continue; }
- /* */ $s = 125; continue;
- /* if (clause === ptrType$64.nil) { */ case 124:
- _r$14 = c.Pos(); /* */ $s = 126; case 126: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- $r = check[0].invalidAST(_r$14, "incorrect expression switch case", new sliceType([])); /* */ $s = 127; case 127: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* continue; */ $s = 122; continue;
- /* } */ case 125:
- /* */ if (!((x$7[0].mode === 0))) { $s = 128; continue; }
- /* */ $s = 129; continue;
- /* if (!((x$7[0].mode === 0))) { */ case 128:
- $r = check[0].caseValues(x$7[0], clause.List); /* */ $s = 130; case 130: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 129:
- $r = check[0].openScope(clause, "case"); /* */ $s = 131; case 131: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- inner$1 = inner;
- if ((i + 1 >> 0) < s$14.Body.List.$length) {
- inner$1 = (inner$1 | (4)) >>> 0;
- }
- $r = check[0].stmtList(inner$1, clause.Body); /* */ $s = 132; case 132: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- check[0].closeScope();
- _i$1++;
- /* } */ $s = 122; continue; case 123:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$66, true)[1]) { */ case 15:
- s$15 = _ref.$val;
- inner = (inner | (1)) >>> 0;
- $r = check[0].openScope(s$15, "type switch"); /* */ $s = 133; case 133: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(check[0], "closeScope"), []]);
- $r = check[0].simpleStmt(s$15.Init); /* */ $s = 134; case 134: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- lhs = ptrType$5.nil;
- rhs = $ifaceNil;
- _ref$7 = s$15.Assign;
- /* */ if ($assertType(_ref$7, ptrType$85, true)[1]) { $s = 135; continue; }
- /* */ if ($assertType(_ref$7, ptrType$62, true)[1]) { $s = 136; continue; }
- /* */ $s = 137; continue;
- /* if ($assertType(_ref$7, ptrType$85, true)[1]) { */ case 135:
- guard = _ref$7.$val;
- rhs = guard.X;
- $s = 138; continue;
- /* } else if ($assertType(_ref$7, ptrType$62, true)[1]) { */ case 136:
- guard$1 = _ref$7.$val;
- /* */ if (!((guard$1.Lhs.$length === 1)) || !((guard$1.Tok === 47)) || !((guard$1.Rhs.$length === 1))) { $s = 139; continue; }
- /* */ $s = 140; continue;
- /* if (!((guard$1.Lhs.$length === 1)) || !((guard$1.Tok === 47)) || !((guard$1.Rhs.$length === 1))) { */ case 139:
- $r = check[0].invalidAST(s$15.Pos(), "incorrect form of type switch guard", new sliceType([])); /* */ $s = 141; case 141: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 140:
- _tuple$3 = $assertType((x$14 = guard$1.Lhs, (0 >= x$14.$length ? $throwRuntimeError("index out of range") : x$14.$array[x$14.$offset + 0])), ptrType$5, true); lhs = _tuple$3[0];
- /* */ if (lhs === ptrType$5.nil) { $s = 142; continue; }
- /* */ $s = 143; continue;
- /* if (lhs === ptrType$5.nil) { */ case 142:
- $r = check[0].invalidAST(s$15.Pos(), "incorrect form of type switch guard", new sliceType([])); /* */ $s = 144; case 144: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 143:
- /* */ if (lhs.Name === "_") { $s = 145; continue; }
- /* */ $s = 146; continue;
- /* if (lhs.Name === "_") { */ case 145:
- $r = check[0].softErrorf(lhs.Pos(), "no new variable on left side of :=", new sliceType([])); /* */ $s = 148; case 148: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- lhs = ptrType$5.nil;
- $s = 147; continue;
- /* } else { */ case 146:
- check[0].recordDef(lhs, $ifaceNil);
- /* } */ case 147:
- rhs = (x$15 = guard$1.Rhs, (0 >= x$15.$length ? $throwRuntimeError("index out of range") : x$15.$array[x$15.$offset + 0]));
- $s = 138; continue;
- /* } else { */ case 137:
- guard$2 = _ref$7;
- $r = check[0].invalidAST(s$15.Pos(), "incorrect form of type switch guard", new sliceType([])); /* */ $s = 149; case 149: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 138:
- _tuple$4 = $assertType(rhs, ptrType$41, true); expr = _tuple$4[0];
- /* */ if (expr === ptrType$41.nil || !($interfaceIsEqual(expr.Type, $ifaceNil))) { $s = 150; continue; }
- /* */ $s = 151; continue;
- /* if (expr === ptrType$41.nil || !($interfaceIsEqual(expr.Type, $ifaceNil))) { */ case 150:
- $r = check[0].invalidAST(s$15.Pos(), "incorrect form of type switch guard", new sliceType([])); /* */ $s = 152; case 152: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 151:
- x$8[0] = $clone(new operand.ptr(), operand);
- $r = check[0].expr(x$8[0], expr.X); /* */ $s = 153; case 153: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (x$8[0].mode === 0) {
- return;
- }
- _r$15 = x$8[0].typ.Underlying(); /* */ $s = 154; case 154: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _tuple$5 = $assertType(_r$15, ptrType$53, true); xtyp = _tuple$5[0];
- /* */ if (xtyp === ptrType$53.nil) { $s = 155; continue; }
- /* */ $s = 156; continue;
- /* if (xtyp === ptrType$53.nil) { */ case 155:
- _r$16 = x$8[0].pos(); /* */ $s = 157; case 157: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$16, "%s is not an interface", new sliceType([x$8[0]])); /* */ $s = 158; case 158: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 156:
- $r = check[0].multipleDefaults(s$15.Body.List); /* */ $s = 159; case 159: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- lhsVars = sliceType$1.nil;
- seen = new $Map();
- _ref$8 = s$15.Body.List;
- _i$2 = 0;
- /* while (true) { */ case 160:
- /* if (!(_i$2 < _ref$8.$length)) { break; } */ if(!(_i$2 < _ref$8.$length)) { $s = 161; continue; }
- s$16 = ((_i$2 < 0 || _i$2 >= _ref$8.$length) ? $throwRuntimeError("index out of range") : _ref$8.$array[_ref$8.$offset + _i$2]);
- _tuple$6 = $assertType(s$16, ptrType$64, true); clause$1 = _tuple$6[0];
- /* */ if (clause$1 === ptrType$64.nil) { $s = 162; continue; }
- /* */ $s = 163; continue;
- /* if (clause$1 === ptrType$64.nil) { */ case 162:
- _r$17 = s$16.Pos(); /* */ $s = 164; case 164: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- $r = check[0].invalidAST(_r$17, "incorrect type switch case", new sliceType([])); /* */ $s = 165; case 165: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* continue; */ $s = 160; continue;
- /* } */ case 163:
- _r$18 = check[0].caseTypes(x$8[0], xtyp, clause$1.List, seen); /* */ $s = 166; case 166: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- T = _r$18;
- $r = check[0].openScope(clause$1, "case"); /* */ $s = 167; case 167: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(lhs === ptrType$5.nil)) { $s = 168; continue; }
- /* */ $s = 169; continue;
- /* if (!(lhs === ptrType$5.nil)) { */ case 168:
- if (!((clause$1.List.$length === 1)) || $interfaceIsEqual(T, $ifaceNil)) {
- T = x$8[0].typ;
- }
- obj$1 = NewVar(lhs.Pos(), check[0].pkg, lhs.Name, T);
- _r$19 = clause$1.End(); /* */ $s = 170; case 170: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- scopePos = _r$19;
- /* */ if (clause$1.Body.$length > 0) { $s = 171; continue; }
- /* */ $s = 172; continue;
- /* if (clause$1.Body.$length > 0) { */ case 171:
- _r$20 = (x$16 = clause$1.Body, (0 >= x$16.$length ? $throwRuntimeError("index out of range") : x$16.$array[x$16.$offset + 0])).Pos(); /* */ $s = 173; case 173: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- scopePos = _r$20;
- /* } */ case 172:
- $r = check[0].declare(check[0].context.scope, ptrType$5.nil, obj$1, scopePos); /* */ $s = 174; case 174: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- check[0].recordImplicit(clause$1, obj$1);
- lhsVars = $append(lhsVars, obj$1);
- /* } */ case 169:
- $r = check[0].stmtList(inner, clause$1.Body); /* */ $s = 175; case 175: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- check[0].closeScope();
- _i$2++;
- /* } */ $s = 160; continue; case 161:
- /* */ if (!(lhs === ptrType$5.nil)) { $s = 176; continue; }
- /* */ $s = 177; continue;
- /* if (!(lhs === ptrType$5.nil)) { */ case 176:
- used = false;
- _ref$9 = lhsVars;
- _i$3 = 0;
- while (true) {
- if (!(_i$3 < _ref$9.$length)) { break; }
- v = ((_i$3 < 0 || _i$3 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$3]);
- if (v.used) {
- used = true;
- }
- v.used = true;
- _i$3++;
- }
- /* */ if (!used) { $s = 178; continue; }
- /* */ $s = 179; continue;
- /* if (!used) { */ case 178:
- $r = check[0].softErrorf(lhs.Pos(), "%s declared but not used", new sliceType([new $String(lhs.Name)])); /* */ $s = 180; case 180: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 179:
- /* } */ case 177:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$68, true)[1]) { */ case 16:
- s$17 = _ref.$val;
- inner = (inner | (1)) >>> 0;
- $r = check[0].multipleDefaults(s$17.Body.List); /* */ $s = 181; case 181: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$10 = s$17.Body.List;
- _i$4 = 0;
- /* while (true) { */ case 182:
- /* if (!(_i$4 < _ref$10.$length)) { break; } */ if(!(_i$4 < _ref$10.$length)) { $s = 183; continue; }
- s$18 = ((_i$4 < 0 || _i$4 >= _ref$10.$length) ? $throwRuntimeError("index out of range") : _ref$10.$array[_ref$10.$offset + _i$4]);
- _tuple$7 = $assertType(s$18, ptrType$67, true); clause$2 = _tuple$7[0];
- /* */ if (clause$2 === ptrType$67.nil) { $s = 184; continue; }
- /* */ $s = 185; continue;
- /* if (clause$2 === ptrType$67.nil) { */ case 184:
- _i$4++;
- /* continue; */ $s = 182; continue;
- /* } */ case 185:
- valid = false;
- rhs$1 = $ifaceNil;
- _ref$11 = clause$2.Comm;
- if (_ref$11 === $ifaceNil || $assertType(_ref$11, ptrType$81, true)[1]) {
- s$19 = _ref$11;
- valid = true;
- } else if ($assertType(_ref$11, ptrType$62, true)[1]) {
- s$20 = _ref$11.$val;
- if (s$20.Rhs.$length === 1) {
- rhs$1 = (x$17 = s$20.Rhs, (0 >= x$17.$length ? $throwRuntimeError("index out of range") : x$17.$array[x$17.$offset + 0]));
- }
- } else if ($assertType(_ref$11, ptrType$85, true)[1]) {
- s$21 = _ref$11.$val;
- rhs$1 = s$21.X;
- }
- if (!($interfaceIsEqual(rhs$1, $ifaceNil))) {
- _tuple$8 = $assertType(unparen(rhs$1), ptrType$36, true); x$18 = _tuple$8[0];
- if (!(x$18 === ptrType$36.nil) && (x$18.Op === 36)) {
- valid = true;
- }
- }
- /* */ if (!valid) { $s = 186; continue; }
- /* */ $s = 187; continue;
- /* if (!valid) { */ case 186:
- _r$21 = clause$2.Comm.Pos(); /* */ $s = 188; case 188: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- $r = check[0].error(_r$21, "select case must be send or receive (possibly with assignment)"); /* */ $s = 189; case 189: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$4++;
- /* continue; */ $s = 182; continue;
- /* } */ case 187:
- $r = check[0].openScope(s$18, "case"); /* */ $s = 190; case 190: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(clause$2.Comm, $ifaceNil))) { $s = 191; continue; }
- /* */ $s = 192; continue;
- /* if (!($interfaceIsEqual(clause$2.Comm, $ifaceNil))) { */ case 191:
- $r = check[0].stmt(inner, clause$2.Comm); /* */ $s = 193; case 193: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 192:
- $r = check[0].stmtList(inner, clause$2.Body); /* */ $s = 194; case 194: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- check[0].closeScope();
- _i$4++;
- /* } */ $s = 182; continue; case 183:
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$69, true)[1]) { */ case 17:
- s$22 = _ref.$val;
- inner = (inner | (3)) >>> 0;
- $r = check[0].openScope(s$22, "for"); /* */ $s = 195; case 195: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(check[0], "closeScope"), []]);
- $r = check[0].simpleStmt(s$22.Init); /* */ $s = 196; case 196: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$22.Cond, $ifaceNil))) { $s = 197; continue; }
- /* */ $s = 198; continue;
- /* if (!($interfaceIsEqual(s$22.Cond, $ifaceNil))) { */ case 197:
- x$3[0] = $clone(new operand.ptr(), operand);
- $r = check[0].expr(x$3[0], s$22.Cond); /* */ $s = 199; case 199: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!(!((x$3[0].mode === 0)))) { _v$2 = false; $s = 202; continue s; }
- _r$22 = isBoolean(x$3[0].typ); /* */ $s = 203; case 203: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _v$2 = !_r$22; case 202:
- /* */ if (_v$2) { $s = 200; continue; }
- /* */ $s = 201; continue;
- /* if (_v$2) { */ case 200:
- _r$23 = s$22.Cond.Pos(); /* */ $s = 204; case 204: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- $r = check[0].error(_r$23, "non-boolean condition in for statement"); /* */ $s = 205; case 205: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 201:
- /* } */ case 198:
- $r = check[0].simpleStmt(s$22.Post); /* */ $s = 206; case 206: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tuple$9 = $assertType(s$22.Post, ptrType$62, true); s$23 = _tuple$9[0];
- /* */ if (!(s$23 === ptrType$62.nil) && (s$23.Tok === 47)) { $s = 207; continue; }
- /* */ $s = 208; continue;
- /* if (!(s$23 === ptrType$62.nil) && (s$23.Tok === 47)) { */ case 207:
- _r$24 = s$23.Pos(); /* */ $s = 209; case 209: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- $r = check[0].softErrorf(_r$24, "cannot declare in post statement", new sliceType([])); /* */ $s = 210; case 210: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].use(s$23.Lhs); /* */ $s = 211; case 211: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 208:
- $r = check[0].stmt(inner, s$22.Body); /* */ $s = 212; case 212: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$70, true)[1]) { */ case 18:
- s$24 = _ref.$val;
- inner = (inner | (3)) >>> 0;
- $r = check[0].openScope(s$24, "for"); /* */ $s = 213; case 213: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $deferred.push([$methodVal(check[0], "closeScope"), []]);
- x$4[0] = $clone(new operand.ptr(), operand);
- $r = check[0].expr(x$4[0], s$24.X); /* */ $s = 214; case 214: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tmp$2 = $ifaceNil; _tmp$3 = $ifaceNil; key = _tmp$2; val = _tmp$3;
- /* */ if (!((x$4[0].mode === 0))) { $s = 215; continue; }
- /* */ $s = 216; continue;
- /* if (!((x$4[0].mode === 0))) { */ case 215:
- _r$25 = x$4[0].typ.Underlying(); /* */ $s = 217; case 217: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _ref$12 = _r$25;
- /* */ if ($assertType(_ref$12, ptrType$3, true)[1]) { $s = 218; continue; }
- /* */ if ($assertType(_ref$12, ptrType$11, true)[1]) { $s = 219; continue; }
- /* */ if ($assertType(_ref$12, ptrType$10, true)[1]) { $s = 220; continue; }
- /* */ if ($assertType(_ref$12, ptrType$15, true)[1]) { $s = 221; continue; }
- /* */ if ($assertType(_ref$12, ptrType$13, true)[1]) { $s = 222; continue; }
- /* */ if ($assertType(_ref$12, ptrType$12, true)[1]) { $s = 223; continue; }
- /* */ $s = 224; continue;
- /* if ($assertType(_ref$12, ptrType$3, true)[1]) { */ case 218:
- typ = _ref$12.$val;
- _r$26 = isString(typ); /* */ $s = 227; case 227: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- /* */ if (_r$26) { $s = 225; continue; }
- /* */ $s = 226; continue;
- /* if (_r$26) { */ case 225:
- key = $pkg.Typ[2];
- val = $pkg.UniverseRune;
- /* } */ case 226:
- $s = 224; continue;
- /* } else if ($assertType(_ref$12, ptrType$11, true)[1]) { */ case 219:
- typ$1 = _ref$12.$val;
- key = $pkg.Typ[2];
- val = typ$1.elem;
- $s = 224; continue;
- /* } else if ($assertType(_ref$12, ptrType$10, true)[1]) { */ case 220:
- typ$2 = _ref$12.$val;
- key = $pkg.Typ[2];
- val = typ$2.elem;
- $s = 224; continue;
- /* } else if ($assertType(_ref$12, ptrType$15, true)[1]) { */ case 221:
- typ$3 = _ref$12.$val;
- _r$27 = typ$3.base.Underlying(); /* */ $s = 228; case 228: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _tuple$10 = $assertType(_r$27, ptrType$11, true); typ$4 = _tuple$10[0];
- /* */ if (!(typ$4 === ptrType$11.nil)) { $s = 229; continue; }
- /* */ $s = 230; continue;
- /* if (!(typ$4 === ptrType$11.nil)) { */ case 229:
- key = $pkg.Typ[2];
- val = typ$4.elem;
- /* } */ case 230:
- $s = 224; continue;
- /* } else if ($assertType(_ref$12, ptrType$13, true)[1]) { */ case 222:
- typ$5 = _ref$12.$val;
- key = typ$5.key;
- val = typ$5.elem;
- $s = 224; continue;
- /* } else if ($assertType(_ref$12, ptrType$12, true)[1]) { */ case 223:
- typ$6 = _ref$12.$val;
- key = typ$6.elem;
- val = $pkg.Typ[0];
- /* */ if (typ$6.dir === 1) { $s = 231; continue; }
- /* */ $s = 232; continue;
- /* if (typ$6.dir === 1) { */ case 231:
- _r$28 = x$4[0].pos(); /* */ $s = 233; case 233: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$28, "cannot range over send-only channel %s", new sliceType([x$4[0]])); /* */ $s = 234; case 234: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 232:
- /* */ if (!($interfaceIsEqual(s$24.Value, $ifaceNil))) { $s = 235; continue; }
- /* */ $s = 236; continue;
- /* if (!($interfaceIsEqual(s$24.Value, $ifaceNil))) { */ case 235:
- _r$29 = s$24.Value.Pos(); /* */ $s = 237; case 237: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$29, "iteration over %s permits only one iteration variable", new sliceType([x$4[0]])); /* */ $s = 238; case 238: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 236:
- /* } */ case 224:
- /* } */ case 216:
- /* */ if ($interfaceIsEqual(key, $ifaceNil)) { $s = 239; continue; }
- /* */ $s = 240; continue;
- /* if ($interfaceIsEqual(key, $ifaceNil)) { */ case 239:
- _r$30 = x$4[0].pos(); /* */ $s = 241; case 241: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$30, "cannot range over %s", new sliceType([x$4[0]])); /* */ $s = 242; case 242: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 240:
- lhs$1 = $toNativeArray($kindInterface, [s$24.Key, s$24.Value]);
- rhs$2 = $toNativeArray($kindInterface, [key, val]);
- /* */ if (s$24.Tok === 47) { $s = 243; continue; }
- /* */ $s = 244; continue;
- /* if (s$24.Tok === 47) { */ case 243:
- vars = sliceType$1.nil;
- _ref$13 = lhs$1;
- _i$5 = 0;
- /* while (true) { */ case 246:
- /* if (!(_i$5 < 2)) { break; } */ if(!(_i$5 < 2)) { $s = 247; continue; }
- i$1 = _i$5;
- lhs$2 = ((_i$5 < 0 || _i$5 >= _ref$13.length) ? $throwRuntimeError("index out of range") : _ref$13[_i$5]);
- /* */ if ($interfaceIsEqual(lhs$2, $ifaceNil)) { $s = 248; continue; }
- /* */ $s = 249; continue;
- /* if ($interfaceIsEqual(lhs$2, $ifaceNil)) { */ case 248:
- _i$5++;
- /* continue; */ $s = 246; continue;
- /* } */ case 249:
- obj$2 = ptrType$9.nil;
- _tuple$11 = $assertType(lhs$2, ptrType$5, true); ident = _tuple$11[0];
- /* */ if (!(ident === ptrType$5.nil)) { $s = 250; continue; }
- /* */ $s = 251; continue;
- /* if (!(ident === ptrType$5.nil)) { */ case 250:
- name = ident.Name;
- obj$2 = NewVar(ident.Pos(), check[0].pkg, name, $ifaceNil);
- check[0].recordDef(ident, obj$2);
- if (!(name === "_")) {
- vars = $append(vars, obj$2);
- }
- $s = 252; continue;
- /* } else { */ case 251:
- _r$31 = lhs$2.Pos(); /* */ $s = 253; case 253: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$31, "cannot declare %s", new sliceType([lhs$2])); /* */ $s = 254; case 254: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$32 = lhs$2.Pos(); /* */ $s = 255; case 255: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _r$33 = NewVar(_r$32, check[0].pkg, "_", $ifaceNil); /* */ $s = 256; case 256: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- obj$2 = _r$33;
- /* } */ case 252:
- typ$7 = ((i$1 < 0 || i$1 >= rhs$2.length) ? $throwRuntimeError("index out of range") : rhs$2[i$1]);
- /* */ if (!($interfaceIsEqual(typ$7, $ifaceNil))) { $s = 257; continue; }
- /* */ $s = 258; continue;
- /* if (!($interfaceIsEqual(typ$7, $ifaceNil))) { */ case 257:
- x$4[0].mode = 7;
- x$4[0].expr = lhs$2;
- x$4[0].typ = typ$7;
- _r$34 = check[0].initVar(obj$2, x$4[0], false); /* */ $s = 260; case 260: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _r$34;
- $s = 259; continue;
- /* } else { */ case 258:
- obj$2.object.typ = $pkg.Typ[0];
- obj$2.used = true;
- /* } */ case 259:
- _i$5++;
- /* } */ $s = 246; continue; case 247:
- /* */ if (vars.$length > 0) { $s = 261; continue; }
- /* */ $s = 262; continue;
- /* if (vars.$length > 0) { */ case 261:
- _ref$14 = vars;
- _i$6 = 0;
- /* while (true) { */ case 264:
- /* if (!(_i$6 < _ref$14.$length)) { break; } */ if(!(_i$6 < _ref$14.$length)) { $s = 265; continue; }
- obj$3 = ((_i$6 < 0 || _i$6 >= _ref$14.$length) ? $throwRuntimeError("index out of range") : _ref$14.$array[_ref$14.$offset + _i$6]);
- scopePos$1 = s$24.End();
- $r = check[0].declare(check[0].context.scope, ptrType$5.nil, obj$3, scopePos$1); /* */ $s = 266; case 266: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$6++;
- /* } */ $s = 264; continue; case 265:
- $s = 263; continue;
- /* } else { */ case 262:
- $r = check[0].error(s$24.TokPos, "no new variables on left side of :="); /* */ $s = 267; case 267: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 263:
- $s = 245; continue;
- /* } else { */ case 244:
- _ref$15 = lhs$1;
- _i$7 = 0;
- /* while (true) { */ case 268:
- /* if (!(_i$7 < 2)) { break; } */ if(!(_i$7 < 2)) { $s = 269; continue; }
- i$2 = _i$7;
- lhs$3 = ((_i$7 < 0 || _i$7 >= _ref$15.length) ? $throwRuntimeError("index out of range") : _ref$15[_i$7]);
- /* */ if ($interfaceIsEqual(lhs$3, $ifaceNil)) { $s = 270; continue; }
- /* */ $s = 271; continue;
- /* if ($interfaceIsEqual(lhs$3, $ifaceNil)) { */ case 270:
- _i$7++;
- /* continue; */ $s = 268; continue;
- /* } */ case 271:
- typ$8 = ((i$2 < 0 || i$2 >= rhs$2.length) ? $throwRuntimeError("index out of range") : rhs$2[i$2]);
- /* */ if (!($interfaceIsEqual(typ$8, $ifaceNil))) { $s = 272; continue; }
- /* */ $s = 273; continue;
- /* if (!($interfaceIsEqual(typ$8, $ifaceNil))) { */ case 272:
- x$4[0].mode = 7;
- x$4[0].expr = lhs$3;
- x$4[0].typ = typ$8;
- _r$35 = check[0].assignVar(lhs$3, x$4[0]); /* */ $s = 274; case 274: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- _r$35;
- /* } */ case 273:
- _i$7++;
- /* } */ $s = 268; continue; case 269:
- /* } */ case 245:
- $r = check[0].stmt(inner, s$24.Body); /* */ $s = 275; case 275: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 20; continue;
- /* } else { */ case 19:
- s$25 = _ref;
- _r$36 = s$25.Pos(); /* */ $s = 276; case 276: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- $r = check[0].error(_r$36, "invalid statement"); /* */ $s = 277; case 277: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.stmt }; } $f.$ptr = $ptr; $f.T = T; $f.Y = Y; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._i$7 = _i$7; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$10 = _ref$10; $f._ref$11 = _ref$11; $f._ref$12 = _ref$12; $f._ref$13 = _ref$13; $f._ref$14 = _ref$14; $f._ref$15 = _ref$15; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$11 = _tuple$11; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.alt = alt; $f.c = c; $f.ch = ch; $f.check = check; $f.clause = clause; $f.clause$1 = clause$1; $f.clause$2 = clause$2; $f.ctxt = ctxt; $f.expr = expr; $f.guard = guard; $f.guard$1 = guard$1; $f.guard$2 = guard$2; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.ident = ident; $f.inner = inner; $f.inner$1 = inner$1; $f.key = key; $f.kind = kind; $f.lhs = lhs; $f.lhs$1 = lhs$1; $f.lhs$2 = lhs$2; $f.lhs$3 = lhs$3; $f.lhsVars = lhsVars; $f.msg = msg; $f.name = name; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.ok = ok; $f.op = op; $f.op$1 = op$1; $f.res = res; $f.rhs = rhs; $f.rhs$1 = rhs$1; $f.rhs$2 = rhs$2; $f.s = s; $f.s$1 = s$1; $f.s$10 = s$10; $f.s$11 = s$11; $f.s$12 = s$12; $f.s$13 = s$13; $f.s$14 = s$14; $f.s$15 = s$15; $f.s$16 = s$16; $f.s$17 = s$17; $f.s$18 = s$18; $f.s$19 = s$19; $f.s$2 = s$2; $f.s$20 = s$20; $f.s$21 = s$21; $f.s$22 = s$22; $f.s$23 = s$23; $f.s$24 = s$24; $f.s$25 = s$25; $f.s$3 = s$3; $f.s$4 = s$4; $f.s$5 = s$5; $f.s$6 = s$6; $f.s$7 = s$7; $f.s$8 = s$8; $f.s$9 = s$9; $f.scopePos = scopePos; $f.scopePos$1 = scopePos$1; $f.seen = seen; $f.tch = tch; $f.typ = typ; $f.typ$1 = typ$1; $f.typ$2 = typ$2; $f.typ$3 = typ$3; $f.typ$4 = typ$4; $f.typ$5 = typ$5; $f.typ$6 = typ$6; $f.typ$7 = typ$7; $f.typ$8 = typ$8; $f.used = used; $f.v = v; $f.val = val; $f.valid = valid; $f.vars = vars; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$17 = x$17; $f.x$18 = x$18; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.xtyp = xtyp; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.stmt = function(ctxt, s) { return this.$val.stmt(ctxt, s); };
- Basic.ptr.prototype.Kind = function() {
- var $ptr, b;
- b = this;
- return b.kind;
- };
- Basic.prototype.Kind = function() { return this.$val.Kind(); };
- Basic.ptr.prototype.Info = function() {
- var $ptr, b;
- b = this;
- return b.info;
- };
- Basic.prototype.Info = function() { return this.$val.Info(); };
- Basic.ptr.prototype.Name = function() {
- var $ptr, b;
- b = this;
- return b.name;
- };
- Basic.prototype.Name = function() { return this.$val.Name(); };
- NewArray = function(elem, len) {
- var $ptr, elem, len;
- return new Array.ptr(len, elem);
- };
- $pkg.NewArray = NewArray;
- Array.ptr.prototype.Len = function() {
- var $ptr, a;
- a = this;
- return a.len;
- };
- Array.prototype.Len = function() { return this.$val.Len(); };
- Array.ptr.prototype.Elem = function() {
- var $ptr, a;
- a = this;
- return a.elem;
- };
- Array.prototype.Elem = function() { return this.$val.Elem(); };
- NewSlice = function(elem) {
- var $ptr, elem;
- return new Slice.ptr(elem);
- };
- $pkg.NewSlice = NewSlice;
- Slice.ptr.prototype.Elem = function() {
- var $ptr, s;
- s = this;
- return s.elem;
- };
- Slice.prototype.Elem = function() { return this.$val.Elem(); };
- NewStruct = function(fields, tags) {
- var $ptr, _i, _r, _ref, _v, f, fields, fset, nonAsciiName$1, tags, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _v = $f._v; f = $f.f; fields = $f.fields; fset = $f.fset; nonAsciiName$1 = $f.nonAsciiName$1; tags = $f.tags; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- fset = false;
- _ref = fields;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!(!(f.object.name === "_"))) { _v = false; $s = 5; continue s; }
- _r = (nonAsciiName$1 || (nonAsciiName$1 = new ptrType$28(function() { return fset; }, function($v) { fset = $v; }))).insert(f); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = !($interfaceIsEqual(_r, $ifaceNil)); case 5:
- /* */ if (_v) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (_v) { */ case 3:
- $panic(new $String("multiple fields with the same name"));
- /* } */ case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- if (tags.$length > fields.$length) {
- $panic(new $String("more tags than fields"));
- }
- return new Struct.ptr(fields, tags, sliceType$4.nil);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: NewStruct }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._v = _v; $f.f = f; $f.fields = fields; $f.fset = fset; $f.nonAsciiName$1 = nonAsciiName$1; $f.tags = tags; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.NewStruct = NewStruct;
- Struct.ptr.prototype.NumFields = function() {
- var $ptr, s;
- s = this;
- return s.fields.$length;
- };
- Struct.prototype.NumFields = function() { return this.$val.NumFields(); };
- Struct.ptr.prototype.Field = function(i) {
- var $ptr, i, s, x;
- s = this;
- return (x = s.fields, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- };
- Struct.prototype.Field = function(i) { return this.$val.Field(i); };
- Struct.ptr.prototype.Tag = function(i) {
- var $ptr, i, s, x;
- s = this;
- if (i < s.tags.$length) {
- return (x = s.tags, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- }
- return "";
- };
- Struct.prototype.Tag = function(i) { return this.$val.Tag(i); };
- NewPointer = function(elem) {
- var $ptr, elem;
- return new Pointer.ptr(elem);
- };
- $pkg.NewPointer = NewPointer;
- Pointer.ptr.prototype.Elem = function() {
- var $ptr, p;
- p = this;
- return p.base;
- };
- Pointer.prototype.Elem = function() { return this.$val.Elem(); };
- NewTuple = function(x) {
- var $ptr, x;
- if (x.$length > 0) {
- return new Tuple.ptr(x);
- }
- return ptrType$8.nil;
- };
- $pkg.NewTuple = NewTuple;
- Tuple.ptr.prototype.Len = function() {
- var $ptr, t;
- t = this;
- if (!(t === ptrType$8.nil)) {
- return t.vars.$length;
- }
- return 0;
- };
- Tuple.prototype.Len = function() { return this.$val.Len(); };
- Tuple.ptr.prototype.At = function(i) {
- var $ptr, i, t, x;
- t = this;
- return (x = t.vars, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- };
- Tuple.prototype.At = function(i) { return this.$val.At(i); };
- NewSignature = function(recv, params, results, variadic) {
- var $ptr, _tuple, n, ok, params, recv, results, variadic;
- if (variadic) {
- n = params.Len();
- if (n === 0) {
- $panic(new $String("types.NewSignature: variadic function must have at least one parameter"));
- }
- _tuple = $assertType(params.At(n - 1 >> 0).object.typ, ptrType$10, true); ok = _tuple[1];
- if (!ok) {
- $panic(new $String("types.NewSignature: variadic parameter must be of unnamed slice type"));
- }
- }
- return new Signature.ptr(ptrType.nil, recv, params, results, variadic);
- };
- $pkg.NewSignature = NewSignature;
- Signature.ptr.prototype.Recv = function() {
- var $ptr, s;
- s = this;
- return s.recv;
- };
- Signature.prototype.Recv = function() { return this.$val.Recv(); };
- Signature.ptr.prototype.Params = function() {
- var $ptr, s;
- s = this;
- return s.params;
- };
- Signature.prototype.Params = function() { return this.$val.Params(); };
- Signature.ptr.prototype.Results = function() {
- var $ptr, s;
- s = this;
- return s.results;
- };
- Signature.prototype.Results = function() { return this.$val.Results(); };
- Signature.ptr.prototype.Variadic = function() {
- var $ptr, s;
- s = this;
- return s.variadic;
- };
- Signature.prototype.Variadic = function() { return this.$val.Variadic(); };
- NewInterface = function(methods, embeddeds) {
- var $ptr, _i, _r, _ref, embeddeds, m, methods, mset, nonAsciiName$1, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; embeddeds = $f.embeddeds; m = $f.m; methods = $f.methods; mset = $f.mset; nonAsciiName$1 = $f.nonAsciiName$1; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- typ = new Interface.ptr();
- mset = false;
- _ref = methods;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- m = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = (nonAsciiName$1 || (nonAsciiName$1 = new ptrType$28(function() { return mset; }, function($v) { mset = $v; }))).insert(m); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(_r, $ifaceNil))) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!($interfaceIsEqual(_r, $ifaceNil))) { */ case 3:
- $panic(new $String("multiple methods with the same name"));
- /* } */ case 4:
- $assertType(m.object.typ, ptrType$17).recv = NewVar(m.object.pos, m.object.pkg, "", typ);
- _i++;
- /* } */ $s = 1; continue; case 2:
- $r = sort.Sort($subslice(new byUniqueMethodName(methods.$array), methods.$offset, methods.$offset + methods.$length)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (embeddeds === sliceType$22.nil) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (embeddeds === sliceType$22.nil) { */ case 7:
- $r = sort.Sort($subslice(new byUniqueTypeName(embeddeds.$array), embeddeds.$offset, embeddeds.$offset + embeddeds.$length)); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- typ.methods = methods;
- typ.embeddeds = embeddeds;
- return typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: NewInterface }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.embeddeds = embeddeds; $f.m = m; $f.methods = methods; $f.mset = mset; $f.nonAsciiName$1 = nonAsciiName$1; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.NewInterface = NewInterface;
- Interface.ptr.prototype.NumExplicitMethods = function() {
- var $ptr, t;
- t = this;
- return t.methods.$length;
- };
- Interface.prototype.NumExplicitMethods = function() { return this.$val.NumExplicitMethods(); };
- Interface.ptr.prototype.ExplicitMethod = function(i) {
- var $ptr, i, t, x;
- t = this;
- return (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- };
- Interface.prototype.ExplicitMethod = function(i) { return this.$val.ExplicitMethod(i); };
- Interface.ptr.prototype.NumEmbeddeds = function() {
- var $ptr, t;
- t = this;
- return t.embeddeds.$length;
- };
- Interface.prototype.NumEmbeddeds = function() { return this.$val.NumEmbeddeds(); };
- Interface.ptr.prototype.Embedded = function(i) {
- var $ptr, i, t, x;
- t = this;
- return (x = t.embeddeds, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- };
- Interface.prototype.Embedded = function(i) { return this.$val.Embedded(i); };
- Interface.ptr.prototype.NumMethods = function() {
- var $ptr, t;
- t = this;
- return t.allMethods.$length;
- };
- Interface.prototype.NumMethods = function() { return this.$val.NumMethods(); };
- Interface.ptr.prototype.Method = function(i) {
- var $ptr, i, t, x;
- t = this;
- return (x = t.allMethods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- };
- Interface.prototype.Method = function(i) { return this.$val.Method(i); };
- Interface.ptr.prototype.Empty = function() {
- var $ptr, t;
- t = this;
- return t.allMethods.$length === 0;
- };
- Interface.prototype.Empty = function() { return this.$val.Empty(); };
- Interface.ptr.prototype.Complete = function() {
- var $ptr, _i, _i$1, _r, _ref, _ref$1, allMethods, et, it, newm, newmtyp, t, tm, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; allMethods = $f.allMethods; et = $f.et; it = $f.it; newm = $f.newm; newmtyp = $f.newmtyp; t = $f.t; tm = $f.tm; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- if (!(t.allMethods === sliceType$7.nil)) {
- return t;
- }
- allMethods = sliceType$7.nil;
- /* */ if (t.embeddeds === sliceType$22.nil) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (t.embeddeds === sliceType$22.nil) { */ case 1:
- if (t.methods === sliceType$7.nil) {
- allMethods = $makeSlice(sliceType$7, 0, 1);
- } else {
- allMethods = t.methods;
- }
- $s = 3; continue;
- /* } else { */ case 2:
- allMethods = $appendSlice(allMethods, t.methods);
- _ref = t.embeddeds;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- et = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- it = $assertType(et.Underlying(), ptrType$53);
- _r = it.Complete(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- _ref$1 = it.allMethods;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- newm = [newm];
- newmtyp = [newmtyp];
- tm = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- newm[0] = $clone(tm, Func);
- newmtyp[0] = $clone($assertType(tm.object.typ, ptrType$17), Signature);
- newm[0].object.typ = newmtyp[0];
- newmtyp[0].recv = NewVar(newm[0].object.pos, newm[0].object.pkg, "", t);
- allMethods = $append(allMethods, newm[0]);
- _i$1++;
- }
- _i++;
- /* } */ $s = 4; continue; case 5:
- $r = sort.Sort($subslice(new byUniqueMethodName(allMethods.$array), allMethods.$offset, allMethods.$offset + allMethods.$length)); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- t.allMethods = allMethods;
- return t;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Interface.ptr.prototype.Complete }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.allMethods = allMethods; $f.et = et; $f.it = it; $f.newm = newm; $f.newmtyp = newmtyp; $f.t = t; $f.tm = tm; $f.$s = $s; $f.$r = $r; return $f;
- };
- Interface.prototype.Complete = function() { return this.$val.Complete(); };
- NewMap = function(key, elem) {
- var $ptr, elem, key;
- return new Map.ptr(key, elem);
- };
- $pkg.NewMap = NewMap;
- Map.ptr.prototype.Key = function() {
- var $ptr, m;
- m = this;
- return m.key;
- };
- Map.prototype.Key = function() { return this.$val.Key(); };
- Map.ptr.prototype.Elem = function() {
- var $ptr, m;
- m = this;
- return m.elem;
- };
- Map.prototype.Elem = function() { return this.$val.Elem(); };
- NewChan = function(dir, elem) {
- var $ptr, dir, elem;
- return new Chan.ptr(dir, elem);
- };
- $pkg.NewChan = NewChan;
- Chan.ptr.prototype.Dir = function() {
- var $ptr, c;
- c = this;
- return c.dir;
- };
- Chan.prototype.Dir = function() { return this.$val.Dir(); };
- Chan.ptr.prototype.Elem = function() {
- var $ptr, c;
- c = this;
- return c.elem;
- };
- Chan.prototype.Elem = function() { return this.$val.Elem(); };
- NewNamed = function(obj, underlying$1, methods) {
- var $ptr, _tuple, methods, obj, ok, typ, underlying$1;
- _tuple = $assertType(underlying$1, ptrType$26, true); ok = _tuple[1];
- if (ok) {
- $panic(new $String("types.NewNamed: underlying type must not be *Named"));
- }
- typ = new Named.ptr(obj, underlying$1, methods);
- if ($interfaceIsEqual(obj.object.typ, $ifaceNil)) {
- obj.object.typ = typ;
- }
- return typ;
- };
- $pkg.NewNamed = NewNamed;
- Named.ptr.prototype.Obj = function() {
- var $ptr, t;
- t = this;
- return t.obj;
- };
- Named.prototype.Obj = function() { return this.$val.Obj(); };
- Named.ptr.prototype.NumMethods = function() {
- var $ptr, t;
- t = this;
- return t.methods.$length;
- };
- Named.prototype.NumMethods = function() { return this.$val.NumMethods(); };
- Named.ptr.prototype.Method = function(i) {
- var $ptr, i, t, x;
- t = this;
- return (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- };
- Named.prototype.Method = function(i) { return this.$val.Method(i); };
- Named.ptr.prototype.SetUnderlying = function(underlying$1) {
- var $ptr, _tuple, ok, t, underlying$1;
- t = this;
- if ($interfaceIsEqual(underlying$1, $ifaceNil)) {
- $panic(new $String("types.Named.SetUnderlying: underlying type must not be nil"));
- }
- _tuple = $assertType(underlying$1, ptrType$26, true); ok = _tuple[1];
- if (ok) {
- $panic(new $String("types.Named.SetUnderlying: underlying type must not be *Named"));
- }
- t.underlying = underlying$1;
- };
- Named.prototype.SetUnderlying = function(underlying$1) { return this.$val.SetUnderlying(underlying$1); };
- Named.ptr.prototype.AddMethod = function(m) {
- var $ptr, _tuple, i, m, t;
- t = this;
- _tuple = lookupMethod(t.methods, m.object.pkg, m.object.name); i = _tuple[0];
- if (i < 0) {
- t.methods = $append(t.methods, m);
- }
- };
- Named.prototype.AddMethod = function(m) { return this.$val.AddMethod(m); };
- Basic.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Basic.prototype.Underlying = function() { return this.$val.Underlying(); };
- Array.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Array.prototype.Underlying = function() { return this.$val.Underlying(); };
- Slice.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Slice.prototype.Underlying = function() { return this.$val.Underlying(); };
- Struct.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Struct.prototype.Underlying = function() { return this.$val.Underlying(); };
- Pointer.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Pointer.prototype.Underlying = function() { return this.$val.Underlying(); };
- Tuple.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Tuple.prototype.Underlying = function() { return this.$val.Underlying(); };
- Signature.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Signature.prototype.Underlying = function() { return this.$val.Underlying(); };
- Interface.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Interface.prototype.Underlying = function() { return this.$val.Underlying(); };
- Map.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Map.prototype.Underlying = function() { return this.$val.Underlying(); };
- Chan.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t;
- };
- Chan.prototype.Underlying = function() { return this.$val.Underlying(); };
- Named.ptr.prototype.Underlying = function() {
- var $ptr, t;
- t = this;
- return t.underlying;
- };
- Named.prototype.Underlying = function() { return this.$val.Underlying(); };
- Basic.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Basic.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Basic.prototype.String = function() { return this.$val.String(); };
- Array.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Array.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Array.prototype.String = function() { return this.$val.String(); };
- Slice.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Slice.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Slice.prototype.String = function() { return this.$val.String(); };
- Struct.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Struct.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Struct.prototype.String = function() { return this.$val.String(); };
- Pointer.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Pointer.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Pointer.prototype.String = function() { return this.$val.String(); };
- Tuple.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Tuple.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Tuple.prototype.String = function() { return this.$val.String(); };
- Signature.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Signature.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Signature.prototype.String = function() { return this.$val.String(); };
- Interface.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Interface.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Interface.prototype.String = function() { return this.$val.String(); };
- Map.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.String = function() { return this.$val.String(); };
- Chan.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Chan.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Chan.prototype.String = function() { return this.$val.String(); };
- Named.ptr.prototype.String = function() {
- var $ptr, _r, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = this;
- _r = TypeString(t, $throwNilPointerError); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Named.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Named.prototype.String = function() { return this.$val.String(); };
- TypeString = function(typ, qf) {
- var $ptr, buf, qf, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; buf = $f.buf; qf = $f.qf; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- $r = WriteType(buf[0], typ, qf); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: TypeString }; } $f.$ptr = $ptr; $f.buf = buf; $f.qf = qf; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.TypeString = TypeString;
- WriteType = function(buf, typ, qf) {
- var $ptr, buf, qf, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; buf = $f.buf; qf = $f.qf; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = writeType(buf, typ, qf, $makeSlice(sliceType$3, 8)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: WriteType }; } $f.$ptr = $ptr; $f.buf = buf; $f.qf = qf; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.WriteType = WriteType;
- writeType = function(buf, typ, qf, visited) {
- var $ptr, _i, _i$1, _i$2, _i$3, _i$4, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _tuple, buf, c, f, i, i$1, i$2, i$3, m, m$1, obj, parens, qf, s, s$1, t, t$1, t$10, t$11, t$12, t$13, t$2, t$3, t$4, t$5, t$6, t$7, t$8, t$9, tag, typ, typ$1, visited, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _tuple = $f._tuple; buf = $f.buf; c = $f.c; f = $f.f; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; m = $f.m; m$1 = $f.m$1; obj = $f.obj; parens = $f.parens; qf = $f.qf; s = $f.s; s$1 = $f.s$1; t = $f.t; t$1 = $f.t$1; t$10 = $f.t$10; t$11 = $f.t$11; t$12 = $f.t$12; t$13 = $f.t$13; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; t$8 = $f.t$8; t$9 = $f.t$9; tag = $f.tag; typ = $f.typ; typ$1 = $f.typ$1; visited = $f.visited; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = visited;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- t = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if ($interfaceIsEqual(t, typ)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($interfaceIsEqual(t, typ)) { */ case 3:
- _r = fmt.Fprintf(buf, "\xE2\x97\x8B%T", new sliceType([typ])); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- return;
- /* } */ case 4:
- _i++;
- /* } */ $s = 1; continue; case 2:
- visited = $append(visited, typ);
- _ref$1 = typ;
- /* */ if (_ref$1 === $ifaceNil) { $s = 6; continue; }
- /* */ if ($assertType(_ref$1, ptrType$3, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref$1, ptrType$11, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref$1, ptrType$10, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref$1, ptrType$27, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref$1, ptrType$15, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref$1, ptrType$8, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref$1, ptrType$17, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref$1, ptrType$53, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref$1, ptrType$13, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref$1, ptrType$12, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref$1, ptrType$26, true)[1]) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (_ref$1 === $ifaceNil) { */ case 6:
- t$1 = _ref$1;
- buf.WriteString("");
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$3, true)[1]) { */ case 7:
- t$2 = _ref$1.$val;
- if (t$2.kind === 18) {
- buf.WriteString("unsafe.");
- }
- if ($pkg.GcCompatibilityMode) {
- _ref$2 = t$2.kind;
- if (_ref$2 === 8) {
- t$2 = $pkg.Typ[8];
- } else if (_ref$2 === 5) {
- t$2 = $pkg.Typ[5];
- }
- }
- buf.WriteString(t$2.name);
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$11, true)[1]) { */ case 8:
- t$3 = _ref$1.$val;
- _r$1 = fmt.Fprintf(buf, "[%d]", new sliceType([t$3.len])); /* */ $s = 20; case 20: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- $r = writeType(buf, t$3.elem, qf, visited); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$10, true)[1]) { */ case 9:
- t$4 = _ref$1.$val;
- buf.WriteString("[]");
- $r = writeType(buf, t$4.elem, qf, visited); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$27, true)[1]) { */ case 10:
- t$5 = _ref$1.$val;
- buf.WriteString("struct{");
- _ref$3 = t$5.fields;
- _i$1 = 0;
- /* while (true) { */ case 23:
- /* if (!(_i$1 < _ref$3.$length)) { break; } */ if(!(_i$1 < _ref$3.$length)) { $s = 24; continue; }
- i = _i$1;
- f = ((_i$1 < 0 || _i$1 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$1]);
- if (i > 0) {
- buf.WriteString("; ");
- }
- if (!f.anonymous) {
- buf.WriteString(f.object.name);
- buf.WriteByte(32);
- }
- $r = writeType(buf, f.object.typ, qf, visited); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- tag = t$5.Tag(i);
- /* */ if (!(tag === "")) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (!(tag === "")) { */ case 26:
- _r$2 = fmt.Fprintf(buf, " %q", new sliceType([new $String(tag)])); /* */ $s = 28; case 28: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* } */ case 27:
- _i$1++;
- /* } */ $s = 23; continue; case 24:
- buf.WriteByte(125);
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$15, true)[1]) { */ case 11:
- t$6 = _ref$1.$val;
- buf.WriteByte(42);
- $r = writeType(buf, t$6.base, qf, visited); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$8, true)[1]) { */ case 12:
- t$7 = _ref$1.$val;
- $r = writeTuple(buf, t$7, false, qf, visited); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$17, true)[1]) { */ case 13:
- t$8 = _ref$1.$val;
- buf.WriteString("func");
- $r = writeSignature(buf, t$8, qf, visited); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$53, true)[1]) { */ case 14:
- t$9 = _ref$1.$val;
- buf.WriteString("interface{");
- /* */ if ($pkg.GcCompatibilityMode) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if ($pkg.GcCompatibilityMode) { */ case 32:
- _ref$4 = t$9.allMethods;
- _i$2 = 0;
- /* while (true) { */ case 35:
- /* if (!(_i$2 < _ref$4.$length)) { break; } */ if(!(_i$2 < _ref$4.$length)) { $s = 36; continue; }
- i$1 = _i$2;
- m = ((_i$2 < 0 || _i$2 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$2]);
- if (i$1 > 0) {
- buf.WriteString("; ");
- }
- buf.WriteString(m.object.name);
- $r = writeSignature(buf, $assertType(m.object.typ, ptrType$17), qf, visited); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 35; continue; case 36:
- $s = 34; continue;
- /* } else { */ case 33:
- _ref$5 = t$9.methods;
- _i$3 = 0;
- /* while (true) { */ case 38:
- /* if (!(_i$3 < _ref$5.$length)) { break; } */ if(!(_i$3 < _ref$5.$length)) { $s = 39; continue; }
- i$2 = _i$3;
- m$1 = ((_i$3 < 0 || _i$3 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$3]);
- if (i$2 > 0) {
- buf.WriteString("; ");
- }
- buf.WriteString(m$1.object.name);
- $r = writeSignature(buf, $assertType(m$1.object.typ, ptrType$17), qf, visited); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* } */ $s = 38; continue; case 39:
- _ref$6 = t$9.embeddeds;
- _i$4 = 0;
- /* while (true) { */ case 41:
- /* if (!(_i$4 < _ref$6.$length)) { break; } */ if(!(_i$4 < _ref$6.$length)) { $s = 42; continue; }
- i$3 = _i$4;
- typ$1 = ((_i$4 < 0 || _i$4 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$4]);
- if (i$3 > 0 || t$9.methods.$length > 0) {
- buf.WriteString("; ");
- }
- $r = writeType(buf, typ$1, qf, visited); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$4++;
- /* } */ $s = 41; continue; case 42:
- /* } */ case 34:
- buf.WriteByte(125);
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$13, true)[1]) { */ case 15:
- t$10 = _ref$1.$val;
- buf.WriteString("map[");
- $r = writeType(buf, t$10.key, qf, visited); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- buf.WriteByte(93);
- $r = writeType(buf, t$10.elem, qf, visited); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$12, true)[1]) { */ case 16:
- t$11 = _ref$1.$val;
- s = "";
- parens = false;
- _ref$7 = t$11.dir;
- if (_ref$7 === 0) {
- s = "chan ";
- _tuple = $assertType(t$11.elem, ptrType$12, true); c = _tuple[0];
- if (!(c === ptrType$12.nil) && (c.dir === 2)) {
- parens = true;
- }
- } else if (_ref$7 === 1) {
- s = "chan<- ";
- } else if (_ref$7 === 2) {
- s = "<-chan ";
- } else {
- $panic(new $String("unreachable"));
- }
- buf.WriteString(s);
- if (parens) {
- buf.WriteByte(40);
- }
- $r = writeType(buf, t$11.elem, qf, visited); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (parens) {
- buf.WriteByte(41);
- }
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$26, true)[1]) { */ case 17:
- t$12 = _ref$1.$val;
- s$1 = "";
- obj = t$12.obj;
- /* */ if (!(obj === ptrType$19.nil)) { $s = 47; continue; }
- /* */ $s = 48; continue;
- /* if (!(obj === ptrType$19.nil)) { */ case 47:
- /* */ if (!(obj.object.pkg === ptrType$1.nil)) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (!(obj.object.pkg === ptrType$1.nil)) { */ case 49:
- $r = writePackage(buf, obj.object.pkg, qf); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 50:
- s$1 = obj.object.name;
- /* } */ case 48:
- buf.WriteString(s$1);
- $s = 19; continue;
- /* } else { */ case 18:
- t$13 = _ref$1;
- _r$3 = t$13.String(); /* */ $s = 52; case 52: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = buf.WriteString(_r$3); /* */ $s = 53; case 53: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$4;
- /* } */ case 19:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: writeType }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._tuple = _tuple; $f.buf = buf; $f.c = c; $f.f = f; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.m = m; $f.m$1 = m$1; $f.obj = obj; $f.parens = parens; $f.qf = qf; $f.s = s; $f.s$1 = s$1; $f.t = t; $f.t$1 = t$1; $f.t$10 = t$10; $f.t$11 = t$11; $f.t$12 = t$12; $f.t$13 = t$13; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.t$8 = t$8; $f.t$9 = t$9; $f.tag = tag; $f.typ = typ; $f.typ$1 = typ$1; $f.visited = visited; $f.$s = $s; $f.$r = $r; return $f;
- };
- writeTuple = function(buf, tup, variadic, qf, visited) {
- var $ptr, _i, _r, _ref, _tuple, _tuple$1, buf, i, ok, ok$1, qf, s, t, tup, typ, v, variadic, visited, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; buf = $f.buf; i = $f.i; ok = $f.ok; ok$1 = $f.ok$1; qf = $f.qf; s = $f.s; t = $f.t; tup = $f.tup; typ = $f.typ; v = $f.v; variadic = $f.variadic; visited = $f.visited; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf.WriteByte(40);
- /* */ if (!(tup === ptrType$8.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(tup === ptrType$8.nil)) { */ case 1:
- _ref = tup.vars;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- i = _i;
- v = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (i > 0) {
- buf.WriteString(", ");
- }
- if (!(v.object.name === "")) {
- buf.WriteString(v.object.name);
- buf.WriteByte(32);
- }
- typ = v.object.typ;
- /* */ if (variadic && (i === (tup.vars.$length - 1 >> 0))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (variadic && (i === (tup.vars.$length - 1 >> 0))) { */ case 5:
- _tuple = $assertType(typ, ptrType$10, true); s = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (ok) { */ case 7:
- buf.WriteString("...");
- typ = s.elem;
- $s = 9; continue;
- /* } else { */ case 8:
- _r = typ.Underlying(); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r, ptrType$3, true); t = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (!ok$1 || !((t.kind === 17))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!ok$1 || !((t.kind === 17))) { */ case 11:
- $panic(new $String("internal error: string type expected"));
- /* } */ case 12:
- $r = writeType(buf, typ, qf, visited); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- buf.WriteString("...");
- _i++;
- /* continue; */ $s = 3; continue;
- /* } */ case 9:
- /* } */ case 6:
- $r = writeType(buf, typ, qf, visited); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 3; continue; case 4:
- /* } */ case 2:
- buf.WriteByte(41);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: writeTuple }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.i = i; $f.ok = ok; $f.ok$1 = ok$1; $f.qf = qf; $f.s = s; $f.t = t; $f.tup = tup; $f.typ = typ; $f.v = v; $f.variadic = variadic; $f.visited = visited; $f.$s = $s; $f.$r = $r; return $f;
- };
- WriteSignature = function(buf, sig, qf) {
- var $ptr, buf, qf, sig, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; buf = $f.buf; qf = $f.qf; sig = $f.sig; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = writeSignature(buf, sig, qf, $makeSlice(sliceType$3, 8)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: WriteSignature }; } $f.$ptr = $ptr; $f.buf = buf; $f.qf = qf; $f.sig = sig; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.WriteSignature = WriteSignature;
- writeSignature = function(buf, sig, qf, visited) {
- var $ptr, buf, n, qf, sig, visited, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; buf = $f.buf; n = $f.n; qf = $f.qf; sig = $f.sig; visited = $f.visited; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = writeTuple(buf, sig.params, sig.variadic, qf, visited); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = sig.results.Len();
- if (n === 0) {
- return;
- }
- buf.WriteByte(32);
- /* */ if ((n === 1) && (x = sig.results.vars, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).object.name === "") { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ((n === 1) && (x = sig.results.vars, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).object.name === "") { */ case 2:
- $r = writeType(buf, (x$1 = sig.results.vars, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])).object.typ, qf, visited); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 3:
- $r = writeTuple(buf, sig.results, false, qf, visited); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: writeSignature }; } $f.$ptr = $ptr; $f.buf = buf; $f.n = n; $f.qf = qf; $f.sig = sig; $f.visited = visited; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.ptr.prototype.ident = function(x, e, def$1, path$1) {
- var $ptr, _entry, _i, _i$1, _r, _r$1, _r$2, _ref, _ref$1, _ref$2, _tuple, check, def$1, e, i, obj, obj$1, obj$2, obj$3, obj$4, obj$5, obj$6, obj$7, obj$8, obj$9, path$1, pkg, prev, scope, typ, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; check = $f.check; def$1 = $f.def$1; e = $f.e; i = $f.i; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; obj$4 = $f.obj$4; obj$5 = $f.obj$5; obj$6 = $f.obj$6; obj$7 = $f.obj$7; obj$8 = $f.obj$8; obj$9 = $f.obj$9; path$1 = $f.path$1; pkg = $f.pkg; prev = $f.prev; scope = $f.scope; typ = $f.typ; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- x.mode = 0;
- x.expr = e;
- _r = check.context.scope.LookupParent(e.Name, check.pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; scope = _tuple[0]; obj = _tuple[1];
- /* */ if ($interfaceIsEqual(obj, $ifaceNil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($interfaceIsEqual(obj, $ifaceNil)) { */ case 2:
- /* */ if (e.Name === "_") { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (e.Name === "_") { */ case 4:
- $r = check.errorf(e.Pos(), "cannot use _ as value or type", new sliceType([])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else { */ case 5:
- $r = check.errorf(e.Pos(), "undeclared name: %s", new sliceType([new $String(e.Name)])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- return;
- /* } */ case 3:
- check.recordUse(e, obj);
- $r = check.objDecl(obj, def$1, path$1); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = obj.Type(); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- typ = _r$1;
- assert(!($interfaceIsEqual(typ, $ifaceNil)));
- _r$2 = obj.Pkg(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- pkg = _r$2;
- /* */ if (!(pkg === check.pkg) && !(pkg === ptrType$1.nil)) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (!(pkg === check.pkg) && !(pkg === ptrType$1.nil)) { */ case 12:
- delete (_entry = check.unusedDotImports[ptrType.keyFor(scope)], _entry !== undefined ? _entry.v : false)[ptrType$1.keyFor(pkg)];
- /* } */ case 13:
- _ref = obj;
- /* */ if ($assertType(_ref, ptrType$18, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$2, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$19, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref, ptrType$6, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref, ptrType$72, true)[1]) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if ($assertType(_ref, ptrType$18, true)[1]) { */ case 14:
- obj$1 = _ref.$val;
- $r = check.errorf(e.Pos(), "use of package %s not in selector", new sliceType([new $String(obj$1.object.name)])); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- $s = 22; continue;
- /* } else if ($assertType(_ref, ptrType$2, true)[1]) { */ case 15:
- obj$2 = _ref.$val;
- check.addDeclDep(obj$2);
- if ($interfaceIsEqual(typ, $pkg.Typ[0])) {
- return;
- }
- /* */ if (obj$2 === universeIota) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (obj$2 === universeIota) { */ case 24:
- /* */ if ($interfaceIsEqual(check.context.iota, $ifaceNil)) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if ($interfaceIsEqual(check.context.iota, $ifaceNil)) { */ case 27:
- $r = check.errorf(e.Pos(), "cannot use iota outside constant declaration", new sliceType([])); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 28:
- x.val = check.context.iota;
- $s = 26; continue;
- /* } else { */ case 25:
- x.val = obj$2.val;
- /* } */ case 26:
- assert(!($interfaceIsEqual(x.val, $ifaceNil)));
- x.mode = 4;
- $s = 22; continue;
- /* } else if ($assertType(_ref, ptrType$19, true)[1]) { */ case 16:
- obj$3 = _ref.$val;
- x.mode = 3;
- _ref$1 = path$1;
- _i = 0;
- /* while (true) { */ case 30:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 31; continue; }
- i = _i;
- prev = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- /* */ if (prev === obj$3) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (prev === obj$3) { */ case 32:
- $r = check.errorf(obj$3.object.pos, "illegal cycle in declaration of %s", new sliceType([new $String(obj$3.object.name)])); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$2 = $subslice(path$1, i);
- _i$1 = 0;
- /* while (true) { */ case 35:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 36; continue; }
- obj$4 = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- $r = check.errorf(obj$4.object.Pos(), "\t%s refers to", new sliceType([new $String(obj$4.object.Name())])); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 35; continue; case 36:
- $r = check.errorf(obj$3.object.Pos(), "\t%s", new sliceType([new $String(obj$3.object.Name())])); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- typ = $pkg.Typ[0];
- /* break; */ $s = 31; continue;
- /* } */ case 33:
- _i++;
- /* } */ $s = 30; continue; case 31:
- $s = 22; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 17:
- obj$5 = _ref.$val;
- if (obj$5.object.pkg === check.pkg) {
- obj$5.used = true;
- }
- check.addDeclDep(obj$5);
- if ($interfaceIsEqual(typ, $pkg.Typ[0])) {
- return;
- }
- x.mode = 5;
- $s = 22; continue;
- /* } else if ($assertType(_ref, ptrType$6, true)[1]) { */ case 18:
- obj$6 = _ref.$val;
- check.addDeclDep(obj$6);
- x.mode = 7;
- $s = 22; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1]) { */ case 19:
- obj$7 = _ref.$val;
- x.id = obj$7.id;
- x.mode = 2;
- $s = 22; continue;
- /* } else if ($assertType(_ref, ptrType$72, true)[1]) { */ case 20:
- obj$8 = _ref.$val;
- x.mode = 7;
- $s = 22; continue;
- /* } else { */ case 21:
- obj$9 = _ref;
- unreachable();
- /* } */ case 22:
- x.typ = typ;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.ident }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f.check = check; $f.def$1 = def$1; $f.e = e; $f.i = i; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.obj$4 = obj$4; $f.obj$5 = obj$5; $f.obj$6 = obj$6; $f.obj$7 = obj$7; $f.obj$8 = obj$8; $f.obj$9 = obj$9; $f.path$1 = path$1; $f.pkg = pkg; $f.prev = prev; $f.scope = scope; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.ident = function(x, e, def$1, path$1) { return this.$val.ident(x, e, def$1, path$1); };
- Checker.ptr.prototype.typExpr = function(e, def$1, path$1) {
- var $ptr, T, _r, _r$1, check, def$1, e, path$1, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; check = $f.check; def$1 = $f.def$1; e = $f.e; path$1 = $f.path$1; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- T = [T];
- check = [check];
- e = [e];
- T[0] = $ifaceNil;
- check[0] = this;
- _r = check[0].typExprInternal(e[0], def$1, path$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- T[0] = _r;
- _r$1 = isTyped(T[0]); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = assert(_r$1); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check[0].recordTypeAndValue(e[0], 3, T[0], $ifaceNil); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return T[0];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return T[0]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.typExpr }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f.check = check; $f.def$1 = def$1; $f.e = e; $f.path$1 = path$1; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Checker.prototype.typExpr = function(e, def$1, path$1) { return this.$val.typExpr(e, def$1, path$1); };
- Checker.ptr.prototype.typ = function(e) {
- var $ptr, _r, check, e, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; check = $f.check; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = check.typExpr(e, ptrType$26.nil, sliceType$11.nil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.typ }; } $f.$ptr = $ptr; $f._r = _r; $f.check = check; $f.e = e; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.typ = function(e) { return this.$val.typ(e); };
- Checker.ptr.prototype.funcType = function(sig, recvPar, ftyp) {
- var $ptr, T, _r, _r$1, _r$2, _r$3, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, check, err, ftyp, params, recv, recvList, recvPar, results, scope, sig, t, u, u$1, variadic, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; T = $f.T; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; check = $f.check; err = $f.err; ftyp = $f.ftyp; params = $f.params; recv = $f.recv; recvList = $f.recvList; recvPar = $f.recvPar; results = $f.results; scope = $f.scope; sig = $f.sig; t = $f.t; u = $f.u; u$1 = $f.u$1; variadic = $f.variadic; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- scope = NewScope(check.context.scope, 0, 0, "function");
- check.recordScope(ftyp, scope);
- _r = check.collectParams(scope, recvPar, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; recvList = _tuple[0];
- _r$1 = check.collectParams(scope, ftyp.Params, true); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; params = _tuple$1[0]; variadic = _tuple$1[1];
- _r$2 = check.collectParams(scope, ftyp.Results, false); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$2 = _r$2; results = _tuple$2[0];
- /* */ if (!(recvPar === ptrType$78.nil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(recvPar === ptrType$78.nil)) { */ case 4:
- recv = ptrType$9.nil;
- _ref = recvList.$length;
- /* */ if (_ref === 0) { $s = 6; continue; }
- /* */ if (_ref === 1) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_ref === 0) { */ case 6:
- _r$3 = recvPar.Pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.error(_r$3, "method is missing receiver"); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- recv = NewParam(0, ptrType$1.nil, "", $pkg.Typ[0]);
- $s = 9; continue;
- /* } else if (_ref === 1) { */ case 7:
- recv = (0 >= recvList.$length ? $throwRuntimeError("index out of range") : recvList.$array[recvList.$offset + 0]);
- $s = 9; continue;
- /* } else { */ case 8:
- $r = check.error((x = recvList.$length - 1 >> 0, ((x < 0 || x >= recvList.$length) ? $throwRuntimeError("index out of range") : recvList.$array[recvList.$offset + x])).object.Pos(), "method must have exactly one receiver"); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- recv = (0 >= recvList.$length ? $throwRuntimeError("index out of range") : recvList.$array[recvList.$offset + 0]);
- /* } */ case 9:
- _tuple$3 = deref(recv.object.typ); t = _tuple$3[0];
- /* */ if (!($interfaceIsEqual(t, $pkg.Typ[0]))) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!($interfaceIsEqual(t, $pkg.Typ[0]))) { */ case 13:
- err = "";
- _tuple$4 = $assertType(t, ptrType$26, true); T = _tuple$4[0];
- if (!(T === ptrType$26.nil)) {
- if (!(T.obj.object.pkg === check.pkg)) {
- err = "type not defined in this package";
- } else {
- _ref$1 = T.underlying;
- if ($assertType(_ref$1, ptrType$3, true)[1]) {
- u = _ref$1.$val;
- if (u.kind === 18) {
- err = "unsafe.Pointer";
- }
- } else if ($assertType(_ref$1, ptrType$15, true)[1] || $assertType(_ref$1, ptrType$53, true)[1]) {
- u$1 = _ref$1;
- err = "pointer or interface type";
- }
- }
- } else {
- err = "basic or unnamed type";
- }
- /* */ if (!(err === "")) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!(err === "")) { */ case 15:
- $r = check.errorf(recv.object.pos, "invalid receiver %s (%s)", new sliceType([recv.object.typ, new $String(err)])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 16:
- /* } */ case 14:
- sig.recv = recv;
- /* } */ case 5:
- sig.scope = scope;
- sig.params = NewTuple(params);
- sig.results = NewTuple(results);
- sig.variadic = variadic;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.funcType }; } $f.$ptr = $ptr; $f.T = T; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.check = check; $f.err = err; $f.ftyp = ftyp; $f.params = params; $f.recv = recv; $f.recvList = recvList; $f.recvPar = recvPar; $f.results = results; $f.scope = scope; $f.sig = sig; $f.t = t; $f.u = u; $f.u$1 = u$1; $f.variadic = variadic; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.funcType = function(sig, recvPar, ftyp) { return this.$val.funcType(sig, recvPar, ftyp); };
- Checker.ptr.prototype.typExprInternal = function(e, def$1, path$1) {
- var $ptr, _r, _r$1, _r$10, _r$11, _r$12, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, check, def$1, dir, e, e$1, e$10, e$11, e$12, e$2, e$3, e$4, e$5, e$6, e$7, e$8, e$9, path$1, typ, typ$1, typ$10, typ$2, typ$3, typ$4, typ$5, typ$6, typ$7, typ$8, typ$9, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; check = $f.check; def$1 = $f.def$1; dir = $f.dir; e = $f.e; e$1 = $f.e$1; e$10 = $f.e$10; e$11 = $f.e$11; e$12 = $f.e$12; e$2 = $f.e$2; e$3 = $f.e$3; e$4 = $f.e$4; e$5 = $f.e$5; e$6 = $f.e$6; e$7 = $f.e$7; e$8 = $f.e$8; e$9 = $f.e$9; path$1 = $f.path$1; typ = $f.typ; typ$1 = $f.typ$1; typ$10 = $f.typ$10; typ$2 = $f.typ$2; typ$3 = $f.typ$3; typ$4 = $f.typ$4; typ$5 = $f.typ$5; typ$6 = $f.typ$6; typ$7 = $f.typ$7; typ$8 = $f.typ$8; typ$9 = $f.typ$9; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = [check];
- e$1 = [e$1];
- typ = [typ];
- x = [x];
- x$1 = [x$1];
- check[0] = this;
- _ref = e;
- /* */ if ($assertType(_ref, ptrType$37, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$14, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$16, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$44, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$45, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$42, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$46, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$47, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$48, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$49, true)[1]) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ($assertType(_ref, ptrType$37, true)[1]) { */ case 1:
- e$2 = _ref.$val;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1]) { */ case 2:
- e$3 = _ref.$val;
- x[0] = $clone(new operand.ptr(), operand);
- $r = check[0].ident(x[0], e$3, def$1, path$1); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$1 = x[0].mode;
- /* */ if (_ref$1 === 3) { $s = 15; continue; }
- /* */ if (_ref$1 === 0) { $s = 16; continue; }
- /* */ if (_ref$1 === 1) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (_ref$1 === 3) { */ case 15:
- typ$1 = x[0].typ;
- def$1.setUnderlying(typ$1);
- return typ$1;
- $s = 19; continue;
- /* } else if (_ref$1 === 0) { */ case 16:
- $s = 19; continue;
- /* } else if (_ref$1 === 1) { */ case 17:
- _r = x[0].pos(); /* */ $s = 20; case 20: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r, "%s used as type", new sliceType([x[0]])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 19; continue;
- /* } else { */ case 18:
- _r$1 = x[0].pos(); /* */ $s = 22; case 22: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$1, "%s is not a type", new sliceType([x[0]])); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 19:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$14, true)[1]) { */ case 3:
- e$4 = _ref.$val;
- x$1[0] = $clone(new operand.ptr(), operand);
- $r = check[0].selector(x$1[0], e$4); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$2 = x$1[0].mode;
- /* */ if (_ref$2 === 3) { $s = 25; continue; }
- /* */ if (_ref$2 === 0) { $s = 26; continue; }
- /* */ if (_ref$2 === 1) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (_ref$2 === 3) { */ case 25:
- typ$2 = x$1[0].typ;
- def$1.setUnderlying(typ$2);
- return typ$2;
- $s = 29; continue;
- /* } else if (_ref$2 === 0) { */ case 26:
- $s = 29; continue;
- /* } else if (_ref$2 === 1) { */ case 27:
- _r$2 = x$1[0].pos(); /* */ $s = 30; case 30: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$2, "%s used as type", new sliceType([x$1[0]])); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 29; continue;
- /* } else { */ case 28:
- _r$3 = x$1[0].pos(); /* */ $s = 32; case 32: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$3, "%s is not a type", new sliceType([x$1[0]])); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 29:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$16, true)[1]) { */ case 4:
- e$5 = _ref.$val;
- _r$4 = check[0].typExpr(e$5.X, def$1, path$1); /* */ $s = 34; case 34: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$44, true)[1]) { */ case 5:
- e$6 = _ref.$val;
- /* */ if (!($interfaceIsEqual(e$6.Len, $ifaceNil))) { $s = 35; continue; }
- /* */ $s = 36; continue;
- /* if (!($interfaceIsEqual(e$6.Len, $ifaceNil))) { */ case 35:
- typ$3 = new Array.ptr();
- def$1.setUnderlying(typ$3);
- _r$5 = check[0].arrayLength(e$6.Len); /* */ $s = 38; case 38: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- typ$3.len = _r$5;
- _r$6 = check[0].typExpr(e$6.Elt, ptrType$26.nil, path$1); /* */ $s = 39; case 39: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- typ$3.elem = _r$6;
- return typ$3;
- $s = 37; continue;
- /* } else { */ case 36:
- typ$4 = new Slice.ptr();
- def$1.setUnderlying(typ$4);
- _r$7 = check[0].typ(e$6.Elt); /* */ $s = 40; case 40: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- typ$4.elem = _r$7;
- return typ$4;
- /* } */ case 37:
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$45, true)[1]) { */ case 6:
- e$7 = _ref.$val;
- typ$5 = new Struct.ptr();
- def$1.setUnderlying(typ$5);
- $r = check[0].structType(typ$5, e$7, path$1); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return typ$5;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$42, true)[1]) { */ case 7:
- e$8 = _ref.$val;
- typ$6 = new Pointer.ptr();
- def$1.setUnderlying(typ$6);
- _r$8 = check[0].typ(e$8.X); /* */ $s = 42; case 42: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- typ$6.base = _r$8;
- return typ$6;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$46, true)[1]) { */ case 8:
- e$9 = _ref.$val;
- typ$7 = new Signature.ptr();
- def$1.setUnderlying(typ$7);
- $r = check[0].funcType(typ$7, ptrType$78.nil, e$9); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return typ$7;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$47, true)[1]) { */ case 9:
- e$10 = _ref.$val;
- typ$8 = new Interface.ptr();
- def$1.setUnderlying(typ$8);
- $r = check[0].interfaceType(typ$8, e$10, def$1, path$1); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return typ$8;
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$48, true)[1]) { */ case 10:
- e$1[0] = _ref.$val;
- typ[0] = new Map.ptr();
- def$1.setUnderlying(typ[0]);
- _r$9 = check[0].typ(e$1[0].Key); /* */ $s = 45; case 45: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- typ[0].key = _r$9;
- _r$10 = check[0].typ(e$1[0].Value); /* */ $s = 46; case 46: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- typ[0].elem = _r$10;
- check[0].delay((function(check, e$1, typ, x, x$1) { return function $b() {
- var $ptr, _r$11, _r$12, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$11 = $f._r$11; _r$12 = $f._r$12; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$11 = Comparable(typ[0].key); /* */ $s = 3; case 3: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- /* */ if (!_r$11) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!_r$11) { */ case 1:
- _r$12 = e$1[0].Key.Pos(); /* */ $s = 4; case 4: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$12, "invalid map key type %s", new sliceType([typ[0].key])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$11 = _r$11; $f._r$12 = _r$12; $f.$s = $s; $f.$r = $r; return $f;
- }; })(check, e$1, typ, x, x$1));
- return typ[0];
- $s = 13; continue;
- /* } else if ($assertType(_ref, ptrType$49, true)[1]) { */ case 11:
- e$11 = _ref.$val;
- typ$9 = new Chan.ptr();
- def$1.setUnderlying(typ$9);
- dir = 0;
- _ref$3 = e$11.Dir;
- /* */ if (_ref$3 === 3) { $s = 47; continue; }
- /* */ if (_ref$3 === 1) { $s = 48; continue; }
- /* */ if (_ref$3 === 2) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (_ref$3 === 3) { */ case 47:
- $s = 51; continue;
- /* } else if (_ref$3 === 1) { */ case 48:
- dir = 1;
- $s = 51; continue;
- /* } else if (_ref$3 === 2) { */ case 49:
- dir = 2;
- $s = 51; continue;
- /* } else { */ case 50:
- $r = check[0].invalidAST(e$11.Pos(), "unknown channel direction %d", new sliceType([new ast.ChanDir(e$11.Dir)])); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 51:
- typ$9.dir = dir;
- _r$11 = check[0].typ(e$11.Value); /* */ $s = 53; case 53: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- typ$9.elem = _r$11;
- return typ$9;
- $s = 13; continue;
- /* } else { */ case 12:
- e$12 = _ref;
- _r$12 = e$12.Pos(); /* */ $s = 54; case 54: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- $r = check[0].errorf(_r$12, "%s is not a type", new sliceType([e$12])); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 13:
- typ$10 = $pkg.Typ[0];
- def$1.setUnderlying(typ$10);
- return typ$10;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.typExprInternal }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f.check = check; $f.def$1 = def$1; $f.dir = dir; $f.e = e; $f.e$1 = e$1; $f.e$10 = e$10; $f.e$11 = e$11; $f.e$12 = e$12; $f.e$2 = e$2; $f.e$3 = e$3; $f.e$4 = e$4; $f.e$5 = e$5; $f.e$6 = e$6; $f.e$7 = e$7; $f.e$8 = e$8; $f.e$9 = e$9; $f.path$1 = path$1; $f.typ = typ; $f.typ$1 = typ$1; $f.typ$10 = typ$10; $f.typ$2 = typ$2; $f.typ$3 = typ$3; $f.typ$4 = typ$4; $f.typ$5 = typ$5; $f.typ$6 = typ$6; $f.typ$7 = typ$7; $f.typ$8 = typ$8; $f.typ$9 = typ$9; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.typExprInternal = function(e, def$1, path$1) { return this.$val.typExprInternal(e, def$1, path$1); };
- Checker.ptr.prototype.typOrNil = function(e) {
- var $ptr, _r, _r$1, _r$2, _r$3, _ref, check, e, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; check = $f.check; e = $f.e; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- check = this;
- x[0] = $clone(new operand.ptr(), operand);
- _r = check.rawExpr(x[0], e, $ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- _ref = x[0].mode;
- /* */ if (_ref === 0) { $s = 2; continue; }
- /* */ if (_ref === 1) { $s = 3; continue; }
- /* */ if (_ref === 3) { $s = 4; continue; }
- /* */ if (_ref === 7) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref === 0) { */ case 2:
- $s = 7; continue;
- /* } else if (_ref === 1) { */ case 3:
- _r$1 = x[0].pos(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = check.errorf(_r$1, "%s used as type", new sliceType([x[0]])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 7; continue;
- /* } else if (_ref === 3) { */ case 4:
- return x[0].typ;
- $s = 7; continue;
- /* } else if (_ref === 7) { */ case 5:
- if (x[0].isNil()) {
- return $ifaceNil;
- }
- _r$2 = x[0].pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.errorf(_r$2, "%s is not a type", new sliceType([x[0]])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 7; continue;
- /* } else { */ case 6:
- _r$3 = x[0].pos(); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = check.errorf(_r$3, "%s is not a type", new sliceType([x[0]])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- return $pkg.Typ[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.typOrNil }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f.check = check; $f.e = e; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.typOrNil = function(e) { return this.$val.typOrNil(e); };
- Checker.ptr.prototype.arrayLength = function(e) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _tuple, check, e, n, ok, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _tuple = $f._tuple; check = $f.check; e = $f.e; n = $f.n; ok = $f.ok; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- x = [x];
- check = this;
- x[0] = $clone(new operand.ptr(), operand);
- $r = check.expr(x[0], e); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!((x[0].mode === 4))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((x[0].mode === 4))) { */ case 2:
- /* */ if (!((x[0].mode === 0))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!((x[0].mode === 0))) { */ case 4:
- _r = x[0].pos(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.errorf(_r, "array length %s must be constant", new sliceType([x[0]])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- return new $Int64(0, 0);
- /* } */ case 3:
- _r$1 = x[0].isInteger(); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!_r$1) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!_r$1) { */ case 8:
- _r$2 = x[0].pos(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = check.errorf(_r$2, "array length %s must be integer", new sliceType([x[0]])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new $Int64(0, 0);
- /* } */ case 9:
- _r$3 = exact.Int64Val(x[0].val); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; n = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok || (n.$high < 0 || (n.$high === 0 && n.$low < 0))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!ok || (n.$high < 0 || (n.$high === 0 && n.$low < 0))) { */ case 14:
- _r$4 = x[0].pos(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.errorf(_r$4, "invalid array length %s", new sliceType([x[0]])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return new $Int64(0, 0);
- /* } */ case 15:
- return n;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.arrayLength }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._tuple = _tuple; $f.check = check; $f.e = e; $f.n = n; $f.ok = ok; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.arrayLength = function(e) { return this.$val.arrayLength(e); };
- Checker.ptr.prototype.collectParams = function(scope, list, variadicOk) {
- var $ptr, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _tmp, _tmp$1, _tuple, anonymous, check, field, ftype, i, last, list, name, named, par, par$1, params, scope, t, typ, variadic, variadicOk, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; anonymous = $f.anonymous; check = $f.check; field = $f.field; ftype = $f.ftype; i = $f.i; last = $f.last; list = $f.list; name = $f.name; named = $f.named; par = $f.par; par$1 = $f.par$1; params = $f.params; scope = $f.scope; t = $f.t; typ = $f.typ; variadic = $f.variadic; variadicOk = $f.variadicOk; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- params = sliceType$1.nil;
- variadic = false;
- check = this;
- if (list === ptrType$78.nil) {
- return [params, variadic];
- }
- _tmp = false; _tmp$1 = false; named = _tmp; anonymous = _tmp$1;
- _ref = list.List;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- field = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ftype = field.Type;
- _tuple = $assertType(ftype, ptrType$54, true); t = _tuple[0];
- /* */ if (!(t === ptrType$54.nil)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(t === ptrType$54.nil)) { */ case 3:
- ftype = t.Elt;
- /* */ if (variadicOk && (i === (list.List.$length - 1 >> 0))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (variadicOk && (i === (list.List.$length - 1 >> 0))) { */ case 5:
- variadic = true;
- $s = 7; continue;
- /* } else { */ case 6:
- _r = field.Pos(); /* */ $s = 8; case 8: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r, "... not permitted", new sliceType([])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- /* } */ case 4:
- _r$1 = check.typ(ftype); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- typ = _r$1;
- /* */ if (field.Names.$length > 0) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (field.Names.$length > 0) { */ case 11:
- _ref$1 = field.Names;
- _i$1 = 0;
- /* while (true) { */ case 14:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 15; continue; }
- name = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- /* */ if (name.Name === "") { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (name.Name === "") { */ case 16:
- $r = check.invalidAST(name.Pos(), "anonymous parameter", new sliceType([])); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 17:
- par = NewParam(name.Pos(), check.pkg, name.Name, typ);
- $r = check.declare(scope, name, par, scope.pos); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- params = $append(params, par);
- _i$1++;
- /* } */ $s = 14; continue; case 15:
- named = true;
- $s = 13; continue;
- /* } else { */ case 12:
- _r$2 = ftype.Pos(); /* */ $s = 20; case 20: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = NewParam(_r$2, check.pkg, "", typ); /* */ $s = 21; case 21: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- par$1 = _r$3;
- check.recordImplicit(field, par$1);
- params = $append(params, par$1);
- anonymous = true;
- /* } */ case 13:
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ if (named && anonymous) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (named && anonymous) { */ case 22:
- _r$4 = list.Pos(); /* */ $s = 24; case 24: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$4, "list contains both named and anonymous parameters", new sliceType([])); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 23:
- if (variadic && params.$length > 0) {
- last = (x = params.$length - 1 >> 0, ((x < 0 || x >= params.$length) ? $throwRuntimeError("index out of range") : params.$array[params.$offset + x]));
- last.object.typ = new Slice.ptr(last.object.typ);
- }
- return [params, variadic];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.collectParams }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.anonymous = anonymous; $f.check = check; $f.field = field; $f.ftype = ftype; $f.i = i; $f.last = last; $f.list = list; $f.name = name; $f.named = named; $f.par = par; $f.par$1 = par$1; $f.params = params; $f.scope = scope; $f.t = t; $f.typ = typ; $f.variadic = variadic; $f.variadicOk = variadicOk; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.collectParams = function(scope, list, variadicOk) { return this.$val.collectParams(scope, list, variadicOk); };
- Checker.ptr.prototype.declareInSet = function(oset, pos, obj) {
- var $ptr, _arg, _arg$1, _r, _r$1, alt, check, obj, oset, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; alt = $f.alt; check = $f.check; obj = $f.obj; oset = $f.oset; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- _r = oset.insert(obj); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- alt = _r;
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil))) { */ case 2:
- _arg = pos;
- _r$1 = obj.Name(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$1);
- $r = check.errorf(_arg, "%s redeclared", new sliceType([_arg$1])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = check.reportAltDecl(alt); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return false;
- /* } */ case 3:
- return true;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.declareInSet }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f.alt = alt; $f.check = check; $f.obj = obj; $f.oset = oset; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.declareInSet = function(oset, pos, obj) { return this.$val.declareInSet(oset, pos, obj); };
- Checker.ptr.prototype.interfaceType = function(iface, ityp, def$1, path$1) {
- var $ptr, _i, _i$1, _i$2, _i$3, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, _ref$1, _ref$2, _ref$3, _tuple, _tuple$1, _tuple$2, check, def$1, e, embed, embedded, expr, f, i, iface, ityp, m, m$1, m$2, mset, name, named, old, path$1, pos, pos$1, recvTyp, sig, sig$1, signatures, typ, typ$1, under, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; check = $f.check; def$1 = $f.def$1; e = $f.e; embed = $f.embed; embedded = $f.embedded; expr = $f.expr; f = $f.f; i = $f.i; iface = $f.iface; ityp = $f.ityp; m = $f.m; m$1 = $f.m$1; m$2 = $f.m$2; mset = $f.mset; name = $f.name; named = $f.named; old = $f.old; path$1 = $f.path$1; pos = $f.pos; pos$1 = $f.pos$1; recvTyp = $f.recvTyp; sig = $f.sig; sig$1 = $f.sig$1; signatures = $f.signatures; typ = $f.typ; typ$1 = $f.typ$1; under = $f.under; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- mset = [mset];
- check = this;
- if (ityp.Methods === ptrType$78.nil) {
- return;
- }
- recvTyp = iface;
- if (!(def$1 === ptrType$26.nil)) {
- recvTyp = def$1;
- }
- mset[0] = false;
- signatures = sliceType$5.nil;
- embedded = sliceType$5.nil;
- _ref = ityp.Methods.List;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (f.Names.$length > 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (f.Names.$length > 0) { */ case 3:
- name = (x = f.Names, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]));
- pos = name.Pos();
- /* */ if (name.Name === "_") { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (name.Name === "_") { */ case 6:
- $r = check.errorf(pos, "invalid method name _", new sliceType([])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 7:
- sig = new Signature.ptr();
- sig.recv = NewVar(pos, check.pkg, "", recvTyp);
- m = NewFunc(pos, check.pkg, name.Name, sig);
- _r = check.declareInSet((mset.$ptr || (mset.$ptr = new ptrType$28(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, mset))), pos, m); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_r) { */ case 9:
- iface.methods = $append(iface.methods, m);
- iface.allMethods = $append(iface.allMethods, m);
- signatures = $append(signatures, f.Type);
- check.recordDef(name, m);
- /* } */ case 10:
- $s = 5; continue;
- /* } else { */ case 4:
- embedded = $append(embedded, f.Type);
- /* } */ case 5:
- _i++;
- /* } */ $s = 1; continue; case 2:
- _ref$1 = embedded;
- _i$1 = 0;
- /* while (true) { */ case 12:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 13; continue; }
- e = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _r$1 = e.Pos(); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos$1 = _r$1;
- _r$2 = check.typExpr(e, ptrType$26.nil, path$1); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- typ = _r$2;
- _tuple = $assertType(typ, ptrType$26, true); named = _tuple[0];
- under = underlying(named);
- _tuple$1 = $assertType(under, ptrType$53, true); embed = _tuple$1[0];
- /* */ if (embed === ptrType$53.nil) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (embed === ptrType$53.nil) { */ case 16:
- /* */ if (!($interfaceIsEqual(typ, $pkg.Typ[0]))) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!($interfaceIsEqual(typ, $pkg.Typ[0]))) { */ case 18:
- $r = check.errorf(pos$1, "%s is not an interface", new sliceType([typ])); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 19:
- _i$1++;
- /* continue; */ $s = 12; continue;
- /* } */ case 17:
- iface.embeddeds = $append(iface.embeddeds, named);
- _ref$2 = embed.allMethods;
- _i$2 = 0;
- /* while (true) { */ case 21:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 22; continue; }
- m$1 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- _r$3 = check.declareInSet((mset.$ptr || (mset.$ptr = new ptrType$28(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, mset))), pos$1, m$1); /* */ $s = 25; case 25: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_r$3) { */ case 23:
- iface.allMethods = $append(iface.allMethods, m$1);
- /* } */ case 24:
- _i$2++;
- /* } */ $s = 21; continue; case 22:
- _i$1++;
- /* } */ $s = 12; continue; case 13:
- _ref$3 = iface.methods;
- _i$3 = 0;
- /* while (true) { */ case 26:
- /* if (!(_i$3 < _ref$3.$length)) { break; } */ if(!(_i$3 < _ref$3.$length)) { $s = 27; continue; }
- i = _i$3;
- m$2 = ((_i$3 < 0 || _i$3 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$3]);
- expr = ((i < 0 || i >= signatures.$length) ? $throwRuntimeError("index out of range") : signatures.$array[signatures.$offset + i]);
- _r$4 = check.typ(expr); /* */ $s = 28; case 28: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- typ$1 = _r$4;
- _tuple$2 = $assertType(typ$1, ptrType$17, true); sig$1 = _tuple$2[0];
- /* */ if (sig$1 === ptrType$17.nil) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (sig$1 === ptrType$17.nil) { */ case 29:
- /* */ if (!($interfaceIsEqual(typ$1, $pkg.Typ[0]))) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (!($interfaceIsEqual(typ$1, $pkg.Typ[0]))) { */ case 31:
- _r$5 = expr.Pos(); /* */ $s = 33; case 33: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = check.invalidAST(_r$5, "%s is not a method signature", new sliceType([typ$1])); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 32:
- _i$3++;
- /* continue; */ $s = 26; continue;
- /* } */ case 30:
- old = $assertType(m$2.object.typ, ptrType$17);
- sig$1.recv = old.recv;
- $copy(old, sig$1, Signature);
- _i$3++;
- /* } */ $s = 26; continue; case 27:
- $r = sort.Sort((x$1 = iface.methods, $subslice(new byUniqueMethodName(x$1.$array), x$1.$offset, x$1.$offset + x$1.$length))); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.Sort((x$2 = iface.embeddeds, $subslice(new byUniqueTypeName(x$2.$array), x$2.$offset, x$2.$offset + x$2.$length))); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.Sort((x$3 = iface.allMethods, $subslice(new byUniqueMethodName(x$3.$array), x$3.$offset, x$3.$offset + x$3.$length))); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.interfaceType }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.check = check; $f.def$1 = def$1; $f.e = e; $f.embed = embed; $f.embedded = embedded; $f.expr = expr; $f.f = f; $f.i = i; $f.iface = iface; $f.ityp = ityp; $f.m = m; $f.m$1 = m$1; $f.m$2 = m$2; $f.mset = mset; $f.name = name; $f.named = named; $f.old = old; $f.path$1 = path$1; $f.pos = pos; $f.pos$1 = pos$1; $f.recvTyp = recvTyp; $f.sig = sig; $f.sig$1 = sig$1; $f.signatures = signatures; $f.typ = typ; $f.typ$1 = typ$1; $f.under = under; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.interfaceType = function(iface, ityp, def$1, path$1) { return this.$val.interfaceType(iface, ityp, def$1, path$1); };
- byUniqueTypeName.prototype.Len = function() {
- var $ptr, a;
- a = this;
- return a.$length;
- };
- $ptrType(byUniqueTypeName).prototype.Len = function() { return this.$get().Len(); };
- byUniqueTypeName.prototype.Less = function(i, j) {
- var $ptr, a, i, j;
- a = this;
- return ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]).obj.object.Id() < ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]).obj.object.Id();
- };
- $ptrType(byUniqueTypeName).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- byUniqueTypeName.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, a, i, j;
- a = this;
- _tmp = ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]); _tmp$1 = ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]); ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = _tmp); ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j] = _tmp$1);
- };
- $ptrType(byUniqueTypeName).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- byUniqueMethodName.prototype.Len = function() {
- var $ptr, a;
- a = this;
- return a.$length;
- };
- $ptrType(byUniqueMethodName).prototype.Len = function() { return this.$get().Len(); };
- byUniqueMethodName.prototype.Less = function(i, j) {
- var $ptr, a, i, j;
- a = this;
- return ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]).object.Id() < ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]).object.Id();
- };
- $ptrType(byUniqueMethodName).prototype.Less = function(i, j) { return this.$get().Less(i, j); };
- byUniqueMethodName.prototype.Swap = function(i, j) {
- var $ptr, _tmp, _tmp$1, a, i, j;
- a = this;
- _tmp = ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j]); _tmp$1 = ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i]); ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = _tmp); ((j < 0 || j >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + j] = _tmp$1);
- };
- $ptrType(byUniqueMethodName).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); };
- Checker.ptr.prototype.tag = function(t) {
- var $ptr, _tuple, check, err, t, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _tuple = $f._tuple; check = $f.check; err = $f.err; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = this;
- /* */ if (!(t === ptrType$51.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(t === ptrType$51.nil)) { */ case 1:
- if (t.Kind === 9) {
- _tuple = strconv.Unquote(t.Value); val = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- return val;
- }
- }
- $r = check.invalidAST(t.Pos(), "incorrect tag syntax: %q", new sliceType([new $String(t.Value)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- return "";
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.tag }; } $f.$ptr = $ptr; $f._tuple = _tuple; $f.check = check; $f.err = err; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.tag = function(t) { return this.$val.tag(t); };
- Checker.ptr.prototype.structType = function(styp, e, path$1) {
- var $ptr, _i, _i$1, _r, _r$1, _r$2, _ref, _ref$1, _ref$2, _ref$3, _tuple, add, check, e, f, fields, fset, isPtr, list, name, name$1, path$1, pos, styp, t, t$1, t$2, t$3, tag, tags, typ, u, u$1, u$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; add = $f.add; check = $f.check; e = $f.e; f = $f.f; fields = $f.fields; fset = $f.fset; isPtr = $f.isPtr; list = $f.list; name = $f.name; name$1 = $f.name$1; path$1 = $f.path$1; pos = $f.pos; styp = $f.styp; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; tag = $f.tag; tags = $f.tags; typ = $f.typ; u = $f.u; u$1 = $f.u$1; u$2 = $f.u$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- check = [check];
- fields = [fields];
- fset = [fset];
- tag = [tag];
- tags = [tags];
- typ = [typ];
- check[0] = this;
- list = e.Fields;
- if (list === ptrType$78.nil) {
- return;
- }
- fields[0] = sliceType$1.nil;
- tags[0] = sliceType$21.nil;
- fset[0] = false;
- typ[0] = $ifaceNil;
- tag[0] = "";
- add = (function(check, fields, fset, tag, tags, typ) { return function $b(field, ident, anonymous, pos) {
- var $ptr, _r, _v, anonymous, field, fld, ident, name, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _v = $f._v; anonymous = $f.anonymous; field = $f.field; fld = $f.fld; ident = $f.ident; name = $f.name; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (!(tag[0] === "") && tags[0] === sliceType$21.nil) {
- tags[0] = $makeSlice(sliceType$21, fields[0].$length);
- }
- if (!(tags[0] === sliceType$21.nil)) {
- tags[0] = $append(tags[0], tag[0]);
- }
- name = ident.Name;
- fld = NewField(pos, check[0].pkg, name, typ[0], !(anonymous === ptrType$19.nil));
- if (name === "_") { _v = true; $s = 3; continue s; }
- _r = check[0].declareInSet((fset.$ptr || (fset.$ptr = new ptrType$28(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, fset))), pos, fld); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r; case 3:
- /* */ if (_v) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v) { */ case 1:
- fields[0] = $append(fields[0], fld);
- check[0].recordDef(ident, fld);
- /* } */ case 2:
- if (!(anonymous === ptrType$19.nil)) {
- check[0].recordUse(ident, anonymous);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f._v = _v; $f.anonymous = anonymous; $f.field = field; $f.fld = fld; $f.ident = ident; $f.name = name; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- }; })(check, fields, fset, tag, tags, typ);
- _ref = list.List;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- f = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = check[0].typExpr(f.Type, ptrType$26.nil, path$1); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typ[0] = _r;
- _r$1 = check[0].tag(f.Tag); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- tag[0] = _r$1;
- /* */ if (f.Names.$length > 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (f.Names.$length > 0) { */ case 5:
- _ref$1 = f.Names;
- _i$1 = 0;
- /* while (true) { */ case 8:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 9; continue; }
- name = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- $r = add(f, name, ptrType$19.nil, name.Pos()); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 8; continue; case 9:
- $s = 7; continue;
- /* } else { */ case 6:
- name$1 = anonymousFieldIdent(f.Type);
- _r$2 = f.Type.Pos(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- pos = _r$2;
- _tuple = deref(typ[0]); t = _tuple[0]; isPtr = _tuple[1];
- _ref$2 = t;
- /* */ if ($assertType(_ref$2, ptrType$3, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref$2, ptrType$26, true)[1]) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if ($assertType(_ref$2, ptrType$3, true)[1]) { */ case 12:
- t$1 = _ref$2.$val;
- /* */ if (t$1 === $pkg.Typ[0]) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (t$1 === $pkg.Typ[0]) { */ case 16:
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 17:
- /* */ if (t$1.kind === 18) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (t$1.kind === 18) { */ case 18:
- $r = check[0].errorf(pos, "anonymous field type cannot be unsafe.Pointer", new sliceType([])); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 19:
- $r = add(f, name$1, $assertType($pkg.Universe.Lookup(t$1.name), ptrType$19), pos); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 15; continue;
- /* } else if ($assertType(_ref$2, ptrType$26, true)[1]) { */ case 13:
- t$2 = _ref$2.$val;
- _ref$3 = t$2.underlying;
- /* */ if ($assertType(_ref$3, ptrType$3, true)[1]) { $s = 22; continue; }
- /* */ if ($assertType(_ref$3, ptrType$15, true)[1]) { $s = 23; continue; }
- /* */ if ($assertType(_ref$3, ptrType$53, true)[1]) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if ($assertType(_ref$3, ptrType$3, true)[1]) { */ case 22:
- u = _ref$3.$val;
- /* */ if (u.kind === 18) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (u.kind === 18) { */ case 26:
- $r = check[0].errorf(pos, "anonymous field type cannot be unsafe.Pointer", new sliceType([])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 27:
- $s = 25; continue;
- /* } else if ($assertType(_ref$3, ptrType$15, true)[1]) { */ case 23:
- u$1 = _ref$3.$val;
- $r = check[0].errorf(pos, "anonymous field type cannot be a pointer", new sliceType([])); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 1; continue;
- $s = 25; continue;
- /* } else if ($assertType(_ref$3, ptrType$53, true)[1]) { */ case 24:
- u$2 = _ref$3.$val;
- /* */ if (isPtr) { $s = 30; continue; }
- /* */ $s = 31; continue;
- /* if (isPtr) { */ case 30:
- $r = check[0].errorf(pos, "anonymous field type cannot be a pointer to an interface", new sliceType([])); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 31:
- /* } */ case 25:
- $r = add(f, name$1, t$2.obj, pos); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 15; continue;
- /* } else { */ case 14:
- t$3 = _ref$2;
- $r = check[0].invalidAST(pos, "anonymous field type %s must be named", new sliceType([typ[0]])); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- /* } */ case 7:
- _i++;
- /* } */ $s = 1; continue; case 2:
- styp.fields = fields[0];
- styp.tags = tags[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Checker.ptr.prototype.structType }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f.add = add; $f.check = check; $f.e = e; $f.f = f; $f.fields = fields; $f.fset = fset; $f.isPtr = isPtr; $f.list = list; $f.name = name; $f.name$1 = name$1; $f.path$1 = path$1; $f.pos = pos; $f.styp = styp; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.tag = tag; $f.tags = tags; $f.typ = typ; $f.u = u; $f.u$1 = u$1; $f.u$2 = u$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- Checker.prototype.structType = function(styp, e, path$1) { return this.$val.structType(styp, e, path$1); };
- anonymousFieldIdent = function(e) {
- var $ptr, _ref, e, e$1, e$2, e$3;
- _ref = e;
- if ($assertType(_ref, ptrType$5, true)[1]) {
- e$1 = _ref.$val;
- return e$1;
- } else if ($assertType(_ref, ptrType$42, true)[1]) {
- e$2 = _ref.$val;
- return anonymousFieldIdent(e$2.X);
- } else if ($assertType(_ref, ptrType$14, true)[1]) {
- e$3 = _ref.$val;
- return e$3.Sel;
- }
- return ptrType$5.nil;
- };
- defPredeclaredTypes = function() {
- var $ptr, _i, _i$1, _r, _r$1, _ref, _ref$1, err, res, sig, t, t$1, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; err = $f.err; res = $f.res; sig = $f.sig; t = $f.t; t$1 = $f.t$1; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = $pkg.Typ;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < 26)) { break; } */ if(!(_i < 26)) { $s = 2; continue; }
- t = ((_i < 0 || _i >= _ref.length) ? $throwRuntimeError("index out of range") : _ref[_i]);
- $r = def(NewTypeName(0, ptrType$1.nil, t.name, t)); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- _ref$1 = aliases;
- _i$1 = 0;
- /* while (true) { */ case 4:
- /* if (!(_i$1 < 2)) { break; } */ if(!(_i$1 < 2)) { $s = 5; continue; }
- t$1 = ((_i$1 < 0 || _i$1 >= _ref$1.length) ? $throwRuntimeError("index out of range") : _ref$1[_i$1]);
- $r = def(NewTypeName(0, ptrType$1.nil, t$1.name, t$1)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 4; continue; case 5:
- res = NewVar(0, ptrType$1.nil, "", $pkg.Typ[17]);
- sig = new Signature.ptr(ptrType.nil, ptrType$9.nil, ptrType$8.nil, NewTuple(new sliceType$1([res])), false);
- err = NewFunc(0, ptrType$1.nil, "Error", sig);
- _r = NewInterface(new sliceType$7([err]), sliceType$22.nil); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.Complete(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- typ = new Named.ptr(ptrType$19.nil, _r$1, sliceType$7.nil);
- sig.recv = NewVar(0, ptrType$1.nil, "", typ);
- $r = def(NewTypeName(0, ptrType$1.nil, "error", typ)); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: defPredeclaredTypes }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f.err = err; $f.res = res; $f.sig = sig; $f.t = t; $f.t$1 = t$1; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- defPredeclaredConsts = function() {
- var $ptr, _i, _ref, c, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; c = $f.c; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = predeclaredConsts;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < 3)) { break; } */ if(!(_i < 3)) { $s = 2; continue; }
- c = $clone(((_i < 0 || _i >= _ref.length) ? $throwRuntimeError("index out of range") : _ref[_i]), structType);
- $r = def(NewConst(0, ptrType$1.nil, c.name, (x = c.kind, ((x < 0 || x >= $pkg.Typ.length) ? $throwRuntimeError("index out of range") : $pkg.Typ[x])), c.val)); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: defPredeclaredConsts }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.c = c; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- defPredeclaredNil = function() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = def(new Nil.ptr(new object.ptr(ptrType.nil, 0, ptrType$1.nil, "nil", $pkg.Typ[25], 0, 0))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: defPredeclaredNil }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- };
- defPredeclaredFuncs = function() {
- var $ptr, _i, _ref, i, id, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; i = $f.i; id = $f.id; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = predeclaredFuncs;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < 20)) { break; } */ if(!(_i < 20)) { $s = 2; continue; }
- i = _i;
- id = (i >> 0);
- /* */ if ((id === 18) || (id === 19)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ((id === 18) || (id === 19)) { */ case 3:
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 4:
- $r = def(newBuiltin(id)); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: defPredeclaredFuncs }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.i = i; $f.id = id; $f.$s = $s; $f.$r = $r; return $f;
- };
- init = function() {
- var $ptr, _r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $pkg.Universe = NewScope(ptrType.nil, 0, 0, "universe");
- _r = NewPackage("unsafe", "unsafe"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $pkg.Unsafe = _r;
- $pkg.Unsafe.complete = true;
- $r = defPredeclaredTypes(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = defPredeclaredConsts(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = defPredeclaredNil(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = defPredeclaredFuncs(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- universeIota = $assertType($pkg.Universe.Lookup("iota"), ptrType$2);
- $pkg.UniverseByte = $assertType($assertType($pkg.Universe.Lookup("byte"), ptrType$19).object.typ, ptrType$3);
- $pkg.UniverseRune = $assertType($assertType($pkg.Universe.Lookup("rune"), ptrType$19).object.typ, ptrType$3);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: init }; } $f.$ptr = $ptr; $f._r = _r; $f.$s = $s; $f.$r = $r; return $f;
- };
- def = function(obj) {
- var $ptr, _r, _r$1, _r$2, _r$3, _ref, _tuple, name, obj, obj$1, obj$2, obj$3, ok, scope, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _tuple = $f._tuple; name = $f.name; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; ok = $f.ok; scope = $f.scope; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = obj.Name(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- name = _r;
- if (strings.Index(name, " ") >= 0) {
- return;
- }
- _r$1 = obj.Type(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$1, ptrType$26, true); typ = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (ok) { */ case 3:
- typ.obj = $assertType(obj, ptrType$19);
- /* } */ case 4:
- scope = $pkg.Universe;
- _r$2 = obj.Exported(); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_r$2) { */ case 5:
- scope = $pkg.Unsafe.scope;
- _ref = obj;
- if ($assertType(_ref, ptrType$19, true)[1]) {
- obj$1 = _ref.$val;
- obj$1.object.pkg = $pkg.Unsafe;
- } else if ($assertType(_ref, ptrType$20, true)[1]) {
- obj$2 = _ref.$val;
- obj$2.object.pkg = $pkg.Unsafe;
- } else {
- obj$3 = _ref;
- unreachable();
- }
- /* } */ case 6:
- _r$3 = scope.Insert(obj); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(_r$3, $ifaceNil))) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!($interfaceIsEqual(_r$3, $ifaceNil))) { */ case 8:
- $panic(new $String("internal error: double declaration"));
- /* } */ case 9:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: def }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._tuple = _tuple; $f.name = name; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.ok = ok; $f.scope = scope; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- Error.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$7.methods = [{prop: "Check", name: "Check", pkg: "", typ: $funcType([$String, ptrType$22, sliceType$8, ptrType$4], [ptrType$1, $error], false)}, {prop: "alignof", name: "alignof", pkg: "golang.org/x/tools/go/types", typ: $funcType([Type], [$Int64], false)}, {prop: "offsetsof", name: "offsetsof", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$27], [sliceType$4], false)}, {prop: "offsetof", name: "offsetof", pkg: "golang.org/x/tools/go/types", typ: $funcType([Type, sliceType$6], [$Int64], false)}, {prop: "sizeof", name: "sizeof", pkg: "golang.org/x/tools/go/types", typ: $funcType([Type], [$Int64], false)}];
- ptrType$4.methods = [{prop: "TypeOf", name: "TypeOf", pkg: "", typ: $funcType([ast.Expr], [Type], false)}, {prop: "ObjectOf", name: "ObjectOf", pkg: "", typ: $funcType([ptrType$5], [Object], false)}];
- TypeAndValue.methods = [{prop: "IsVoid", name: "IsVoid", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsType", name: "IsType", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsBuiltin", name: "IsBuiltin", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsValue", name: "IsValue", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsNil", name: "IsNil", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Addressable", name: "Addressable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Assignable", name: "Assignable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "HasOk", name: "HasOk", pkg: "", typ: $funcType([], [$Bool], false)}];
- ptrType$88.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$89.methods = [{prop: "assignment", name: "assignment", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, Type], [$Bool], false)}, {prop: "initConst", name: "initConst", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$2, ptrType$34], [], false)}, {prop: "initVar", name: "initVar", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$9, ptrType$34, $Bool], [Type], false)}, {prop: "assignVar", name: "assignVar", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, ptrType$34], [Type], false)}, {prop: "initVars", name: "initVars", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$1, sliceType$5, token.Pos], [], false)}, {prop: "assignVars", name: "assignVars", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$5, sliceType$5], [], false)}, {prop: "shortVarDecl", name: "shortVarDecl", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, sliceType$5, sliceType$5], [], false)}, {prop: "builtin", name: "builtin", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$50, builtinId], [$Bool], false)}, {prop: "complexArg", name: "complexArg", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34], [$Bool], false)}, {prop: "call", name: "call", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$50], [exprKind], false)}, {prop: "use", name: "use", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$5], [], true)}, {prop: "useGetter", name: "useGetter", pkg: "golang.org/x/tools/go/types", typ: $funcType([getter, $Int], [], false)}, {prop: "arguments$", name: "arguments", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$50, ptrType$17, getter, $Int], [], false)}, {prop: "argument", name: "argument", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$17, $Int, ptrType$34, token.Pos], [], false)}, {prop: "selector", name: "selector", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$14], [], false)}, {prop: "addUnusedDotImport", name: "addUnusedDotImport", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType, ptrType$1, token.Pos], [], false)}, {prop: "addDeclDep", name: "addDeclDep", pkg: "golang.org/x/tools/go/types", typ: $funcType([Object], [], false)}, {prop: "assocMethod", name: "assocMethod", pkg: "golang.org/x/tools/go/types", typ: $funcType([$String, ptrType$6], [], false)}, {prop: "rememberUntyped", name: "rememberUntyped", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, $Bool, operandMode, ptrType$3, exact.Value], [], false)}, {prop: "later", name: "later", pkg: "golang.org/x/tools/go/types", typ: $funcType([$String, ptrType$21, ptrType$17, ptrType$29], [], false)}, {prop: "delay", name: "delay", pkg: "golang.org/x/tools/go/types", typ: $funcType([funcType], [], false)}, {prop: "initFiles", name: "initFiles", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$8], [], false)}, {prop: "handleBailout", name: "handleBailout", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$24], [], false)}, {prop: "Files", name: "Files", pkg: "", typ: $funcType([sliceType$8], [$error], false)}, {prop: "recordUntyped", name: "recordUntyped", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [], false)}, {prop: "recordTypeAndValue", name: "recordTypeAndValue", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, operandMode, Type, exact.Value], [], false)}, {prop: "recordBuiltinType", name: "recordBuiltinType", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, ptrType$17], [], false)}, {prop: "recordCommaOkTypes", name: "recordCommaOkTypes", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, arrayType], [], false)}, {prop: "recordDef", name: "recordDef", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$5, Object], [], false)}, {prop: "recordUse", name: "recordUse", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$5, Object], [], false)}, {prop: "recordImplicit", name: "recordImplicit", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Node, Object], [], false)}, {prop: "recordSelection", name: "recordSelection", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$14, SelectionKind, Type, Object, sliceType$6, $Bool], [], false)}, {prop: "recordScope", name: "recordScope", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Node, ptrType], [], false)}, {prop: "conversion", name: "conversion", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, Type], [], false)}, {prop: "reportAltDecl", name: "reportAltDecl", pkg: "golang.org/x/tools/go/types", typ: $funcType([Object], [], false)}, {prop: "declare", name: "declare", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType, ptrType$5, Object, token.Pos], [], false)}, {prop: "objDecl", name: "objDecl", pkg: "golang.org/x/tools/go/types", typ: $funcType([Object, ptrType$26, sliceType$11], [], false)}, {prop: "constDecl", name: "constDecl", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$2, ast.Expr, ast.Expr], [], false)}, {prop: "varDecl", name: "varDecl", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$9, sliceType$1, ast.Expr, ast.Expr], [], false)}, {prop: "typeDecl", name: "typeDecl", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$19, ast.Expr, ptrType$26, sliceType$11], [], false)}, {prop: "addMethodDecls", name: "addMethodDecls", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$19], [], false)}, {prop: "funcDecl", name: "funcDecl", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$6, ptrType$21], [], false)}, {prop: "declStmt", name: "declStmt", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Decl], [], false)}, {prop: "qualifier", name: "qualifier", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$1], [$String], false)}, {prop: "sprintf", name: "sprintf", pkg: "golang.org/x/tools/go/types", typ: $funcType([$String, sliceType], [$String], true)}, {prop: "trace", name: "trace", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String, sliceType], [], true)}, {prop: "dump", name: "dump", pkg: "golang.org/x/tools/go/types", typ: $funcType([$String, sliceType], [], true)}, {prop: "err", name: "err", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String, $Bool], [], false)}, {prop: "error", name: "error", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String], [], false)}, {prop: "errorf", name: "errorf", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String, sliceType], [], true)}, {prop: "softErrorf", name: "softErrorf", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String, sliceType], [], true)}, {prop: "invalidAST", name: "invalidAST", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String, sliceType], [], true)}, {prop: "invalidArg", name: "invalidArg", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String, sliceType], [], true)}, {prop: "invalidOp", name: "invalidOp", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, $String, sliceType], [], true)}, {prop: "op", name: "op", pkg: "golang.org/x/tools/go/types", typ: $funcType([opPredicates, ptrType$34, token.Token], [$Bool], false)}, {prop: "unary", name: "unary", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$36, token.Token], [], false)}, {prop: "representable", name: "representable", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$3], [], false)}, {prop: "updateExprType", name: "updateExprType", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, Type, $Bool], [], false)}, {prop: "updateExprVal", name: "updateExprVal", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, exact.Value], [], false)}, {prop: "convertUntyped", name: "convertUntyped", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, Type], [], false)}, {prop: "comparison", name: "comparison", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$34, token.Token], [], false)}, {prop: "shift", name: "shift", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$34, token.Token], [], false)}, {prop: "binary", name: "binary", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$52, ast.Expr, ast.Expr, token.Token], [], false)}, {prop: "index", name: "index", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, $Int64], [$Int64, $Bool], false)}, {prop: "indexedElts", name: "indexedElts", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$5, Type, $Int64], [$Int64], false)}, {prop: "rawExpr", name: "rawExpr", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ast.Expr, Type], [exprKind], false)}, {prop: "exprInternal", name: "exprInternal", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ast.Expr, Type], [exprKind], false)}, {prop: "typeAssertion", name: "typeAssertion", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos, ptrType$34, ptrType$53, Type], [], false)}, {prop: "expr", name: "expr", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ast.Expr], [], false)}, {prop: "exprWithHint", name: "exprWithHint", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ast.Expr, Type], [], false)}, {prop: "exprOrType", name: "exprOrType", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ast.Expr], [], false)}, {prop: "initOrder", name: "initOrder", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [], false)}, {prop: "reportCycle", name: "reportCycle", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$14, $Int], [], false)}, {prop: "labels", name: "labels", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$29], [], false)}, {prop: "blockBranches", name: "blockBranches", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType, ptrType$57, ptrType$58, sliceType$24], [sliceType$15], false)}, {prop: "resolveOrder", name: "resolveOrder", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [sliceType$18], false)}, {prop: "interfaceFor", name: "interfaceFor", pkg: "golang.org/x/tools/go/types", typ: $funcType([Object], [ptrType$47], false)}, {prop: "appendInPostOrder", name: "appendInPostOrder", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$73, Object], [], false)}, {prop: "arityMatch", name: "arityMatch", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$32, ptrType$32], [], false)}, {prop: "declarePkgObj", name: "declarePkgObj", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$5, Object, ptrType$21], [], false)}, {prop: "filename", name: "filename", pkg: "golang.org/x/tools/go/types", typ: $funcType([$Int], [$String], false)}, {prop: "collectObjects", name: "collectObjects", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [], false)}, {prop: "packageObjects", name: "packageObjects", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$18], [], false)}, {prop: "functionBodies", name: "functionBodies", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [], false)}, {prop: "unusedImports", name: "unusedImports", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [], false)}, {prop: "isTerminating", name: "isTerminating", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Stmt, $String], [$Bool], false)}, {prop: "isTerminatingList", name: "isTerminatingList", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$24, $String], [$Bool], false)}, {prop: "isTerminatingSwitch", name: "isTerminatingSwitch", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$29, $String], [$Bool], false)}, {prop: "funcBody", name: "funcBody", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$21, $String, ptrType$17, ptrType$29], [], false)}, {prop: "usage", name: "usage", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType], [], false)}, {prop: "simpleStmt", name: "simpleStmt", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Stmt], [], false)}, {prop: "stmtList", name: "stmtList", pkg: "golang.org/x/tools/go/types", typ: $funcType([stmtContext, sliceType$24], [], false)}, {prop: "multipleDefaults", name: "multipleDefaults", pkg: "golang.org/x/tools/go/types", typ: $funcType([sliceType$24], [], false)}, {prop: "openScope", name: "openScope", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Stmt, $String], [], false)}, {prop: "closeScope", name: "closeScope", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [], false)}, {prop: "suspendedCall", name: "suspendedCall", pkg: "golang.org/x/tools/go/types", typ: $funcType([$String, ptrType$50], [], false)}, {prop: "caseValues", name: "caseValues", pkg: "golang.org/x/tools/go/types", typ: $funcType([operand, sliceType$5], [], false)}, {prop: "caseTypes", name: "caseTypes", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$53, sliceType$5, mapType$6], [Type], false)}, {prop: "stmt", name: "stmt", pkg: "golang.org/x/tools/go/types", typ: $funcType([stmtContext, ast.Stmt], [], false)}, {prop: "ident", name: "ident", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$34, ptrType$5, ptrType$26, sliceType$11], [], false)}, {prop: "typExpr", name: "typExpr", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, ptrType$26, sliceType$11], [Type], false)}, {prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr], [Type], false)}, {prop: "funcType", name: "funcType", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$17, ptrType$78, ptrType$46], [], false)}, {prop: "typExprInternal", name: "typExprInternal", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr, ptrType$26, sliceType$11], [Type], false)}, {prop: "typOrNil", name: "typOrNil", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr], [Type], false)}, {prop: "arrayLength", name: "arrayLength", pkg: "golang.org/x/tools/go/types", typ: $funcType([ast.Expr], [$Int64], false)}, {prop: "collectParams", name: "collectParams", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType, ptrType$78, $Bool], [sliceType$1, $Bool], false)}, {prop: "declareInSet", name: "declareInSet", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$28, token.Pos, Object], [$Bool], false)}, {prop: "interfaceType", name: "interfaceType", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$53, ptrType$47, ptrType$26, sliceType$11], [], false)}, {prop: "tag", name: "tag", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$51], [$String], false)}, {prop: "structType", name: "structType", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$27, ptrType$45, sliceType$11], [], false)}];
- nodeQueue.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}];
- ptrType$55.methods = [{prop: "Push", name: "Push", pkg: "", typ: $funcType([$emptyInterface], [], false)}, {prop: "Pop", name: "Pop", pkg: "", typ: $funcType([], [$emptyInterface], false)}];
- ptrType$57.methods = [{prop: "insert", name: "insert", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$58], [], false)}, {prop: "gotoTarget", name: "gotoTarget", pkg: "golang.org/x/tools/go/types", typ: $funcType([$String], [ptrType$58], false)}, {prop: "enclosingTarget", name: "enclosingTarget", pkg: "golang.org/x/tools/go/types", typ: $funcType([$String], [ptrType$58], false)}];
- ptrType$91.methods = [{prop: "Parent", name: "Parent", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Pkg", name: "Pkg", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Exported", name: "Exported", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Id", name: "Id", pkg: "", typ: $funcType([], [$String], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "order", name: "order", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [$Uint32], false)}, {prop: "scopePos", name: "scopePos", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [token.Pos], false)}, {prop: "setParent", name: "setParent", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType], [], false)}, {prop: "setOrder", name: "setOrder", pkg: "golang.org/x/tools/go/types", typ: $funcType([$Uint32], [], false)}, {prop: "setScopePos", name: "setScopePos", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos], [], false)}, {prop: "sameId", name: "sameId", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$1, $String], [$Bool], false)}];
- ptrType$18.methods = [{prop: "Imported", name: "Imported", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$2.methods = [{prop: "Val", name: "Val", pkg: "", typ: $funcType([], [exact.Value], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$19.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$9.methods = [{prop: "Anonymous", name: "Anonymous", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsField", name: "IsField", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$6.methods = [{prop: "FullName", name: "FullName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Scope", name: "Scope", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$59.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$20.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$72.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$28.methods = [{prop: "insert", name: "insert", pkg: "golang.org/x/tools/go/types", typ: $funcType([Object], [Object], false)}];
- ptrType$34.methods = [{prop: "convertibleTo", name: "convertibleTo", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$7, Type], [$Bool], false)}, {prop: "pos", name: "pos", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [token.Pos], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "setConst", name: "setConst", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Token, $String], [], false)}, {prop: "isNil", name: "isNil", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [$Bool], false)}, {prop: "assignableTo", name: "assignableTo", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$7, Type], [$Bool], false)}, {prop: "isInteger", name: "isInteger", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [$Bool], false)}];
- inSourceOrder.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}];
- ptrType$1.methods = [{prop: "Path", name: "Path", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Scope", name: "Scope", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "Complete", name: "Complete", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "MarkComplete", name: "MarkComplete", pkg: "", typ: $funcType([], [], false)}, {prop: "Imports", name: "Imports", pkg: "", typ: $funcType([], [sliceType$19], false)}, {prop: "SetImports", name: "SetImports", pkg: "", typ: $funcType([sliceType$19], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$74.methods = [{prop: "identical", name: "identical", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$74], [$Bool], false)}];
- ptrType$21.methods = [{prop: "hasInitializer", name: "hasInitializer", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [$Bool], false)}, {prop: "addDep", name: "addDep", pkg: "golang.org/x/tools/go/types", typ: $funcType([Object], [], false)}];
- ptrType.methods = [{prop: "Parent", name: "Parent", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Names", name: "Names", pkg: "", typ: $funcType([], [sliceType$21], false)}, {prop: "NumChildren", name: "NumChildren", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Child", name: "Child", pkg: "", typ: $funcType([$Int], [ptrType], false)}, {prop: "Lookup", name: "Lookup", pkg: "", typ: $funcType([$String], [Object], false)}, {prop: "LookupParent", name: "LookupParent", pkg: "", typ: $funcType([$String, token.Pos], [ptrType, Object], false)}, {prop: "Insert", name: "Insert", pkg: "", typ: $funcType([Object], [Object], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "End", name: "End", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "Contains", name: "Contains", pkg: "", typ: $funcType([token.Pos], [$Bool], false)}, {prop: "Innermost", name: "Innermost", pkg: "", typ: $funcType([token.Pos], [ptrType], false)}, {prop: "WriteTo", name: "WriteTo", pkg: "", typ: $funcType([io.Writer, $Int, $Bool], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$71.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [SelectionKind], false)}, {prop: "Recv", name: "Recv", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Obj", name: "Obj", pkg: "", typ: $funcType([], [Object], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([], [sliceType$6], false)}, {prop: "Indirect", name: "Indirect", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$92.methods = [{prop: "Alignof", name: "Alignof", pkg: "", typ: $funcType([Type], [$Int64], false)}, {prop: "Offsetsof", name: "Offsetsof", pkg: "", typ: $funcType([sliceType$1], [sliceType$4], false)}, {prop: "Sizeof", name: "Sizeof", pkg: "", typ: $funcType([Type], [$Int64], false)}];
- ptrType$3.methods = [{prop: "Kind", name: "Kind", pkg: "", typ: $funcType([], [BasicKind], false)}, {prop: "Info", name: "Info", pkg: "", typ: $funcType([], [BasicInfo], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$11.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int64], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$10.methods = [{prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$27.methods = [{prop: "NumFields", name: "NumFields", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [ptrType$9], false)}, {prop: "Tag", name: "Tag", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$15.methods = [{prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$8.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "At", name: "At", pkg: "", typ: $funcType([$Int], [ptrType$9], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$17.methods = [{prop: "Recv", name: "Recv", pkg: "", typ: $funcType([], [ptrType$9], false)}, {prop: "Params", name: "Params", pkg: "", typ: $funcType([], [ptrType$8], false)}, {prop: "Results", name: "Results", pkg: "", typ: $funcType([], [ptrType$8], false)}, {prop: "Variadic", name: "Variadic", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$53.methods = [{prop: "NumExplicitMethods", name: "NumExplicitMethods", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ExplicitMethod", name: "ExplicitMethod", pkg: "", typ: $funcType([$Int], [ptrType$6], false)}, {prop: "NumEmbeddeds", name: "NumEmbeddeds", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Embedded", name: "Embedded", pkg: "", typ: $funcType([$Int], [ptrType$26], false)}, {prop: "NumMethods", name: "NumMethods", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [ptrType$6], false)}, {prop: "Empty", name: "Empty", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Complete", name: "Complete", pkg: "", typ: $funcType([], [ptrType$53], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$13.methods = [{prop: "Key", name: "Key", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$12.methods = [{prop: "Dir", name: "Dir", pkg: "", typ: $funcType([], [ChanDir], false)}, {prop: "Elem", name: "Elem", pkg: "", typ: $funcType([], [Type], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$26.methods = [{prop: "setUnderlying", name: "setUnderlying", pkg: "golang.org/x/tools/go/types", typ: $funcType([Type], [], false)}, {prop: "Obj", name: "Obj", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "NumMethods", name: "NumMethods", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [ptrType$6], false)}, {prop: "SetUnderlying", name: "SetUnderlying", pkg: "", typ: $funcType([Type], [], false)}, {prop: "AddMethod", name: "AddMethod", pkg: "", typ: $funcType([ptrType$6], [], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}];
- byUniqueTypeName.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}];
- byUniqueMethodName.methods = [{prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Less", name: "Less", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Swap", name: "Swap", pkg: "", typ: $funcType([$Int, $Int], [], false)}];
- Error.init([{prop: "Fset", name: "Fset", pkg: "", typ: ptrType$22, tag: ""}, {prop: "Pos", name: "Pos", pkg: "", typ: token.Pos, tag: ""}, {prop: "Msg", name: "Msg", pkg: "", typ: $String, tag: ""}, {prop: "Soft", name: "Soft", pkg: "", typ: $Bool, tag: ""}]);
- Importer.init([mapType, $String], [ptrType$1, $error], false);
- Config.init([{prop: "IgnoreFuncBodies", name: "IgnoreFuncBodies", pkg: "", typ: $Bool, tag: ""}, {prop: "FakeImportC", name: "FakeImportC", pkg: "", typ: $Bool, tag: ""}, {prop: "Packages", name: "Packages", pkg: "", typ: mapType, tag: ""}, {prop: "Error", name: "Error", pkg: "", typ: funcType$1, tag: ""}, {prop: "Import", name: "Import", pkg: "", typ: Importer, tag: ""}, {prop: "Sizes", name: "Sizes", pkg: "", typ: Sizes, tag: ""}, {prop: "DisableUnusedImportCheck", name: "DisableUnusedImportCheck", pkg: "", typ: $Bool, tag: ""}]);
- Info.init([{prop: "Types", name: "Types", pkg: "", typ: mapType$1, tag: ""}, {prop: "Defs", name: "Defs", pkg: "", typ: mapType$2, tag: ""}, {prop: "Uses", name: "Uses", pkg: "", typ: mapType$2, tag: ""}, {prop: "Implicits", name: "Implicits", pkg: "", typ: mapType$3, tag: ""}, {prop: "Selections", name: "Selections", pkg: "", typ: mapType$4, tag: ""}, {prop: "Scopes", name: "Scopes", pkg: "", typ: mapType$5, tag: ""}, {prop: "InitOrder", name: "InitOrder", pkg: "", typ: sliceType$23, tag: ""}]);
- TypeAndValue.init([{prop: "mode", name: "mode", pkg: "golang.org/x/tools/go/types", typ: operandMode, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Type, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: exact.Value, tag: ""}]);
- Initializer.init([{prop: "Lhs", name: "Lhs", pkg: "", typ: sliceType$1, tag: ""}, {prop: "Rhs", name: "Rhs", pkg: "", typ: ast.Expr, tag: ""}]);
- getter.init([ptrType$34, $Int], [], false);
- exprInfo.init([{prop: "isLhs", name: "isLhs", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "mode", name: "mode", pkg: "golang.org/x/tools/go/types", typ: operandMode, tag: ""}, {prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/types", typ: ptrType$3, tag: ""}, {prop: "val", name: "val", pkg: "golang.org/x/tools/go/types", typ: exact.Value, tag: ""}]);
- funcInfo.init([{prop: "name", name: "name", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}, {prop: "decl", name: "decl", pkg: "golang.org/x/tools/go/types", typ: ptrType$21, tag: ""}, {prop: "sig", name: "sig", pkg: "golang.org/x/tools/go/types", typ: ptrType$17, tag: ""}, {prop: "body", name: "body", pkg: "golang.org/x/tools/go/types", typ: ptrType$29, tag: ""}]);
- context.init([{prop: "decl", name: "decl", pkg: "golang.org/x/tools/go/types", typ: ptrType$21, tag: ""}, {prop: "scope", name: "scope", pkg: "golang.org/x/tools/go/types", typ: ptrType, tag: ""}, {prop: "iota", name: "iota", pkg: "golang.org/x/tools/go/types", typ: exact.Value, tag: ""}, {prop: "sig", name: "sig", pkg: "golang.org/x/tools/go/types", typ: ptrType$17, tag: ""}, {prop: "hasLabel", name: "hasLabel", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "hasCallOrRecv", name: "hasCallOrRecv", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- Checker.init([{prop: "conf", name: "conf", pkg: "golang.org/x/tools/go/types", typ: ptrType$7, tag: ""}, {prop: "fset", name: "fset", pkg: "golang.org/x/tools/go/types", typ: ptrType$22, tag: ""}, {prop: "pkg", name: "pkg", pkg: "golang.org/x/tools/go/types", typ: ptrType$1, tag: ""}, {prop: "Info", name: "", pkg: "", typ: ptrType$4, tag: ""}, {prop: "objMap", name: "objMap", pkg: "golang.org/x/tools/go/types", typ: mapType$7, tag: ""}, {prop: "files", name: "files", pkg: "golang.org/x/tools/go/types", typ: sliceType$8, tag: ""}, {prop: "unusedDotImports", name: "unusedDotImports", pkg: "golang.org/x/tools/go/types", typ: mapType$9, tag: ""}, {prop: "firstErr", name: "firstErr", pkg: "golang.org/x/tools/go/types", typ: $error, tag: ""}, {prop: "methods", name: "methods", pkg: "golang.org/x/tools/go/types", typ: mapType$10, tag: ""}, {prop: "untyped", name: "untyped", pkg: "golang.org/x/tools/go/types", typ: mapType$11, tag: ""}, {prop: "funcs", name: "funcs", pkg: "golang.org/x/tools/go/types", typ: sliceType$9, tag: ""}, {prop: "delayed", name: "delayed", pkg: "golang.org/x/tools/go/types", typ: sliceType$10, tag: ""}, {prop: "context", name: "", pkg: "golang.org/x/tools/go/types", typ: context, tag: ""}, {prop: "pos", name: "pos", pkg: "golang.org/x/tools/go/types", typ: token.Pos, tag: ""}, {prop: "indent", name: "indent", pkg: "golang.org/x/tools/go/types", typ: $Int, tag: ""}]);
- bailout.init([]);
- opPredicates.init(token.Token, funcType$2);
- objNode.init([{prop: "obj", name: "obj", pkg: "golang.org/x/tools/go/types", typ: Object, tag: ""}, {prop: "in$1", name: "in", pkg: "golang.org/x/tools/go/types", typ: $Int, tag: ""}, {prop: "out", name: "out", pkg: "golang.org/x/tools/go/types", typ: sliceType$14, tag: ""}, {prop: "index", name: "index", pkg: "golang.org/x/tools/go/types", typ: $Int, tag: ""}, {prop: "mark", name: "mark", pkg: "golang.org/x/tools/go/types", typ: $Int, tag: ""}]);
- nodeQueue.init(ptrType$56);
- block.init([{prop: "parent", name: "parent", pkg: "golang.org/x/tools/go/types", typ: ptrType$57, tag: ""}, {prop: "lstmt", name: "lstmt", pkg: "golang.org/x/tools/go/types", typ: ptrType$58, tag: ""}, {prop: "labels", name: "labels", pkg: "golang.org/x/tools/go/types", typ: mapType$12, tag: ""}]);
- embeddedType.init([{prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/types", typ: ptrType$26, tag: ""}, {prop: "index", name: "index", pkg: "golang.org/x/tools/go/types", typ: sliceType$6, tag: ""}, {prop: "indirect", name: "indirect", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "multiples", name: "multiples", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- Object.init([{prop: "Exported", name: "Exported", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Id", name: "Id", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Parent", name: "Parent", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "Pkg", name: "Pkg", pkg: "", typ: $funcType([], [ptrType$1], false)}, {prop: "Pos", name: "Pos", pkg: "", typ: $funcType([], [token.Pos], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [Type], false)}, {prop: "order", name: "order", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [$Uint32], false)}, {prop: "sameId", name: "sameId", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType$1, $String], [$Bool], false)}, {prop: "scopePos", name: "scopePos", pkg: "golang.org/x/tools/go/types", typ: $funcType([], [token.Pos], false)}, {prop: "setOrder", name: "setOrder", pkg: "golang.org/x/tools/go/types", typ: $funcType([$Uint32], [], false)}, {prop: "setParent", name: "setParent", pkg: "golang.org/x/tools/go/types", typ: $funcType([ptrType], [], false)}, {prop: "setScopePos", name: "setScopePos", pkg: "golang.org/x/tools/go/types", typ: $funcType([token.Pos], [], false)}]);
- object.init([{prop: "parent", name: "parent", pkg: "golang.org/x/tools/go/types", typ: ptrType, tag: ""}, {prop: "pos", name: "pos", pkg: "golang.org/x/tools/go/types", typ: token.Pos, tag: ""}, {prop: "pkg", name: "pkg", pkg: "golang.org/x/tools/go/types", typ: ptrType$1, tag: ""}, {prop: "name", name: "name", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}, {prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}, {prop: "order_", name: "order_", pkg: "golang.org/x/tools/go/types", typ: $Uint32, tag: ""}, {prop: "scopePos_", name: "scopePos_", pkg: "golang.org/x/tools/go/types", typ: token.Pos, tag: ""}]);
- PkgName.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}, {prop: "imported", name: "imported", pkg: "golang.org/x/tools/go/types", typ: ptrType$1, tag: ""}, {prop: "used", name: "used", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- Const.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}, {prop: "val", name: "val", pkg: "golang.org/x/tools/go/types", typ: exact.Value, tag: ""}, {prop: "visited", name: "visited", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- TypeName.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}]);
- Var.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}, {prop: "anonymous", name: "anonymous", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "visited", name: "visited", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "isField", name: "isField", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "used", name: "used", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- Func.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}]);
- Label.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}, {prop: "used", name: "used", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- Builtin.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}, {prop: "id", name: "id", pkg: "golang.org/x/tools/go/types", typ: builtinId, tag: ""}]);
- Nil.init([{prop: "object", name: "", pkg: "golang.org/x/tools/go/types", typ: object, tag: ""}]);
- objset.init($String, Object);
- operand.init([{prop: "mode", name: "mode", pkg: "golang.org/x/tools/go/types", typ: operandMode, tag: ""}, {prop: "expr", name: "expr", pkg: "golang.org/x/tools/go/types", typ: ast.Expr, tag: ""}, {prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}, {prop: "val", name: "val", pkg: "golang.org/x/tools/go/types", typ: exact.Value, tag: ""}, {prop: "id", name: "id", pkg: "golang.org/x/tools/go/types", typ: builtinId, tag: ""}]);
- inSourceOrder.init(Object);
- Package.init([{prop: "path", name: "path", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}, {prop: "name", name: "name", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}, {prop: "scope", name: "scope", pkg: "golang.org/x/tools/go/types", typ: ptrType, tag: ""}, {prop: "complete", name: "complete", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}, {prop: "imports", name: "imports", pkg: "golang.org/x/tools/go/types", typ: sliceType$19, tag: ""}, {prop: "fake", name: "fake", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- ifacePair.init([{prop: "x", name: "x", pkg: "golang.org/x/tools/go/types", typ: ptrType$53, tag: ""}, {prop: "y", name: "y", pkg: "golang.org/x/tools/go/types", typ: ptrType$53, tag: ""}, {prop: "prev", name: "prev", pkg: "golang.org/x/tools/go/types", typ: ptrType$74, tag: ""}]);
- declInfo.init([{prop: "file", name: "file", pkg: "golang.org/x/tools/go/types", typ: ptrType, tag: ""}, {prop: "lhs", name: "lhs", pkg: "golang.org/x/tools/go/types", typ: sliceType$1, tag: ""}, {prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/types", typ: ast.Expr, tag: ""}, {prop: "init", name: "init", pkg: "golang.org/x/tools/go/types", typ: ast.Expr, tag: ""}, {prop: "fdecl", name: "fdecl", pkg: "golang.org/x/tools/go/types", typ: ptrType$75, tag: ""}, {prop: "deps", name: "deps", pkg: "golang.org/x/tools/go/types", typ: mapType$13, tag: ""}, {prop: "mark", name: "mark", pkg: "golang.org/x/tools/go/types", typ: $Int, tag: ""}]);
- Scope.init([{prop: "parent", name: "parent", pkg: "golang.org/x/tools/go/types", typ: ptrType, tag: ""}, {prop: "children", name: "children", pkg: "golang.org/x/tools/go/types", typ: sliceType$20, tag: ""}, {prop: "elems", name: "elems", pkg: "golang.org/x/tools/go/types", typ: mapType$14, tag: ""}, {prop: "pos", name: "pos", pkg: "golang.org/x/tools/go/types", typ: token.Pos, tag: ""}, {prop: "end", name: "end", pkg: "golang.org/x/tools/go/types", typ: token.Pos, tag: ""}, {prop: "comment", name: "comment", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}]);
- Selection.init([{prop: "kind", name: "kind", pkg: "golang.org/x/tools/go/types", typ: SelectionKind, tag: ""}, {prop: "recv", name: "recv", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}, {prop: "obj", name: "obj", pkg: "golang.org/x/tools/go/types", typ: Object, tag: ""}, {prop: "index", name: "index", pkg: "golang.org/x/tools/go/types", typ: sliceType$6, tag: ""}, {prop: "indirect", name: "indirect", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- Sizes.init([{prop: "Alignof", name: "Alignof", pkg: "", typ: $funcType([Type], [$Int64], false)}, {prop: "Offsetsof", name: "Offsetsof", pkg: "", typ: $funcType([sliceType$1], [sliceType$4], false)}, {prop: "Sizeof", name: "Sizeof", pkg: "", typ: $funcType([Type], [$Int64], false)}]);
- StdSizes.init([{prop: "WordSize", name: "WordSize", pkg: "", typ: $Int64, tag: ""}, {prop: "MaxAlign", name: "MaxAlign", pkg: "", typ: $Int64, tag: ""}]);
- Type.init([{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [Type], false)}]);
- Basic.init([{prop: "kind", name: "kind", pkg: "golang.org/x/tools/go/types", typ: BasicKind, tag: ""}, {prop: "info", name: "info", pkg: "golang.org/x/tools/go/types", typ: BasicInfo, tag: ""}, {prop: "name", name: "name", pkg: "golang.org/x/tools/go/types", typ: $String, tag: ""}]);
- Array.init([{prop: "len", name: "len", pkg: "golang.org/x/tools/go/types", typ: $Int64, tag: ""}, {prop: "elem", name: "elem", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}]);
- Slice.init([{prop: "elem", name: "elem", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}]);
- Struct.init([{prop: "fields", name: "fields", pkg: "golang.org/x/tools/go/types", typ: sliceType$1, tag: ""}, {prop: "tags", name: "tags", pkg: "golang.org/x/tools/go/types", typ: sliceType$21, tag: ""}, {prop: "offsets", name: "offsets", pkg: "golang.org/x/tools/go/types", typ: sliceType$4, tag: ""}]);
- Pointer.init([{prop: "base", name: "base", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}]);
- Tuple.init([{prop: "vars", name: "vars", pkg: "golang.org/x/tools/go/types", typ: sliceType$1, tag: ""}]);
- Signature.init([{prop: "scope", name: "scope", pkg: "golang.org/x/tools/go/types", typ: ptrType, tag: ""}, {prop: "recv", name: "recv", pkg: "golang.org/x/tools/go/types", typ: ptrType$9, tag: ""}, {prop: "params", name: "params", pkg: "golang.org/x/tools/go/types", typ: ptrType$8, tag: ""}, {prop: "results", name: "results", pkg: "golang.org/x/tools/go/types", typ: ptrType$8, tag: ""}, {prop: "variadic", name: "variadic", pkg: "golang.org/x/tools/go/types", typ: $Bool, tag: ""}]);
- Interface.init([{prop: "methods", name: "methods", pkg: "golang.org/x/tools/go/types", typ: sliceType$7, tag: ""}, {prop: "embeddeds", name: "embeddeds", pkg: "golang.org/x/tools/go/types", typ: sliceType$22, tag: ""}, {prop: "allMethods", name: "allMethods", pkg: "golang.org/x/tools/go/types", typ: sliceType$7, tag: ""}]);
- Map.init([{prop: "key", name: "key", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}, {prop: "elem", name: "elem", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}]);
- Chan.init([{prop: "dir", name: "dir", pkg: "golang.org/x/tools/go/types", typ: ChanDir, tag: ""}, {prop: "elem", name: "elem", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}]);
- Named.init([{prop: "obj", name: "obj", pkg: "golang.org/x/tools/go/types", typ: ptrType$19, tag: ""}, {prop: "underlying", name: "underlying", pkg: "golang.org/x/tools/go/types", typ: Type, tag: ""}, {prop: "methods", name: "methods", pkg: "golang.org/x/tools/go/types", typ: sliceType$7, tag: ""}]);
- byUniqueTypeName.init(ptrType$26);
- byUniqueMethodName.init(ptrType$6);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = heap.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = errors.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = parser.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = exact.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = math.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = path.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.DefaultImport = $throwNilPointerError;
- $pkg.GcCompatibilityMode = false;
- $pkg.Universe = ptrType.nil;
- $pkg.Unsafe = ptrType$1.nil;
- universeIota = ptrType$2.nil;
- $pkg.UniverseByte = ptrType$3.nil;
- $pkg.UniverseRune = ptrType$3.nil;
- operandModeString = $toNativeArray($kindString, ["invalid operand", "no value", "built-in", "type", "constant", "variable", "map index expression", "value", "comma, ok expression"]);
- stdSizes = new StdSizes.ptr(new $Int64(0, 8), new $Int64(0, 8));
- basicSizes = $toNativeArray($kindUint8, [0, 1, 0, 1, 2, 4, 8, 0, 1, 2, 4, 8, 0, 4, 8, 8, 16]);
- unaryOpPredicates = (_map = new $Map(), _key = 12, _map[token.Token.keyFor(_key)] = { k: _key, v: isNumeric }, _key = 13, _map[token.Token.keyFor(_key)] = { k: _key, v: isNumeric }, _key = 19, _map[token.Token.keyFor(_key)] = { k: _key, v: isInteger }, _key = 43, _map[token.Token.keyFor(_key)] = { k: _key, v: isBoolean }, _map);
- binaryOpPredicates = (_map$1 = new $Map(), _key$1 = 12, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: (function $b(typ) {
- var $ptr, _r, _r$1, _v, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = isNumeric(typ); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- if (_r) { _v = true; $s = 1; continue s; }
- _r$1 = isString(typ); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1; case 1:
- return _v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- }) }, _key$1 = 13, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isNumeric }, _key$1 = 14, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isNumeric }, _key$1 = 15, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isNumeric }, _key$1 = 16, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isInteger }, _key$1 = 17, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isInteger }, _key$1 = 18, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isInteger }, _key$1 = 19, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isInteger }, _key$1 = 22, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isInteger }, _key$1 = 34, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isBoolean }, _key$1 = 35, _map$1[token.Token.keyFor(_key$1)] = { k: _key$1, v: isBoolean }, _map$1);
- $pkg.Typ = $toNativeArray($kindPtr, [new Basic.ptr(0, 0, "invalid type"), new Basic.ptr(1, 1, "bool"), new Basic.ptr(2, 2, "int"), new Basic.ptr(3, 2, "int8"), new Basic.ptr(4, 2, "int16"), new Basic.ptr(5, 2, "int32"), new Basic.ptr(6, 2, "int64"), new Basic.ptr(7, 6, "uint"), new Basic.ptr(8, 6, "uint8"), new Basic.ptr(9, 6, "uint16"), new Basic.ptr(10, 6, "uint32"), new Basic.ptr(11, 6, "uint64"), new Basic.ptr(12, 6, "uintptr"), new Basic.ptr(13, 8, "float32"), new Basic.ptr(14, 8, "float64"), new Basic.ptr(15, 16, "complex64"), new Basic.ptr(16, 16, "complex128"), new Basic.ptr(17, 32, "string"), new Basic.ptr(18, 0, "Pointer"), new Basic.ptr(19, 65, "untyped bool"), new Basic.ptr(20, 66, "untyped int"), new Basic.ptr(21, 66, "untyped rune"), new Basic.ptr(22, 72, "untyped float"), new Basic.ptr(23, 80, "untyped complex"), new Basic.ptr(24, 96, "untyped string"), new Basic.ptr(25, 64, "untyped nil")]);
- aliases = $toNativeArray($kindPtr, [new Basic.ptr(8, 6, "byte"), new Basic.ptr(5, 2, "rune")]);
- predeclaredConsts = $toNativeArray($kindStruct, [new structType.ptr("true", 19, exact.MakeBool(true)), new structType.ptr("false", 19, exact.MakeBool(false)), new structType.ptr("iota", 20, exact.MakeInt64(new $Int64(0, 0)))]);
- predeclaredFuncs = $toNativeArray($kindStruct, [new structType$1.ptr("append", 1, true, 1), new structType$1.ptr("cap", 1, false, 1), new structType$1.ptr("close", 1, false, 2), new structType$1.ptr("complex", 2, false, 1), new structType$1.ptr("copy", 2, false, 2), new structType$1.ptr("delete", 2, false, 2), new structType$1.ptr("imag", 1, false, 1), new structType$1.ptr("len", 1, false, 1), new structType$1.ptr("make", 1, true, 1), new structType$1.ptr("new", 1, false, 1), new structType$1.ptr("panic", 1, false, 2), new structType$1.ptr("print", 0, true, 2), new structType$1.ptr("println", 0, true, 2), new structType$1.ptr("real", 1, false, 1), new structType$1.ptr("recover", 0, false, 2), new structType$1.ptr("Alignof", 1, false, 1), new structType$1.ptr("Offsetof", 1, false, 1), new structType$1.ptr("Sizeof", 1, false, 1), new structType$1.ptr("assert", 1, false, 2), new structType$1.ptr("trace", 0, true, 2)]);
- $r = init(); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs/compiler/astutil"] = (function() {
- var $pkg = {}, $init, ast, types, ptrType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, RemoveParens, SetType, NewIdent, IsTypeExpr;
- ast = $packages["go/ast"];
- types = $packages["golang.org/x/tools/go/types"];
- ptrType = $ptrType(ast.ParenExpr);
- ptrType$1 = $ptrType(ast.Ident);
- ptrType$2 = $ptrType(ast.ArrayType);
- ptrType$3 = $ptrType(ast.ChanType);
- ptrType$4 = $ptrType(ast.FuncType);
- ptrType$5 = $ptrType(ast.InterfaceType);
- ptrType$6 = $ptrType(ast.MapType);
- ptrType$7 = $ptrType(ast.StructType);
- ptrType$8 = $ptrType(ast.StarExpr);
- ptrType$9 = $ptrType(ast.SelectorExpr);
- ptrType$10 = $ptrType(types.TypeName);
- RemoveParens = function(e) {
- var $ptr, _tuple, e, isParen, p;
- while (true) {
- _tuple = $assertType(e, ptrType, true); p = _tuple[0]; isParen = _tuple[1];
- if (!isParen) {
- return e;
- }
- e = p.X;
- }
- };
- $pkg.RemoveParens = RemoveParens;
- SetType = function(info, t, e) {
- var $ptr, _key, e, info, t;
- _key = e; (info.Types || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key)] = { k: _key, v: new types.TypeAndValue.ptr(0, t, $ifaceNil) };
- return e;
- };
- $pkg.SetType = SetType;
- NewIdent = function(name, t, info, pkg) {
- var $ptr, _key, _key$1, ident, info, name, obj, pkg, t;
- ident = ast.NewIdent(name);
- _key = ident; (info.Types || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key)] = { k: _key, v: new types.TypeAndValue.ptr(0, t, $ifaceNil) };
- obj = types.NewVar(0, pkg, name, t);
- _key$1 = ident; (info.Uses || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$1)] = { k: _key$1, v: obj };
- return ident;
- };
- $pkg.NewIdent = NewIdent;
- IsTypeExpr = function(expr, info) {
- var $ptr, _entry, _entry$1, _ref, _tuple, _tuple$1, e, e$1, e$2, e$3, e$4, e$5, expr, info, ok, ok$1;
- _ref = expr;
- if ($assertType(_ref, ptrType$2, true)[1] || $assertType(_ref, ptrType$3, true)[1] || $assertType(_ref, ptrType$4, true)[1] || $assertType(_ref, ptrType$5, true)[1] || $assertType(_ref, ptrType$6, true)[1] || $assertType(_ref, ptrType$7, true)[1]) {
- e = _ref;
- return true;
- } else if ($assertType(_ref, ptrType$8, true)[1]) {
- e$1 = _ref.$val;
- return IsTypeExpr(e$1.X, info);
- } else if ($assertType(_ref, ptrType$1, true)[1]) {
- e$2 = _ref.$val;
- _tuple = $assertType((_entry = info.Uses[ptrType$1.keyFor(e$2)], _entry !== undefined ? _entry.v : $ifaceNil), ptrType$10, true); ok = _tuple[1];
- return ok;
- } else if ($assertType(_ref, ptrType$9, true)[1]) {
- e$3 = _ref.$val;
- _tuple$1 = $assertType((_entry$1 = info.Uses[ptrType$1.keyFor(e$3.Sel)], _entry$1 !== undefined ? _entry$1.v : $ifaceNil), ptrType$10, true); ok$1 = _tuple$1[1];
- return ok$1;
- } else if ($assertType(_ref, ptrType, true)[1]) {
- e$4 = _ref.$val;
- return IsTypeExpr(e$4.X, info);
- } else {
- e$5 = _ref;
- return false;
- }
- };
- $pkg.IsTypeExpr = IsTypeExpr;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = ast.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = types.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs/compiler/typesutil"] = (function() {
- var $pkg = {}, $init, types, ptrType, ptrType$1, ptrType$2, IsJsPackage, IsJsObject;
- types = $packages["golang.org/x/tools/go/types"];
- ptrType = $ptrType(types.Package);
- ptrType$1 = $ptrType(types.Pointer);
- ptrType$2 = $ptrType(types.Named);
- IsJsPackage = function(pkg) {
- var $ptr, pkg;
- return !(pkg === ptrType.nil) && pkg.Path() === "github.com/gopherjs/gopherjs/js";
- };
- $pkg.IsJsPackage = IsJsPackage;
- IsJsObject = function(t) {
- var $ptr, _tuple, _tuple$1, isNamed, isPtr, named, ptr, t;
- _tuple = $assertType(t, ptrType$1, true); ptr = _tuple[0]; isPtr = _tuple[1];
- if (!isPtr) {
- return false;
- }
- _tuple$1 = $assertType(ptr.Elem(), ptrType$2, true); named = _tuple$1[0]; isNamed = _tuple$1[1];
- return isNamed && IsJsPackage(named.Obj().object.Pkg()) && named.Obj().object.Name() === "Object";
- };
- $pkg.IsJsObject = IsJsObject;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = types.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs/compiler/analysis"] = (function() {
- var $pkg = {}, $init, astutil, typesutil, ast, token, exact, types, hasBreakVisitor, escapeAnalysis, escapingObjectCollector, continueStmt, Info, FuncInfo, hasSideEffectVisitor, ptrType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, ptrType$12, ptrType$13, sliceType, ptrType$14, sliceType$1, ptrType$15, ptrType$16, sliceType$2, ptrType$17, ptrType$18, ptrType$19, ptrType$20, ptrType$21, ptrType$22, ptrType$23, ptrType$24, ptrType$25, ptrType$26, ptrType$27, sliceType$3, ptrType$28, ptrType$29, ptrType$30, ptrType$31, ptrType$32, ptrType$33, ptrType$34, mapType, mapType$1, ptrType$35, funcType, mapType$2, mapType$3, mapType$4, mapType$5, mapType$6, ptrType$36, BoolValue, HasBreak, EscapingObjects, AnalyzePkg, HasSideEffect;
- astutil = $packages["github.com/gopherjs/gopherjs/compiler/astutil"];
- typesutil = $packages["github.com/gopherjs/gopherjs/compiler/typesutil"];
- ast = $packages["go/ast"];
- token = $packages["go/token"];
- exact = $packages["golang.org/x/tools/go/exact"];
- types = $packages["golang.org/x/tools/go/types"];
- hasBreakVisitor = $pkg.hasBreakVisitor = $newType(0, $kindStruct, "analysis.hasBreakVisitor", "hasBreakVisitor", "github.com/gopherjs/gopherjs/compiler/analysis", function(hasBreak_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.hasBreak = false;
- return;
- }
- this.hasBreak = hasBreak_;
- });
- escapeAnalysis = $pkg.escapeAnalysis = $newType(0, $kindStruct, "analysis.escapeAnalysis", "escapeAnalysis", "github.com/gopherjs/gopherjs/compiler/analysis", function(info_, escaping_, topScope_, bottomScopes_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.info = ptrType$10.nil;
- this.escaping = false;
- this.topScope = ptrType$11.nil;
- this.bottomScopes = false;
- return;
- }
- this.info = info_;
- this.escaping = escaping_;
- this.topScope = topScope_;
- this.bottomScopes = bottomScopes_;
- });
- escapingObjectCollector = $pkg.escapingObjectCollector = $newType(0, $kindStruct, "analysis.escapingObjectCollector", "escapingObjectCollector", "github.com/gopherjs/gopherjs/compiler/analysis", function(analysis_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.analysis = ptrType$34.nil;
- return;
- }
- this.analysis = analysis_;
- });
- continueStmt = $pkg.continueStmt = $newType(0, $kindStruct, "analysis.continueStmt", "continueStmt", "github.com/gopherjs/gopherjs/compiler/analysis", function(forStmt_, analyzeStack_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.forStmt = ptrType$4.nil;
- this.analyzeStack = sliceType$1.nil;
- return;
- }
- this.forStmt = forStmt_;
- this.analyzeStack = analyzeStack_;
- });
- Info = $pkg.Info = $newType(0, $kindStruct, "analysis.Info", "Info", "github.com/gopherjs/gopherjs/compiler/analysis", function(Info_, Pkg_, IsBlocking_, HasPointer_, FuncDeclInfos_, FuncLitInfos_, InitFuncInfo_, allInfos_, comments_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Info = ptrType$10.nil;
- this.Pkg = ptrType$15.nil;
- this.IsBlocking = $throwNilPointerError;
- this.HasPointer = false;
- this.FuncDeclInfos = false;
- this.FuncLitInfos = false;
- this.InitFuncInfo = ptrType$16.nil;
- this.allInfos = sliceType$2.nil;
- this.comments = false;
- return;
- }
- this.Info = Info_;
- this.Pkg = Pkg_;
- this.IsBlocking = IsBlocking_;
- this.HasPointer = HasPointer_;
- this.FuncDeclInfos = FuncDeclInfos_;
- this.FuncLitInfos = FuncLitInfos_;
- this.InitFuncInfo = InitFuncInfo_;
- this.allInfos = allInfos_;
- this.comments = comments_;
- });
- FuncInfo = $pkg.FuncInfo = $newType(0, $kindStruct, "analysis.FuncInfo", "FuncInfo", "github.com/gopherjs/gopherjs/compiler/analysis", function(HasDefer_, Flattened_, Blocking_, GotoLabel_, LocalCalls_, ContinueStmts_, p_, analyzeStack_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.HasDefer = false;
- this.Flattened = false;
- this.Blocking = false;
- this.GotoLabel = false;
- this.LocalCalls = false;
- this.ContinueStmts = sliceType.nil;
- this.p = ptrType$14.nil;
- this.analyzeStack = sliceType$1.nil;
- return;
- }
- this.HasDefer = HasDefer_;
- this.Flattened = Flattened_;
- this.Blocking = Blocking_;
- this.GotoLabel = GotoLabel_;
- this.LocalCalls = LocalCalls_;
- this.ContinueStmts = ContinueStmts_;
- this.p = p_;
- this.analyzeStack = analyzeStack_;
- });
- hasSideEffectVisitor = $pkg.hasSideEffectVisitor = $newType(0, $kindStruct, "analysis.hasSideEffectVisitor", "hasSideEffectVisitor", "github.com/gopherjs/gopherjs/compiler/analysis", function(info_, hasSideEffect_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.info = ptrType$10.nil;
- this.hasSideEffect = false;
- return;
- }
- this.info = info_;
- this.hasSideEffect = hasSideEffect_;
- });
- ptrType = $ptrType(ast.BinaryExpr);
- ptrType$1 = $ptrType(ast.UnaryExpr);
- ptrType$2 = $ptrType(ast.ParenExpr);
- ptrType$3 = $ptrType(ast.BranchStmt);
- ptrType$4 = $ptrType(ast.ForStmt);
- ptrType$5 = $ptrType(ast.RangeStmt);
- ptrType$6 = $ptrType(ast.SwitchStmt);
- ptrType$7 = $ptrType(ast.TypeSwitchStmt);
- ptrType$8 = $ptrType(ast.SelectStmt);
- ptrType$9 = $ptrType(ast.Ident);
- ptrType$10 = $ptrType(types.Info);
- ptrType$11 = $ptrType(types.Scope);
- ptrType$12 = $ptrType(ast.FuncLit);
- ptrType$13 = $ptrType(types.Var);
- sliceType = $sliceType(continueStmt);
- ptrType$14 = $ptrType(Info);
- sliceType$1 = $sliceType(ast.Node);
- ptrType$15 = $ptrType(types.Package);
- ptrType$16 = $ptrType(FuncInfo);
- sliceType$2 = $sliceType(ptrType$16);
- ptrType$17 = $ptrType(types.Func);
- ptrType$18 = $ptrType(ast.FuncDecl);
- ptrType$19 = $ptrType(ast.CallExpr);
- ptrType$20 = $ptrType(ast.SendStmt);
- ptrType$21 = $ptrType(ast.CommClause);
- ptrType$22 = $ptrType(ast.GoStmt);
- ptrType$23 = $ptrType(ast.DeferStmt);
- ptrType$24 = $ptrType(types.Label);
- ptrType$25 = $ptrType(ast.LabeledStmt);
- ptrType$26 = $ptrType(types.Signature);
- ptrType$27 = $ptrType(types.Interface);
- sliceType$3 = $sliceType(sliceType$1);
- ptrType$28 = $ptrType(ast.SelectorExpr);
- ptrType$29 = $ptrType(types.Selection);
- ptrType$30 = $ptrType(types.Chan);
- ptrType$31 = $ptrType(ast.ExprStmt);
- ptrType$32 = $ptrType(ast.AssignStmt);
- ptrType$33 = $ptrType(hasBreakVisitor);
- ptrType$34 = $ptrType(escapeAnalysis);
- mapType = $mapType(ptrType$13, $Bool);
- mapType$1 = $mapType(ptrType$11, $Bool);
- ptrType$35 = $ptrType(escapingObjectCollector);
- funcType = $funcType([ptrType$17], [$Bool], false);
- mapType$2 = $mapType(ptrType$17, ptrType$16);
- mapType$3 = $mapType(ptrType$12, ptrType$16);
- mapType$4 = $mapType(ast.Node, $Bool);
- mapType$5 = $mapType(ptrType$24, $Bool);
- mapType$6 = $mapType(ptrType$17, sliceType$3);
- ptrType$36 = $ptrType(hasSideEffectVisitor);
- BoolValue = function(expr, info) {
- var $ptr, _entry, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, _v, b, b$1, b$2, e, e$1, e$2, expr, info, ok, ok$1, ok$2, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _v = $f._v; b = $f.b; b$1 = $f.b$1; b$2 = $f.b$2; e = $f.e; e$1 = $f.e$1; e$2 = $f.e$2; expr = $f.expr; info = $f.info; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = (_entry = info.Types[ast.Expr.keyFor(expr)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Value;
- if (!(!($interfaceIsEqual(v, $ifaceNil)))) { _v = false; $s = 3; continue s; }
- _r = v.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _v = _r === 1; case 3:
- /* */ if (_v) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v) { */ case 1:
- _r$1 = exact.BoolVal(v); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return [_r$1, true];
- /* } */ case 2:
- _ref = expr;
- /* */ if ($assertType(_ref, ptrType, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$1, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$2, true)[1]) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($assertType(_ref, ptrType, true)[1]) { */ case 6:
- e = _ref.$val;
- _ref$1 = e.Op;
- /* */ if (_ref$1 === 34) { $s = 10; continue; }
- /* */ if (_ref$1 === 35) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_ref$1 === 34) { */ case 10:
- _r$2 = BoolValue(e.X, info); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; b = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (ok) { */ case 14:
- if (!b) {
- return [false, true];
- }
- _r$3 = BoolValue(e.Y, info); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- /* } */ case 15:
- $s = 12; continue;
- /* } else if (_ref$1 === 35) { */ case 11:
- _r$4 = BoolValue(e.X, info); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple$1 = _r$4; b$1 = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (ok$1) { */ case 18:
- if (b$1) {
- return [true, true];
- }
- _r$5 = BoolValue(e.Y, info); /* */ $s = 20; case 20: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- /* } */ case 19:
- /* } */ case 12:
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$1, true)[1]) { */ case 7:
- e$1 = _ref.$val;
- /* */ if (e$1.Op === 43) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (e$1.Op === 43) { */ case 21:
- _r$6 = BoolValue(e$1.X, info); /* */ $s = 23; case 23: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$2 = _r$6; b$2 = _tuple$2[0]; ok$2 = _tuple$2[1];
- /* */ if (ok$2) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (ok$2) { */ case 24:
- return [!b$2, true];
- /* } */ case 25:
- /* } */ case 22:
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$2, true)[1]) { */ case 8:
- e$2 = _ref.$val;
- _r$7 = BoolValue(e$2.X, info); /* */ $s = 26; case 26: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7;
- /* } */ case 9:
- return [false, false];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BoolValue }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._v = _v; $f.b = b; $f.b$1 = b$1; $f.b$2 = b$2; $f.e = e; $f.e$1 = e$1; $f.e$2 = e$2; $f.expr = expr; $f.info = info; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.BoolValue = BoolValue;
- HasBreak = function(n) {
- var $ptr, n, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; n = $f.n; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = [v];
- v[0] = new hasBreakVisitor.ptr(false);
- $r = ast.Walk(v[0], n); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return v[0].hasBreak;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: HasBreak }; } $f.$ptr = $ptr; $f.n = n; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.HasBreak = HasBreak;
- hasBreakVisitor.ptr.prototype.Visit = function(node) {
- var $ptr, _ref, n, n$1, node, v, w;
- w = $ifaceNil;
- v = this;
- if (v.hasBreak) {
- w = $ifaceNil;
- return w;
- }
- _ref = node;
- if ($assertType(_ref, ptrType$3, true)[1]) {
- n = _ref.$val;
- if ((n.Tok === 61) && n.Label === ptrType$9.nil) {
- v.hasBreak = true;
- w = $ifaceNil;
- return w;
- }
- } else if ($assertType(_ref, ptrType$4, true)[1] || $assertType(_ref, ptrType$5, true)[1] || $assertType(_ref, ptrType$6, true)[1] || $assertType(_ref, ptrType$7, true)[1] || $assertType(_ref, ptrType$8, true)[1] || $assertType(_ref, ast.Expr, true)[1]) {
- n$1 = _ref;
- w = $ifaceNil;
- return w;
- }
- w = v;
- return w;
- };
- hasBreakVisitor.prototype.Visit = function(node) { return this.$val.Visit(node); };
- EscapingObjects = function(n, info) {
- var $ptr, _entry, info, n, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; info = $f.info; n = $f.n; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = [v];
- v[0] = new escapeAnalysis.ptr(info, new $Map(), (_entry = info.Scopes[ast.Node.keyFor(n)], _entry !== undefined ? _entry.v : ptrType$11.nil), new $Map());
- $r = ast.Walk(v[0], n); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return v[0].escaping;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: EscapingObjects }; } $f.$ptr = $ptr; $f._entry = _entry; $f.info = info; $f.n = n; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.EscapingObjects = EscapingObjects;
- escapeAnalysis.ptr.prototype.Visit = function(node) {
- var $ptr, _entry, _entry$1, _key, _key$1, _ref, _tuple, n, n$1, n$2, node, ok, v, w;
- w = $ifaceNil;
- v = this;
- _ref = node;
- if ($assertType(_ref, ptrType$1, true)[1]) {
- n = _ref.$val;
- if (n.Op === 17) {
- _tuple = $assertType(n.X, ptrType$9, true); ok = _tuple[1];
- if (ok) {
- w = new escapingObjectCollector.ptr(v);
- return w;
- }
- }
- } else if ($assertType(_ref, ptrType$12, true)[1]) {
- n$1 = _ref.$val;
- _key = (_entry = v.info.Scopes[ast.Node.keyFor(n$1.Type)], _entry !== undefined ? _entry.v : ptrType$11.nil); (v.bottomScopes || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key)] = { k: _key, v: true };
- w = new escapingObjectCollector.ptr(v);
- return w;
- } else if ($assertType(_ref, ptrType$4, true)[1] || $assertType(_ref, ptrType$5, true)[1]) {
- n$2 = _ref;
- _key$1 = (_entry$1 = v.info.Scopes[ast.Node.keyFor(n$2)], _entry$1 !== undefined ? _entry$1.v : ptrType$11.nil); (v.bottomScopes || $throwRuntimeError("assignment to entry in nil map"))[ptrType$11.keyFor(_key$1)] = { k: _key$1, v: true };
- }
- w = v;
- return w;
- };
- escapeAnalysis.prototype.Visit = function(node) { return this.$val.Visit(node); };
- escapingObjectCollector.ptr.prototype.Visit = function(node) {
- var $ptr, _entry, _entry$1, _key, _tuple, _tuple$1, id, node, obj, ok, ok$1, s, v, w;
- w = $ifaceNil;
- v = this;
- _tuple = $assertType(node, ptrType$9, true); id = _tuple[0]; ok = _tuple[1];
- if (ok) {
- _tuple$1 = $assertType((_entry = v.analysis.info.Uses[ptrType$9.keyFor(id)], _entry !== undefined ? _entry.v : $ifaceNil), ptrType$13, true); obj = _tuple$1[0]; ok$1 = _tuple$1[1];
- if (ok$1) {
- s = obj.object.Parent();
- while (true) {
- if (!(!(s === ptrType$11.nil))) { break; }
- if (s === v.analysis.topScope) {
- _key = obj; (v.analysis.escaping || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key)] = { k: _key, v: true };
- break;
- }
- if ((_entry$1 = v.analysis.bottomScopes[ptrType$11.keyFor(s)], _entry$1 !== undefined ? _entry$1.v : false)) {
- break;
- }
- s = s.Parent();
- }
- }
- }
- w = v;
- return w;
- };
- escapingObjectCollector.prototype.Visit = function(node) { return this.$val.Visit(node); };
- Info.ptr.prototype.newFuncInfo = function() {
- var $ptr, funcInfo, info;
- info = this;
- funcInfo = new FuncInfo.ptr(false, new $Map(), new $Map(), new $Map(), new $Map(), sliceType.nil, info, sliceType$1.nil);
- info.allInfos = $append(info.allInfos, funcInfo);
- return funcInfo;
- };
- Info.prototype.newFuncInfo = function() { return this.$val.newFuncInfo(); };
- AnalyzePkg = function(files, fileSet, typesInfo, typesPkg, isBlocking) {
- var $ptr, _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _key, _keys, _keys$1, _r, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, call, calls, continueStmt$1, done, file, fileSet, files, funcInfo, funcInfo$1, info, isBlocking, k, obj, typesInfo, typesPkg, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _key = $f._key; _keys = $f._keys; _keys$1 = $f._keys$1; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; call = $f.call; calls = $f.calls; continueStmt$1 = $f.continueStmt$1; done = $f.done; file = $f.file; fileSet = $f.fileSet; files = $f.files; funcInfo = $f.funcInfo; funcInfo$1 = $f.funcInfo$1; info = $f.info; isBlocking = $f.isBlocking; k = $f.k; obj = $f.obj; typesInfo = $f.typesInfo; typesPkg = $f.typesPkg; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- info = new Info.ptr(typesInfo, typesPkg, isBlocking, new $Map(), new $Map(), new $Map(), ptrType$16.nil, sliceType$2.nil, new $Map());
- info.InitFuncInfo = info.newFuncInfo();
- _ref = files;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- file = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = ast.NewCommentMap(fileSet, file, file.Comments); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref$1 = _r;
- _i$1 = 0;
- _keys = $keys(_ref$1);
- /* while (true) { */ case 4:
- /* if (!(_i$1 < _keys.length)) { break; } */ if(!(_i$1 < _keys.length)) { $s = 5; continue; }
- _entry = _ref$1[_keys[_i$1]];
- if (_entry === undefined) {
- _i$1++;
- /* continue; */ $s = 4; continue;
- }
- k = _entry.k;
- v = _entry.v;
- _key = k; (info.comments || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key)] = { k: _key, v: v };
- _i$1++;
- /* } */ $s = 4; continue; case 5:
- $r = ast.Walk(info.InitFuncInfo, file); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- while (true) {
- done = true;
- _ref$2 = info.allInfos;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$2.$length)) { break; }
- funcInfo = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- _ref$3 = funcInfo.LocalCalls;
- _i$3 = 0;
- _keys$1 = $keys(_ref$3);
- while (true) {
- if (!(_i$3 < _keys$1.length)) { break; }
- _entry$1 = _ref$3[_keys$1[_i$3]];
- if (_entry$1 === undefined) {
- _i$3++;
- continue;
- }
- obj = _entry$1.k;
- calls = _entry$1.v;
- if (!(($keys((_entry$2 = info.FuncDeclInfos[ptrType$17.keyFor(obj)], _entry$2 !== undefined ? _entry$2.v : ptrType$16.nil).Blocking).length === 0))) {
- _ref$4 = calls;
- _i$4 = 0;
- while (true) {
- if (!(_i$4 < _ref$4.$length)) { break; }
- call = ((_i$4 < 0 || _i$4 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$4]);
- funcInfo.markBlocking(call);
- _i$4++;
- }
- delete funcInfo.LocalCalls[ptrType$17.keyFor(obj)];
- done = false;
- }
- _i$3++;
- }
- _i$2++;
- }
- if (done) {
- break;
- }
- }
- _ref$5 = info.allInfos;
- _i$5 = 0;
- while (true) {
- if (!(_i$5 < _ref$5.$length)) { break; }
- funcInfo$1 = ((_i$5 < 0 || _i$5 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$5]);
- _ref$6 = funcInfo$1.ContinueStmts;
- _i$6 = 0;
- while (true) {
- if (!(_i$6 < _ref$6.$length)) { break; }
- continueStmt$1 = $clone(((_i$6 < 0 || _i$6 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$6]), continueStmt);
- if ((_entry$3 = funcInfo$1.Blocking[ast.Node.keyFor(continueStmt$1.forStmt.Post)], _entry$3 !== undefined ? _entry$3.v : false)) {
- funcInfo$1.markBlocking(continueStmt$1.analyzeStack);
- }
- _i$6++;
- }
- _i$5++;
- }
- return info;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: AnalyzePkg }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._key = _key; $f._keys = _keys; $f._keys$1 = _keys$1; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f.call = call; $f.calls = calls; $f.continueStmt$1 = continueStmt$1; $f.done = done; $f.file = file; $f.fileSet = fileSet; $f.files = files; $f.funcInfo = funcInfo; $f.funcInfo$1 = funcInfo$1; $f.info = info; $f.isBlocking = isBlocking; $f.k = k; $f.obj = obj; $f.typesInfo = typesInfo; $f.typesPkg = typesPkg; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.AnalyzePkg = AnalyzePkg;
- FuncInfo.ptr.prototype.Visit = function(node) {
- var $ptr, _entry, _entry$1, _entry$2, _entry$3, _entry$4, _entry$5, _entry$6, _entry$7, _entry$8, _entry$9, _i, _i$1, _i$2, _i$3, _i$4, _key, _key$1, _key$2, _key$3, _key$4, _r, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, arg, arg$1, c, callTo, comm, comm$1, comm$2, f, f$1, f$2, f$3, forStmt, funcLit, i, i$1, id, label, labelStmt, n, n$1, n$10, n$2, n$3, n$4, n$5, n$6, n$7, n$8, n$9, n2, newInfo, newInfo$1, node, ok, ok$1, ok$2, ok$3, ok$4, ok$5, ok$6, s, s$1, sel, stack, stack$1, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _entry$7 = $f._entry$7; _entry$8 = $f._entry$8; _entry$9 = $f._entry$9; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _key$4 = $f._key$4; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; arg = $f.arg; arg$1 = $f.arg$1; c = $f.c; callTo = $f.callTo; comm = $f.comm; comm$1 = $f.comm$1; comm$2 = $f.comm$2; f = $f.f; f$1 = $f.f$1; f$2 = $f.f$2; f$3 = $f.f$3; forStmt = $f.forStmt; funcLit = $f.funcLit; i = $f.i; i$1 = $f.i$1; id = $f.id; label = $f.label; labelStmt = $f.labelStmt; n = $f.n; n$1 = $f.n$1; n$10 = $f.n$10; n$2 = $f.n$2; n$3 = $f.n$3; n$4 = $f.n$4; n$5 = $f.n$5; n$6 = $f.n$6; n$7 = $f.n$7; n$8 = $f.n$8; n$9 = $f.n$9; n2 = $f.n2; newInfo = $f.newInfo; newInfo$1 = $f.newInfo$1; node = $f.node; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; ok$3 = $f.ok$3; ok$4 = $f.ok$4; ok$5 = $f.ok$5; ok$6 = $f.ok$6; s = $f.s; s$1 = $f.s$1; sel = $f.sel; stack = $f.stack; stack$1 = $f.stack$1; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = [c];
- c[0] = this;
- if ($interfaceIsEqual(node, $ifaceNil)) {
- if (!((c[0].analyzeStack.$length === 0))) {
- c[0].analyzeStack = $subslice(c[0].analyzeStack, 0, (c[0].analyzeStack.$length - 1 >> 0));
- }
- return $ifaceNil;
- }
- c[0].analyzeStack = $append(c[0].analyzeStack, node);
- _ref = node;
- /* */ if ($assertType(_ref, ptrType$18, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$12, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$19, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$1, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$8, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$22, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$23, true)[1]) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ($assertType(_ref, ptrType$18, true)[1]) { */ case 1:
- n = _ref.$val;
- newInfo = c[0].p.newFuncInfo();
- _key = $assertType((_entry = c[0].p.Info.Defs[ptrType$9.keyFor(n.Name)], _entry !== undefined ? _entry.v : $ifaceNil), ptrType$17); (c[0].p.FuncDeclInfos || $throwRuntimeError("assignment to entry in nil map"))[ptrType$17.keyFor(_key)] = { k: _key, v: newInfo };
- return newInfo;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$12, true)[1]) { */ case 2:
- n$1 = _ref.$val;
- newInfo$1 = c[0].p.newFuncInfo();
- _key$1 = n$1; (c[0].p.FuncLitInfos || $throwRuntimeError("assignment to entry in nil map"))[ptrType$12.keyFor(_key$1)] = { k: _key$1, v: newInfo$1 };
- return newInfo$1;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$3, true)[1]) { */ case 3:
- n$2 = _ref.$val;
- _ref$1 = n$2.Tok;
- if (_ref$1 === 73) {
- _ref$2 = c[0].analyzeStack;
- _i = 0;
- while (true) {
- if (!(_i < _ref$2.$length)) { break; }
- n2 = ((_i < 0 || _i >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i]);
- _key$2 = n2; (c[0].Flattened || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$2)] = { k: _key$2, v: true };
- _i++;
- }
- _key$3 = $assertType((_entry$1 = c[0].p.Info.Uses[ptrType$9.keyFor(n$2.Label)], _entry$1 !== undefined ? _entry$1.v : $ifaceNil), ptrType$24); (c[0].GotoLabel || $throwRuntimeError("assignment to entry in nil map"))[ptrType$24.keyFor(_key$3)] = { k: _key$3, v: true };
- } else if (_ref$1 === 65) {
- if (!(n$2.Label === ptrType$9.nil)) {
- label = $assertType((_entry$2 = c[0].p.Info.Uses[ptrType$9.keyFor(n$2.Label)], _entry$2 !== undefined ? _entry$2.v : $ifaceNil), ptrType$24);
- i = c[0].analyzeStack.$length - 1 >> 0;
- while (true) {
- if (!(i >= 0)) { break; }
- _tuple = $assertType((x = c[0].analyzeStack, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])), ptrType$25, true); labelStmt = _tuple[0]; ok = _tuple[1];
- if (ok && $interfaceIsEqual((_entry$3 = c[0].p.Info.Defs[ptrType$9.keyFor(labelStmt.Label)], _entry$3 !== undefined ? _entry$3.v : $ifaceNil), label)) {
- _tuple$1 = $assertType(labelStmt.Stmt, ptrType$5, true); ok$1 = _tuple$1[1];
- if (ok$1) {
- return $ifaceNil;
- }
- stack = $makeSlice(sliceType$1, c[0].analyzeStack.$length);
- $copySlice(stack, c[0].analyzeStack);
- c[0].ContinueStmts = $append(c[0].ContinueStmts, new continueStmt.ptr($assertType(labelStmt.Stmt, ptrType$4), stack));
- return $ifaceNil;
- }
- i = i - (1) >> 0;
- }
- return $ifaceNil;
- }
- i$1 = c[0].analyzeStack.$length - 1 >> 0;
- while (true) {
- if (!(i$1 >= 0)) { break; }
- _tuple$2 = $assertType((x$1 = c[0].analyzeStack, ((i$1 < 0 || i$1 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i$1])), ptrType$5, true); ok$2 = _tuple$2[1];
- if (ok$2) {
- return $ifaceNil;
- }
- _tuple$3 = $assertType((x$2 = c[0].analyzeStack, ((i$1 < 0 || i$1 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$1])), ptrType$4, true); forStmt = _tuple$3[0]; ok$3 = _tuple$3[1];
- if (ok$3) {
- stack$1 = $makeSlice(sliceType$1, c[0].analyzeStack.$length);
- $copySlice(stack$1, c[0].analyzeStack);
- c[0].ContinueStmts = $append(c[0].ContinueStmts, new continueStmt.ptr(forStmt, stack$1));
- return $ifaceNil;
- }
- i$1 = i$1 - (1) >> 0;
- }
- }
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$19, true)[1]) { */ case 4:
- n$3 = _ref.$val;
- callTo = (function(c) { return function $b(obj) {
- var $ptr, _entry$4, _key$4, _r, _r$1, _ref$3, _tuple$4, o, o$1, obj, ok$4, recv, stack$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry$4 = $f._entry$4; _key$4 = $f._key$4; _r = $f._r; _r$1 = $f._r$1; _ref$3 = $f._ref$3; _tuple$4 = $f._tuple$4; o = $f.o; o$1 = $f.o$1; obj = $f.obj; ok$4 = $f.ok$4; recv = $f.recv; stack$2 = $f.stack$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref$3 = obj;
- /* */ if ($assertType(_ref$3, ptrType$17, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref$3, ptrType$13, true)[1]) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($assertType(_ref$3, ptrType$17, true)[1]) { */ case 1:
- o = _ref$3.$val;
- recv = $assertType(o.object.Type(), ptrType$26).Recv();
- /* */ if (!(recv === ptrType$13.nil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(recv === ptrType$13.nil)) { */ case 4:
- _r = recv.object.Type().Underlying(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$4 = $assertType(_r, ptrType$27, true); ok$4 = _tuple$4[1];
- /* */ if (ok$4) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (ok$4) { */ case 7:
- c[0].markBlocking(c[0].analyzeStack);
- return;
- /* } */ case 8:
- /* } */ case 5:
- /* */ if (!(o.object.Pkg() === c[0].p.Pkg)) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!(o.object.Pkg() === c[0].p.Pkg)) { */ case 9:
- _r$1 = c[0].p.IsBlocking(o); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_r$1) { */ case 11:
- c[0].markBlocking(c[0].analyzeStack);
- /* } */ case 12:
- return;
- /* } */ case 10:
- stack$2 = $makeSlice(sliceType$1, c[0].analyzeStack.$length);
- $copySlice(stack$2, c[0].analyzeStack);
- _key$4 = o; (c[0].LocalCalls || $throwRuntimeError("assignment to entry in nil map"))[ptrType$17.keyFor(_key$4)] = { k: _key$4, v: $append((_entry$4 = c[0].LocalCalls[ptrType$17.keyFor(o)], _entry$4 !== undefined ? _entry$4.v : sliceType$3.nil), stack$2) };
- $s = 3; continue;
- /* } else if ($assertType(_ref$3, ptrType$13, true)[1]) { */ case 2:
- o$1 = _ref$3.$val;
- c[0].markBlocking(c[0].analyzeStack);
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry$4 = _entry$4; $f._key$4 = _key$4; $f._r = _r; $f._r$1 = _r$1; $f._ref$3 = _ref$3; $f._tuple$4 = _tuple$4; $f.o = o; $f.o$1 = o$1; $f.obj = obj; $f.ok$4 = ok$4; $f.recv = recv; $f.stack$2 = stack$2; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c);
- _ref$3 = astutil.RemoveParens(n$3.Fun);
- /* */ if ($assertType(_ref$3, ptrType$9, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref$3, ptrType$28, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref$3, ptrType$12, true)[1]) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* switch (0) { default: if ($assertType(_ref$3, ptrType$9, true)[1]) { */ case 13:
- f = _ref$3.$val;
- $r = callTo((_entry$4 = c[0].p.Info.Uses[ptrType$9.keyFor(f)], _entry$4 !== undefined ? _entry$4.v : $ifaceNil)); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 17; continue;
- /* } else if ($assertType(_ref$3, ptrType$28, true)[1]) { */ case 14:
- f$1 = _ref$3.$val;
- sel = (_entry$5 = c[0].p.Info.Selections[ptrType$28.keyFor(f$1)], _entry$5 !== undefined ? _entry$5.v : ptrType$29.nil);
- if (!(sel === ptrType$29.nil) && typesutil.IsJsObject(sel.Recv())) {
- /* break; */ $s = 17; continue;
- }
- $r = callTo((_entry$6 = c[0].p.Info.Uses[ptrType$9.keyFor(f$1.Sel)], _entry$6 !== undefined ? _entry$6.v : $ifaceNil)); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 17; continue;
- /* } else if ($assertType(_ref$3, ptrType$12, true)[1]) { */ case 15:
- f$2 = _ref$3.$val;
- $r = ast.Walk(c[0], n$3.Fun); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$4 = n$3.Args;
- _i$1 = 0;
- /* while (true) { */ case 21:
- /* if (!(_i$1 < _ref$4.$length)) { break; } */ if(!(_i$1 < _ref$4.$length)) { $s = 22; continue; }
- arg = ((_i$1 < 0 || _i$1 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$1]);
- $r = ast.Walk(c[0], arg); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 21; continue; case 22:
- if (!(($keys((_entry$7 = c[0].p.FuncLitInfos[ptrType$12.keyFor(f$2)], _entry$7 !== undefined ? _entry$7.v : ptrType$16.nil).Blocking).length === 0))) {
- c[0].markBlocking(c[0].analyzeStack);
- }
- return $ifaceNil;
- $s = 17; continue;
- /* } else { */ case 16:
- f$3 = _ref$3;
- if (!astutil.IsTypeExpr(f$3, c[0].p.Info)) {
- c[0].markBlocking(c[0].analyzeStack);
- }
- /* } } */ case 17:
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1]) { */ case 5:
- n$4 = _ref.$val;
- c[0].markBlocking(c[0].analyzeStack);
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$1, true)[1]) { */ case 6:
- n$5 = _ref.$val;
- _ref$5 = n$5.Op;
- if (_ref$5 === 17) {
- _tuple$4 = $assertType(astutil.RemoveParens(n$5.X), ptrType$9, true); id = _tuple$4[0]; ok$4 = _tuple$4[1];
- if (ok$4) {
- _key$4 = $assertType((_entry$8 = c[0].p.Info.Uses[ptrType$9.keyFor(id)], _entry$8 !== undefined ? _entry$8.v : $ifaceNil), ptrType$13); (c[0].p.HasPointer || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$4)] = { k: _key$4, v: true };
- }
- } else if (_ref$5 === 36) {
- c[0].markBlocking(c[0].analyzeStack);
- }
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1]) { */ case 7:
- n$6 = _ref.$val;
- _r = (_entry$9 = c[0].p.Info.Types[ast.Expr.keyFor(n$6.X)], _entry$9 !== undefined ? _entry$9.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 24; case 24: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$5 = $assertType(_r, ptrType$30, true); ok$5 = _tuple$5[1];
- /* */ if (ok$5) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if (ok$5) { */ case 25:
- c[0].markBlocking(c[0].analyzeStack);
- /* } */ case 26:
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$8, true)[1]) { */ case 8:
- n$7 = _ref.$val;
- _ref$6 = n$7.Body.List;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$6.$length)) { break; }
- s = ((_i$2 < 0 || _i$2 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$2]);
- if ($interfaceIsEqual($assertType(s, ptrType$21).Comm, $ifaceNil)) {
- return c[0];
- }
- _i$2++;
- }
- c[0].markBlocking(c[0].analyzeStack);
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$21, true)[1]) { */ case 9:
- n$8 = _ref.$val;
- _ref$7 = n$8.Comm;
- /* */ if ($assertType(_ref$7, ptrType$20, true)[1]) { $s = 27; continue; }
- /* */ if ($assertType(_ref$7, ptrType$31, true)[1]) { $s = 28; continue; }
- /* */ if ($assertType(_ref$7, ptrType$32, true)[1]) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if ($assertType(_ref$7, ptrType$20, true)[1]) { */ case 27:
- comm = _ref$7.$val;
- $r = ast.Walk(c[0], comm.Chan); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.Walk(c[0], comm.Value); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 30; continue;
- /* } else if ($assertType(_ref$7, ptrType$31, true)[1]) { */ case 28:
- comm$1 = _ref$7.$val;
- $r = ast.Walk(c[0], $assertType(comm$1.X, ptrType$1).X); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 30; continue;
- /* } else if ($assertType(_ref$7, ptrType$32, true)[1]) { */ case 29:
- comm$2 = _ref$7.$val;
- $r = ast.Walk(c[0], $assertType((x$3 = comm$2.Rhs, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0])), ptrType$1).X); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 30:
- _ref$8 = n$8.Body;
- _i$3 = 0;
- /* while (true) { */ case 35:
- /* if (!(_i$3 < _ref$8.$length)) { break; } */ if(!(_i$3 < _ref$8.$length)) { $s = 36; continue; }
- s$1 = ((_i$3 < 0 || _i$3 >= _ref$8.$length) ? $throwRuntimeError("index out of range") : _ref$8.$array[_ref$8.$offset + _i$3]);
- $r = ast.Walk(c[0], s$1); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$3++;
- /* } */ $s = 35; continue; case 36:
- return $ifaceNil;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$22, true)[1]) { */ case 10:
- n$9 = _ref.$val;
- $r = ast.Walk(c[0], n$9.Call.Fun); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$9 = n$9.Call.Args;
- _i$4 = 0;
- /* while (true) { */ case 39:
- /* if (!(_i$4 < _ref$9.$length)) { break; } */ if(!(_i$4 < _ref$9.$length)) { $s = 40; continue; }
- arg$1 = ((_i$4 < 0 || _i$4 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$4]);
- $r = ast.Walk(c[0], arg$1); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$4++;
- /* } */ $s = 39; continue; case 40:
- return $ifaceNil;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$23, true)[1]) { */ case 11:
- n$10 = _ref.$val;
- c[0].HasDefer = true;
- _tuple$6 = $assertType(n$10.Call.Fun, ptrType$12, true); funcLit = _tuple$6[0]; ok$6 = _tuple$6[1];
- /* */ if (ok$6) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (ok$6) { */ case 42:
- $r = ast.Walk(c[0], funcLit.Body); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 43:
- /* } */ case 12:
- return c[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FuncInfo.ptr.prototype.Visit }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._entry$7 = _entry$7; $f._entry$8 = _entry$8; $f._entry$9 = _entry$9; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._key$4 = _key$4; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f.arg = arg; $f.arg$1 = arg$1; $f.c = c; $f.callTo = callTo; $f.comm = comm; $f.comm$1 = comm$1; $f.comm$2 = comm$2; $f.f = f; $f.f$1 = f$1; $f.f$2 = f$2; $f.f$3 = f$3; $f.forStmt = forStmt; $f.funcLit = funcLit; $f.i = i; $f.i$1 = i$1; $f.id = id; $f.label = label; $f.labelStmt = labelStmt; $f.n = n; $f.n$1 = n$1; $f.n$10 = n$10; $f.n$2 = n$2; $f.n$3 = n$3; $f.n$4 = n$4; $f.n$5 = n$5; $f.n$6 = n$6; $f.n$7 = n$7; $f.n$8 = n$8; $f.n$9 = n$9; $f.n2 = n2; $f.newInfo = newInfo; $f.newInfo$1 = newInfo$1; $f.node = node; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.ok$3 = ok$3; $f.ok$4 = ok$4; $f.ok$5 = ok$5; $f.ok$6 = ok$6; $f.s = s; $f.s$1 = s$1; $f.sel = sel; $f.stack = stack; $f.stack$1 = stack$1; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- FuncInfo.prototype.Visit = function(node) { return this.$val.Visit(node); };
- FuncInfo.ptr.prototype.markBlocking = function(stack) {
- var $ptr, _i, _key, _key$1, _ref, c, n, stack;
- c = this;
- _ref = stack;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- n = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _key = n; (c.Blocking || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key)] = { k: _key, v: true };
- _key$1 = n; (c.Flattened || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$1)] = { k: _key$1, v: true };
- _i++;
- }
- };
- FuncInfo.prototype.markBlocking = function(stack) { return this.$val.markBlocking(stack); };
- HasSideEffect = function(n, info) {
- var $ptr, info, n, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; info = $f.info; n = $f.n; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- v = [v];
- v[0] = new hasSideEffectVisitor.ptr(info, false);
- $r = ast.Walk(v[0], n); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return v[0].hasSideEffect;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: HasSideEffect }; } $f.$ptr = $ptr; $f.info = info; $f.n = n; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.HasSideEffect = HasSideEffect;
- hasSideEffectVisitor.ptr.prototype.Visit = function(node) {
- var $ptr, _entry, _ref, _tuple, isSig, n, n$1, node, v, w;
- w = $ifaceNil;
- v = this;
- if (v.hasSideEffect) {
- w = $ifaceNil;
- return w;
- }
- _ref = node;
- if ($assertType(_ref, ptrType$19, true)[1]) {
- n = _ref.$val;
- _tuple = $assertType((_entry = v.info.Types[ast.Expr.keyFor(n.Fun)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type, ptrType$26, true); isSig = _tuple[1];
- if (isSig) {
- v.hasSideEffect = true;
- w = $ifaceNil;
- return w;
- }
- } else if ($assertType(_ref, ptrType$1, true)[1]) {
- n$1 = _ref.$val;
- if (n$1.Op === 36) {
- v.hasSideEffect = true;
- w = $ifaceNil;
- return w;
- }
- }
- w = v;
- return w;
- };
- hasSideEffectVisitor.prototype.Visit = function(node) { return this.$val.Visit(node); };
- ptrType$33.methods = [{prop: "Visit", name: "Visit", pkg: "", typ: $funcType([ast.Node], [ast.Visitor], false)}];
- ptrType$34.methods = [{prop: "Visit", name: "Visit", pkg: "", typ: $funcType([ast.Node], [ast.Visitor], false)}];
- ptrType$35.methods = [{prop: "Visit", name: "Visit", pkg: "", typ: $funcType([ast.Node], [ast.Visitor], false)}];
- ptrType$14.methods = [{prop: "newFuncInfo", name: "newFuncInfo", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: $funcType([], [ptrType$16], false)}];
- ptrType$16.methods = [{prop: "Visit", name: "Visit", pkg: "", typ: $funcType([ast.Node], [ast.Visitor], false)}, {prop: "markBlocking", name: "markBlocking", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: $funcType([sliceType$1], [], false)}];
- ptrType$36.methods = [{prop: "Visit", name: "Visit", pkg: "", typ: $funcType([ast.Node], [ast.Visitor], false)}];
- hasBreakVisitor.init([{prop: "hasBreak", name: "hasBreak", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: $Bool, tag: ""}]);
- escapeAnalysis.init([{prop: "info", name: "info", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: ptrType$10, tag: ""}, {prop: "escaping", name: "escaping", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: mapType, tag: ""}, {prop: "topScope", name: "topScope", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: ptrType$11, tag: ""}, {prop: "bottomScopes", name: "bottomScopes", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: mapType$1, tag: ""}]);
- escapingObjectCollector.init([{prop: "analysis", name: "analysis", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: ptrType$34, tag: ""}]);
- continueStmt.init([{prop: "forStmt", name: "forStmt", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: ptrType$4, tag: ""}, {prop: "analyzeStack", name: "analyzeStack", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: sliceType$1, tag: ""}]);
- Info.init([{prop: "Info", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "Pkg", name: "Pkg", pkg: "", typ: ptrType$15, tag: ""}, {prop: "IsBlocking", name: "IsBlocking", pkg: "", typ: funcType, tag: ""}, {prop: "HasPointer", name: "HasPointer", pkg: "", typ: mapType, tag: ""}, {prop: "FuncDeclInfos", name: "FuncDeclInfos", pkg: "", typ: mapType$2, tag: ""}, {prop: "FuncLitInfos", name: "FuncLitInfos", pkg: "", typ: mapType$3, tag: ""}, {prop: "InitFuncInfo", name: "InitFuncInfo", pkg: "", typ: ptrType$16, tag: ""}, {prop: "allInfos", name: "allInfos", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: sliceType$2, tag: ""}, {prop: "comments", name: "comments", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: ast.CommentMap, tag: ""}]);
- FuncInfo.init([{prop: "HasDefer", name: "HasDefer", pkg: "", typ: $Bool, tag: ""}, {prop: "Flattened", name: "Flattened", pkg: "", typ: mapType$4, tag: ""}, {prop: "Blocking", name: "Blocking", pkg: "", typ: mapType$4, tag: ""}, {prop: "GotoLabel", name: "GotoLabel", pkg: "", typ: mapType$5, tag: ""}, {prop: "LocalCalls", name: "LocalCalls", pkg: "", typ: mapType$6, tag: ""}, {prop: "ContinueStmts", name: "ContinueStmts", pkg: "", typ: sliceType, tag: ""}, {prop: "p", name: "p", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: ptrType$14, tag: ""}, {prop: "analyzeStack", name: "analyzeStack", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: sliceType$1, tag: ""}]);
- hasSideEffectVisitor.init([{prop: "info", name: "info", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: ptrType$10, tag: ""}, {prop: "hasSideEffect", name: "hasSideEffect", pkg: "github.com/gopherjs/gopherjs/compiler/analysis", typ: $Bool, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = astutil.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = typesutil.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = exact.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = types.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs/compiler/filter"] = (function() {
- var $pkg = {}, $init, analysis, astutil, ast, token, exact, types, ptrType, sliceType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, sliceType$1, ptrType$7, ptrType$8, ptrType$9, ptrType$10, Assign, IncDecStmt;
- analysis = $packages["github.com/gopherjs/gopherjs/compiler/analysis"];
- astutil = $packages["github.com/gopherjs/gopherjs/compiler/astutil"];
- ast = $packages["go/ast"];
- token = $packages["go/token"];
- exact = $packages["golang.org/x/tools/go/exact"];
- types = $packages["golang.org/x/tools/go/types"];
- ptrType = $ptrType(ast.AssignStmt);
- sliceType = $sliceType(ast.Stmt);
- ptrType$1 = $ptrType(ast.IndexExpr);
- ptrType$2 = $ptrType(ast.SelectorExpr);
- ptrType$3 = $ptrType(ast.StarExpr);
- ptrType$4 = $ptrType(ast.Ident);
- ptrType$5 = $ptrType(ast.BasicLit);
- ptrType$6 = $ptrType(types.Selection);
- sliceType$1 = $sliceType(ast.Expr);
- ptrType$7 = $ptrType(ast.IncDecStmt);
- ptrType$8 = $ptrType(types.Array);
- ptrType$9 = $ptrType(types.Slice);
- ptrType$10 = $ptrType(types.Map);
- Assign = function(stmt, info) {
- var $ptr, _entry, _entry$1, _r, _ref, _tuple, info, lhs, list, ok, op, s, stmt, viaTmpVars, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; info = $f.info; lhs = $f.lhs; list = $f.list; ok = $f.ok; op = $f.op; s = $f.s; stmt = $f.stmt; viaTmpVars = $f.viaTmpVars; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- info = [info];
- list = [list];
- viaTmpVars = [viaTmpVars];
- _tuple = $assertType(stmt, ptrType, true); s = _tuple[0]; ok = _tuple[1];
- /* */ if (ok && !((s.Tok === 42)) && !((s.Tok === 47))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok && !((s.Tok === 42)) && !((s.Tok === 47))) { */ case 1:
- op = 0;
- _ref = s.Tok;
- if (_ref === 23) {
- op = 12;
- } else if (_ref === 24) {
- op = 13;
- } else if (_ref === 25) {
- op = 14;
- } else if (_ref === 26) {
- op = 15;
- } else if (_ref === 27) {
- op = 16;
- } else if (_ref === 28) {
- op = 17;
- } else if (_ref === 29) {
- op = 18;
- } else if (_ref === 30) {
- op = 19;
- } else if (_ref === 31) {
- op = 20;
- } else if (_ref === 32) {
- op = 21;
- } else if (_ref === 33) {
- op = 22;
- } else {
- $panic(new token.Token(s.Tok));
- }
- list[0] = sliceType.nil;
- viaTmpVars[0] = $throwNilPointerError;
- viaTmpVars[0] = (function(info, list, viaTmpVars) { return function $b(expr, name) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _entry, _entry$1, _entry$2, _entry$3, _entry$4, _key, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref$1, _tuple$1, e, e$1, e$2, e$3, e$4, expr, name, newSel, ok$1, sel, tmpVar, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref$1 = $f._ref$1; _tuple$1 = $f._tuple$1; e = $f.e; e$1 = $f.e$1; e$2 = $f.e$2; e$3 = $f.e$3; e$4 = $f.e$4; expr = $f.expr; name = $f.name; newSel = $f.newSel; ok$1 = $f.ok$1; sel = $f.sel; tmpVar = $f.tmpVar; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref$1 = astutil.RemoveParens(expr);
- /* */ if ($assertType(_ref$1, ptrType$1, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref$1, ptrType$2, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref$1, ptrType$3, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref$1, ptrType$4, true)[1] || $assertType(_ref$1, ptrType$5, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref$1, ptrType$1, true)[1]) { */ case 1:
- e = _ref$1.$val;
- _arg = info[0].Info;
- _arg$1 = (_entry = info[0].Info.Types[ast.Expr.keyFor(e)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type;
- _r = viaTmpVars[0](e.X, "_slice"); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = viaTmpVars[0](e.Index, "_index"); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$2 = new ast.IndexExpr.ptr(_r, 0, _r$1, 0);
- _r$2 = astutil.SetType(_arg, _arg$1, _arg$2); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- $s = 6; continue;
- /* } else if ($assertType(_ref$1, ptrType$2, true)[1]) { */ case 2:
- e$1 = _ref$1.$val;
- _tuple$1 = (_entry$1 = info[0].Info.Selections[ptrType$2.keyFor(e$1)], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$6.nil, false]); sel = _tuple$1[0]; ok$1 = _tuple$1[1];
- if (!ok$1) {
- return e$1;
- }
- _r$3 = viaTmpVars[0](e$1.X, "_struct"); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- newSel = new ast.SelectorExpr.ptr(_r$3, e$1.Sel);
- _key = newSel; (info[0].Info.Selections || $throwRuntimeError("assignment to entry in nil map"))[ptrType$2.keyFor(_key)] = { k: _key, v: sel };
- return astutil.SetType(info[0].Info, (_entry$2 = info[0].Info.Types[ast.Expr.keyFor(e$1)], _entry$2 !== undefined ? _entry$2.v : new types.TypeAndValue.ptr()).Type, newSel);
- $s = 6; continue;
- /* } else if ($assertType(_ref$1, ptrType$3, true)[1]) { */ case 3:
- e$2 = _ref$1.$val;
- _arg$3 = info[0].Info;
- _arg$4 = (_entry$3 = info[0].Info.Types[ast.Expr.keyFor(e$2)], _entry$3 !== undefined ? _entry$3.v : new types.TypeAndValue.ptr()).Type;
- _r$4 = viaTmpVars[0](e$2.X, "_ptr"); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$5 = new ast.StarExpr.ptr(0, _r$4);
- _r$5 = astutil.SetType(_arg$3, _arg$4, _arg$5); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- $s = 6; continue;
- /* } else if ($assertType(_ref$1, ptrType$4, true)[1] || $assertType(_ref$1, ptrType$5, true)[1]) { */ case 4:
- e$3 = _ref$1;
- return e$3;
- $s = 6; continue;
- /* } else { */ case 5:
- e$4 = _ref$1;
- tmpVar = astutil.NewIdent(name, (_entry$4 = info[0].Info.Types[ast.Expr.keyFor(e$4)], _entry$4 !== undefined ? _entry$4.v : new types.TypeAndValue.ptr()).Type, info[0].Info, info[0].Pkg);
- list[0] = $append(list[0], new ast.AssignStmt.ptr(new sliceType$1([tmpVar]), 0, 47, new sliceType$1([e$4])));
- return tmpVar;
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref$1 = _ref$1; $f._tuple$1 = _tuple$1; $f.e = e; $f.e$1 = e$1; $f.e$2 = e$2; $f.e$3 = e$3; $f.e$4 = e$4; $f.expr = expr; $f.name = name; $f.newSel = newSel; $f.ok$1 = ok$1; $f.sel = sel; $f.tmpVar = tmpVar; $f.$s = $s; $f.$r = $r; return $f;
- }; })(info, list, viaTmpVars);
- _r = viaTmpVars[0]((x = s.Lhs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])), "_val"); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- lhs = _r;
- list[0] = $append(list[0], new ast.AssignStmt.ptr(new sliceType$1([lhs]), 0, 42, new sliceType$1([astutil.SetType(info[0].Info, (_entry = info[0].Info.Types[ast.Expr.keyFor((x$1 = s.Lhs, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])))], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type, new ast.BinaryExpr.ptr(lhs, 0, op, astutil.SetType(info[0].Info, (_entry$1 = info[0].Info.Types[ast.Expr.keyFor((x$2 = s.Rhs, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])))], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Type, new ast.ParenExpr.ptr(0, (x$3 = s.Rhs, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0])), 0))))])));
- return new ast.BlockStmt.ptr(0, list[0], 0);
- /* } */ case 2:
- return stmt;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Assign }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.info = info; $f.lhs = lhs; $f.list = list; $f.ok = ok; $f.op = op; $f.s = s; $f.stmt = stmt; $f.viaTmpVars = viaTmpVars; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Assign = Assign;
- IncDecStmt = function(stmt, info) {
- var $ptr, _entry, _entry$1, _key, _r, _ref, _tuple, _tuple$1, iExpr, info, isIExpr, ok, one, s, stmt, t, tok, u, u$1, u$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _key = $f._key; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; iExpr = $f.iExpr; info = $f.info; isIExpr = $f.isIExpr; ok = $f.ok; one = $f.one; s = $f.s; stmt = $f.stmt; t = $f.t; tok = $f.tok; u = $f.u; u$1 = $f.u$1; u$2 = $f.u$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tuple = $assertType(stmt, ptrType$7, true); s = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- t = (_entry = info.Info.Types[ast.Expr.keyFor(s.X)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type;
- _tuple$1 = $assertType(s.X, ptrType$1, true); iExpr = _tuple$1[0]; isIExpr = _tuple$1[1];
- /* */ if (isIExpr) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (isIExpr) { */ case 3:
- _r = (_entry$1 = info.Info.Types[ast.Expr.keyFor(iExpr.X)], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$8, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($assertType(_ref, ptrType$8, true)[1]) { */ case 6:
- u = _ref.$val;
- t = u.Elem();
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 7:
- u$1 = _ref.$val;
- t = u$1.Elem();
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1]) { */ case 8:
- u$2 = _ref.$val;
- t = u$2.Elem();
- /* } */ case 9:
- /* } */ case 4:
- tok = 23;
- if (s.Tok === 38) {
- tok = 24;
- }
- one = new ast.BasicLit.ptr(0, 5, "");
- _key = one; (info.Info.Types || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key)] = { k: _key, v: new types.TypeAndValue.ptr(0, t, exact.MakeInt64(new $Int64(0, 1))) };
- return new ast.AssignStmt.ptr(new sliceType$1([s.X]), 0, tok, new sliceType$1([one]));
- /* } */ case 2:
- return stmt;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: IncDecStmt }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._key = _key; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.iExpr = iExpr; $f.info = info; $f.isIExpr = isIExpr; $f.ok = ok; $f.one = one; $f.s = s; $f.stmt = stmt; $f.t = t; $f.tok = tok; $f.u = u; $f.u$1 = u$1; $f.u$2 = u$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.IncDecStmt = IncDecStmt;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = analysis.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = astutil.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = exact.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = types.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs/compiler/prelude"] = (function() {
- var $pkg = {}, $init;
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["golang.org/x/tools/go/importer"] = (function() {
- var $pkg = {}, $init, bytes, binary, fmt, ast, token, exact, types, strings, exporter, importer, sliceType, sliceType$1, sliceType$2, ptrType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, sliceType$3, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, ptrType$12, ptrType$13, arrayType, sliceType$4, sliceType$5, sliceType$6, sliceType$7, sliceType$8, ptrType$14, ptrType$15, ptrType$16, mapType, mapType$1, ptrType$17, mapType$2, predeclared, _r, format, ExportData, exported, ImportData, deref;
- bytes = $packages["bytes"];
- binary = $packages["encoding/binary"];
- fmt = $packages["fmt"];
- ast = $packages["go/ast"];
- token = $packages["go/token"];
- exact = $packages["golang.org/x/tools/go/exact"];
- types = $packages["golang.org/x/tools/go/types"];
- strings = $packages["strings"];
- exporter = $pkg.exporter = $newType(0, $kindStruct, "importer.exporter", "exporter", "golang.org/x/tools/go/importer", function(data_, pkgIndex_, typIndex_, indent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.data = sliceType$1.nil;
- this.pkgIndex = false;
- this.typIndex = false;
- this.indent = "";
- return;
- }
- this.data = data_;
- this.pkgIndex = pkgIndex_;
- this.typIndex = typIndex_;
- this.indent = indent_;
- });
- importer = $pkg.importer = $newType(0, $kindStruct, "importer.importer", "importer", "golang.org/x/tools/go/importer", function(data_, datalen_, imports_, pkgList_, typList_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.data = sliceType$1.nil;
- this.datalen = 0;
- this.imports = false;
- this.pkgList = sliceType$4.nil;
- this.typList = sliceType.nil;
- return;
- }
- this.data = data_;
- this.datalen = datalen_;
- this.imports = imports_;
- this.pkgList = pkgList_;
- this.typList = typList_;
- });
- sliceType = $sliceType(types.Type);
- sliceType$1 = $sliceType($Uint8);
- sliceType$2 = $sliceType(types.Object);
- ptrType = $ptrType(types.Package);
- ptrType$1 = $ptrType(types.Const);
- ptrType$2 = $ptrType(types.TypeName);
- ptrType$3 = $ptrType(types.Var);
- ptrType$4 = $ptrType(types.Func);
- ptrType$5 = $ptrType(types.Named);
- sliceType$3 = $sliceType($emptyInterface);
- ptrType$6 = $ptrType(types.Array);
- ptrType$7 = $ptrType(types.Slice);
- ptrType$8 = $ptrType(types.Struct);
- ptrType$9 = $ptrType(types.Pointer);
- ptrType$10 = $ptrType(types.Signature);
- ptrType$11 = $ptrType(types.Interface);
- ptrType$12 = $ptrType(types.Map);
- ptrType$13 = $ptrType(types.Chan);
- arrayType = $arrayType($Uint8, 10);
- sliceType$4 = $sliceType(ptrType);
- sliceType$5 = $sliceType(ptrType$3);
- sliceType$6 = $sliceType($String);
- sliceType$7 = $sliceType(ptrType$5);
- sliceType$8 = $sliceType(ptrType$4);
- ptrType$14 = $ptrType(types.Basic);
- ptrType$15 = $ptrType(types.Tuple);
- ptrType$16 = $ptrType(exporter);
- mapType = $mapType(ptrType, $Int);
- mapType$1 = $mapType(types.Type, $Int);
- ptrType$17 = $ptrType(importer);
- mapType$2 = $mapType($String, ptrType);
- format = function() {
- var $ptr;
- return 112;
- };
- ExportData = function(pkg) {
- var $ptr, _i, _i$1, _i$2, _key, _r$1, _ref, _ref$1, _ref$2, list, name, obj, p, pkg, scope, t, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _key = $f._key; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; list = $f.list; name = $f.name; obj = $f.obj; p = $f.p; pkg = $f.pkg; scope = $f.scope; t = $f.t; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = new exporter.ptr($append(new sliceType$1($stringToBytes("\n$$ exports $$\n")), format()), new $Map(), new $Map(), "");
- _ref = predeclared;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- t = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _key = t; (p.typIndex || $throwRuntimeError("assignment to entry in nil map"))[types.Type.keyFor(_key)] = { k: _key, v: $keys(p.typIndex).length };
- _i++;
- }
- $r = p.string("v0"); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.pkg(pkg); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- list = sliceType$2.nil;
- scope = pkg.Scope();
- _r$1 = scope.Names(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _ref$1 = _r$1;
- _i$1 = 0;
- /* while (true) { */ case 4:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 5; continue; }
- name = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- if (exported(name)) {
- list = $append(list, scope.Lookup(name));
- }
- _i$1++;
- /* } */ $s = 4; continue; case 5:
- $r = p.int$(list.$length); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$2 = list;
- _i$2 = 0;
- /* while (true) { */ case 7:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 8; continue; }
- obj = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- $r = p.obj(obj); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 7; continue; case 8:
- return p.data;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return sliceType$1.nil; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: ExportData }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._key = _key; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f.list = list; $f.name = name; $f.obj = obj; $f.p = p; $f.pkg = pkg; $f.scope = scope; $f.t = t; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- $pkg.ExportData = ExportData;
- exporter.ptr.prototype.pkg = function(pkg) {
- var $ptr, _entry, _key, _tuple, i, ok, p, pkg, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _tuple = $f._tuple; i = $f.i; ok = $f.ok; p = $f.p; pkg = $f.pkg; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- if (pkg === ptrType.nil) {
- $panic(new $String("unexpected nil pkg"));
- }
- _tuple = (_entry = p.pkgIndex[ptrType.keyFor(pkg)], _entry !== undefined ? [_entry.v, true] : [0, false]); i = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- $r = p.int$(i); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- _key = pkg; (p.pkgIndex || $throwRuntimeError("assignment to entry in nil map"))[ptrType.keyFor(_key)] = { k: _key, v: $keys(p.pkgIndex).length };
- $r = p.int$(-1); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.string(pkg.Name()); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.string(pkg.Path()); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.pkg }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._tuple = _tuple; $f.i = i; $f.ok = ok; $f.p = p; $f.pkg = pkg; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- exporter.prototype.pkg = function(pkg) { return this.$val.pkg(pkg); };
- exporter.ptr.prototype.obj = function(obj) {
- var $ptr, _r$1, _ref, obj, obj$1, obj$2, obj$3, obj$4, obj$5, p, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _ref = $f._ref; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; obj$4 = $f.obj$4; obj$5 = $f.obj$5; p = $f.p; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- _ref = obj;
- /* */ if ($assertType(_ref, ptrType$1, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$2, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$4, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref, ptrType$1, true)[1]) { */ case 1:
- obj$1 = _ref.$val;
- $r = p.int$(-2); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.string(obj$1.object.Name()); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(obj$1.object.Type()); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.value(obj$1.Val()); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if ($assertType(_ref, ptrType$2, true)[1]) { */ case 2:
- obj$2 = _ref.$val;
- $r = p.int$(-3); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ($assertType(obj$2.object.Type(), ptrType$5)); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if ($assertType(_ref, ptrType$3, true)[1]) { */ case 3:
- obj$3 = _ref.$val;
- $r = p.int$(-4); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.string(obj$3.object.Name()); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(obj$3.object.Type()); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else if ($assertType(_ref, ptrType$4, true)[1]) { */ case 4:
- obj$4 = _ref.$val;
- $r = p.int$(-5); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.string(obj$4.object.Name()); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(obj$4.object.Type()); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 6; continue;
- /* } else { */ case 5:
- obj$5 = _ref;
- _r$1 = fmt.Sprintf("unexpected object type %T", new sliceType$3([obj$5])); /* */ $s = 19; case 19: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $panic(new $String(_r$1));
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.obj }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._ref = _ref; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.obj$4 = obj$4; $f.obj$5 = obj$5; $f.p = p; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- exporter.prototype.obj = function(obj) { return this.$val.obj(obj); };
- exporter.ptr.prototype.value = function(x) {
- var $ptr, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _tuple, i, kind, ok, p, tag, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _tuple = $f._tuple; i = $f.i; kind = $f.kind; ok = $f.ok; p = $f.p; tag = $f.tag; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- _r$1 = x.Kind(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- kind = _r$1;
- _ref = kind;
- /* */ if (_ref === 1) { $s = 2; continue; }
- /* */ if (_ref === 3) { $s = 3; continue; }
- /* */ if (_ref === 4) { $s = 4; continue; }
- /* */ if (_ref === 5) { $s = 5; continue; }
- /* */ if (_ref === 2) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 1) { */ case 2:
- tag = -15;
- _r$2 = exact.BoolVal(x); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (_r$2) { */ case 9:
- tag = -16;
- /* } */ case 10:
- $r = p.int$(tag); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else if (_ref === 3) { */ case 3:
- _r$3 = exact.Int64Val(x); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; i = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (ok) { */ case 14:
- $r = p.int$(-17); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.int64(i); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 15:
- $r = p.int$(-18); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.float$(x); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else if (_ref === 4) { */ case 4:
- $r = p.int$(-19); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.fraction(x); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else if (_ref === 5) { */ case 5:
- $r = p.int$(-20); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$4 = exact.Real(x); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = p.fraction(_r$4); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$5 = exact.Imag(x); /* */ $s = 25; case 25: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- $r = p.fraction(_r$5); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else if (_ref === 2) { */ case 6:
- $r = p.int$(-21); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$6 = exact.StringVal(x); /* */ $s = 28; case 28: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = p.string(_r$6); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else { */ case 7:
- _r$7 = fmt.Sprintf("unexpected value kind %d", new sliceType$3([new exact.Kind(kind)])); /* */ $s = 30; case 30: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- $panic(new $String(_r$7));
- /* } */ case 8:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.value }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._tuple = _tuple; $f.i = i; $f.kind = kind; $f.ok = ok; $f.p = p; $f.tag = tag; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- exporter.prototype.value = function(x) { return this.$val.value(x); };
- exporter.ptr.prototype.float$ = function(x) {
- var $ptr, _r$1, p, sign, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; p = $f.p; sign = $f.sign; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = exact.Sign(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- sign = _r$1;
- $r = p.int$(sign); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (sign === 0) {
- return;
- }
- $r = p.ufloat(x); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.float$ }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.p = p; $f.sign = sign; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.float$ = function(x) { return this.$val.float$(x); };
- exporter.ptr.prototype.fraction = function(x) {
- var $ptr, _r$1, _r$2, _r$3, p, sign, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; p = $f.p; sign = $f.sign; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = exact.Sign(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- sign = _r$1;
- $r = p.int$(sign); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (sign === 0) {
- return;
- }
- _r$2 = exact.Num(x); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = p.ufloat(_r$2); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = exact.Denom(x); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $r = p.ufloat(_r$3); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.fraction }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.p = p; $f.sign = sign; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.fraction = function(x) { return this.$val.fraction(x); };
- exporter.ptr.prototype.ufloat = function(x) {
- var $ptr, _i, _r$1, _r$2, _ref, b, exp8, i, mant, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; b = $f.b; exp8 = $f.exp8; i = $f.i; mant = $f.mant; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = exact.Bytes(x); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- mant = _r$1;
- exp8 = -1;
- _ref = mant;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!((b === 0))) {
- exp8 = i;
- break;
- }
- _i++;
- }
- /* */ if (exp8 < 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (exp8 < 0) { */ case 2:
- _r$2 = fmt.Sprintf("%s has no mantissa", new sliceType$3([x])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $panic(new $String(_r$2));
- /* } */ case 3:
- $r = p.int$(exp8 * 8 >> 0); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.bytes($subslice(mant, exp8)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.ufloat }; } $f.$ptr = $ptr; $f._i = _i; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.b = b; $f.exp8 = exp8; $f.i = i; $f.mant = mant; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.ufloat = function(x) { return this.$val.ufloat(x); };
- exporter.ptr.prototype.typ = function(typ) {
- var $ptr, _entry, _key, _ref, _tuple, i, i$1, i$2, i$3, i$4, m, m$1, m$2, n, n$1, n$2, obj, ok, p, t, t$1, t$2, t$3, t$4, t$5, t$6, t$7, t$8, t$9, typ, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _ref = $f._ref; _tuple = $f._tuple; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; m = $f.m; m$1 = $f.m$1; m$2 = $f.m$2; n = $f.n; n$1 = $f.n$1; n$2 = $f.n$2; obj = $f.obj; ok = $f.ok; p = $f.p; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; t$8 = $f.t$8; t$9 = $f.t$9; typ = $f.typ; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = this;
- _tuple = (_entry = p.typIndex[types.Type.keyFor(typ)], _entry !== undefined ? [_entry.v, true] : [0, false]); i = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- $r = p.int$(i); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- _key = typ; (p.typIndex || $throwRuntimeError("assignment to entry in nil map"))[types.Type.keyFor(_key)] = { k: _key, v: $keys(p.typIndex).length };
- _ref = typ;
- /* */ if ($assertType(_ref, ptrType$6, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$7, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$8, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$12, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$13, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1]) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ($assertType(_ref, ptrType$6, true)[1]) { */ case 4:
- t = _ref.$val;
- $r = p.int$(-6); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.int64(t.Len()); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(t.Elem()); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$7, true)[1]) { */ case 5:
- t$1 = _ref.$val;
- $r = p.int$(-7); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(t$1.Elem()); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$8, true)[1]) { */ case 6:
- t$2 = _ref.$val;
- $r = p.int$(-8); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = t$2.NumFields();
- $r = p.int$(n); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$1 = 0;
- /* while (true) { */ case 22:
- /* if (!(i$1 < n)) { break; } */ if(!(i$1 < n)) { $s = 23; continue; }
- $r = p.field(t$2.Field(i$1)); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.string(t$2.Tag(i$1)); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$1 = i$1 + (1) >> 0;
- /* } */ $s = 22; continue; case 23:
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 7:
- t$3 = _ref.$val;
- $r = p.int$(-9); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(t$3.Elem()); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1]) { */ case 8:
- t$4 = _ref.$val;
- $r = p.int$(-10); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.signature(t$4); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$11, true)[1]) { */ case 9:
- t$5 = _ref.$val;
- $r = p.int$(-11); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- m = t$5.NumEmbeddeds();
- $r = p.int$(m); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$2 = 0;
- /* while (true) { */ case 32:
- /* if (!(i$2 < m)) { break; } */ if(!(i$2 < m)) { $s = 33; continue; }
- $r = p.typ(t$5.Embedded(i$2)); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$2 = i$2 + (1) >> 0;
- /* } */ $s = 32; continue; case 33:
- n$1 = t$5.NumExplicitMethods();
- $r = p.int$(n$1); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$3 = 0;
- /* while (true) { */ case 36:
- /* if (!(i$3 < n$1)) { break; } */ if(!(i$3 < n$1)) { $s = 37; continue; }
- m$1 = t$5.ExplicitMethod(i$3);
- $r = p.qualifiedName(m$1.object.Pkg(), m$1.object.Name()); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(m$1.object.Type()); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$3 = i$3 + (1) >> 0;
- /* } */ $s = 36; continue; case 37:
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$12, true)[1]) { */ case 10:
- t$6 = _ref.$val;
- $r = p.int$(-12); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(t$6.Key()); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(t$6.Elem()); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$13, true)[1]) { */ case 11:
- t$7 = _ref.$val;
- $r = p.int$(-13); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.int$((t$7.Dir() >> 0)); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(t$7.Elem()); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 14; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1]) { */ case 12:
- t$8 = _ref.$val;
- $r = p.int$(-14); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- obj = t$8.Obj();
- $r = p.string(obj.object.Name()); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.pkg(obj.object.Pkg()); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(t$8.Underlying()); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n$2 = t$8.NumMethods();
- $r = p.int$(n$2); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$4 = 0;
- /* while (true) { */ case 51:
- /* if (!(i$4 < n$2)) { break; } */ if(!(i$4 < n$2)) { $s = 52; continue; }
- m$2 = t$8.Method(i$4);
- $r = p.string(m$2.object.Name()); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(m$2.object.Type()); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$4 = i$4 + (1) >> 0;
- /* } */ $s = 51; continue; case 52:
- $s = 14; continue;
- /* } else { */ case 13:
- t$9 = _ref;
- $panic(new $String("unreachable"));
- /* } */ case 14:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.typ }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._ref = _ref; $f._tuple = _tuple; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.m = m; $f.m$1 = m$1; $f.m$2 = m$2; $f.n = n; $f.n$1 = n$1; $f.n$2 = n$2; $f.obj = obj; $f.ok = ok; $f.p = p; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.t$8 = t$8; $f.t$9 = t$9; $f.typ = typ; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- exporter.prototype.typ = function(typ) { return this.$val.typ(typ); };
- exporter.ptr.prototype.field = function(f) {
- var $ptr, f, name, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- name = "";
- if (!f.Anonymous()) {
- name = f.object.Name();
- }
- $r = p.qualifiedName(f.object.Pkg(), name); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(f.object.Type()); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.field }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.field = function(f) { return this.$val.field(f); };
- exporter.ptr.prototype.qualifiedName = function(pkg, name) {
- var $ptr, _r$1, name, p, pkg, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; name = $f.name; p = $f.p; pkg = $f.pkg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.string(name); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!exported(name)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!exported(name)) { */ case 2:
- /* */ if (pkg === ptrType.nil) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (pkg === ptrType.nil) { */ case 4:
- _r$1 = fmt.Sprintf("nil package for unexported qualified name %s", new sliceType$3([new $String(name)])); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $panic(new $String(_r$1));
- /* } */ case 5:
- $r = p.pkg(pkg); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.qualifiedName }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.name = name; $f.p = p; $f.pkg = pkg; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.qualifiedName = function(pkg, name) { return this.$val.qualifiedName(pkg, name); };
- exporter.ptr.prototype.signature = function(sig) {
- var $ptr, _r$1, _tuple, ok, p, recv, sig, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple = $f._tuple; ok = $f.ok; p = $f.p; recv = $f.recv; sig = $f.sig; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- recv = sig.Recv();
- /* */ if (!(recv === ptrType$3.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(recv === ptrType$3.nil)) { */ case 1:
- _r$1 = recv.object.Type().Underlying(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$1, ptrType$11, true); ok = _tuple[1];
- /* */ if (!ok) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!ok) { */ case 5:
- $r = p.int$(1); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.param(recv); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 7; continue;
- /* } else { */ case 6:
- $r = p.int$(0); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- $s = 3; continue;
- /* } else { */ case 2:
- $r = p.int$(0); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- $r = p.tuple(sig.Params()); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.tuple(sig.Results()); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (sig.Variadic()) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (sig.Variadic()) { */ case 14:
- $r = p.int$(1); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 16; continue;
- /* } else { */ case 15:
- $r = p.int$(0); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 16:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.signature }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple = _tuple; $f.ok = ok; $f.p = p; $f.recv = recv; $f.sig = sig; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.signature = function(sig) { return this.$val.signature(sig); };
- exporter.ptr.prototype.param = function(v) {
- var $ptr, p, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.string(v.object.Name()); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.typ(v.object.Type()); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.param }; } $f.$ptr = $ptr; $f.p = p; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.param = function(v) { return this.$val.param(v); };
- exporter.ptr.prototype.tuple = function(t) {
- var $ptr, i, n, p, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; i = $f.i; n = $f.n; p = $f.p; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- n = t.Len();
- $r = p.int$(n); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = 0;
- /* while (true) { */ case 2:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 3; continue; }
- $r = p.param(t.At(i)); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 2; continue; case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.tuple }; } $f.$ptr = $ptr; $f.i = i; $f.n = n; $f.p = p; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.tuple = function(t) { return this.$val.tuple(t); };
- exporter.ptr.prototype.string = function(s) {
- var $ptr, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.bytes(new sliceType$1($stringToBytes(s))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.string }; } $f.$ptr = $ptr; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.string = function(s) { return this.$val.string(s); };
- exporter.ptr.prototype.int$ = function(x) {
- var $ptr, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.int64(new $Int64(0, x)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.int$ }; } $f.$ptr = $ptr; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.int$ = function(x) { return this.$val.int$(x); };
- exporter.ptr.prototype.int64 = function(x) {
- var $ptr, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- p.rawInt64(x);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.int64 }; } $f.$ptr = $ptr; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.int64 = function(x) { return this.$val.int64(x); };
- exporter.ptr.prototype.bytes = function(b) {
- var $ptr, b, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; b = $f.b; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- p.rawInt64(new $Int64(0, b.$length));
- if (b.$length > 0) {
- p.data = $appendSlice(p.data, b);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: exporter.ptr.prototype.bytes }; } $f.$ptr = $ptr; $f.b = b; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- exporter.prototype.bytes = function(b) { return this.$val.bytes(b); };
- exporter.ptr.prototype.rawInt64 = function(x) {
- var $ptr, n, p, tmp, x;
- p = this;
- tmp = $clone(arrayType.zero(), arrayType);
- n = binary.PutVarint(new sliceType$1(tmp), x);
- p.data = $appendSlice(p.data, $subslice(new sliceType$1(tmp), 0, n));
- };
- exporter.prototype.rawInt64 = function(x) { return this.$val.rawInt64(x); };
- exported = function(name) {
- var $ptr, name;
- return ast.IsExported(name);
- };
- ImportData = function(imports, data) {
- var $ptr, _i, _i$1, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _ref$1, _tuple, data, datalen, i, imports, it, m, n, ok, p, pkg, s, t, typ, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; data = $f.data; datalen = $f.datalen; i = $f.i; imports = $f.imports; it = $f.it; m = $f.m; n = $f.n; ok = $f.ok; p = $f.p; pkg = $f.pkg; s = $f.s; t = $f.t; typ = $f.typ; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- datalen = data.$length;
- s = "";
- if (data.$length >= 15) {
- s = $bytesToString($subslice(data, 0, 15));
- data = $subslice(data, 15);
- }
- /* */ if (!(s === "\n$$ exports $$\n")) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(s === "\n$$ exports $$\n")) { */ case 1:
- _r$1 = fmt.Errorf("incorrect magic string: got %q; want %q", new sliceType$3([new $String(s), new $String("\n$$ exports $$\n")])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return [0, ptrType.nil, _r$1];
- /* } */ case 2:
- m = 109;
- if (data.$length > 0) {
- m = (0 >= data.$length ? $throwRuntimeError("index out of range") : data.$array[data.$offset + 0]);
- data = $subslice(data, 1);
- }
- /* */ if (!((m === format()))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!((m === format()))) { */ case 4:
- _r$2 = fmt.Errorf("incorrect low-level encoding format: got %c; want %c", new sliceType$3([new $Uint8(m), new $Uint8(format())])); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return [0, ptrType.nil, _r$2];
- /* } */ case 5:
- p = new importer.ptr(data, datalen, imports, sliceType$4.nil, sliceType.nil);
- _ref = predeclared;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- t = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- p.typList = $append(p.typList, t);
- _i++;
- }
- _r$3 = p.string(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- v = _r$3;
- /* */ if (!(v === "v0")) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!(v === "v0")) { */ case 8:
- _r$4 = fmt.Errorf("unknown version: got %s; want %s", new sliceType$3([new $String(v), new $String("v0")])); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return [0, ptrType.nil, _r$4];
- /* } */ case 9:
- _r$5 = p.pkg(); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- pkg = _r$5;
- _r$6 = p.int$(); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- n = _r$6;
- i = 0;
- /* while (true) { */ case 13:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 14; continue; }
- $r = p.obj(pkg); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 13; continue; case 14:
- _ref$1 = p.typList;
- _i$1 = 0;
- /* while (true) { */ case 16:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 17; continue; }
- typ = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _tuple = $assertType(typ, ptrType$11, true); it = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (ok) { */ case 18:
- _r$7 = it.Complete(); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$7;
- /* } */ case 19:
- _i$1++;
- /* } */ $s = 16; continue; case 17:
- pkg.MarkComplete();
- return [p.consumed(), pkg, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ImportData }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f.data = data; $f.datalen = datalen; $f.i = i; $f.imports = imports; $f.it = it; $f.m = m; $f.n = n; $f.ok = ok; $f.p = p; $f.pkg = pkg; $f.s = s; $f.t = t; $f.typ = typ; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ImportData = ImportData;
- importer.ptr.prototype.pkg = function() {
- var $ptr, _entry, _key, _r$1, _r$2, _r$3, _r$4, _r$5, i, name, p, path, pkg, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; i = $f.i; name = $f.name; p = $f.p; path = $f.path; pkg = $f.pkg; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- i = _r$1;
- if (i >= 0) {
- return (x = p.pkgList, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- }
- /* */ if (!((i === -1))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!((i === -1))) { */ case 2:
- _r$2 = fmt.Sprintf("unexpected package tag %d", new sliceType$3([new $Int(i)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $panic(new $String(_r$2));
- /* } */ case 3:
- _r$3 = p.string(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- name = _r$3;
- _r$4 = p.string(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- path = _r$4;
- pkg = (_entry = p.imports[$String.keyFor(path)], _entry !== undefined ? _entry.v : ptrType.nil);
- /* */ if (pkg === ptrType.nil) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (pkg === ptrType.nil) { */ case 7:
- _r$5 = types.NewPackage(path, name); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- pkg = _r$5;
- _key = path; (p.imports || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: pkg };
- /* } */ case 8:
- p.pkgList = $append(p.pkgList, pkg);
- return pkg;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.pkg }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.i = i; $f.name = name; $f.p = p; $f.path = path; $f.pkg = pkg; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.pkg = function() { return this.$val.pkg(); };
- importer.ptr.prototype.obj = function(pkg) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, alt, obj, p, pkg, tag, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; alt = $f.alt; obj = $f.obj; p = $f.p; pkg = $f.pkg; tag = $f.tag; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- obj = $ifaceNil;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- tag = _r$1;
- _ref = tag;
- /* */ if (_ref === -2) { $s = 2; continue; }
- /* */ if (_ref === -3) { $s = 3; continue; }
- /* */ if (_ref === -4) { $s = 4; continue; }
- /* */ if (_ref === -5) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref === -2) { */ case 2:
- _arg = pkg;
- _r$2 = p.string(); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = _r$2;
- _r$3 = p.typ(); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$2 = _r$3;
- _r$4 = p.value(); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$3 = _r$4;
- _r$5 = types.NewConst(0, _arg, _arg$1, _arg$2, _arg$3); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- obj = _r$5;
- $s = 7; continue;
- /* } else if (_ref === -3) { */ case 3:
- _r$6 = p.typ(); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $assertType(_r$6, ptrType$5);
- return;
- $s = 7; continue;
- /* } else if (_ref === -4) { */ case 4:
- _arg$4 = pkg;
- _r$7 = p.string(); /* */ $s = 13; case 13: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$5 = _r$7;
- _r$8 = p.typ(); /* */ $s = 14; case 14: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$6 = _r$8;
- _r$9 = types.NewVar(0, _arg$4, _arg$5, _arg$6); /* */ $s = 15; case 15: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- obj = _r$9;
- $s = 7; continue;
- /* } else if (_ref === -5) { */ case 5:
- _arg$7 = pkg;
- _r$10 = p.string(); /* */ $s = 16; case 16: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _arg$8 = _r$10;
- _r$11 = p.typ(); /* */ $s = 17; case 17: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _arg$9 = $assertType(_r$11, ptrType$10);
- _r$12 = types.NewFunc(0, _arg$7, _arg$8, _arg$9); /* */ $s = 18; case 18: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- obj = _r$12;
- $s = 7; continue;
- /* } else { */ case 6:
- _r$13 = fmt.Sprintf("unexpected object tag %d", new sliceType$3([new $Int(tag)])); /* */ $s = 19; case 19: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- $panic(new $String(_r$13));
- /* } */ case 7:
- _r$14 = pkg.Scope().Insert(obj); /* */ $s = 20; case 20: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- alt = _r$14;
- /* */ if (!($interfaceIsEqual(alt, $ifaceNil))) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (!($interfaceIsEqual(alt, $ifaceNil))) { */ case 21:
- _r$15 = alt.Name(); /* */ $s = 23; case 23: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _arg$10 = new $String(_r$15);
- _r$16 = fmt.Sprintf("%s already declared", new sliceType$3([_arg$10])); /* */ $s = 24; case 24: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- $panic(new $String(_r$16));
- /* } */ case 22:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.obj }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f.alt = alt; $f.obj = obj; $f.p = p; $f.pkg = pkg; $f.tag = tag; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.obj = function(pkg) { return this.$val.obj(pkg); };
- importer.ptr.prototype.value = function() {
- var $ptr, _arg, _arg$1, _r$1, _r$10, _r$11, _r$12, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, im, kind, p, re, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; im = $f.im; kind = $f.kind; p = $f.p; re = $f.re; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- kind = (_r$1 >> 0);
- _ref = kind;
- /* */ if (_ref === -15) { $s = 2; continue; }
- /* */ if (_ref === -16) { $s = 3; continue; }
- /* */ if (_ref === -17) { $s = 4; continue; }
- /* */ if (_ref === -18) { $s = 5; continue; }
- /* */ if (_ref === -19) { $s = 6; continue; }
- /* */ if (_ref === -20) { $s = 7; continue; }
- /* */ if (_ref === -21) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref === -15) { */ case 2:
- return exact.MakeBool(false);
- $s = 10; continue;
- /* } else if (_ref === -16) { */ case 3:
- return exact.MakeBool(true);
- $s = 10; continue;
- /* } else if (_ref === -17) { */ case 4:
- _r$2 = p.int64(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = exact.MakeInt64(_r$2); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 10; continue;
- /* } else if (_ref === -18) { */ case 5:
- _r$4 = p.float$(); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- $s = 10; continue;
- /* } else if (_ref === -19) { */ case 6:
- _r$5 = p.fraction(); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- $s = 10; continue;
- /* } else if (_ref === -20) { */ case 7:
- _r$6 = p.fraction(); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- re = _r$6;
- _r$7 = p.fraction(); /* */ $s = 16; case 16: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- im = _r$7;
- _arg = re;
- _r$8 = exact.MakeImag(im); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$1 = _r$8;
- _r$9 = exact.BinaryOp(_arg, 12, _arg$1); /* */ $s = 18; case 18: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- return _r$9;
- $s = 10; continue;
- /* } else if (_ref === -21) { */ case 8:
- _r$10 = p.string(); /* */ $s = 19; case 19: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$11 = exact.MakeString(_r$10); /* */ $s = 20; case 20: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- $s = 10; continue;
- /* } else { */ case 9:
- _r$12 = fmt.Sprintf("unexpected value kind %d", new sliceType$3([new exact.Kind(kind)])); /* */ $s = 21; case 21: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- $panic(new $String(_r$12));
- /* } */ case 10:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.value }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f.im = im; $f.kind = kind; $f.p = p; $f.re = re; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.value = function() { return this.$val.value(); };
- importer.ptr.prototype.float$ = function() {
- var $ptr, _r$1, _r$2, _r$3, p, sign, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; p = $f.p; sign = $f.sign; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- sign = _r$1;
- if (sign === 0) {
- return exact.MakeInt64(new $Int64(0, 0));
- }
- _r$2 = p.ufloat(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- x = _r$2;
- /* */ if (sign < 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (sign < 0) { */ case 3:
- _r$3 = exact.UnaryOp(13, x, 0); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- x = _r$3;
- /* } */ case 4:
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.float$ }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.p = p; $f.sign = sign; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.float$ = function() { return this.$val.float$(); };
- importer.ptr.prototype.fraction = function() {
- var $ptr, _arg, _arg$1, _r$1, _r$2, _r$3, _r$4, _r$5, p, sign, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; p = $f.p; sign = $f.sign; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- sign = _r$1;
- if (sign === 0) {
- return exact.MakeInt64(new $Int64(0, 0));
- }
- _r$2 = p.ufloat(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg = _r$2;
- _r$3 = p.ufloat(); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$1 = _r$3;
- _r$4 = exact.BinaryOp(_arg, 15, _arg$1); /* */ $s = 4; case 4: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- x = _r$4;
- /* */ if (sign < 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (sign < 0) { */ case 5:
- _r$5 = exact.UnaryOp(13, x, 0); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- x = _r$5;
- /* } */ case 6:
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.fraction }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.p = p; $f.sign = sign; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.fraction = function() { return this.$val.fraction(); };
- importer.ptr.prototype.ufloat = function() {
- var $ptr, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, d, exp, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; d = $f.d; exp = $f.exp; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- exp = _r$1;
- _r$2 = p.bytes(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = exact.MakeFromBytes(_r$2); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- x = _r$3;
- /* */ if (exp < 0) { $s = 4; continue; }
- /* */ if (exp > 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (exp < 0) { */ case 4:
- _r$4 = exact.Shift(exact.MakeInt64(new $Int64(0, 1)), 20, (-exp >>> 0)); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- d = _r$4;
- _r$5 = exact.BinaryOp(x, 15, d); /* */ $s = 8; case 8: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- x = _r$5;
- $s = 6; continue;
- /* } else if (exp > 0) { */ case 5:
- _r$6 = exact.Shift(x, 20, (exp >>> 0)); /* */ $s = 9; case 9: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- x = _r$6;
- /* } */ case 6:
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.ufloat }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f.d = d; $f.exp = exp; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.ufloat = function() { return this.$val.ufloat(); };
- importer.ptr.prototype.record = function(t) {
- var $ptr, p, t;
- p = this;
- p.typList = $append(p.typList, t);
- };
- importer.prototype.record = function(t) { return this.$val.record(t); };
- importer.ptr.prototype.typ = function() {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _i, _i$1, _i$2, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _tmp, _tmp$1, _tuple, embeddeds, fields, i, i$1, i$2, i$3, i$4, methods, n, n$1, n$2, n$3, name, name$1, obj, p, pkg, pkg$1, scope, t, t$1, t$2, t$3, t$4, t$5, t$6, t$7, t$8, t0, tags, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; embeddeds = $f.embeddeds; fields = $f.fields; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; methods = $f.methods; n = $f.n; n$1 = $f.n$1; n$2 = $f.n$2; n$3 = $f.n$3; name = $f.name; name$1 = $f.name$1; obj = $f.obj; p = $f.p; pkg = $f.pkg; pkg$1 = $f.pkg$1; scope = $f.scope; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; t$8 = $f.t$8; t0 = $f.t0; tags = $f.tags; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- i = _r$1;
- if (i >= 0) {
- return (x = p.typList, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- }
- _ref = i;
- /* */ if (_ref === -6) { $s = 2; continue; }
- /* */ if (_ref === -7) { $s = 3; continue; }
- /* */ if (_ref === -8) { $s = 4; continue; }
- /* */ if (_ref === -9) { $s = 5; continue; }
- /* */ if (_ref === -10) { $s = 6; continue; }
- /* */ if (_ref === -11) { $s = 7; continue; }
- /* */ if (_ref === -12) { $s = 8; continue; }
- /* */ if (_ref === -13) { $s = 9; continue; }
- /* */ if (_ref === -14) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_ref === -6) { */ case 2:
- t = new types.Array.ptr();
- p.record(t);
- _r$2 = p.int64(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- n = _r$2;
- _r$3 = p.typ(); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = types.NewArray(_r$3, n); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $copy(t, _r$4, types.Array);
- return t;
- $s = 12; continue;
- /* } else if (_ref === -7) { */ case 3:
- t$1 = new types.Slice.ptr();
- p.record(t$1);
- _r$5 = p.typ(); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = types.NewSlice(_r$5); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $copy(t$1, _r$6, types.Slice);
- return t$1;
- $s = 12; continue;
- /* } else if (_ref === -8) { */ case 4:
- t$2 = new types.Struct.ptr();
- p.record(t$2);
- _r$7 = p.int$(); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- n$1 = _r$7;
- fields = $makeSlice(sliceType$5, n$1);
- tags = $makeSlice(sliceType$6, n$1);
- _ref$1 = fields;
- _i = 0;
- /* while (true) { */ case 19:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 20; continue; }
- i$1 = _i;
- _r$8 = p.field(); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- ((i$1 < 0 || i$1 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + i$1] = _r$8);
- _r$9 = p.string(); /* */ $s = 22; case 22: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- ((i$1 < 0 || i$1 >= tags.$length) ? $throwRuntimeError("index out of range") : tags.$array[tags.$offset + i$1] = _r$9);
- _i++;
- /* } */ $s = 19; continue; case 20:
- _r$10 = types.NewStruct(fields, tags); /* */ $s = 23; case 23: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- $copy(t$2, _r$10, types.Struct);
- return t$2;
- $s = 12; continue;
- /* } else if (_ref === -9) { */ case 5:
- t$3 = new types.Pointer.ptr();
- p.record(t$3);
- _r$11 = p.typ(); /* */ $s = 24; case 24: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$12 = types.NewPointer(_r$11); /* */ $s = 25; case 25: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- $copy(t$3, _r$12, types.Pointer);
- return t$3;
- $s = 12; continue;
- /* } else if (_ref === -10) { */ case 6:
- t$4 = new types.Signature.ptr();
- p.record(t$4);
- _r$13 = p.signature(); /* */ $s = 26; case 26: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- $copy(t$4, _r$13, types.Signature);
- return t$4;
- $s = 12; continue;
- /* } else if (_ref === -11) { */ case 7:
- n$2 = p.typList.$length;
- p.record($ifaceNil);
- _r$14 = p.int$(); /* */ $s = 27; case 27: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- embeddeds = $makeSlice(sliceType$7, _r$14);
- _ref$2 = embeddeds;
- _i$1 = 0;
- /* while (true) { */ case 28:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 29; continue; }
- i$2 = _i$1;
- _r$15 = p.typ(); /* */ $s = 30; case 30: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- ((i$2 < 0 || i$2 >= embeddeds.$length) ? $throwRuntimeError("index out of range") : embeddeds.$array[embeddeds.$offset + i$2] = $assertType(_r$15, ptrType$5));
- _i$1++;
- /* } */ $s = 28; continue; case 29:
- _r$16 = p.int$(); /* */ $s = 31; case 31: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- methods = $makeSlice(sliceType$8, _r$16);
- _ref$3 = methods;
- _i$2 = 0;
- /* while (true) { */ case 32:
- /* if (!(_i$2 < _ref$3.$length)) { break; } */ if(!(_i$2 < _ref$3.$length)) { $s = 33; continue; }
- i$3 = _i$2;
- _r$17 = p.qualifiedName(); /* */ $s = 34; case 34: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _tuple = _r$17; pkg = _tuple[0]; name = _tuple[1];
- _arg = pkg;
- _arg$1 = name;
- _r$18 = p.typ(); /* */ $s = 35; case 35: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _arg$2 = $assertType(_r$18, ptrType$10);
- _r$19 = types.NewFunc(0, _arg, _arg$1, _arg$2); /* */ $s = 36; case 36: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- ((i$3 < 0 || i$3 >= methods.$length) ? $throwRuntimeError("index out of range") : methods.$array[methods.$offset + i$3] = _r$19);
- _i$2++;
- /* } */ $s = 32; continue; case 33:
- _r$20 = types.NewInterface(methods, embeddeds); /* */ $s = 37; case 37: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- t$5 = _r$20;
- (x$1 = p.typList, ((n$2 < 0 || n$2 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + n$2] = t$5));
- return t$5;
- $s = 12; continue;
- /* } else if (_ref === -12) { */ case 8:
- t$6 = new types.Map.ptr();
- p.record(t$6);
- _r$21 = p.typ(); /* */ $s = 38; case 38: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- _arg$3 = _r$21;
- _r$22 = p.typ(); /* */ $s = 39; case 39: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$4 = _r$22;
- _r$23 = types.NewMap(_arg$3, _arg$4); /* */ $s = 40; case 40: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- $copy(t$6, _r$23, types.Map);
- return t$6;
- $s = 12; continue;
- /* } else if (_ref === -13) { */ case 9:
- t$7 = new types.Chan.ptr();
- p.record(t$7);
- _r$24 = p.int$(); /* */ $s = 41; case 41: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _arg$5 = (_r$24 >> 0);
- _r$25 = p.typ(); /* */ $s = 42; case 42: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _arg$6 = _r$25;
- _r$26 = types.NewChan(_arg$5, _arg$6); /* */ $s = 43; case 43: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- $copy(t$7, _r$26, types.Chan);
- return t$7;
- $s = 12; continue;
- /* } else if (_ref === -14) { */ case 10:
- _r$27 = p.string(); /* */ $s = 44; case 44: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- name$1 = _r$27;
- _r$28 = p.pkg(); /* */ $s = 45; case 45: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- pkg$1 = _r$28;
- scope = pkg$1.Scope();
- obj = scope.Lookup(name$1);
- /* */ if ($interfaceIsEqual(obj, $ifaceNil)) { $s = 46; continue; }
- /* */ $s = 47; continue;
- /* if ($interfaceIsEqual(obj, $ifaceNil)) { */ case 46:
- obj = types.NewTypeName(0, pkg$1, name$1, $ifaceNil);
- _r$29 = scope.Insert(obj); /* */ $s = 48; case 48: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _r$29;
- /* } */ case 47:
- t0 = types.NewNamed($assertType(obj, ptrType$2), $ifaceNil, sliceType$8.nil);
- _r$30 = obj.Type(); /* */ $s = 49; case 49: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- t$8 = $assertType(_r$30, ptrType$5);
- p.record(t$8);
- _r$31 = p.typ(); /* */ $s = 50; case 50: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- $r = t0.SetUnderlying(_r$31); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$32 = p.int$(); /* */ $s = 52; case 52: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _tmp = 0; _tmp$1 = _r$32; i$4 = _tmp; n$3 = _tmp$1;
- /* while (true) { */ case 53:
- /* if (!(i$4 < n$3)) { break; } */ if(!(i$4 < n$3)) { $s = 54; continue; }
- _arg$7 = pkg$1;
- _r$33 = p.string(); /* */ $s = 55; case 55: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- _arg$8 = _r$33;
- _r$34 = p.typ(); /* */ $s = 56; case 56: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _arg$9 = $assertType(_r$34, ptrType$10);
- _r$35 = types.NewFunc(0, _arg$7, _arg$8, _arg$9); /* */ $s = 57; case 57: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- $r = t0.AddMethod(_r$35); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i$4 = i$4 + (1) >> 0;
- /* } */ $s = 53; continue; case 54:
- return t$8;
- $s = 12; continue;
- /* } else { */ case 11:
- _r$36 = fmt.Sprintf("unexpected type tag %d", new sliceType$3([new $Int(i)])); /* */ $s = 59; case 59: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- $panic(new $String(_r$36));
- /* } */ case 12:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.typ }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.embeddeds = embeddeds; $f.fields = fields; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.methods = methods; $f.n = n; $f.n$1 = n$1; $f.n$2 = n$2; $f.n$3 = n$3; $f.name = name; $f.name$1 = name$1; $f.obj = obj; $f.p = p; $f.pkg = pkg; $f.pkg$1 = pkg$1; $f.scope = scope; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.t$8 = t$8; $f.t0 = t0; $f.tags = tags; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.typ = function() { return this.$val.typ(); };
- deref = function(typ) {
- var $ptr, _tuple, p, typ;
- _tuple = $assertType(typ, ptrType$9, true); p = _tuple[0];
- if (!(p === ptrType$9.nil)) {
- return p.Elem();
- }
- return typ;
- };
- importer.ptr.prototype.field = function() {
- var $ptr, _r$1, _r$2, _ref, _tuple, anonymous, name, obj, p, pkg, typ, typ$1, typ$2, typ$3, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; anonymous = $f.anonymous; name = $f.name; obj = $f.obj; p = $f.p; pkg = $f.pkg; typ = $f.typ; typ$1 = $f.typ$1; typ$2 = $f.typ$2; typ$3 = $f.typ$3; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.qualifiedName(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; pkg = _tuple[0]; name = _tuple[1];
- _r$2 = p.typ(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- typ = _r$2;
- anonymous = false;
- if (name === "") {
- _ref = deref(typ);
- if ($assertType(_ref, ptrType$14, true)[1]) {
- typ$1 = _ref.$val;
- pkg = ptrType.nil;
- name = typ$1.Name();
- } else if ($assertType(_ref, ptrType$5, true)[1]) {
- typ$2 = _ref.$val;
- obj = typ$2.Obj();
- name = obj.object.Name();
- if (exported(name)) {
- pkg = (x = p.pkgList, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]));
- }
- } else {
- typ$3 = _ref;
- $panic(new $String("anonymous field expected"));
- }
- anonymous = true;
- }
- return types.NewField(0, pkg, name, typ, anonymous);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.field }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f.anonymous = anonymous; $f.name = name; $f.obj = obj; $f.p = p; $f.pkg = pkg; $f.typ = typ; $f.typ$1 = typ$1; $f.typ$2 = typ$2; $f.typ$3 = typ$3; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.field = function() { return this.$val.field(); };
- importer.ptr.prototype.qualifiedName = function() {
- var $ptr, _r$1, _r$2, name, p, pkg, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; name = $f.name; p = $f.p; pkg = $f.pkg; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.string(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- name = _r$1;
- pkg = (x = p.pkgList, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]));
- /* */ if (!exported(name)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!exported(name)) { */ case 2:
- _r$2 = p.pkg(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- pkg = _r$2;
- /* } */ case 3:
- return [pkg, name];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.qualifiedName }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.name = name; $f.p = p; $f.pkg = pkg; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.qualifiedName = function() { return this.$val.qualifiedName(); };
- importer.ptr.prototype.signature = function() {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, p, recv, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; p = $f.p; recv = $f.recv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- recv = ptrType$3.nil;
- _r$1 = p.int$(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (!((_r$1 === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((_r$1 === 0))) { */ case 1:
- _r$2 = p.param(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- recv = _r$2;
- /* } */ case 2:
- _arg = recv;
- _r$3 = p.tuple(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$1 = _r$3;
- _r$4 = p.tuple(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$2 = _r$4;
- _r$5 = p.int$(); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$3 = !((_r$5 === 0));
- _r$6 = types.NewSignature(_arg, _arg$1, _arg$2, _arg$3); /* */ $s = 8; case 8: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.signature }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f.p = p; $f.recv = recv; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.signature = function() { return this.$val.signature(); };
- importer.ptr.prototype.param = function() {
- var $ptr, _arg, _arg$1, _arg$2, _r$1, _r$2, _r$3, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _arg = ptrType.nil;
- _r$1 = p.string(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = _r$1;
- _r$2 = p.typ(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$2 = _r$2;
- _r$3 = types.NewVar(0, _arg, _arg$1, _arg$2); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.param }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.param = function() { return this.$val.param(); };
- importer.ptr.prototype.tuple = function() {
- var $ptr, _i, _r$1, _r$2, _ref, i, p, vars, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; i = $f.i; p = $f.p; vars = $f.vars; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int$(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- vars = $makeSlice(sliceType$5, _r$1);
- _ref = vars;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- i = _i;
- _r$2 = p.param(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- ((i < 0 || i >= vars.$length) ? $throwRuntimeError("index out of range") : vars.$array[vars.$offset + i] = _r$2);
- _i++;
- /* } */ $s = 2; continue; case 3:
- return types.NewTuple(vars);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.tuple }; } $f.$ptr = $ptr; $f._i = _i; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.i = i; $f.p = p; $f.vars = vars; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.tuple = function() { return this.$val.tuple(); };
- importer.ptr.prototype.string = function() {
- var $ptr, _r$1, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return $bytesToString(_r$1);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.string }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.string = function() { return this.$val.string(); };
- importer.ptr.prototype.int$ = function() {
- var $ptr, _r$1, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r$1 = p.int64(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return ((x = _r$1, x.$low + ((x.$high >> 31) * 4294967296)) >> 0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.int$ }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.int$ = function() { return this.$val.int$(); };
- importer.ptr.prototype.int64 = function() {
- var $ptr, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- return p.rawInt64();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.int64 }; } $f.$ptr = $ptr; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.int64 = function() { return this.$val.int64(); };
- importer.ptr.prototype.bytes = function() {
- var $ptr, b, n, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; b = $f.b; n = $f.n; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- b = sliceType$1.nil;
- n = ((x = p.rawInt64(), x.$low + ((x.$high >> 31) * 4294967296)) >> 0);
- if (n > 0) {
- b = $subslice(p.data, 0, n);
- p.data = $subslice(p.data, n);
- }
- return b;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: importer.ptr.prototype.bytes }; } $f.$ptr = $ptr; $f.b = b; $f.n = n; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- importer.prototype.bytes = function() { return this.$val.bytes(); };
- importer.ptr.prototype.rawInt64 = function() {
- var $ptr, _tuple, i, n, p;
- p = this;
- _tuple = binary.Varint(p.data); i = _tuple[0]; n = _tuple[1];
- p.data = $subslice(p.data, n);
- return i;
- };
- importer.prototype.rawInt64 = function() { return this.$val.rawInt64(); };
- importer.ptr.prototype.consumed = function() {
- var $ptr, p;
- p = this;
- return p.datalen - p.data.$length >> 0;
- };
- importer.prototype.consumed = function() { return this.$val.consumed(); };
- ptrType$16.methods = [{prop: "pkg", name: "pkg", pkg: "golang.org/x/tools/go/importer", typ: $funcType([ptrType], [], false)}, {prop: "obj", name: "obj", pkg: "golang.org/x/tools/go/importer", typ: $funcType([types.Object], [], false)}, {prop: "value", name: "value", pkg: "golang.org/x/tools/go/importer", typ: $funcType([exact.Value], [], false)}, {prop: "float$", name: "float", pkg: "golang.org/x/tools/go/importer", typ: $funcType([exact.Value], [], false)}, {prop: "fraction", name: "fraction", pkg: "golang.org/x/tools/go/importer", typ: $funcType([exact.Value], [], false)}, {prop: "ufloat", name: "ufloat", pkg: "golang.org/x/tools/go/importer", typ: $funcType([exact.Value], [], false)}, {prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/importer", typ: $funcType([types.Type], [], false)}, {prop: "field", name: "field", pkg: "golang.org/x/tools/go/importer", typ: $funcType([ptrType$3], [], false)}, {prop: "qualifiedName", name: "qualifiedName", pkg: "golang.org/x/tools/go/importer", typ: $funcType([ptrType, $String], [], false)}, {prop: "signature", name: "signature", pkg: "golang.org/x/tools/go/importer", typ: $funcType([ptrType$10], [], false)}, {prop: "param", name: "param", pkg: "golang.org/x/tools/go/importer", typ: $funcType([ptrType$3], [], false)}, {prop: "tuple", name: "tuple", pkg: "golang.org/x/tools/go/importer", typ: $funcType([ptrType$15], [], false)}, {prop: "string", name: "string", pkg: "golang.org/x/tools/go/importer", typ: $funcType([$String], [], false)}, {prop: "int$", name: "int", pkg: "golang.org/x/tools/go/importer", typ: $funcType([$Int], [], false)}, {prop: "int64", name: "int64", pkg: "golang.org/x/tools/go/importer", typ: $funcType([$Int64], [], false)}, {prop: "bytes", name: "bytes", pkg: "golang.org/x/tools/go/importer", typ: $funcType([sliceType$1], [], false)}, {prop: "marker", name: "marker", pkg: "golang.org/x/tools/go/importer", typ: $funcType([$Uint8], [], false)}, {prop: "rawInt64", name: "rawInt64", pkg: "golang.org/x/tools/go/importer", typ: $funcType([$Int64], [], false)}, {prop: "tracef", name: "tracef", pkg: "golang.org/x/tools/go/importer", typ: $funcType([$String, sliceType$3], [], true)}];
- ptrType$17.methods = [{prop: "pkg", name: "pkg", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [ptrType], false)}, {prop: "obj", name: "obj", pkg: "golang.org/x/tools/go/importer", typ: $funcType([ptrType], [], false)}, {prop: "value", name: "value", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [exact.Value], false)}, {prop: "float$", name: "float", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [exact.Value], false)}, {prop: "fraction", name: "fraction", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [exact.Value], false)}, {prop: "ufloat", name: "ufloat", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [exact.Value], false)}, {prop: "record", name: "record", pkg: "golang.org/x/tools/go/importer", typ: $funcType([types.Type], [], false)}, {prop: "typ", name: "typ", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [types.Type], false)}, {prop: "field", name: "field", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [ptrType$3], false)}, {prop: "qualifiedName", name: "qualifiedName", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [ptrType, $String], false)}, {prop: "signature", name: "signature", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [ptrType$10], false)}, {prop: "param", name: "param", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [ptrType$3], false)}, {prop: "tuple", name: "tuple", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [ptrType$15], false)}, {prop: "string", name: "string", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [$String], false)}, {prop: "int$", name: "int", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [$Int], false)}, {prop: "int64", name: "int64", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [$Int64], false)}, {prop: "bytes", name: "bytes", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [sliceType$1], false)}, {prop: "marker", name: "marker", pkg: "golang.org/x/tools/go/importer", typ: $funcType([$Uint8], [], false)}, {prop: "rawInt64", name: "rawInt64", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [$Int64], false)}, {prop: "consumed", name: "consumed", pkg: "golang.org/x/tools/go/importer", typ: $funcType([], [$Int], false)}];
- exporter.init([{prop: "data", name: "data", pkg: "golang.org/x/tools/go/importer", typ: sliceType$1, tag: ""}, {prop: "pkgIndex", name: "pkgIndex", pkg: "golang.org/x/tools/go/importer", typ: mapType, tag: ""}, {prop: "typIndex", name: "typIndex", pkg: "golang.org/x/tools/go/importer", typ: mapType$1, tag: ""}, {prop: "indent", name: "indent", pkg: "golang.org/x/tools/go/importer", typ: $String, tag: ""}]);
- importer.init([{prop: "data", name: "data", pkg: "golang.org/x/tools/go/importer", typ: sliceType$1, tag: ""}, {prop: "datalen", name: "datalen", pkg: "golang.org/x/tools/go/importer", typ: $Int, tag: ""}, {prop: "imports", name: "imports", pkg: "golang.org/x/tools/go/importer", typ: mapType$2, tag: ""}, {prop: "pkgList", name: "pkgList", pkg: "golang.org/x/tools/go/importer", typ: sliceType$4, tag: ""}, {prop: "typList", name: "typList", pkg: "golang.org/x/tools/go/importer", typ: sliceType, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = binary.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = exact.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = types.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = types.Universe.Lookup("error").Type(); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- predeclared = new sliceType([types.Typ[1], types.Typ[2], types.Typ[3], types.Typ[4], types.Typ[5], types.Typ[6], types.Typ[7], types.Typ[8], types.Typ[9], types.Typ[10], types.Typ[11], types.Typ[12], types.Typ[13], types.Typ[14], types.Typ[15], types.Typ[16], types.Typ[17], types.Typ[19], types.Typ[20], types.Typ[21], types.Typ[22], types.Typ[23], types.Typ[24], types.Typ[25], types.Typ[18], types.UniverseByte, types.UniverseRune, _r]);
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["golang.org/x/tools/go/types/typeutil"] = (function() {
- var $pkg = {}, $init, bytes, fmt, types, reflect, sync, Map, entry, Hasher, ptrType$1, sliceType$1, ptrType$2, sliceType$2, sliceType$3, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, ptrType$12, ptrType$13, funcType, mapType, mapType$1, MakeHasher, hashString;
- bytes = $packages["bytes"];
- fmt = $packages["fmt"];
- types = $packages["golang.org/x/tools/go/types"];
- reflect = $packages["reflect"];
- sync = $packages["sync"];
- Map = $pkg.Map = $newType(0, $kindStruct, "typeutil.Map", "Map", "golang.org/x/tools/go/types/typeutil", function(hasher_, table_, length_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.hasher = new Hasher.ptr();
- this.table = false;
- this.length = 0;
- return;
- }
- this.hasher = hasher_;
- this.table = table_;
- this.length = length_;
- });
- entry = $pkg.entry = $newType(0, $kindStruct, "typeutil.entry", "entry", "golang.org/x/tools/go/types/typeutil", function(key_, value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.key = $ifaceNil;
- this.value = $ifaceNil;
- return;
- }
- this.key = key_;
- this.value = value_;
- });
- Hasher = $pkg.Hasher = $newType(0, $kindStruct, "typeutil.Hasher", "Hasher", "golang.org/x/tools/go/types/typeutil", function(memo_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.memo = false;
- return;
- }
- this.memo = memo_;
- });
- ptrType$1 = $ptrType(Map);
- sliceType$1 = $sliceType(entry);
- ptrType$2 = $ptrType(entry);
- sliceType$2 = $sliceType(types.Type);
- sliceType$3 = $sliceType($emptyInterface);
- ptrType$3 = $ptrType(types.Basic);
- ptrType$4 = $ptrType(types.Array);
- ptrType$5 = $ptrType(types.Slice);
- ptrType$6 = $ptrType(types.Struct);
- ptrType$7 = $ptrType(types.Pointer);
- ptrType$8 = $ptrType(types.Signature);
- ptrType$9 = $ptrType(types.Interface);
- ptrType$10 = $ptrType(types.Map);
- ptrType$11 = $ptrType(types.Chan);
- ptrType$12 = $ptrType(types.Named);
- ptrType$13 = $ptrType(types.Tuple);
- funcType = $funcType([types.Type, $emptyInterface], [], false);
- mapType = $mapType($Uint32, sliceType$1);
- mapType$1 = $mapType(types.Type, $Uint32);
- Map.ptr.prototype.SetHasher = function(hasher) {
- var $ptr, hasher, m;
- m = this;
- hasher = $clone(hasher, Hasher);
- $copy(m.hasher, hasher, Hasher);
- };
- Map.prototype.SetHasher = function(hasher) { return this.$val.SetHasher(hasher); };
- Map.ptr.prototype.Delete = function(key) {
- var $ptr, _entry, _i, _r, _r$1, _ref, _v, bucket, e, hash, i, key, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _v = $f._v; bucket = $f.bucket; e = $f.e; hash = $f.hash; i = $f.i; key = $f.key; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- /* */ if (!(m === ptrType$1.nil) && !(m.table === false)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(m === ptrType$1.nil) && !(m.table === false)) { */ case 1:
- _r = m.hasher.Hash(key); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- hash = _r;
- bucket = (_entry = m.table[$Uint32.keyFor(hash)], _entry !== undefined ? _entry.v : sliceType$1.nil);
- _ref = bucket;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- i = _i;
- e = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), entry);
- if (!(!($interfaceIsEqual(e.key, $ifaceNil)))) { _v = false; $s = 8; continue s; }
- _r$1 = types.Identical(key, e.key); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1; case 8:
- /* */ if (_v) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_v) { */ case 6:
- $copy(((i < 0 || i >= bucket.$length) ? $throwRuntimeError("index out of range") : bucket.$array[bucket.$offset + i]), new entry.ptr($ifaceNil, $ifaceNil), entry);
- m.length = m.length - (1) >> 0;
- return true;
- /* } */ case 7:
- _i++;
- /* } */ $s = 4; continue; case 5:
- /* } */ case 2:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Delete }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._v = _v; $f.bucket = bucket; $f.e = e; $f.hash = hash; $f.i = i; $f.key = key; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.Delete = function(key) { return this.$val.Delete(key); };
- Map.ptr.prototype.At = function(key) {
- var $ptr, _entry, _i, _r, _r$1, _ref, _v, e, key, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _v = $f._v; e = $f.e; key = $f.key; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- /* */ if (!(m === ptrType$1.nil) && !(m.table === false)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(m === ptrType$1.nil) && !(m.table === false)) { */ case 1:
- _r = m.hasher.Hash(key); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = (_entry = m.table[$Uint32.keyFor(_r)], _entry !== undefined ? _entry.v : sliceType$1.nil);
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- e = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), entry);
- if (!(!($interfaceIsEqual(e.key, $ifaceNil)))) { _v = false; $s = 8; continue s; }
- _r$1 = types.Identical(key, e.key); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1; case 8:
- /* */ if (_v) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_v) { */ case 6:
- return e.value;
- /* } */ case 7:
- _i++;
- /* } */ $s = 4; continue; case 5:
- /* } */ case 2:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.At }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._v = _v; $f.e = e; $f.key = key; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.At = function(key) { return this.$val.At(key); };
- Map.ptr.prototype.Set = function(key, value) {
- var $ptr, _entry, _i, _key, _key$1, _map, _r, _r$1, _r$2, _ref, bucket, e, hash, hash$1, hole, i, key, m, prev, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _key = $f._key; _key$1 = $f._key$1; _map = $f._map; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; bucket = $f.bucket; e = $f.e; hash = $f.hash; hash$1 = $f.hash$1; hole = $f.hole; i = $f.i; key = $f.key; m = $f.m; prev = $f.prev; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- prev = $ifaceNil;
- m = this;
- /* */ if (!(m.table === false)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(m.table === false)) { */ case 1:
- _r = m.hasher.Hash(key); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- hash = _r;
- bucket = (_entry = m.table[$Uint32.keyFor(hash)], _entry !== undefined ? _entry.v : sliceType$1.nil);
- hole = ptrType$2.nil;
- _ref = bucket;
- _i = 0;
- /* while (true) { */ case 5:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 6; continue; }
- i = _i;
- e = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), entry);
- /* */ if ($interfaceIsEqual(e.key, $ifaceNil)) { $s = 7; continue; }
- _r$1 = types.Identical(key, e.key); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($interfaceIsEqual(e.key, $ifaceNil)) { */ case 7:
- hole = ((i < 0 || i >= bucket.$length) ? $throwRuntimeError("index out of range") : bucket.$array[bucket.$offset + i]);
- $s = 9; continue;
- /* } else if (_r$1) { */ case 8:
- prev = e.value;
- ((i < 0 || i >= bucket.$length) ? $throwRuntimeError("index out of range") : bucket.$array[bucket.$offset + i]).value = value;
- return prev;
- /* } */ case 9:
- _i++;
- /* } */ $s = 5; continue; case 6:
- if (!(hole === ptrType$2.nil)) {
- $copy(hole, new entry.ptr(key, value), entry);
- } else {
- _key = hash; (m.table || $throwRuntimeError("assignment to entry in nil map"))[$Uint32.keyFor(_key)] = { k: _key, v: $append(bucket, new entry.ptr(key, value)) };
- }
- $s = 3; continue;
- /* } else { */ case 2:
- if (m.hasher.memo === false) {
- $copy(m.hasher, MakeHasher(), Hasher);
- }
- _r$2 = m.hasher.Hash(key); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- hash$1 = _r$2;
- m.table = (_map = new $Map(), _key$1 = hash$1, _map[$Uint32.keyFor(_key$1)] = { k: _key$1, v: new sliceType$1([new entry.ptr(key, value)]) }, _map);
- /* } */ case 3:
- m.length = m.length + (1) >> 0;
- return prev;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Set }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._key = _key; $f._key$1 = _key$1; $f._map = _map; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.bucket = bucket; $f.e = e; $f.hash = hash; $f.hash$1 = hash$1; $f.hole = hole; $f.i = i; $f.key = key; $f.m = m; $f.prev = prev; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.Set = function(key, value) { return this.$val.Set(key, value); };
- Map.ptr.prototype.Len = function() {
- var $ptr, m;
- m = this;
- if (!(m === ptrType$1.nil)) {
- return m.length;
- }
- return 0;
- };
- Map.prototype.Len = function() { return this.$val.Len(); };
- Map.ptr.prototype.Iterate = function(f) {
- var $ptr, _entry, _i, _i$1, _keys, _ref, _ref$1, bucket, e, f, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _keys = $f._keys; _ref = $f._ref; _ref$1 = $f._ref$1; bucket = $f.bucket; e = $f.e; f = $f.f; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- /* */ if (!(m === ptrType$1.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(m === ptrType$1.nil)) { */ case 1:
- _ref = m.table;
- _i = 0;
- _keys = $keys(_ref);
- /* while (true) { */ case 3:
- /* if (!(_i < _keys.length)) { break; } */ if(!(_i < _keys.length)) { $s = 4; continue; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- /* continue; */ $s = 3; continue;
- }
- bucket = _entry.v;
- _ref$1 = bucket;
- _i$1 = 0;
- /* while (true) { */ case 5:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 6; continue; }
- e = $clone(((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]), entry);
- /* */ if (!($interfaceIsEqual(e.key, $ifaceNil))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!($interfaceIsEqual(e.key, $ifaceNil))) { */ case 7:
- $r = f(e.key, e.value); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- _i$1++;
- /* } */ $s = 5; continue; case 6:
- _i++;
- /* } */ $s = 3; continue; case 4:
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Iterate }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._keys = _keys; $f._ref = _ref; $f._ref$1 = _ref$1; $f.bucket = bucket; $f.e = e; $f.f = f; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.Iterate = function(f) { return this.$val.Iterate(f); };
- Map.ptr.prototype.Keys = function() {
- var $ptr, keys, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; keys = $f.keys; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- keys = [keys];
- m = this;
- keys[0] = $makeSlice(sliceType$2, 0, m.Len());
- $r = m.Iterate((function(keys) { return function(key, param) {
- var $ptr, key, param;
- keys[0] = $append(keys[0], key);
- }; })(keys)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return keys[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.Keys }; } $f.$ptr = $ptr; $f.keys = keys; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.Keys = function() { return this.$val.Keys(); };
- Map.ptr.prototype.toString = function(values) {
- var $ptr, _r, _r$1, buf, m, sep, values, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; buf = $f.buf; m = $f.m; sep = $f.sep; values = $f.values; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- sep = [sep];
- values = [values];
- m = this;
- if (m === ptrType$1.nil) {
- return "{}";
- }
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _r = fmt.Fprint(buf[0], new sliceType$3([new $String("{")])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- sep[0] = "";
- $r = m.Iterate((function(buf, sep, values) { return function $b(key, value) {
- var $ptr, _r$1, _r$2, _r$3, key, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; key = $f.key; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$1 = fmt.Fprint(buf[0], new sliceType$3([new $String(sep[0])])); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- sep[0] = ", ";
- _r$2 = fmt.Fprint(buf[0], new sliceType$3([key])); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* */ if (values[0]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (values[0]) { */ case 3:
- _r$3 = fmt.Fprintf(buf[0], ": %q", new sliceType$3([value])); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.key = key; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- }; })(buf, sep, values)); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = fmt.Fprint(buf[0], new sliceType$3([new $String("}")])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- return buf[0].String();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.toString }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.buf = buf; $f.m = m; $f.sep = sep; $f.values = values; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.toString = function(values) { return this.$val.toString(values); };
- Map.ptr.prototype.String = function() {
- var $ptr, _r, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- _r = m.toString(true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.String = function() { return this.$val.String(); };
- Map.ptr.prototype.KeysString = function() {
- var $ptr, _r, m, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; m = $f.m; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = this;
- _r = m.toString(false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Map.ptr.prototype.KeysString }; } $f.$ptr = $ptr; $f._r = _r; $f.m = m; $f.$s = $s; $f.$r = $r; return $f;
- };
- Map.prototype.KeysString = function() { return this.$val.KeysString(); };
- MakeHasher = function() {
- var $ptr;
- return new Hasher.ptr(new $Map());
- };
- $pkg.MakeHasher = MakeHasher;
- Hasher.ptr.prototype.Hash = function(t) {
- var $ptr, _entry, _key, _r, _tuple, h, hash, ok, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r = $f._r; _tuple = $f._tuple; h = $f.h; hash = $f.hash; ok = $f.ok; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- h = $clone(this, Hasher);
- _tuple = (_entry = h.memo[types.Type.keyFor(t)], _entry !== undefined ? [_entry.v, true] : [0, false]); hash = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!ok) { */ case 1:
- _r = h.hashFor(t); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- hash = _r;
- _key = t; (h.memo || $throwRuntimeError("assignment to entry in nil map"))[types.Type.keyFor(_key)] = { k: _key, v: hash };
- /* } */ case 2:
- return hash;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Hasher.ptr.prototype.Hash }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r = _r; $f._tuple = _tuple; $f.h = h; $f.hash = hash; $f.ok = ok; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- Hasher.prototype.Hash = function(t) { return this.$val.Hash(t); };
- hashString = function(s) {
- var $ptr, h, i, s, x;
- h = 0;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- h = (h ^ ((s.charCodeAt(i) >>> 0))) >>> 0;
- h = (x = 16777619, (((h >>> 16 << 16) * x >>> 0) + (h << 16 >>> 16) * x) >>> 0);
- i = i + (1) >> 0;
- }
- return h;
- };
- Hasher.ptr.prototype.hashFor = function(t) {
- var $ptr, _r, _r$1, _r$10, _r$11, _r$12, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tmp, _tmp$1, _tmp$2, _tmp$3, f, h, hash, hash$1, hash$2, i, i$1, m, n, n$1, t, t$1, t$10, t$11, t$2, t$3, t$4, t$5, t$6, t$7, t$8, t$9, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; f = $f.f; h = $f.h; hash = $f.hash; hash$1 = $f.hash$1; hash$2 = $f.hash$2; i = $f.i; i$1 = $f.i$1; m = $f.m; n = $f.n; n$1 = $f.n$1; t = $f.t; t$1 = $f.t$1; t$10 = $f.t$10; t$11 = $f.t$11; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; t$8 = $f.t$8; t$9 = $f.t$9; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- h = $clone(this, Hasher);
- _ref = t;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$4, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$5, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$6, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$7, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$8, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$12, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$13, true)[1]) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 1:
- t$1 = _ref.$val;
- return (t$1.Kind() >>> 0);
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$4, true)[1]) { */ case 2:
- t$2 = _ref.$val;
- _r = h.Hash(t$2.Elem()); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return (9043 + (x = (t$2.Len().$low >>> 0), (((2 >>> 16 << 16) * x >>> 0) + (2 << 16 >>> 16) * x) >>> 0) >>> 0) + (x$1 = _r, (((3 >>> 16 << 16) * x$1 >>> 0) + (3 << 16 >>> 16) * x$1) >>> 0) >>> 0;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$5, true)[1]) { */ case 3:
- t$3 = _ref.$val;
- _r$1 = h.Hash(t$3.Elem()); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return 9049 + (x$2 = _r$1, (((2 >>> 16 << 16) * x$2 >>> 0) + (2 << 16 >>> 16) * x$2) >>> 0) >>> 0;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$6, true)[1]) { */ case 4:
- t$4 = _ref.$val;
- hash = 9059;
- _tmp = 0; _tmp$1 = t$4.NumFields(); i = _tmp; n = _tmp$1;
- /* while (true) { */ case 15:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 16; continue; }
- f = t$4.Field(i);
- if (f.Anonymous()) {
- hash = hash + (8861) >>> 0;
- }
- hash = hash + (hashString(t$4.Tag(i))) >>> 0;
- hash = hash + (hashString(f.object.Name())) >>> 0;
- _r$2 = h.Hash(f.object.Type()); /* */ $s = 17; case 17: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- hash = hash + (_r$2) >>> 0;
- i = i + (1) >> 0;
- /* } */ $s = 15; continue; case 16:
- return hash;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$7, true)[1]) { */ case 5:
- t$5 = _ref.$val;
- _r$3 = h.Hash(t$5.Elem()); /* */ $s = 18; case 18: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return 9067 + (x$3 = _r$3, (((2 >>> 16 << 16) * x$3 >>> 0) + (2 << 16 >>> 16) * x$3) >>> 0) >>> 0;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$8, true)[1]) { */ case 6:
- t$6 = _ref.$val;
- hash$1 = 9091;
- if (t$6.Variadic()) {
- hash$1 = (x$4 = 8863, (((hash$1 >>> 16 << 16) * x$4 >>> 0) + (hash$1 << 16 >>> 16) * x$4) >>> 0);
- }
- _r$4 = h.hashTuple(t$6.Params()); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = h.hashTuple(t$6.Results()); /* */ $s = 20; case 20: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return (hash$1 + (x$5 = _r$4, (((3 >>> 16 << 16) * x$5 >>> 0) + (3 << 16 >>> 16) * x$5) >>> 0) >>> 0) + (x$6 = _r$5, (((5 >>> 16 << 16) * x$6 >>> 0) + (5 << 16 >>> 16) * x$6) >>> 0) >>> 0;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 7:
- t$7 = _ref.$val;
- hash$2 = 9103;
- _tmp$2 = 0; _tmp$3 = t$7.NumMethods(); i$1 = _tmp$2; n$1 = _tmp$3;
- /* while (true) { */ case 21:
- /* if (!(i$1 < n$1)) { break; } */ if(!(i$1 < n$1)) { $s = 22; continue; }
- m = t$7.Method(i$1);
- _r$6 = h.Hash(m.object.Type()); /* */ $s = 23; case 23: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- hash$2 = hash$2 + (((x$7 = hashString(m.object.Name()), (((3 >>> 16 << 16) * x$7 >>> 0) + (3 << 16 >>> 16) * x$7) >>> 0) + (x$8 = _r$6, (((5 >>> 16 << 16) * x$8 >>> 0) + (5 << 16 >>> 16) * x$8) >>> 0) >>> 0)) >>> 0;
- i$1 = i$1 + (1) >> 0;
- /* } */ $s = 21; continue; case 22:
- return hash$2;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1]) { */ case 8:
- t$8 = _ref.$val;
- _r$7 = h.Hash(t$8.Key()); /* */ $s = 24; case 24: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$8 = h.Hash(t$8.Elem()); /* */ $s = 25; case 25: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- return (9109 + (x$9 = _r$7, (((2 >>> 16 << 16) * x$9 >>> 0) + (2 << 16 >>> 16) * x$9) >>> 0) >>> 0) + (x$10 = _r$8, (((3 >>> 16 << 16) * x$10 >>> 0) + (3 << 16 >>> 16) * x$10) >>> 0) >>> 0;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$11, true)[1]) { */ case 9:
- t$9 = _ref.$val;
- _r$9 = h.Hash(t$9.Elem()); /* */ $s = 26; case 26: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- return (9127 + (x$11 = (t$9.Dir() >>> 0), (((2 >>> 16 << 16) * x$11 >>> 0) + (2 << 16 >>> 16) * x$11) >>> 0) >>> 0) + (x$12 = _r$9, (((3 >>> 16 << 16) * x$12 >>> 0) + (3 << 16 >>> 16) * x$12) >>> 0) >>> 0;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$12, true)[1]) { */ case 10:
- t$10 = _ref.$val;
- _r$10 = reflect.ValueOf(t$10.Obj()); /* */ $s = 27; case 27: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$11 = _r$10.Pointer(); /* */ $s = 28; case 28: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return (_r$11 >>> 0);
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$13, true)[1]) { */ case 11:
- t$11 = _ref.$val;
- _r$12 = h.hashTuple(t$11); /* */ $s = 29; case 29: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- return _r$12;
- /* } */ case 12:
- $panic(t);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Hasher.ptr.prototype.hashFor }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f.f = f; $f.h = h; $f.hash = hash; $f.hash$1 = hash$1; $f.hash$2 = hash$2; $f.i = i; $f.i$1 = i$1; $f.m = m; $f.n = n; $f.n$1 = n$1; $f.t = t; $f.t$1 = t$1; $f.t$10 = t$10; $f.t$11 = t$11; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.t$8 = t$8; $f.t$9 = t$9; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f;
- };
- Hasher.prototype.hashFor = function(t) { return this.$val.hashFor(t); };
- Hasher.ptr.prototype.hashTuple = function(tuple) {
- var $ptr, _r, h, hash, i, n, tuple, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; h = $f.h; hash = $f.hash; i = $f.i; n = $f.n; tuple = $f.tuple; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- h = $clone(this, Hasher);
- n = tuple.Len();
- hash = 9137 + (x = (n >>> 0), (((2 >>> 16 << 16) * x >>> 0) + (2 << 16 >>> 16) * x) >>> 0) >>> 0;
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; }
- _r = h.Hash(tuple.At(i).object.Type()); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- hash = hash + ((x$1 = _r, (((3 >>> 16 << 16) * x$1 >>> 0) + (3 << 16 >>> 16) * x$1) >>> 0)) >>> 0;
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- return hash;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Hasher.ptr.prototype.hashTuple }; } $f.$ptr = $ptr; $f._r = _r; $f.h = h; $f.hash = hash; $f.i = i; $f.n = n; $f.tuple = tuple; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Hasher.prototype.hashTuple = function(tuple) { return this.$val.hashTuple(tuple); };
- ptrType$1.methods = [{prop: "SetHasher", name: "SetHasher", pkg: "", typ: $funcType([Hasher], [], false)}, {prop: "Delete", name: "Delete", pkg: "", typ: $funcType([types.Type], [$Bool], false)}, {prop: "At", name: "At", pkg: "", typ: $funcType([types.Type], [$emptyInterface], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([types.Type, $emptyInterface], [$emptyInterface], false)}, {prop: "Len", name: "Len", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Iterate", name: "Iterate", pkg: "", typ: $funcType([funcType], [], false)}, {prop: "Keys", name: "Keys", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "toString", name: "toString", pkg: "golang.org/x/tools/go/types/typeutil", typ: $funcType([$Bool], [$String], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "KeysString", name: "KeysString", pkg: "", typ: $funcType([], [$String], false)}];
- Hasher.methods = [{prop: "Hash", name: "Hash", pkg: "", typ: $funcType([types.Type], [$Uint32], false)}, {prop: "hashFor", name: "hashFor", pkg: "golang.org/x/tools/go/types/typeutil", typ: $funcType([types.Type], [$Uint32], false)}, {prop: "hashTuple", name: "hashTuple", pkg: "golang.org/x/tools/go/types/typeutil", typ: $funcType([ptrType$13], [$Uint32], false)}];
- Map.init([{prop: "hasher", name: "hasher", pkg: "golang.org/x/tools/go/types/typeutil", typ: Hasher, tag: ""}, {prop: "table", name: "table", pkg: "golang.org/x/tools/go/types/typeutil", typ: mapType, tag: ""}, {prop: "length", name: "length", pkg: "golang.org/x/tools/go/types/typeutil", typ: $Int, tag: ""}]);
- entry.init([{prop: "key", name: "key", pkg: "golang.org/x/tools/go/types/typeutil", typ: types.Type, tag: ""}, {prop: "value", name: "value", pkg: "golang.org/x/tools/go/types/typeutil", typ: $emptyInterface, tag: ""}]);
- Hasher.init([{prop: "memo", name: "memo", pkg: "golang.org/x/tools/go/types/typeutil", typ: mapType$1, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = types.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = reflect.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs/compiler"] = (function() {
- var $pkg = {}, $init, bytes, binary, gob, json, fmt, analysis, astutil, filter, prelude, typesutil, ast, token, exact, importer, types, typeutil, io, sort, strconv, strings, ErrorList, Archive, Decl, dceInfo, SourceMapFilter, expression, pkgContext, funcContext, flowData, ImportContext, this$1, branch, sliceType, ptrType, sliceType$1, ptrType$1, sliceType$2, ptrType$2, sliceType$3, structType, sliceType$4, sliceType$5, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, ptrType$12, ptrType$13, ptrType$14, ptrType$15, ptrType$16, ptrType$17, ptrType$19, ptrType$20, ptrType$21, ptrType$22, ptrType$23, sliceType$6, ptrType$24, ptrType$25, ptrType$26, ptrType$27, sliceType$7, ptrType$28, sliceType$8, ptrType$29, ptrType$30, ptrType$31, ptrType$32, ptrType$33, sliceType$9, ptrType$34, sliceType$10, ptrType$35, ptrType$36, ptrType$37, ptrType$38, ptrType$39, sliceType$11, ptrType$40, sliceType$12, ptrType$41, ptrType$42, ptrType$43, sliceType$13, ptrType$44, ptrType$45, sliceType$14, ptrType$46, ptrType$47, ptrType$48, ptrType$49, sliceType$15, ptrType$50, ptrType$51, ptrType$52, ptrType$53, ptrType$54, ptrType$55, ptrType$56, ptrType$57, ptrType$58, ptrType$59, ptrType$60, ptrType$61, ptrType$62, ptrType$63, ptrType$64, ptrType$65, ptrType$66, ptrType$67, ptrType$68, ptrType$69, ptrType$70, ptrType$71, sliceType$16, ptrType$72, funcType, mapType, mapType$1, mapType$2, mapType$3, mapType$4, funcType$1, funcType$2, funcType$3, funcType$4, mapType$5, mapType$6, mapType$7, mapType$8, funcType$5, sizes32, reservedKeywords, init, ImportDependencies, WriteProgramCode, WritePkgCode, ReadArchive, NewImportContext, Compile, translateFunction, hasFallthrough, isVarOrConst, isPkgLevel, fieldName, typeKind, toJavaScriptType, is64Bit, isBoolean, isComplex, isFloat, isInteger, isNumeric, isString, isUnsigned, isBlank, isWrapped, encodeString, getJsTag, needsSpace, removeWhitespace, rangeCheck;
- bytes = $packages["bytes"];
- binary = $packages["encoding/binary"];
- gob = $packages["encoding/gob"];
- json = $packages["encoding/json"];
- fmt = $packages["fmt"];
- analysis = $packages["github.com/gopherjs/gopherjs/compiler/analysis"];
- astutil = $packages["github.com/gopherjs/gopherjs/compiler/astutil"];
- filter = $packages["github.com/gopherjs/gopherjs/compiler/filter"];
- prelude = $packages["github.com/gopherjs/gopherjs/compiler/prelude"];
- typesutil = $packages["github.com/gopherjs/gopherjs/compiler/typesutil"];
- ast = $packages["go/ast"];
- token = $packages["go/token"];
- exact = $packages["golang.org/x/tools/go/exact"];
- importer = $packages["golang.org/x/tools/go/importer"];
- types = $packages["golang.org/x/tools/go/types"];
- typeutil = $packages["golang.org/x/tools/go/types/typeutil"];
- io = $packages["io"];
- sort = $packages["sort"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- ErrorList = $pkg.ErrorList = $newType(12, $kindSlice, "compiler.ErrorList", "ErrorList", "github.com/gopherjs/gopherjs/compiler", null);
- Archive = $pkg.Archive = $newType(0, $kindStruct, "compiler.Archive", "Archive", "github.com/gopherjs/gopherjs/compiler", function(ImportPath_, Name_, Imports_, ExportData_, Declarations_, FileSet_, Minified_, types_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.ImportPath = "";
- this.Name = "";
- this.Imports = sliceType.nil;
- this.ExportData = sliceType$4.nil;
- this.Declarations = sliceType$2.nil;
- this.FileSet = sliceType$4.nil;
- this.Minified = false;
- this.types = ptrType$28.nil;
- return;
- }
- this.ImportPath = ImportPath_;
- this.Name = Name_;
- this.Imports = Imports_;
- this.ExportData = ExportData_;
- this.Declarations = Declarations_;
- this.FileSet = FileSet_;
- this.Minified = Minified_;
- this.types = types_;
- });
- Decl = $pkg.Decl = $newType(0, $kindStruct, "compiler.Decl", "Decl", "github.com/gopherjs/gopherjs/compiler", function(FullName_, Vars_, DeclCode_, MethodListCode_, TypeInitCode_, InitCode_, DceObjectFilter_, DceMethodFilter_, DceDeps_, Blocking_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.FullName = "";
- this.Vars = sliceType.nil;
- this.DeclCode = sliceType$4.nil;
- this.MethodListCode = sliceType$4.nil;
- this.TypeInitCode = sliceType$4.nil;
- this.InitCode = sliceType$4.nil;
- this.DceObjectFilter = "";
- this.DceMethodFilter = "";
- this.DceDeps = sliceType.nil;
- this.Blocking = false;
- return;
- }
- this.FullName = FullName_;
- this.Vars = Vars_;
- this.DeclCode = DeclCode_;
- this.MethodListCode = MethodListCode_;
- this.TypeInitCode = TypeInitCode_;
- this.InitCode = InitCode_;
- this.DceObjectFilter = DceObjectFilter_;
- this.DceMethodFilter = DceMethodFilter_;
- this.DceDeps = DceDeps_;
- this.Blocking = Blocking_;
- });
- dceInfo = $pkg.dceInfo = $newType(0, $kindStruct, "compiler.dceInfo", "dceInfo", "github.com/gopherjs/gopherjs/compiler", function(decl_, objectFilter_, methodFilter_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.decl = ptrType$1.nil;
- this.objectFilter = "";
- this.methodFilter = "";
- return;
- }
- this.decl = decl_;
- this.objectFilter = objectFilter_;
- this.methodFilter = methodFilter_;
- });
- SourceMapFilter = $pkg.SourceMapFilter = $newType(0, $kindStruct, "compiler.SourceMapFilter", "SourceMapFilter", "github.com/gopherjs/gopherjs/compiler", function(Writer_, MappingCallback_, line_, column_, fileSet_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Writer = $ifaceNil;
- this.MappingCallback = $throwNilPointerError;
- this.line = 0;
- this.column = 0;
- this.fileSet = ptrType$31.nil;
- return;
- }
- this.Writer = Writer_;
- this.MappingCallback = MappingCallback_;
- this.line = line_;
- this.column = column_;
- this.fileSet = fileSet_;
- });
- expression = $pkg.expression = $newType(0, $kindStruct, "compiler.expression", "expression", "github.com/gopherjs/gopherjs/compiler", function(str_, parens_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.str = "";
- this.parens = false;
- return;
- }
- this.str = str_;
- this.parens = parens_;
- });
- pkgContext = $pkg.pkgContext = $newType(0, $kindStruct, "compiler.pkgContext", "pkgContext", "github.com/gopherjs/gopherjs/compiler", function(Info_, typeNames_, pkgVars_, objectNames_, varPtrNames_, anonTypes_, anonTypeMap_, escapingVars_, indentation_, dependencies_, minify_, fileSet_, errList_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Info = ptrType$43.nil;
- this.typeNames = sliceType$13.nil;
- this.pkgVars = false;
- this.objectNames = false;
- this.varPtrNames = false;
- this.anonTypes = sliceType$13.nil;
- this.anonTypeMap = new typeutil.Map.ptr();
- this.escapingVars = false;
- this.indentation = 0;
- this.dependencies = false;
- this.minify = false;
- this.fileSet = ptrType$31.nil;
- this.errList = ErrorList.nil;
- return;
- }
- this.Info = Info_;
- this.typeNames = typeNames_;
- this.pkgVars = pkgVars_;
- this.objectNames = objectNames_;
- this.varPtrNames = varPtrNames_;
- this.anonTypes = anonTypes_;
- this.anonTypeMap = anonTypeMap_;
- this.escapingVars = escapingVars_;
- this.indentation = indentation_;
- this.dependencies = dependencies_;
- this.minify = minify_;
- this.fileSet = fileSet_;
- this.errList = errList_;
- });
- funcContext = $pkg.funcContext = $newType(0, $kindStruct, "compiler.funcContext", "funcContext", "github.com/gopherjs/gopherjs/compiler", function(FuncInfo_, p_, parent_, sig_, allVars_, localVars_, resultNames_, flowDatas_, caseCounter_, labelCases_, output_, delayedOutput_, posAvailable_, pos_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.FuncInfo = ptrType$25.nil;
- this.p = ptrType$41.nil;
- this.parent = ptrType$42.nil;
- this.sig = ptrType$24.nil;
- this.allVars = false;
- this.localVars = sliceType.nil;
- this.resultNames = sliceType$7.nil;
- this.flowDatas = false;
- this.caseCounter = 0;
- this.labelCases = false;
- this.output = sliceType$4.nil;
- this.delayedOutput = sliceType$4.nil;
- this.posAvailable = false;
- this.pos = 0;
- return;
- }
- this.FuncInfo = FuncInfo_;
- this.p = p_;
- this.parent = parent_;
- this.sig = sig_;
- this.allVars = allVars_;
- this.localVars = localVars_;
- this.resultNames = resultNames_;
- this.flowDatas = flowDatas_;
- this.caseCounter = caseCounter_;
- this.labelCases = labelCases_;
- this.output = output_;
- this.delayedOutput = delayedOutput_;
- this.posAvailable = posAvailable_;
- this.pos = pos_;
- });
- flowData = $pkg.flowData = $newType(0, $kindStruct, "compiler.flowData", "flowData", "github.com/gopherjs/gopherjs/compiler", function(postStmt_, beginCase_, endCase_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.postStmt = $throwNilPointerError;
- this.beginCase = 0;
- this.endCase = 0;
- return;
- }
- this.postStmt = postStmt_;
- this.beginCase = beginCase_;
- this.endCase = endCase_;
- });
- ImportContext = $pkg.ImportContext = $newType(0, $kindStruct, "compiler.ImportContext", "ImportContext", "github.com/gopherjs/gopherjs/compiler", function(Packages_, Import_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Packages = false;
- this.Import = $throwNilPointerError;
- return;
- }
- this.Packages = Packages_;
- this.Import = Import_;
- });
- this$1 = $pkg.this = $newType(0, $kindStruct, "compiler.this", "this", "github.com/gopherjs/gopherjs/compiler", function(Ident_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Ident = new ast.Ident.ptr();
- return;
- }
- this.Ident = Ident_;
- });
- branch = $pkg.branch = $newType(0, $kindStruct, "compiler.branch", "branch", "github.com/gopherjs/gopherjs/compiler", function(index_, clause_, conds_, condStr_, body_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.index = 0;
- this.clause = ptrType$68.nil;
- this.conds = sliceType$7.nil;
- this.condStr = "";
- this.body = sliceType$6.nil;
- return;
- }
- this.index = index_;
- this.clause = clause_;
- this.conds = conds_;
- this.condStr = condStr_;
- this.body = body_;
- });
- sliceType = $sliceType($String);
- ptrType = $ptrType(Archive);
- sliceType$1 = $sliceType(ptrType);
- ptrType$1 = $ptrType(Decl);
- sliceType$2 = $sliceType(ptrType$1);
- ptrType$2 = $ptrType(dceInfo);
- sliceType$3 = $sliceType(ptrType$2);
- structType = $structType([]);
- sliceType$4 = $sliceType($Uint8);
- sliceType$5 = $sliceType($emptyInterface);
- ptrType$3 = $ptrType(types.Basic);
- ptrType$4 = $ptrType(ast.SelectorExpr);
- ptrType$5 = $ptrType(ast.Ident);
- ptrType$6 = $ptrType(ast.CompositeLit);
- ptrType$7 = $ptrType(ast.FuncLit);
- ptrType$8 = $ptrType(ast.UnaryExpr);
- ptrType$9 = $ptrType(ast.BinaryExpr);
- ptrType$10 = $ptrType(ast.ParenExpr);
- ptrType$11 = $ptrType(ast.IndexExpr);
- ptrType$12 = $ptrType(ast.SliceExpr);
- ptrType$13 = $ptrType(ast.CallExpr);
- ptrType$14 = $ptrType(ast.StarExpr);
- ptrType$15 = $ptrType(ast.TypeAssertExpr);
- ptrType$16 = $ptrType(this$1);
- ptrType$17 = $ptrType(types.Pointer);
- ptrType$19 = $ptrType(ast.KeyValueExpr);
- ptrType$20 = $ptrType(types.Array);
- ptrType$21 = $ptrType(types.Slice);
- ptrType$22 = $ptrType(types.Map);
- ptrType$23 = $ptrType(types.Struct);
- sliceType$6 = $sliceType(ast.Stmt);
- ptrType$24 = $ptrType(types.Signature);
- ptrType$25 = $ptrType(analysis.FuncInfo);
- ptrType$26 = $ptrType(types.Var);
- ptrType$27 = $ptrType(types.Selection);
- sliceType$7 = $sliceType(ast.Expr);
- ptrType$28 = $ptrType(types.Package);
- sliceType$8 = $sliceType(ptrType$26);
- ptrType$29 = $ptrType(types.Tuple);
- ptrType$30 = $ptrType(types.Interface);
- ptrType$31 = $ptrType(token.FileSet);
- ptrType$32 = $ptrType(types.Func);
- ptrType$33 = $ptrType(types.Builtin);
- sliceType$9 = $sliceType(ptrType$32);
- ptrType$34 = $ptrType(types.Named);
- sliceType$10 = $sliceType(ptrType$34);
- ptrType$35 = $ptrType(types.Const);
- ptrType$36 = $ptrType(types.TypeName);
- ptrType$37 = $ptrType(types.Nil);
- ptrType$38 = $ptrType(expression);
- ptrType$39 = $ptrType(types.Chan);
- sliceType$11 = $sliceType($Int);
- ptrType$40 = $ptrType(types.Initializer);
- sliceType$12 = $sliceType(ptrType$40);
- ptrType$41 = $ptrType(pkgContext);
- ptrType$42 = $ptrType(funcContext);
- ptrType$43 = $ptrType(analysis.Info);
- sliceType$13 = $sliceType(ptrType$36);
- ptrType$44 = $ptrType(types.Label);
- ptrType$45 = $ptrType(ast.FuncDecl);
- sliceType$14 = $sliceType(ptrType$45);
- ptrType$46 = $ptrType(ast.GenDecl);
- ptrType$47 = $ptrType(ast.TypeSpec);
- ptrType$48 = $ptrType(ast.ValueSpec);
- ptrType$49 = $ptrType(ast.FieldList);
- sliceType$15 = $sliceType(ptrType$5);
- ptrType$50 = $ptrType(ast.BlockStmt);
- ptrType$51 = $ptrType(types.Scope);
- ptrType$52 = $ptrType(ast.IfStmt);
- ptrType$53 = $ptrType(ast.SwitchStmt);
- ptrType$54 = $ptrType(ast.TypeSwitchStmt);
- ptrType$55 = $ptrType(ast.ForStmt);
- ptrType$56 = $ptrType(ast.RangeStmt);
- ptrType$57 = $ptrType(ast.BranchStmt);
- ptrType$58 = $ptrType(ast.ReturnStmt);
- ptrType$59 = $ptrType(ast.DeferStmt);
- ptrType$60 = $ptrType(ast.AssignStmt);
- ptrType$61 = $ptrType(ast.DeclStmt);
- ptrType$62 = $ptrType(ast.ExprStmt);
- ptrType$63 = $ptrType(ast.LabeledStmt);
- ptrType$64 = $ptrType(ast.GoStmt);
- ptrType$65 = $ptrType(ast.SendStmt);
- ptrType$66 = $ptrType(ast.SelectStmt);
- ptrType$67 = $ptrType(ast.EmptyStmt);
- ptrType$68 = $ptrType(ast.CaseClause);
- ptrType$69 = $ptrType(flowData);
- ptrType$70 = $ptrType(ast.CommClause);
- ptrType$71 = $ptrType(branch);
- sliceType$16 = $sliceType(ptrType$71);
- ptrType$72 = $ptrType(SourceMapFilter);
- funcType = $funcType([$Int, $Int, token.Position], [], false);
- mapType = $mapType($String, $String);
- mapType$1 = $mapType(types.Object, $String);
- mapType$2 = $mapType(ptrType$26, $String);
- mapType$3 = $mapType(ptrType$26, $Bool);
- mapType$4 = $mapType(types.Object, $Bool);
- funcType$1 = $funcType([ast.Expr], [ptrType$38], false);
- funcType$2 = $funcType([$Int], [], false);
- funcType$3 = $funcType([], [$String], false);
- funcType$4 = $funcType([], [], false);
- mapType$5 = $mapType($String, $Int);
- mapType$6 = $mapType(ptrType$44, ptrType$69);
- mapType$7 = $mapType(ptrType$44, $Int);
- mapType$8 = $mapType($String, ptrType$28);
- funcType$5 = $funcType([$String], [ptrType, $error], false);
- init = function() {
- var $ptr, _i, _key, _ref, keyword;
- _ref = new sliceType(["abstract", "arguments", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "debugger", "default", "delete", "do", "double", "else", "enum", "eval", "export", "extends", "false", "final", "finally", "float", "for", "function", "goto", "if", "implements", "import", "in", "instanceof", "int", "interface", "let", "long", "native", "new", "null", "package", "private", "protected", "public", "return", "short", "static", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "typeof", "undefined", "var", "void", "volatile", "while", "with", "yield"]);
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- keyword = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _key = keyword; (reservedKeywords || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: true };
- _i++;
- }
- };
- ErrorList.prototype.Error = function() {
- var $ptr, _r, err, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; err = $f.err; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- err = this;
- _r = (0 >= err.$length ? $throwRuntimeError("index out of range") : err.$array[err.$offset + 0]).Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ErrorList.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.err = err; $f.$s = $s; $f.$r = $r; return $f;
- };
- $ptrType(ErrorList).prototype.Error = function() { return this.$get().Error(); };
- ImportDependencies = function(archive, importPkg) {
- var $ptr, _i, _r, _r$1, _ref, archive, collectDependencies, deps, err, err$1, imp, importPkg, paths, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; archive = $f.archive; collectDependencies = $f.collectDependencies; deps = $f.deps; err = $f.err; err$1 = $f.err$1; imp = $f.imp; importPkg = $f.importPkg; paths = $f.paths; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- collectDependencies = [collectDependencies];
- deps = [deps];
- importPkg = [importPkg];
- paths = [paths];
- deps[0] = sliceType$1.nil;
- paths[0] = new $Map();
- collectDependencies[0] = $throwNilPointerError;
- collectDependencies[0] = (function(collectDependencies, deps, importPkg, paths) { return function $b(path) {
- var $ptr, _entry, _i, _key, _r, _r$1, _ref, _tuple, dep, err, err$1, imp, path, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tuple = $f._tuple; dep = $f.dep; err = $f.err; err$1 = $f.err$1; imp = $f.imp; path = $f.path; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if ((_entry = paths[0][$String.keyFor(path)], _entry !== undefined ? _entry.v : false)) {
- return $ifaceNil;
- }
- _r = importPkg[0](path); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; dep = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return err;
- }
- _ref = dep.Imports;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- imp = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$1 = collectDependencies[0](imp); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- err$1 = _r$1;
- /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 5:
- return err$1;
- /* } */ case 6:
- _i++;
- /* } */ $s = 2; continue; case 3:
- deps[0] = $append(deps[0], dep);
- _key = dep.ImportPath; (paths[0] || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: true };
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tuple = _tuple; $f.dep = dep; $f.err = err; $f.err$1 = err$1; $f.imp = imp; $f.path = path; $f.$s = $s; $f.$r = $r; return $f;
- }; })(collectDependencies, deps, importPkg, paths);
- _r = collectDependencies[0]("runtime"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- return [sliceType$1.nil, err];
- /* } */ case 3:
- _ref = archive.Imports;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- imp = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$1 = collectDependencies[0](imp); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- err$1 = _r$1;
- /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 7:
- return [sliceType$1.nil, err$1];
- /* } */ case 8:
- _i++;
- /* } */ $s = 4; continue; case 5:
- deps[0] = $append(deps[0], archive);
- return [deps[0], $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ImportDependencies }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.archive = archive; $f.collectDependencies = collectDependencies; $f.deps = deps; $f.err = err; $f.err$1 = err$1; $f.imp = imp; $f.importPkg = importPkg; $f.paths = paths; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ImportDependencies = ImportDependencies;
- WriteProgramCode = function(pkgs, w) {
- var $ptr, _entry, _entry$1, _entry$2, _i, _i$1, _i$2, _i$3, _i$4, _key, _key$1, _key$2, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, byFilter, d, d$1, dceSelection, dep, err, err$1, err$2, err$3, err$4, info, info$1, infos, mainPkg, minify, ok, pendingDecls, pkg, pkg$1, pkgs, w, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; byFilter = $f.byFilter; d = $f.d; d$1 = $f.d$1; dceSelection = $f.dceSelection; dep = $f.dep; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; err$3 = $f.err$3; err$4 = $f.err$4; info = $f.info; info$1 = $f.info$1; infos = $f.infos; mainPkg = $f.mainPkg; minify = $f.minify; ok = $f.ok; pendingDecls = $f.pendingDecls; pkg = $f.pkg; pkg$1 = $f.pkg$1; pkgs = $f.pkgs; w = $f.w; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- mainPkg = (x = pkgs.$length - 1 >> 0, ((x < 0 || x >= pkgs.$length) ? $throwRuntimeError("index out of range") : pkgs.$array[pkgs.$offset + x]));
- minify = mainPkg.Minified;
- byFilter = new $Map();
- pendingDecls = sliceType$2.nil;
- _ref = pkgs;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- pkg = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = pkg.Declarations;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- d = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- if (d.DceObjectFilter === "" && d.DceMethodFilter === "") {
- pendingDecls = $append(pendingDecls, d);
- _i$1++;
- continue;
- }
- info = new dceInfo.ptr(d, "", "");
- if (!(d.DceObjectFilter === "")) {
- info.objectFilter = pkg.ImportPath + "." + d.DceObjectFilter;
- _key = info.objectFilter; (byFilter || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: $append((_entry = byFilter[$String.keyFor(info.objectFilter)], _entry !== undefined ? _entry.v : sliceType$3.nil), info) };
- }
- if (!(d.DceMethodFilter === "")) {
- info.methodFilter = pkg.ImportPath + "." + d.DceMethodFilter;
- _key$1 = info.methodFilter; (byFilter || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$1)] = { k: _key$1, v: $append((_entry$1 = byFilter[$String.keyFor(info.methodFilter)], _entry$1 !== undefined ? _entry$1.v : sliceType$3.nil), info) };
- }
- _i$1++;
- }
- _i++;
- /* } */ $s = 1; continue; case 2:
- dceSelection = new $Map();
- while (true) {
- if (!(!((pendingDecls.$length === 0)))) { break; }
- d$1 = (x$1 = pendingDecls.$length - 1 >> 0, ((x$1 < 0 || x$1 >= pendingDecls.$length) ? $throwRuntimeError("index out of range") : pendingDecls.$array[pendingDecls.$offset + x$1]));
- pendingDecls = $subslice(pendingDecls, 0, (pendingDecls.$length - 1 >> 0));
- _key$2 = d$1; (dceSelection || $throwRuntimeError("assignment to entry in nil map"))[ptrType$1.keyFor(_key$2)] = { k: _key$2, v: new structType.ptr() };
- _ref$2 = d$1.DceDeps;
- _i$2 = 0;
- while (true) {
- if (!(_i$2 < _ref$2.$length)) { break; }
- dep = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- _tuple = (_entry$2 = byFilter[$String.keyFor(dep)], _entry$2 !== undefined ? [_entry$2.v, true] : [sliceType$3.nil, false]); infos = _tuple[0]; ok = _tuple[1];
- if (ok) {
- delete byFilter[$String.keyFor(dep)];
- _ref$3 = infos;
- _i$3 = 0;
- while (true) {
- if (!(_i$3 < _ref$3.$length)) { break; }
- info$1 = ((_i$3 < 0 || _i$3 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$3]);
- if (info$1.objectFilter === dep) {
- info$1.objectFilter = "";
- }
- if (info$1.methodFilter === dep) {
- info$1.methodFilter = "";
- }
- if (info$1.objectFilter === "" && info$1.methodFilter === "") {
- pendingDecls = $append(pendingDecls, info$1.decl);
- }
- _i$3++;
- }
- }
- _i$2++;
- }
- }
- _r = w.Write(new sliceType$4($stringToBytes("\"use strict\";\n(function() {\n\n"))); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = _r; err = _tuple$1[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 4:
- return err;
- /* } */ case 5:
- _r$1 = w.Write(removeWhitespace(new sliceType$4($stringToBytes("Error.stackTraceLimit = Infinity;\n\nvar $global, $module;\nif (typeof window !== \"undefined\") { /* web page */\n $global = window;\n} else if (typeof self !== \"undefined\") { /* web worker */\n $global = self;\n} else if (typeof global !== \"undefined\") { /* Node.js */\n $global = global;\n $global.require = require;\n} else { /* others (e.g. Nashorn) */\n $global = this;\n}\n\nif ($global === undefined || $global.Array === undefined) {\n throw new Error(\"no global object found\");\n}\nif (typeof module !== \"undefined\") {\n $module = module;\n}\n\nvar $packages = {}, $idCounter = 0;\nvar $keys = function(m) { return m ? Object.keys(m) : []; };\nvar $min = Math.min;\nvar $mod = function(x, y) { return x % y; };\nvar $parseInt = parseInt;\nvar $parseFloat = function(f) {\n if (f !== undefined && f !== null && f.constructor === Number) {\n return f;\n }\n return parseFloat(f);\n};\nvar $flushConsole = function() {};\nvar $throwRuntimeError; /* set by package \"runtime\" */\nvar $throwNilPointerError = function() { $throwRuntimeError(\"invalid memory address or nil pointer dereference\"); };\nvar $call = function(fn, rcvr, args) { return fn.apply(rcvr, args); };\nvar $makeFunc = function(fn) { return function() { return fn(new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))); } };\n\nvar $froundBuf = new Float32Array(1);\nvar $fround = Math.fround || function(f) { $froundBuf[0] = f; return $froundBuf[0]; };\n\nvar $mapArray = function(array, f) {\n var newArray = new array.constructor(array.length);\n for (var i = 0; i < array.length; i++) {\n newArray[i] = f(array[i]);\n }\n return newArray;\n};\n\nvar $methodVal = function(recv, name) {\n var vals = recv.$methodVals || {};\n recv.$methodVals = vals; /* noop for primitives */\n var f = vals[name];\n if (f !== undefined) {\n return f;\n }\n var method = recv[name];\n f = function() {\n $stackDepthOffset--;\n try {\n return method.apply(recv, arguments);\n } finally {\n $stackDepthOffset++;\n }\n };\n vals[name] = f;\n return f;\n};\n\nvar $methodExpr = function(method) {\n if (method.$expr === undefined) {\n method.$expr = function() {\n $stackDepthOffset--;\n try {\n return Function.call.apply(method, arguments);\n } finally {\n $stackDepthOffset++;\n }\n };\n }\n return method.$expr;\n};\n\nvar $subslice = function(slice, low, high, max) {\n if (low < 0 || high < low || max < high || high > slice.$capacity || max > slice.$capacity) {\n $throwRuntimeError(\"slice bounds out of range\");\n }\n var s = new slice.constructor(slice.$array);\n s.$offset = slice.$offset + low;\n s.$length = slice.$length - low;\n s.$capacity = slice.$capacity - low;\n if (high !== undefined) {\n s.$length = high - low;\n }\n if (max !== undefined) {\n s.$capacity = max - low;\n }\n return s;\n};\n\nvar $sliceToArray = function(slice) {\n if (slice.$length === 0) {\n return [];\n }\n if (slice.$array.constructor !== Array) {\n return slice.$array.subarray(slice.$offset, slice.$offset + slice.$length);\n }\n return slice.$array.slice(slice.$offset, slice.$offset + slice.$length);\n};\n\nvar $decodeRune = function(str, pos) {\n var c0 = str.charCodeAt(pos);\n\n if (c0 < 0x80) {\n return [c0, 1];\n }\n\n if (c0 !== c0 || c0 < 0xC0) {\n return [0xFFFD, 1];\n }\n\n var c1 = str.charCodeAt(pos + 1);\n if (c1 !== c1 || c1 < 0x80 || 0xC0 <= c1) {\n return [0xFFFD, 1];\n }\n\n if (c0 < 0xE0) {\n var r = (c0 & 0x1F) << 6 | (c1 & 0x3F);\n if (r <= 0x7F) {\n return [0xFFFD, 1];\n }\n return [r, 2];\n }\n\n var c2 = str.charCodeAt(pos + 2);\n if (c2 !== c2 || c2 < 0x80 || 0xC0 <= c2) {\n return [0xFFFD, 1];\n }\n\n if (c0 < 0xF0) {\n var r = (c0 & 0x0F) << 12 | (c1 & 0x3F) << 6 | (c2 & 0x3F);\n if (r <= 0x7FF) {\n return [0xFFFD, 1];\n }\n if (0xD800 <= r && r <= 0xDFFF) {\n return [0xFFFD, 1];\n }\n return [r, 3];\n }\n\n var c3 = str.charCodeAt(pos + 3);\n if (c3 !== c3 || c3 < 0x80 || 0xC0 <= c3) {\n return [0xFFFD, 1];\n }\n\n if (c0 < 0xF8) {\n var r = (c0 & 0x07) << 18 | (c1 & 0x3F) << 12 | (c2 & 0x3F) << 6 | (c3 & 0x3F);\n if (r <= 0xFFFF || 0x10FFFF < r) {\n return [0xFFFD, 1];\n }\n return [r, 4];\n }\n\n return [0xFFFD, 1];\n};\n\nvar $encodeRune = function(r) {\n if (r < 0 || r > 0x10FFFF || (0xD800 <= r && r <= 0xDFFF)) {\n r = 0xFFFD;\n }\n if (r <= 0x7F) {\n return String.fromCharCode(r);\n }\n if (r <= 0x7FF) {\n return String.fromCharCode(0xC0 | r >> 6, 0x80 | (r & 0x3F));\n }\n if (r <= 0xFFFF) {\n return String.fromCharCode(0xE0 | r >> 12, 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F));\n }\n return String.fromCharCode(0xF0 | r >> 18, 0x80 | (r >> 12 & 0x3F), 0x80 | (r >> 6 & 0x3F), 0x80 | (r & 0x3F));\n};\n\nvar $stringToBytes = function(str) {\n var array = new Uint8Array(str.length);\n for (var i = 0; i < str.length; i++) {\n array[i] = str.charCodeAt(i);\n }\n return array;\n};\n\nvar $bytesToString = function(slice) {\n if (slice.$length === 0) {\n return \"\";\n }\n var str = \"\";\n for (var i = 0; i < slice.$length; i += 10000) {\n str += String.fromCharCode.apply(undefined, slice.$array.subarray(slice.$offset + i, slice.$offset + Math.min(slice.$length, i + 10000)));\n }\n return str;\n};\n\nvar $stringToRunes = function(str) {\n var array = new Int32Array(str.length);\n var rune, j = 0;\n for (var i = 0; i < str.length; i += rune[1], j++) {\n rune = $decodeRune(str, i);\n array[j] = rune[0];\n }\n return array.subarray(0, j);\n};\n\nvar $runesToString = function(slice) {\n if (slice.$length === 0) {\n return \"\";\n }\n var str = \"\";\n for (var i = 0; i < slice.$length; i++) {\n str += $encodeRune(slice.$array[slice.$offset + i]);\n }\n return str;\n};\n\nvar $copyString = function(dst, src) {\n var n = Math.min(src.length, dst.$length);\n for (var i = 0; i < n; i++) {\n dst.$array[dst.$offset + i] = src.charCodeAt(i);\n }\n return n;\n};\n\nvar $copySlice = function(dst, src) {\n var n = Math.min(src.$length, dst.$length);\n $internalCopy(dst.$array, src.$array, dst.$offset, src.$offset, n, dst.constructor.elem);\n return n;\n};\n\nvar $copy = function(dst, src, typ) {\n switch (typ.kind) {\n case $kindArray:\n $internalCopy(dst, src, 0, 0, src.length, typ.elem);\n break;\n case $kindStruct:\n for (var i = 0; i < typ.fields.length; i++) {\n var f = typ.fields[i];\n switch (f.typ.kind) {\n case $kindArray:\n case $kindStruct:\n $copy(dst[f.prop], src[f.prop], f.typ);\n continue;\n default:\n dst[f.prop] = src[f.prop];\n continue;\n }\n }\n break;\n }\n};\n\nvar $internalCopy = function(dst, src, dstOffset, srcOffset, n, elem) {\n if (n === 0 || (dst === src && dstOffset === srcOffset)) {\n return;\n }\n\n if (src.subarray) {\n dst.set(src.subarray(srcOffset, srcOffset + n), dstOffset);\n return;\n }\n\n switch (elem.kind) {\n case $kindArray:\n case $kindStruct:\n if (dst === src && dstOffset > srcOffset) {\n for (var i = n - 1; i >= 0; i--) {\n $copy(dst[dstOffset + i], src[srcOffset + i], elem);\n }\n return;\n }\n for (var i = 0; i < n; i++) {\n $copy(dst[dstOffset + i], src[srcOffset + i], elem);\n }\n return;\n }\n\n if (dst === src && dstOffset > srcOffset) {\n for (var i = n - 1; i >= 0; i--) {\n dst[dstOffset + i] = src[srcOffset + i];\n }\n return;\n }\n for (var i = 0; i < n; i++) {\n dst[dstOffset + i] = src[srcOffset + i];\n }\n};\n\nvar $clone = function(src, type) {\n var clone = type.zero();\n $copy(clone, src, type);\n return clone;\n};\n\nvar $pointerOfStructConversion = function(obj, type) {\n if(obj.$proxies === undefined) {\n obj.$proxies = {};\n obj.$proxies[obj.constructor.string] = obj;\n }\n var proxy = obj.$proxies[type.string];\n if (proxy === undefined) {\n var properties = {};\n for (var i = 0; i < type.elem.fields.length; i++) {\n (function(fieldProp) {\n properties[fieldProp] = {\n get: function() { return obj[fieldProp]; },\n set: function(value) { obj[fieldProp] = value; },\n };\n })(type.elem.fields[i].prop);\n }\n proxy = Object.create(type.prototype, properties);\n proxy.$val = proxy;\n obj.$proxies[type.string] = proxy;\n proxy.$proxies = obj.$proxies;\n }\n return proxy;\n};\n\nvar $append = function(slice) {\n return $internalAppend(slice, arguments, 1, arguments.length - 1);\n};\n\nvar $appendSlice = function(slice, toAppend) {\n return $internalAppend(slice, toAppend.$array, toAppend.$offset, toAppend.$length);\n};\n\nvar $internalAppend = function(slice, array, offset, length) {\n if (length === 0) {\n return slice;\n }\n\n var newArray = slice.$array;\n var newOffset = slice.$offset;\n var newLength = slice.$length + length;\n var newCapacity = slice.$capacity;\n\n if (newLength > newCapacity) {\n newOffset = 0;\n newCapacity = Math.max(newLength, slice.$capacity < 1024 ? slice.$capacity * 2 : Math.floor(slice.$capacity * 5 / 4));\n\n if (slice.$array.constructor === Array) {\n newArray = slice.$array.slice(slice.$offset, slice.$offset + slice.$length);\n newArray.length = newCapacity;\n var zero = slice.constructor.elem.zero;\n for (var i = slice.$length; i < newCapacity; i++) {\n newArray[i] = zero();\n }\n } else {\n newArray = new slice.$array.constructor(newCapacity);\n newArray.set(slice.$array.subarray(slice.$offset, slice.$offset + slice.$length));\n }\n }\n\n $internalCopy(newArray, array, newOffset + slice.$length, offset, length, slice.constructor.elem);\n\n var newSlice = new slice.constructor(newArray);\n newSlice.$offset = newOffset;\n newSlice.$length = newLength;\n newSlice.$capacity = newCapacity;\n return newSlice;\n};\n\nvar $equal = function(a, b, type) {\n if (type === $jsObjectPtr) {\n return a === b;\n }\n switch (type.kind) {\n case $kindComplex64:\n case $kindComplex128:\n return a.$real === b.$real && a.$imag === b.$imag;\n case $kindInt64:\n case $kindUint64:\n return a.$high === b.$high && a.$low === b.$low;\n case $kindArray:\n if (a.length !== b.length) {\n return false;\n }\n for (var i = 0; i < a.length; i++) {\n if (!$equal(a[i], b[i], type.elem)) {\n return false;\n }\n }\n return true;\n case $kindStruct:\n for (var i = 0; i < type.fields.length; i++) {\n var f = type.fields[i];\n if (!$equal(a[f.prop], b[f.prop], f.typ)) {\n return false;\n }\n }\n return true;\n case $kindInterface:\n return $interfaceIsEqual(a, b);\n default:\n return a === b;\n }\n};\n\nvar $interfaceIsEqual = function(a, b) {\n if (a === $ifaceNil || b === $ifaceNil) {\n return a === b;\n }\n if (a.constructor !== b.constructor) {\n return false;\n }\n if (a.constructor === $jsObjectPtr) {\n return a.object === b.object;\n }\n if (!a.constructor.comparable) {\n $throwRuntimeError(\"comparing uncomparable type \" + a.constructor.string);\n }\n return $equal(a.$val, b.$val, a.constructor);\n};\n\nvar $kindBool = 1;\nvar $kindInt = 2;\nvar $kindInt8 = 3;\nvar $kindInt16 = 4;\nvar $kindInt32 = 5;\nvar $kindInt64 = 6;\nvar $kindUint = 7;\nvar $kindUint8 = 8;\nvar $kindUint16 = 9;\nvar $kindUint32 = 10;\nvar $kindUint64 = 11;\nvar $kindUintptr = 12;\nvar $kindFloat32 = 13;\nvar $kindFloat64 = 14;\nvar $kindComplex64 = 15;\nvar $kindComplex128 = 16;\nvar $kindArray = 17;\nvar $kindChan = 18;\nvar $kindFunc = 19;\nvar $kindInterface = 20;\nvar $kindMap = 21;\nvar $kindPtr = 22;\nvar $kindSlice = 23;\nvar $kindString = 24;\nvar $kindStruct = 25;\nvar $kindUnsafePointer = 26;\n\nvar $methodSynthesizers = [];\nvar $addMethodSynthesizer = function(f) {\n if ($methodSynthesizers === null) {\n f();\n return;\n }\n $methodSynthesizers.push(f);\n};\nvar $synthesizeMethods = function() {\n $methodSynthesizers.forEach(function(f) { f(); });\n $methodSynthesizers = null;\n};\n\nvar $ifaceKeyFor = function(x) {\n if (x === $ifaceNil) {\n return 'nil';\n }\n var c = x.constructor;\n return c.string + '$' + c.keyFor(x.$val);\n};\n\nvar $identity = function(x) { return x; };\n\nvar $newType = function(size, kind, string, name, pkg, constructor) {\n var typ;\n switch(kind) {\n case $kindBool:\n case $kindInt:\n case $kindInt8:\n case $kindInt16:\n case $kindInt32:\n case $kindUint:\n case $kindUint8:\n case $kindUint16:\n case $kindUint32:\n case $kindUintptr:\n case $kindString:\n case $kindUnsafePointer:\n typ = function(v) { this.$val = v; };\n break;\n\n case $kindFloat32:\n case $kindFloat64:\n typ = function(v) { this.$val = v; };\n typ.keyFor = function(x) { return $floatKey(x); };\n break;\n\n case $kindInt64:\n typ = function(high, low) {\n this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >> 0;\n this.$low = low >>> 0;\n this.$val = this;\n };\n typ.keyFor = function(x) { return x.$high + \"$\" + x.$low; };\n break;\n\n case $kindUint64:\n typ = function(high, low) {\n this.$high = (high + Math.floor(Math.ceil(low) / 4294967296)) >>> 0;\n this.$low = low >>> 0;\n this.$val = this;\n };\n typ.keyFor = function(x) { return x.$high + \"$\" + x.$low; };\n break;\n\n case $kindComplex64:\n typ = function(real, imag) {\n this.$real = $fround(real);\n this.$imag = $fround(imag);\n this.$val = this;\n };\n typ.keyFor = function(x) { return x.$real + \"$\" + x.$imag; };\n break;\n\n case $kindComplex128:\n typ = function(real, imag) {\n this.$real = real;\n this.$imag = imag;\n this.$val = this;\n };\n typ.keyFor = function(x) { return x.$real + \"$\" + x.$imag; };\n break;\n\n case $kindArray:\n typ = function(v) { this.$val = v; };\n typ.ptr = $newType(4, $kindPtr, \"*\" + string, \"\", \"\", function(array) {\n this.$get = function() { return array; };\n this.$set = function(v) { $copy(this, v, typ); };\n this.$val = array;\n });\n typ.init = function(elem, len) {\n typ.elem = elem;\n typ.len = len;\n typ.comparable = elem.comparable;\n typ.keyFor = function(x) {\n return Array.prototype.join.call($mapArray(x, function(e) {\n return String(elem.keyFor(e)).replace(/\\\\/g, \"\\\\\\\\\").replace(/\\$/g, \"\\\\$\");\n }), \"$\");\n };\n typ.ptr.init(typ);\n Object.defineProperty(typ.ptr.nil, \"nilCheck\", { get: $throwNilPointerError });\n };\n break;\n\n case $kindChan:\n typ = function(capacity) {\n this.$val = this;\n this.$capacity = capacity;\n this.$buffer = [];\n this.$sendQueue = [];\n this.$recvQueue = [];\n this.$closed = false;\n };\n typ.keyFor = function(x) {\n if (x.$id === undefined) {\n $idCounter++;\n x.$id = $idCounter;\n }\n return String(x.$id);\n };\n typ.init = function(elem, sendOnly, recvOnly) {\n typ.elem = elem;\n typ.sendOnly = sendOnly;\n typ.recvOnly = recvOnly;\n typ.nil = new typ(0);\n typ.nil.$sendQueue = typ.nil.$recvQueue = { length: 0, push: function() {}, shift: function() { return undefined; }, indexOf: function() { return -1; } };\n };\n break;\n\n case $kindFunc:\n typ = function(v) { this.$val = v; };\n typ.init = function(params, results, variadic) {\n typ.params = params;\n typ.results = results;\n typ.variadic = variadic;\n typ.comparable = false;\n };\n break;\n\n case $kindInterface:\n typ = { implementedBy: {}, missingMethodFor: {} };\n typ.keyFor = $ifaceKeyFor;\n typ.init = function(methods) {\n typ.methods = methods;\n methods.forEach(function(m) {\n $ifaceNil[m.prop] = $throwNilPointerError;\n });\n };\n break;\n\n case $kindMap:\n typ = function(v) { this.$val = v; };\n typ.init = function(key, elem) {\n typ.key = key;\n typ.elem = elem;\n typ.comparable = false;\n };\n break;\n\n case $kindPtr:\n typ = constructor || function(getter, setter, target) {\n this.$get = getter;\n this.$set = setter;\n this.$target = target;\n this.$val = this;\n };\n typ.keyFor = function(x) {\n if (x.$id === undefined) {\n $idCounter++;\n x.$id = $idCounter;\n }\n return String(x.$id);\n };\n typ.init = function(elem) {\n typ.elem = elem;\n typ.nil = new typ($throwNilPointerError, $throwNilPointerError);\n };\n break;\n\n case $kindSlice:\n typ = function(array) {\n if (array.constructor !== typ.nativeArray) {\n array = new typ.nativeArray(array);\n }\n this.$array = array;\n this.$offset = 0;\n this.$length = array.length;\n this.$capacity = array.length;\n this.$val = this;\n };\n typ.init = function(elem) {\n typ.elem = elem;\n typ.comparable = false;\n typ.nativeArray = $nativeArray(elem.kind);\n typ.nil = new typ([]);\n };\n break;\n\n case $kindStruct:\n typ = function(v) { this.$val = v; };\n typ.ptr = $newType(4, $kindPtr, \"*\" + string, \"\", \"\", constructor);\n typ.ptr.elem = typ;\n typ.ptr.prototype.$get = function() { return this; };\n typ.ptr.prototype.$set = function(v) { $copy(this, v, typ); };\n typ.init = function(fields) {\n typ.fields = fields;\n fields.forEach(function(f) {\n if (!f.typ.comparable) {\n typ.comparable = false;\n }\n });\n typ.keyFor = function(x) {\n var val = x.$val;\n return $mapArray(fields, function(f) {\n return String(f.typ.keyFor(val[f.prop])).replace(/\\\\/g, \"\\\\\\\\\").replace(/\\$/g, \"\\\\$\");\n }).join(\"$\");\n };\n /* nil value */\n var properties = {};\n fields.forEach(function(f) {\n properties[f.prop] = { get: $throwNilPointerError, set: $throwNilPointerError };\n });\n typ.ptr.nil = Object.create(constructor.prototype, properties);\n typ.ptr.nil.$val = typ.ptr.nil;\n /* methods for embedded fields */\n $addMethodSynthesizer(function() {\n var synthesizeMethod = function(target, m, f) {\n if (target.prototype[m.prop] !== undefined) { return; }\n target.prototype[m.prop] = function() {\n var v = this.$val[f.prop];\n if (f.typ === $jsObjectPtr) {\n v = new $jsObjectPtr(v);\n }\n if (v.$val === undefined) {\n v = new f.typ(v);\n }\n return v[m.prop].apply(v, arguments);\n };\n };\n fields.forEach(function(f) {\n if (f.name === \"\") {\n $methodSet(f.typ).forEach(function(m) {\n synthesizeMethod(typ, m, f);\n synthesizeMethod(typ.ptr, m, f);\n });\n $methodSet($ptrType(f.typ)).forEach(function(m) {\n synthesizeMethod(typ.ptr, m, f);\n });\n }\n });\n });\n };\n break;\n\n default:\n $panic(new $String(\"invalid kind: \" + kind));\n }\n\n switch (kind) {\n case $kindBool:\n case $kindMap:\n typ.zero = function() { return false; };\n break;\n\n case $kindInt:\n case $kindInt8:\n case $kindInt16:\n case $kindInt32:\n case $kindUint:\n case $kindUint8 :\n case $kindUint16:\n case $kindUint32:\n case $kindUintptr:\n case $kindUnsafePointer:\n case $kindFloat32:\n case $kindFloat64:\n typ.zero = function() { return 0; };\n break;\n\n case $kindString:\n typ.zero = function() { return \"\"; };\n break;\n\n case $kindInt64:\n case $kindUint64:\n case $kindComplex64:\n case $kindComplex128:\n var zero = new typ(0, 0);\n typ.zero = function() { return zero; };\n break;\n\n case $kindChan:\n case $kindPtr:\n case $kindSlice:\n typ.zero = function() { return typ.nil; };\n break;\n\n case $kindFunc:\n typ.zero = function() { return $throwNilPointerError; };\n break;\n\n case $kindInterface:\n typ.zero = function() { return $ifaceNil; };\n break;\n\n case $kindArray:\n typ.zero = function() {\n var arrayClass = $nativeArray(typ.elem.kind);\n if (arrayClass !== Array) {\n return new arrayClass(typ.len);\n }\n var array = new Array(typ.len);\n for (var i = 0; i < typ.len; i++) {\n array[i] = typ.elem.zero();\n }\n return array;\n };\n break;\n\n case $kindStruct:\n typ.zero = function() { return new typ.ptr(); };\n break;\n\n default:\n $panic(new $String(\"invalid kind: \" + kind));\n }\n\n typ.size = size;\n typ.kind = kind;\n typ.string = string;\n typ.typeName = name;\n typ.pkg = pkg;\n typ.methods = [];\n typ.methodSetCache = null;\n typ.comparable = true;\n typ.keyFor = typ.keyFor || $identity;\n return typ;\n};\n\nvar $methodSet = function(typ) {\n if (typ.methodSetCache !== null) {\n return typ.methodSetCache;\n }\n var base = {};\n\n var isPtr = (typ.kind === $kindPtr);\n if (isPtr && typ.elem.kind === $kindInterface) {\n typ.methodSetCache = [];\n return [];\n }\n\n var current = [{typ: isPtr ? typ.elem : typ, indirect: isPtr}];\n\n var seen = {};\n\n while (current.length > 0) {\n var next = [];\n var mset = [];\n\n current.forEach(function(e) {\n if (seen[e.typ.string]) {\n return;\n }\n seen[e.typ.string] = true;\n\n if(e.typ.typeName !== \"\") {\n mset = mset.concat(e.typ.methods);\n if (e.indirect) {\n mset = mset.concat($ptrType(e.typ).methods);\n }\n }\n\n switch (e.typ.kind) {\n case $kindStruct:\n e.typ.fields.forEach(function(f) {\n if (f.name === \"\") {\n var fTyp = f.typ;\n var fIsPtr = (fTyp.kind === $kindPtr);\n next.push({typ: fIsPtr ? fTyp.elem : fTyp, indirect: e.indirect || fIsPtr});\n }\n });\n break;\n\n case $kindInterface:\n mset = mset.concat(e.typ.methods);\n break;\n }\n });\n\n mset.forEach(function(m) {\n if (base[m.name] === undefined) {\n base[m.name] = m;\n }\n });\n\n current = next;\n }\n\n typ.methodSetCache = [];\n Object.keys(base).sort().forEach(function(name) {\n typ.methodSetCache.push(base[name]);\n });\n return typ.methodSetCache;\n};\n\nvar $Bool = $newType( 1, $kindBool, \"bool\", \"bool\", \"\", null);\nvar $Int = $newType( 4, $kindInt, \"int\", \"int\", \"\", null);\nvar $Int8 = $newType( 1, $kindInt8, \"int8\", \"int8\", \"\", null);\nvar $Int16 = $newType( 2, $kindInt16, \"int16\", \"int16\", \"\", null);\nvar $Int32 = $newType( 4, $kindInt32, \"int32\", \"int32\", \"\", null);\nvar $Int64 = $newType( 8, $kindInt64, \"int64\", \"int64\", \"\", null);\nvar $Uint = $newType( 4, $kindUint, \"uint\", \"uint\", \"\", null);\nvar $Uint8 = $newType( 1, $kindUint8, \"uint8\", \"uint8\", \"\", null);\nvar $Uint16 = $newType( 2, $kindUint16, \"uint16\", \"uint16\", \"\", null);\nvar $Uint32 = $newType( 4, $kindUint32, \"uint32\", \"uint32\", \"\", null);\nvar $Uint64 = $newType( 8, $kindUint64, \"uint64\", \"uint64\", \"\", null);\nvar $Uintptr = $newType( 4, $kindUintptr, \"uintptr\", \"uintptr\", \"\", null);\nvar $Float32 = $newType( 4, $kindFloat32, \"float32\", \"float32\", \"\", null);\nvar $Float64 = $newType( 8, $kindFloat64, \"float64\", \"float64\", \"\", null);\nvar $Complex64 = $newType( 8, $kindComplex64, \"complex64\", \"complex64\", \"\", null);\nvar $Complex128 = $newType(16, $kindComplex128, \"complex128\", \"complex128\", \"\", null);\nvar $String = $newType( 8, $kindString, \"string\", \"string\", \"\", null);\nvar $UnsafePointer = $newType( 4, $kindUnsafePointer, \"unsafe.Pointer\", \"Pointer\", \"\", null);\n\nvar $nativeArray = function(elemKind) {\n switch (elemKind) {\n case $kindInt:\n return Int32Array;\n case $kindInt8:\n return Int8Array;\n case $kindInt16:\n return Int16Array;\n case $kindInt32:\n return Int32Array;\n case $kindUint:\n return Uint32Array;\n case $kindUint8:\n return Uint8Array;\n case $kindUint16:\n return Uint16Array;\n case $kindUint32:\n return Uint32Array;\n case $kindUintptr:\n return Uint32Array;\n case $kindFloat32:\n return Float32Array;\n case $kindFloat64:\n return Float64Array;\n default:\n return Array;\n }\n};\nvar $toNativeArray = function(elemKind, array) {\n var nativeArray = $nativeArray(elemKind);\n if (nativeArray === Array) {\n return array;\n }\n return new nativeArray(array);\n};\nvar $arrayTypes = {};\nvar $arrayType = function(elem, len) {\n var string = \"[\" + len + \"]\" + elem.string;\n var typ = $arrayTypes[string];\n if (typ === undefined) {\n typ = $newType(12, $kindArray, string, \"\", \"\", null);\n $arrayTypes[string] = typ;\n typ.init(elem, len);\n }\n return typ;\n};\n\nvar $chanType = function(elem, sendOnly, recvOnly) {\n var string = (recvOnly ? \"<-\" : \"\") + \"chan\" + (sendOnly ? \"<- \" : \" \") + elem.string;\n var field = sendOnly ? \"SendChan\" : (recvOnly ? \"RecvChan\" : \"Chan\");\n var typ = elem[field];\n if (typ === undefined) {\n typ = $newType(4, $kindChan, string, \"\", \"\", null);\n elem[field] = typ;\n typ.init(elem, sendOnly, recvOnly);\n }\n return typ;\n};\n\nvar $funcTypes = {};\nvar $funcType = function(params, results, variadic) {\n var paramTypes = $mapArray(params, function(p) { return p.string; });\n if (variadic) {\n paramTypes[paramTypes.length - 1] = \"...\" + paramTypes[paramTypes.length - 1].substr(2);\n }\n var string = \"func(\" + paramTypes.join(\", \") + \")\";\n if (results.length === 1) {\n string += \" \" + results[0].string;\n } else if (results.length > 1) {\n string += \" (\" + $mapArray(results, function(r) { return r.string; }).join(\", \") + \")\";\n }\n var typ = $funcTypes[string];\n if (typ === undefined) {\n typ = $newType(4, $kindFunc, string, \"\", \"\", null);\n $funcTypes[string] = typ;\n typ.init(params, results, variadic);\n }\n return typ;\n};\n\nvar $interfaceTypes = {};\nvar $interfaceType = function(methods) {\n var string = \"interface {}\";\n if (methods.length !== 0) {\n string = \"interface { \" + $mapArray(methods, function(m) {\n return (m.pkg !== \"\" ? m.pkg + \".\" : \"\") + m.name + m.typ.string.substr(4);\n }).join(\"; \") + \" }\";\n }\n var typ = $interfaceTypes[string];\n if (typ === undefined) {\n typ = $newType(8, $kindInterface, string, \"\", \"\", null);\n $interfaceTypes[string] = typ;\n typ.init(methods);\n }\n return typ;\n};\nvar $emptyInterface = $interfaceType([]);\nvar $ifaceNil = {};\nvar $error = $newType(8, $kindInterface, \"error\", \"error\", \"\", null);\n$error.init([{prop: \"Error\", name: \"Error\", pkg: \"\", typ: $funcType([], [$String], false)}]);\n\nvar $Map = function() {};\n(function() {\n var names = Object.getOwnPropertyNames(Object.prototype);\n for (var i = 0; i < names.length; i++) {\n $Map.prototype[names[i]] = undefined;\n }\n})();\nvar $mapTypes = {};\nvar $mapType = function(key, elem) {\n var string = \"map[\" + key.string + \"]\" + elem.string;\n var typ = $mapTypes[string];\n if (typ === undefined) {\n typ = $newType(4, $kindMap, string, \"\", \"\", null);\n $mapTypes[string] = typ;\n typ.init(key, elem);\n }\n return typ;\n};\n\nvar $ptrType = function(elem) {\n var typ = elem.ptr;\n if (typ === undefined) {\n typ = $newType(4, $kindPtr, \"*\" + elem.string, \"\", \"\", null);\n elem.ptr = typ;\n typ.init(elem);\n }\n return typ;\n};\n\nvar $newDataPointer = function(data, constructor) {\n if (constructor.elem.kind === $kindStruct) {\n return data;\n }\n return new constructor(function() { return data; }, function(v) { data = v; });\n};\n\nvar $indexPtr = function(array, index, constructor) {\n array.$ptr = array.$ptr || {};\n return array.$ptr[index] || (array.$ptr[index] = new constructor(function() { return array[index]; }, function(v) { array[index] = v; }));\n};\n\nvar $sliceType = function(elem) {\n var typ = elem.Slice;\n if (typ === undefined) {\n typ = $newType(12, $kindSlice, \"[]\" + elem.string, \"\", \"\", null);\n elem.Slice = typ;\n typ.init(elem);\n }\n return typ;\n};\nvar $makeSlice = function(typ, length, capacity) {\n capacity = capacity || length;\n var array = new typ.nativeArray(capacity);\n if (typ.nativeArray === Array) {\n for (var i = 0; i < capacity; i++) {\n array[i] = typ.elem.zero();\n }\n }\n var slice = new typ(array);\n slice.$length = length;\n return slice;\n};\n\nvar $structTypes = {};\nvar $structType = function(fields) {\n var string = \"struct { \" + $mapArray(fields, function(f) {\n return f.name + \" \" + f.typ.string + (f.tag !== \"\" ? (\" \\\"\" + f.tag.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, \"\\\\\\\"\") + \"\\\"\") : \"\");\n }).join(\"; \") + \" }\";\n if (fields.length === 0) {\n string = \"struct {}\";\n }\n var typ = $structTypes[string];\n if (typ === undefined) {\n typ = $newType(0, $kindStruct, string, \"\", \"\", function() {\n this.$val = this;\n for (var i = 0; i < fields.length; i++) {\n var f = fields[i];\n var arg = arguments[i];\n this[f.prop] = arg !== undefined ? arg : f.typ.zero();\n }\n });\n $structTypes[string] = typ;\n typ.init(fields);\n }\n return typ;\n};\n\nvar $assertType = function(value, type, returnTuple) {\n var isInterface = (type.kind === $kindInterface), ok, missingMethod = \"\";\n if (value === $ifaceNil) {\n ok = false;\n } else if (!isInterface) {\n ok = value.constructor === type;\n } else {\n var valueTypeString = value.constructor.string;\n ok = type.implementedBy[valueTypeString];\n if (ok === undefined) {\n ok = true;\n var valueMethodSet = $methodSet(value.constructor);\n var interfaceMethods = type.methods;\n for (var i = 0; i < interfaceMethods.length; i++) {\n var tm = interfaceMethods[i];\n var found = false;\n for (var j = 0; j < valueMethodSet.length; j++) {\n var vm = valueMethodSet[j];\n if (vm.name === tm.name && vm.pkg === tm.pkg && vm.typ === tm.typ) {\n found = true;\n break;\n }\n }\n if (!found) {\n ok = false;\n type.missingMethodFor[valueTypeString] = tm.name;\n break;\n }\n }\n type.implementedBy[valueTypeString] = ok;\n }\n if (!ok) {\n missingMethod = type.missingMethodFor[valueTypeString];\n }\n }\n\n if (!ok) {\n if (returnTuple) {\n return [type.zero(), false];\n }\n $panic(new $packages[\"runtime\"].TypeAssertionError.ptr(\"\", (value === $ifaceNil ? \"\" : value.constructor.string), type.string, missingMethod));\n }\n\n if (!isInterface) {\n value = value.$val;\n }\n if (type === $jsObjectPtr) {\n value = value.object;\n }\n return returnTuple ? [value, true] : value;\n};\n\nvar $floatKey = function(f) {\n if (f !== f) {\n $idCounter++;\n return \"NaN$\" + $idCounter;\n }\n return String(f);\n};\n\nvar $flatten64 = function(x) {\n return x.$high * 4294967296 + x.$low;\n};\n\nvar $shiftLeft64 = function(x, y) {\n if (y === 0) {\n return x;\n }\n if (y < 32) {\n return new x.constructor(x.$high << y | x.$low >>> (32 - y), (x.$low << y) >>> 0);\n }\n if (y < 64) {\n return new x.constructor(x.$low << (y - 32), 0);\n }\n return new x.constructor(0, 0);\n};\n\nvar $shiftRightInt64 = function(x, y) {\n if (y === 0) {\n return x;\n }\n if (y < 32) {\n return new x.constructor(x.$high >> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0);\n }\n if (y < 64) {\n return new x.constructor(x.$high >> 31, (x.$high >> (y - 32)) >>> 0);\n }\n if (x.$high < 0) {\n return new x.constructor(-1, 4294967295);\n }\n return new x.constructor(0, 0);\n};\n\nvar $shiftRightUint64 = function(x, y) {\n if (y === 0) {\n return x;\n }\n if (y < 32) {\n return new x.constructor(x.$high >>> y, (x.$low >>> y | x.$high << (32 - y)) >>> 0);\n }\n if (y < 64) {\n return new x.constructor(0, x.$high >>> (y - 32));\n }\n return new x.constructor(0, 0);\n};\n\nvar $mul64 = function(x, y) {\n var high = 0, low = 0;\n if ((y.$low & 1) !== 0) {\n high = x.$high;\n low = x.$low;\n }\n for (var i = 1; i < 32; i++) {\n if ((y.$low & 1<>> (32 - i);\n low += (x.$low << i) >>> 0;\n }\n }\n for (var i = 0; i < 32; i++) {\n if ((y.$high & 1< yHigh) || (xHigh === yHigh && xLow > yLow))) {\n yHigh = (yHigh << 1 | yLow >>> 31) >>> 0;\n yLow = (yLow << 1) >>> 0;\n n++;\n }\n for (var i = 0; i <= n; i++) {\n high = high << 1 | low >>> 31;\n low = (low << 1) >>> 0;\n if ((xHigh > yHigh) || (xHigh === yHigh && xLow >= yLow)) {\n xHigh = xHigh - yHigh;\n xLow = xLow - yLow;\n if (xLow < 0) {\n xHigh--;\n xLow += 4294967296;\n }\n low++;\n if (low === 4294967296) {\n high++;\n low = 0;\n }\n }\n yLow = (yLow >>> 1 | yHigh << (32 - 1)) >>> 0;\n yHigh = yHigh >>> 1;\n }\n\n if (returnRemainder) {\n return new x.constructor(xHigh * rs, xLow * rs);\n }\n return new x.constructor(high * s, low * s);\n};\n\nvar $divComplex = function(n, d) {\n var ninf = n.$real === 1/0 || n.$real === -1/0 || n.$imag === 1/0 || n.$imag === -1/0;\n var dinf = d.$real === 1/0 || d.$real === -1/0 || d.$imag === 1/0 || d.$imag === -1/0;\n var nnan = !ninf && (n.$real !== n.$real || n.$imag !== n.$imag);\n var dnan = !dinf && (d.$real !== d.$real || d.$imag !== d.$imag);\n if(nnan || dnan) {\n return new n.constructor(0/0, 0/0);\n }\n if (ninf && !dinf) {\n return new n.constructor(1/0, 1/0);\n }\n if (!ninf && dinf) {\n return new n.constructor(0, 0);\n }\n if (d.$real === 0 && d.$imag === 0) {\n if (n.$real === 0 && n.$imag === 0) {\n return new n.constructor(0/0, 0/0);\n }\n return new n.constructor(1/0, 1/0);\n }\n var a = Math.abs(d.$real);\n var b = Math.abs(d.$imag);\n if (a <= b) {\n var ratio = d.$real / d.$imag;\n var denom = d.$real * ratio + d.$imag;\n return new n.constructor((n.$real * ratio + n.$imag) / denom, (n.$imag * ratio - n.$real) / denom);\n }\n var ratio = d.$imag / d.$real;\n var denom = d.$imag * ratio + d.$real;\n return new n.constructor((n.$imag * ratio + n.$real) / denom, (n.$imag - n.$real * ratio) / denom);\n};\n\nvar $stackDepthOffset = 0;\nvar $getStackDepth = function() {\n var err = new Error();\n if (err.stack === undefined) {\n return undefined;\n }\n return $stackDepthOffset + err.stack.split(\"\\n\").length;\n};\n\nvar $panicStackDepth = null, $panicValue;\nvar $callDeferred = function(deferred, jsErr, fromPanic) {\n if (!fromPanic && deferred !== null && deferred.index >= $curGoroutine.deferStack.length) {\n throw jsErr;\n }\n if (jsErr !== null) {\n var newErr = null;\n try {\n $curGoroutine.deferStack.push(deferred);\n $panic(new $jsErrorPtr(jsErr));\n } catch (err) {\n newErr = err;\n }\n $curGoroutine.deferStack.pop();\n $callDeferred(deferred, newErr);\n return;\n }\n if ($curGoroutine.asleep) {\n return;\n }\n\n $stackDepthOffset--;\n var outerPanicStackDepth = $panicStackDepth;\n var outerPanicValue = $panicValue;\n\n var localPanicValue = $curGoroutine.panicStack.pop();\n if (localPanicValue !== undefined) {\n $panicStackDepth = $getStackDepth();\n $panicValue = localPanicValue;\n }\n\n try {\n while (true) {\n if (deferred === null) {\n deferred = $curGoroutine.deferStack[$curGoroutine.deferStack.length - 1];\n if (deferred === undefined) {\n if (localPanicValue.Object instanceof Error) {\n throw localPanicValue.Object;\n }\n var msg;\n if (localPanicValue.constructor === $String) {\n msg = localPanicValue.$val;\n } else if (localPanicValue.Error !== undefined) {\n msg = localPanicValue.Error();\n } else if (localPanicValue.String !== undefined) {\n msg = localPanicValue.String();\n } else {\n msg = localPanicValue;\n }\n throw new Error(msg);\n }\n }\n var call = deferred.pop();\n if (call === undefined) {\n $curGoroutine.deferStack.pop();\n if (localPanicValue !== undefined) {\n deferred = null;\n continue;\n }\n return;\n }\n var r = call[0].apply(call[2], call[1]);\n if (r && r.$blk !== undefined) {\n deferred.push([r.$blk, [], r]);\n if (fromPanic) {\n throw null;\n }\n return;\n }\n\n if (localPanicValue !== undefined && $panicStackDepth === null) {\n throw null; /* error was recovered */\n }\n }\n } finally {\n if (localPanicValue !== undefined) {\n if ($panicStackDepth !== null) {\n $curGoroutine.panicStack.push(localPanicValue);\n }\n $panicStackDepth = outerPanicStackDepth;\n $panicValue = outerPanicValue;\n }\n $stackDepthOffset++;\n }\n};\n\nvar $panic = function(value) {\n $curGoroutine.panicStack.push(value);\n $callDeferred(null, null, true);\n};\nvar $recover = function() {\n if ($panicStackDepth === null || ($panicStackDepth !== undefined && $panicStackDepth !== $getStackDepth() - 2)) {\n return $ifaceNil;\n }\n $panicStackDepth = null;\n return $panicValue;\n};\nvar $throw = function(err) { throw err; };\n\nvar $dummyGoroutine = { asleep: false, exit: false, deferStack: [], panicStack: [], canBlock: false };\nvar $curGoroutine = $dummyGoroutine, $totalGoroutines = 0, $awakeGoroutines = 0, $checkForDeadlock = true;\nvar $go = function(fun, args, direct) {\n $totalGoroutines++;\n $awakeGoroutines++;\n var $goroutine = function() {\n var rescheduled = false;\n try {\n $curGoroutine = $goroutine;\n var r = fun.apply(undefined, args);\n if (r && r.$blk !== undefined) {\n fun = function() { return r.$blk(); };\n args = [];\n rescheduled = true;\n return;\n }\n $goroutine.exit = true;\n } catch (err) {\n $goroutine.exit = true;\n throw err;\n } finally {\n $curGoroutine = $dummyGoroutine;\n if ($goroutine.exit && !rescheduled) { /* also set by runtime.Goexit() */\n $totalGoroutines--;\n $goroutine.asleep = true;\n }\n if ($goroutine.asleep && !rescheduled) {\n $awakeGoroutines--;\n if ($awakeGoroutines === 0 && $totalGoroutines !== 0 && $checkForDeadlock) {\n console.error(\"fatal error: all goroutines are asleep - deadlock!\");\n }\n }\n }\n };\n $goroutine.asleep = false;\n $goroutine.exit = false;\n $goroutine.deferStack = [];\n $goroutine.panicStack = [];\n $goroutine.canBlock = true;\n $schedule($goroutine, direct);\n};\n\nvar $scheduled = [], $schedulerActive = false;\nvar $runScheduled = function() {\n try {\n var r;\n while ((r = $scheduled.shift()) !== undefined) {\n r();\n }\n $schedulerActive = false;\n } finally {\n if ($schedulerActive) {\n setTimeout($runScheduled, 0);\n }\n }\n};\nvar $schedule = function(goroutine, direct) {\n if (goroutine.asleep) {\n goroutine.asleep = false;\n $awakeGoroutines++;\n }\n\n if (direct) {\n goroutine();\n return;\n }\n\n $scheduled.push(goroutine);\n if (!$schedulerActive) {\n $schedulerActive = true;\n setTimeout($runScheduled, 0);\n }\n};\n\nvar $block = function() {\n if (!$curGoroutine.canBlock) {\n $throwRuntimeError(\"cannot block in JavaScript callback, fix by wrapping code in goroutine\");\n }\n $curGoroutine.asleep = true;\n};\n\nvar $send = function(chan, value) {\n if (chan.$closed) {\n $throwRuntimeError(\"send on closed channel\");\n }\n var queuedRecv = chan.$recvQueue.shift();\n if (queuedRecv !== undefined) {\n queuedRecv([value, true]);\n return;\n }\n if (chan.$buffer.length < chan.$capacity) {\n chan.$buffer.push(value);\n return;\n }\n\n var thisGoroutine = $curGoroutine;\n chan.$sendQueue.push(function() {\n $schedule(thisGoroutine);\n return value;\n });\n $block();\n return {\n $blk: function() {\n if (chan.$closed) {\n $throwRuntimeError(\"send on closed channel\");\n }\n },\n };\n};\nvar $recv = function(chan) {\n var queuedSend = chan.$sendQueue.shift();\n if (queuedSend !== undefined) {\n chan.$buffer.push(queuedSend());\n }\n var bufferedValue = chan.$buffer.shift();\n if (bufferedValue !== undefined) {\n return [bufferedValue, true];\n }\n if (chan.$closed) {\n return [chan.constructor.elem.zero(), false];\n }\n\n var thisGoroutine = $curGoroutine;\n var f = { $blk: function() { return this.value; } };\n var queueEntry = function(v) {\n f.value = v;\n $schedule(thisGoroutine);\n };\n chan.$recvQueue.push(queueEntry);\n $block();\n return f;\n};\nvar $close = function(chan) {\n if (chan.$closed) {\n $throwRuntimeError(\"close of closed channel\");\n }\n chan.$closed = true;\n while (true) {\n var queuedSend = chan.$sendQueue.shift();\n if (queuedSend === undefined) {\n break;\n }\n queuedSend(); /* will panic because of closed channel */\n }\n while (true) {\n var queuedRecv = chan.$recvQueue.shift();\n if (queuedRecv === undefined) {\n break;\n }\n queuedRecv([chan.constructor.elem.zero(), false]);\n }\n};\nvar $select = function(comms) {\n var ready = [];\n var selection = -1;\n for (var i = 0; i < comms.length; i++) {\n var comm = comms[i];\n var chan = comm[0];\n switch (comm.length) {\n case 0: /* default */\n selection = i;\n break;\n case 1: /* recv */\n if (chan.$sendQueue.length !== 0 || chan.$buffer.length !== 0 || chan.$closed) {\n ready.push(i);\n }\n break;\n case 2: /* send */\n if (chan.$closed) {\n $throwRuntimeError(\"send on closed channel\");\n }\n if (chan.$recvQueue.length !== 0 || chan.$buffer.length < chan.$capacity) {\n ready.push(i);\n }\n break;\n }\n }\n\n if (ready.length !== 0) {\n selection = ready[Math.floor(Math.random() * ready.length)];\n }\n if (selection !== -1) {\n var comm = comms[selection];\n switch (comm.length) {\n case 0: /* default */\n return [selection];\n case 1: /* recv */\n return [selection, $recv(comm[0])];\n case 2: /* send */\n $send(comm[0], comm[1]);\n return [selection];\n }\n }\n\n var entries = [];\n var thisGoroutine = $curGoroutine;\n var f = { $blk: function() { return this.selection; } };\n var removeFromQueues = function() {\n for (var i = 0; i < entries.length; i++) {\n var entry = entries[i];\n var queue = entry[0];\n var index = queue.indexOf(entry[1]);\n if (index !== -1) {\n queue.splice(index, 1);\n }\n }\n };\n for (var i = 0; i < comms.length; i++) {\n (function(i) {\n var comm = comms[i];\n switch (comm.length) {\n case 1: /* recv */\n var queueEntry = function(value) {\n f.selection = [i, value];\n removeFromQueues();\n $schedule(thisGoroutine);\n };\n entries.push([comm[0].$recvQueue, queueEntry]);\n comm[0].$recvQueue.push(queueEntry);\n break;\n case 2: /* send */\n var queueEntry = function() {\n if (comm[0].$closed) {\n $throwRuntimeError(\"send on closed channel\");\n }\n f.selection = [i];\n removeFromQueues();\n $schedule(thisGoroutine);\n return comm[1];\n };\n entries.push([comm[0].$sendQueue, queueEntry]);\n comm[0].$sendQueue.push(queueEntry);\n break;\n }\n })(i);\n }\n $block();\n return f;\n};\n\nvar $jsObjectPtr, $jsErrorPtr;\n\nvar $needsExternalization = function(t) {\n switch (t.kind) {\n case $kindBool:\n case $kindInt:\n case $kindInt8:\n case $kindInt16:\n case $kindInt32:\n case $kindUint:\n case $kindUint8:\n case $kindUint16:\n case $kindUint32:\n case $kindUintptr:\n case $kindFloat32:\n case $kindFloat64:\n return false;\n default:\n return t !== $jsObjectPtr;\n }\n};\n\nvar $externalize = function(v, t) {\n if (t === $jsObjectPtr) {\n return v;\n }\n switch (t.kind) {\n case $kindBool:\n case $kindInt:\n case $kindInt8:\n case $kindInt16:\n case $kindInt32:\n case $kindUint:\n case $kindUint8:\n case $kindUint16:\n case $kindUint32:\n case $kindUintptr:\n case $kindFloat32:\n case $kindFloat64:\n return v;\n case $kindInt64:\n case $kindUint64:\n return $flatten64(v);\n case $kindArray:\n if ($needsExternalization(t.elem)) {\n return $mapArray(v, function(e) { return $externalize(e, t.elem); });\n }\n return v;\n case $kindFunc:\n return $externalizeFunction(v, t, false);\n case $kindInterface:\n if (v === $ifaceNil) {\n return null;\n }\n if (v.constructor === $jsObjectPtr) {\n return v.$val.object;\n }\n return $externalize(v.$val, v.constructor);\n case $kindMap:\n var m = {};\n var keys = $keys(v);\n for (var i = 0; i < keys.length; i++) {\n var entry = v[keys[i]];\n m[$externalize(entry.k, t.key)] = $externalize(entry.v, t.elem);\n }\n return m;\n case $kindPtr:\n if (v === t.nil) {\n return null;\n }\n return $externalize(v.$get(), t.elem);\n case $kindSlice:\n if ($needsExternalization(t.elem)) {\n return $mapArray($sliceToArray(v), function(e) { return $externalize(e, t.elem); });\n }\n return $sliceToArray(v);\n case $kindString:\n if (v.search(/^[\\x00-\\x7F]*$/) !== -1) {\n return v;\n }\n var s = \"\", r;\n for (var i = 0; i < v.length; i += r[1]) {\n r = $decodeRune(v, i);\n s += String.fromCharCode(r[0]);\n }\n return s;\n case $kindStruct:\n var timePkg = $packages[\"time\"];\n if (timePkg && v.constructor === timePkg.Time.ptr) {\n var milli = $div64(v.UnixNano(), new $Int64(0, 1000000));\n return new Date($flatten64(milli));\n }\n\n var noJsObject = {};\n var searchJsObject = function(v, t) {\n if (t === $jsObjectPtr) {\n return v;\n }\n switch (t.kind) {\n case $kindPtr:\n if (v === t.nil) {\n return noJsObject;\n }\n return searchJsObject(v.$get(), t.elem);\n case $kindStruct:\n var f = t.fields[0];\n return searchJsObject(v[f.prop], f.typ);\n case $kindInterface:\n return searchJsObject(v.$val, v.constructor);\n default:\n return noJsObject;\n }\n };\n var o = searchJsObject(v, t);\n if (o !== noJsObject) {\n return o;\n }\n\n o = {};\n for (var i = 0; i < t.fields.length; i++) {\n var f = t.fields[i];\n if (f.pkg !== \"\") { /* not exported */\n continue;\n }\n o[f.name] = $externalize(v[f.prop], f.typ);\n }\n return o;\n }\n $panic(new $String(\"cannot externalize \" + t.string));\n};\n\nvar $externalizeFunction = function(v, t, passThis) {\n if (v === $throwNilPointerError) {\n return null;\n }\n if (v.$externalizeWrapper === undefined) {\n $checkForDeadlock = false;\n v.$externalizeWrapper = function() {\n var args = [];\n for (var i = 0; i < t.params.length; i++) {\n if (t.variadic && i === t.params.length - 1) {\n var vt = t.params[i].elem, varargs = [];\n for (var j = i; j < arguments.length; j++) {\n varargs.push($internalize(arguments[j], vt));\n }\n args.push(new (t.params[i])(varargs));\n break;\n }\n args.push($internalize(arguments[i], t.params[i]));\n }\n var canBlock = $curGoroutine.canBlock;\n $curGoroutine.canBlock = false;\n try {\n var result = v.apply(passThis ? this : undefined, args);\n } finally {\n $curGoroutine.canBlock = canBlock;\n }\n switch (t.results.length) {\n case 0:\n return;\n case 1:\n return $externalize(result, t.results[0]);\n default:\n for (var i = 0; i < t.results.length; i++) {\n result[i] = $externalize(result[i], t.results[i]);\n }\n return result;\n }\n };\n }\n return v.$externalizeWrapper;\n};\n\nvar $internalize = function(v, t, recv) {\n if (t === $jsObjectPtr) {\n return v;\n }\n if (t === $jsObjectPtr.elem) {\n $panic(new $String(\"cannot internalize js.Object, use *js.Object instead\"));\n }\n switch (t.kind) {\n case $kindBool:\n return !!v;\n case $kindInt:\n return parseInt(v);\n case $kindInt8:\n return parseInt(v) << 24 >> 24;\n case $kindInt16:\n return parseInt(v) << 16 >> 16;\n case $kindInt32:\n return parseInt(v) >> 0;\n case $kindUint:\n return parseInt(v);\n case $kindUint8:\n return parseInt(v) << 24 >>> 24;\n case $kindUint16:\n return parseInt(v) << 16 >>> 16;\n case $kindUint32:\n case $kindUintptr:\n return parseInt(v) >>> 0;\n case $kindInt64:\n case $kindUint64:\n return new t(0, v);\n case $kindFloat32:\n case $kindFloat64:\n return parseFloat(v);\n case $kindArray:\n if (v.length !== t.len) {\n $throwRuntimeError(\"got array with wrong size from JavaScript native\");\n }\n return $mapArray(v, function(e) { return $internalize(e, t.elem); });\n case $kindFunc:\n return function() {\n var args = [];\n for (var i = 0; i < t.params.length; i++) {\n if (t.variadic && i === t.params.length - 1) {\n var vt = t.params[i].elem, varargs = arguments[i];\n for (var j = 0; j < varargs.$length; j++) {\n args.push($externalize(varargs.$array[varargs.$offset + j], vt));\n }\n break;\n }\n args.push($externalize(arguments[i], t.params[i]));\n }\n var result = v.apply(recv, args);\n switch (t.results.length) {\n case 0:\n return;\n case 1:\n return $internalize(result, t.results[0]);\n default:\n for (var i = 0; i < t.results.length; i++) {\n result[i] = $internalize(result[i], t.results[i]);\n }\n return result;\n }\n };\n case $kindInterface:\n if (t.methods.length !== 0) {\n $panic(new $String(\"cannot internalize \" + t.string));\n }\n if (v === null) {\n return $ifaceNil;\n }\n if (v === undefined) {\n return new $jsObjectPtr(undefined);\n }\n switch (v.constructor) {\n case Int8Array:\n return new ($sliceType($Int8))(v);\n case Int16Array:\n return new ($sliceType($Int16))(v);\n case Int32Array:\n return new ($sliceType($Int))(v);\n case Uint8Array:\n return new ($sliceType($Uint8))(v);\n case Uint16Array:\n return new ($sliceType($Uint16))(v);\n case Uint32Array:\n return new ($sliceType($Uint))(v);\n case Float32Array:\n return new ($sliceType($Float32))(v);\n case Float64Array:\n return new ($sliceType($Float64))(v);\n case Array:\n return $internalize(v, $sliceType($emptyInterface));\n case Boolean:\n return new $Bool(!!v);\n case Date:\n var timePkg = $packages[\"time\"];\n if (timePkg) {\n return new timePkg.Time(timePkg.Unix(new $Int64(0, 0), new $Int64(0, v.getTime() * 1000000)));\n }\n case Function:\n var funcType = $funcType([$sliceType($emptyInterface)], [$jsObjectPtr], true);\n return new funcType($internalize(v, funcType));\n case Number:\n return new $Float64(parseFloat(v));\n case String:\n return new $String($internalize(v, $String));\n default:\n if ($global.Node && v instanceof $global.Node) {\n return new $jsObjectPtr(v);\n }\n var mapType = $mapType($String, $emptyInterface);\n return new mapType($internalize(v, mapType));\n }\n case $kindMap:\n var m = new $Map();\n var keys = $keys(v);\n for (var i = 0; i < keys.length; i++) {\n var k = $internalize(keys[i], t.key);\n m[t.key.keyFor(k)] = { k: k, v: $internalize(v[keys[i]], t.elem) };\n }\n return m;\n case $kindPtr:\n if (t.elem.kind === $kindStruct) {\n return $internalize(v, t.elem);\n }\n case $kindSlice:\n return new t($mapArray(v, function(e) { return $internalize(e, t.elem); }));\n case $kindString:\n v = String(v);\n if (v.search(/^[\\x00-\\x7F]*$/) !== -1) {\n return v;\n }\n var s = \"\";\n for (var i = 0; i < v.length; i++) {\n s += $encodeRune(v.charCodeAt(i));\n }\n return s;\n case $kindStruct:\n var noJsObject = {};\n var searchJsObject = function(t) {\n if (t === $jsObjectPtr) {\n return v;\n }\n if (t === $jsObjectPtr.elem) {\n $panic(new $String(\"cannot internalize js.Object, use *js.Object instead\"));\n }\n switch (t.kind) {\n case $kindPtr:\n return searchJsObject(t.elem);\n case $kindStruct:\n var f = t.fields[0];\n var o = searchJsObject(f.typ);\n if (o !== noJsObject) {\n var n = new t.ptr();\n n[f.prop] = o;\n return n;\n }\n return noJsObject;\n default:\n return noJsObject;\n }\n };\n var o = searchJsObject(t);\n if (o !== noJsObject) {\n return o;\n }\n }\n $panic(new $String(\"cannot internalize \" + t.string));\n};\n")), minify)); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$2 = _r$1; err$1 = _tuple$2[1];
- /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 7:
- return err$1;
- /* } */ case 8:
- _r$2 = w.Write(new sliceType$4($stringToBytes("\n"))); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$3 = _r$2; err$2 = _tuple$3[1];
- /* */ if (!($interfaceIsEqual(err$2, $ifaceNil))) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!($interfaceIsEqual(err$2, $ifaceNil))) { */ case 10:
- return err$2;
- /* } */ case 11:
- _ref$4 = pkgs;
- _i$4 = 0;
- /* while (true) { */ case 12:
- /* if (!(_i$4 < _ref$4.$length)) { break; } */ if(!(_i$4 < _ref$4.$length)) { $s = 13; continue; }
- pkg$1 = ((_i$4 < 0 || _i$4 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$4]);
- _r$3 = WritePkgCode(pkg$1, dceSelection, minify, w); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- err$3 = _r$3;
- /* */ if (!($interfaceIsEqual(err$3, $ifaceNil))) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!($interfaceIsEqual(err$3, $ifaceNil))) { */ case 15:
- return err$3;
- /* } */ case 16:
- _i$4++;
- /* } */ $s = 12; continue; case 13:
- _r$4 = w.Write(new sliceType$4($stringToBytes("$synthesizeMethods();\n$packages[\"runtime\"].$init();\n$go($packages[\"" + mainPkg.ImportPath + "\"].$init, [], true);\n$flushConsole();\n\n}).call(this);\n"))); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple$4 = _r$4; err$4 = _tuple$4[1];
- /* */ if (!($interfaceIsEqual(err$4, $ifaceNil))) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (!($interfaceIsEqual(err$4, $ifaceNil))) { */ case 18:
- return err$4;
- /* } */ case 19:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: WriteProgramCode }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.byFilter = byFilter; $f.d = d; $f.d$1 = d$1; $f.dceSelection = dceSelection; $f.dep = dep; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.err$3 = err$3; $f.err$4 = err$4; $f.info = info; $f.info$1 = info$1; $f.infos = infos; $f.mainPkg = mainPkg; $f.minify = minify; $f.ok = ok; $f.pendingDecls = pendingDecls; $f.pkg = pkg; $f.pkg$1 = pkg$1; $f.pkgs = pkgs; $f.w = w; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.WriteProgramCode = WriteProgramCode;
- WritePkgCode = function(pkg, dceSelection, minify, w) {
- var $ptr, _entry, _i, _i$1, _i$2, _i$3, _i$4, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, d, d$1, d$2, d$3, d$4, dceSelection, err, err$1, err$2, err$3, err$4, err$5, err$6, err$7, err$8, err$9, filteredDecls, minify, ok, pkg, vars, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; d = $f.d; d$1 = $f.d$1; d$2 = $f.d$2; d$3 = $f.d$3; d$4 = $f.d$4; dceSelection = $f.dceSelection; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; err$3 = $f.err$3; err$4 = $f.err$4; err$5 = $f.err$5; err$6 = $f.err$6; err$7 = $f.err$7; err$8 = $f.err$8; err$9 = $f.err$9; filteredDecls = $f.filteredDecls; minify = $f.minify; ok = $f.ok; pkg = $f.pkg; vars = $f.vars; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!(w.MappingCallback === $throwNilPointerError) && !(pkg.FileSet === sliceType$4.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(w.MappingCallback === $throwNilPointerError) && !(pkg.FileSet === sliceType$4.nil)) { */ case 1:
- w.fileSet = token.NewFileSet();
- _r = w.fileSet.Read($methodVal(json.NewDecoder(bytes.NewReader(pkg.FileSet)), "Decode")); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 4:
- $panic(err);
- /* } */ case 5:
- /* } */ case 2:
- _r$1 = fmt.Sprintf("$packages[\"%s\"] = (function() {\n", new sliceType$5([new $String(pkg.ImportPath)])); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = removeWhitespace(new sliceType$4($stringToBytes(_r$1)), minify); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = w.Write(_r$2); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple = _r$3; err$1 = _tuple[1];
- /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 9:
- return err$1;
- /* } */ case 10:
- vars = new sliceType(["$pkg = {}", "$init"]);
- filteredDecls = sliceType$2.nil;
- _ref = pkg.Declarations;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- d = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple$1 = (_entry = dceSelection[ptrType$1.keyFor(d)], _entry !== undefined ? [_entry.v, true] : [new structType.ptr(), false]); ok = _tuple$1[1];
- if (ok) {
- vars = $appendSlice(vars, d.Vars);
- filteredDecls = $append(filteredDecls, d);
- }
- _i++;
- }
- _r$4 = fmt.Sprintf("\tvar %s;\n", new sliceType$5([new $String(strings.Join(vars, ", "))])); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = removeWhitespace(new sliceType$4($stringToBytes(_r$4)), minify); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = w.Write(_r$5); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$2 = _r$6; err$2 = _tuple$2[1];
- /* */ if (!($interfaceIsEqual(err$2, $ifaceNil))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!($interfaceIsEqual(err$2, $ifaceNil))) { */ case 14:
- return err$2;
- /* } */ case 15:
- _ref$1 = filteredDecls;
- _i$1 = 0;
- /* while (true) { */ case 16:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 17; continue; }
- d$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _r$7 = w.Write(d$1.DeclCode); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _tuple$3 = _r$7; err$3 = _tuple$3[1];
- /* */ if (!($interfaceIsEqual(err$3, $ifaceNil))) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!($interfaceIsEqual(err$3, $ifaceNil))) { */ case 19:
- return err$3;
- /* } */ case 20:
- _i$1++;
- /* } */ $s = 16; continue; case 17:
- _ref$2 = filteredDecls;
- _i$2 = 0;
- /* while (true) { */ case 21:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 22; continue; }
- d$2 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- _r$8 = w.Write(d$2.MethodListCode); /* */ $s = 23; case 23: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _tuple$4 = _r$8; err$4 = _tuple$4[1];
- /* */ if (!($interfaceIsEqual(err$4, $ifaceNil))) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (!($interfaceIsEqual(err$4, $ifaceNil))) { */ case 24:
- return err$4;
- /* } */ case 25:
- _i$2++;
- /* } */ $s = 21; continue; case 22:
- _ref$3 = filteredDecls;
- _i$3 = 0;
- /* while (true) { */ case 26:
- /* if (!(_i$3 < _ref$3.$length)) { break; } */ if(!(_i$3 < _ref$3.$length)) { $s = 27; continue; }
- d$3 = ((_i$3 < 0 || _i$3 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$3]);
- _r$9 = w.Write(d$3.TypeInitCode); /* */ $s = 28; case 28: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _tuple$5 = _r$9; err$5 = _tuple$5[1];
- /* */ if (!($interfaceIsEqual(err$5, $ifaceNil))) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (!($interfaceIsEqual(err$5, $ifaceNil))) { */ case 29:
- return err$5;
- /* } */ case 30:
- _i$3++;
- /* } */ $s = 26; continue; case 27:
- _r$10 = w.Write(removeWhitespace(new sliceType$4($stringToBytes("\t$init = function() {\n\t\t$pkg.$init = function() {};\n\t\t/* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:\n")), minify)); /* */ $s = 31; case 31: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _tuple$6 = _r$10; err$6 = _tuple$6[1];
- /* */ if (!($interfaceIsEqual(err$6, $ifaceNil))) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (!($interfaceIsEqual(err$6, $ifaceNil))) { */ case 32:
- return err$6;
- /* } */ case 33:
- _ref$4 = filteredDecls;
- _i$4 = 0;
- /* while (true) { */ case 34:
- /* if (!(_i$4 < _ref$4.$length)) { break; } */ if(!(_i$4 < _ref$4.$length)) { $s = 35; continue; }
- d$4 = ((_i$4 < 0 || _i$4 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$4]);
- _r$11 = w.Write(d$4.InitCode); /* */ $s = 36; case 36: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _tuple$7 = _r$11; err$7 = _tuple$7[1];
- /* */ if (!($interfaceIsEqual(err$7, $ifaceNil))) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (!($interfaceIsEqual(err$7, $ifaceNil))) { */ case 37:
- return err$7;
- /* } */ case 38:
- _i$4++;
- /* } */ $s = 34; continue; case 35:
- _r$12 = w.Write(removeWhitespace(new sliceType$4($stringToBytes("\t\t/* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;\n\t};\n\t$pkg.$init = $init;\n\treturn $pkg;\n})();")), minify)); /* */ $s = 39; case 39: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _tuple$8 = _r$12; err$8 = _tuple$8[1];
- /* */ if (!($interfaceIsEqual(err$8, $ifaceNil))) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if (!($interfaceIsEqual(err$8, $ifaceNil))) { */ case 40:
- return err$8;
- /* } */ case 41:
- _r$13 = w.Write(new sliceType$4($stringToBytes("\n"))); /* */ $s = 42; case 42: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _tuple$9 = _r$13; err$9 = _tuple$9[1];
- /* */ if (!($interfaceIsEqual(err$9, $ifaceNil))) { $s = 43; continue; }
- /* */ $s = 44; continue;
- /* if (!($interfaceIsEqual(err$9, $ifaceNil))) { */ case 43:
- return err$9;
- /* } */ case 44:
- return $ifaceNil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: WritePkgCode }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f.d = d; $f.d$1 = d$1; $f.d$2 = d$2; $f.d$3 = d$3; $f.d$4 = d$4; $f.dceSelection = dceSelection; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.err$3 = err$3; $f.err$4 = err$4; $f.err$5 = err$5; $f.err$6 = err$6; $f.err$7 = err$7; $f.err$8 = err$8; $f.err$9 = err$9; $f.filteredDecls = filteredDecls; $f.minify = minify; $f.ok = ok; $f.pkg = pkg; $f.vars = vars; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.WritePkgCode = WritePkgCode;
- ReadArchive = function(filename, path, r, packages) {
- var $ptr, _key, _r, _r$1, _tuple, a, err, err$1, filename, packages, path, r, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; err = $f.err; err$1 = $f.err$1; filename = $f.filename; packages = $f.packages; path = $f.path; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = [a];
- a[0] = $clone(new Archive.ptr(), Archive);
- _r = gob.NewDecoder(r).Decode(a[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- return [ptrType.nil, err];
- /* } */ case 3:
- err$1 = $ifaceNil;
- _r$1 = importer.ImportData(packages, a[0].ExportData); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = _r$1; a[0].types = _tuple[1]; err$1 = _tuple[2];
- if (!($interfaceIsEqual(err$1, $ifaceNil))) {
- return [ptrType.nil, err$1];
- }
- _key = path; (packages || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: a[0].types };
- return [a[0], $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ReadArchive }; } $f.$ptr = $ptr; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.a = a; $f.err = err; $f.err$1 = err$1; $f.filename = filename; $f.packages = packages; $f.path = path; $f.r = r; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.ReadArchive = ReadArchive;
- SourceMapFilter.ptr.prototype.Write = function(p) {
- var $ptr, _arg, _arg$1, _arg$2, _r, _r$1, _tuple, err, f, i, i$1, n, n2, p, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; f = $f.f; i = $f.i; i$1 = $f.i$1; n = $f.n; n2 = $f.n2; p = $f.p; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- f = this;
- n2 = 0;
- /* while (true) { */ case 1:
- i = bytes.IndexByte(p, 8);
- w = p;
- if (!((i === -1))) {
- w = $subslice(p, 0, i);
- }
- _r = f.Writer.Write(w); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; n2 = _tuple[0]; err = _tuple[1];
- n = n + (n2) >> 0;
- while (true) {
- i$1 = bytes.IndexByte(w, 10);
- if (i$1 === -1) {
- f.column = f.column + (w.$length) >> 0;
- break;
- }
- f.line = f.line + (1) >> 0;
- f.column = 0;
- w = $subslice(w, (i$1 + 1 >> 0));
- }
- if (!($interfaceIsEqual(err, $ifaceNil)) || (i === -1)) {
- return [n, err];
- }
- /* */ if (!(f.MappingCallback === $throwNilPointerError)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(f.MappingCallback === $throwNilPointerError)) { */ case 4:
- _arg = f.line + 1 >> 0;
- _arg$1 = f.column;
- _r$1 = f.fileSet.Position((binary.BigEndian.Uint32($subslice(p, (i + 1 >> 0), (i + 5 >> 0))) >> 0)); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$2 = _r$1;
- $r = f.MappingCallback(_arg, _arg$1, _arg$2); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- p = $subslice(p, (i + 5 >> 0));
- n = n + (5) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: SourceMapFilter.ptr.prototype.Write }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.i = i; $f.i$1 = i$1; $f.n = n; $f.n2 = n2; $f.p = p; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- SourceMapFilter.prototype.Write = function(p) { return this.$val.Write(p); };
- expression.ptr.prototype.String = function() {
- var $ptr, e;
- e = this;
- return e.str;
- };
- expression.prototype.String = function() { return this.$val.String(); };
- expression.ptr.prototype.StringWithParens = function() {
- var $ptr, e;
- e = this;
- if (e.parens) {
- return "(" + e.str + ")";
- }
- return e.str;
- };
- expression.prototype.StringWithParens = function() { return this.$val.StringWithParens(); };
- funcContext.ptr.prototype.translateExpr = function(expr) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$100, _arg$101, _arg$102, _arg$103, _arg$104, _arg$105, _arg$106, _arg$107, _arg$108, _arg$109, _arg$11, _arg$110, _arg$111, _arg$112, _arg$113, _arg$114, _arg$115, _arg$116, _arg$117, _arg$118, _arg$119, _arg$12, _arg$120, _arg$121, _arg$122, _arg$123, _arg$124, _arg$125, _arg$126, _arg$127, _arg$128, _arg$129, _arg$13, _arg$130, _arg$131, _arg$132, _arg$133, _arg$134, _arg$135, _arg$136, _arg$137, _arg$138, _arg$139, _arg$14, _arg$140, _arg$141, _arg$142, _arg$143, _arg$144, _arg$145, _arg$146, _arg$147, _arg$148, _arg$149, _arg$15, _arg$150, _arg$151, _arg$152, _arg$153, _arg$154, _arg$155, _arg$156, _arg$157, _arg$158, _arg$159, _arg$16, _arg$160, _arg$161, _arg$162, _arg$163, _arg$164, _arg$165, _arg$166, _arg$167, _arg$168, _arg$169, _arg$17, _arg$170, _arg$171, _arg$172, _arg$173, _arg$174, _arg$175, _arg$176, _arg$177, _arg$178, _arg$179, _arg$18, _arg$180, _arg$181, _arg$182, _arg$183, _arg$184, _arg$185, _arg$186, _arg$187, _arg$188, _arg$189, _arg$19, _arg$190, _arg$191, _arg$192, _arg$193, _arg$194, _arg$195, _arg$196, _arg$197, _arg$198, _arg$199, _arg$2, _arg$20, _arg$200, _arg$201, _arg$202, _arg$21, _arg$22, _arg$23, _arg$24, _arg$25, _arg$26, _arg$27, _arg$28, _arg$29, _arg$3, _arg$30, _arg$31, _arg$32, _arg$33, _arg$34, _arg$35, _arg$36, _arg$37, _arg$38, _arg$39, _arg$4, _arg$40, _arg$41, _arg$42, _arg$43, _arg$44, _arg$45, _arg$46, _arg$47, _arg$48, _arg$49, _arg$5, _arg$50, _arg$51, _arg$52, _arg$53, _arg$54, _arg$55, _arg$56, _arg$57, _arg$58, _arg$59, _arg$6, _arg$60, _arg$61, _arg$62, _arg$63, _arg$64, _arg$65, _arg$66, _arg$67, _arg$68, _arg$69, _arg$7, _arg$70, _arg$71, _arg$72, _arg$73, _arg$74, _arg$75, _arg$76, _arg$77, _arg$78, _arg$79, _arg$8, _arg$80, _arg$81, _arg$82, _arg$83, _arg$84, _arg$85, _arg$86, _arg$87, _arg$88, _arg$89, _arg$9, _arg$90, _arg$91, _arg$92, _arg$93, _arg$94, _arg$95, _arg$96, _arg$97, _arg$98, _arg$99, _entry, _entry$1, _entry$10, _entry$11, _entry$12, _entry$13, _entry$14, _entry$15, _entry$16, _entry$17, _entry$18, _entry$19, _entry$2, _entry$20, _entry$21, _entry$22, _entry$23, _entry$24, _entry$25, _entry$26, _entry$27, _entry$28, _entry$29, _entry$3, _entry$30, _entry$31, _entry$32, _entry$33, _entry$34, _entry$35, _entry$36, _entry$37, _entry$38, _entry$4, _entry$5, _entry$6, _entry$7, _entry$8, _entry$9, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _key, _key$1, _key$2, _keys, _r, _r$1, _r$10, _r$100, _r$101, _r$102, _r$103, _r$104, _r$105, _r$106, _r$107, _r$108, _r$109, _r$11, _r$110, _r$111, _r$112, _r$113, _r$114, _r$115, _r$116, _r$117, _r$118, _r$119, _r$12, _r$120, _r$121, _r$122, _r$123, _r$124, _r$125, _r$126, _r$127, _r$128, _r$129, _r$13, _r$130, _r$131, _r$132, _r$133, _r$134, _r$135, _r$136, _r$137, _r$138, _r$139, _r$14, _r$140, _r$141, _r$142, _r$143, _r$144, _r$145, _r$146, _r$147, _r$148, _r$149, _r$15, _r$150, _r$151, _r$152, _r$153, _r$154, _r$155, _r$156, _r$157, _r$158, _r$159, _r$16, _r$160, _r$161, _r$162, _r$163, _r$164, _r$165, _r$166, _r$167, _r$168, _r$169, _r$17, _r$170, _r$171, _r$172, _r$173, _r$174, _r$175, _r$176, _r$177, _r$178, _r$179, _r$18, _r$180, _r$181, _r$182, _r$183, _r$184, _r$185, _r$186, _r$187, _r$188, _r$189, _r$19, _r$190, _r$191, _r$192, _r$193, _r$194, _r$195, _r$196, _r$197, _r$198, _r$199, _r$2, _r$20, _r$200, _r$201, _r$202, _r$203, _r$204, _r$205, _r$206, _r$207, _r$208, _r$209, _r$21, _r$210, _r$211, _r$212, _r$213, _r$214, _r$215, _r$216, _r$217, _r$218, _r$219, _r$22, _r$220, _r$221, _r$222, _r$223, _r$224, _r$225, _r$226, _r$227, _r$228, _r$229, _r$23, _r$230, _r$231, _r$232, _r$233, _r$234, _r$235, _r$236, _r$237, _r$238, _r$239, _r$24, _r$240, _r$241, _r$242, _r$243, _r$244, _r$245, _r$246, _r$247, _r$248, _r$249, _r$25, _r$250, _r$251, _r$252, _r$253, _r$254, _r$255, _r$256, _r$257, _r$258, _r$259, _r$26, _r$260, _r$261, _r$262, _r$263, _r$264, _r$265, _r$266, _r$267, _r$268, _r$269, _r$27, _r$270, _r$271, _r$272, _r$273, _r$274, _r$275, _r$276, _r$277, _r$278, _r$279, _r$28, _r$280, _r$281, _r$282, _r$283, _r$284, _r$285, _r$286, _r$287, _r$288, _r$289, _r$29, _r$290, _r$291, _r$292, _r$293, _r$294, _r$295, _r$296, _r$297, _r$298, _r$299, _r$3, _r$30, _r$300, _r$301, _r$302, _r$303, _r$304, _r$305, _r$306, _r$307, _r$308, _r$309, _r$31, _r$310, _r$311, _r$312, _r$313, _r$314, _r$315, _r$316, _r$317, _r$318, _r$319, _r$32, _r$320, _r$321, _r$322, _r$323, _r$324, _r$325, _r$326, _r$327, _r$328, _r$329, _r$33, _r$330, _r$331, _r$332, _r$333, _r$334, _r$335, _r$336, _r$337, _r$338, _r$339, _r$34, _r$340, _r$341, _r$342, _r$35, _r$36, _r$37, _r$38, _r$39, _r$4, _r$40, _r$41, _r$42, _r$43, _r$44, _r$45, _r$46, _r$47, _r$48, _r$49, _r$5, _r$50, _r$51, _r$52, _r$53, _r$54, _r$55, _r$56, _r$57, _r$58, _r$59, _r$6, _r$60, _r$61, _r$62, _r$63, _r$64, _r$65, _r$66, _r$67, _r$68, _r$69, _r$7, _r$70, _r$71, _r$72, _r$73, _r$74, _r$75, _r$76, _r$77, _r$78, _r$79, _r$8, _r$80, _r$81, _r$82, _r$83, _r$84, _r$85, _r$86, _r$87, _r$88, _r$89, _r$9, _r$90, _r$91, _r$92, _r$93, _r$94, _r$95, _r$96, _r$97, _r$98, _r$99, _ref, _ref$1, _ref$10, _ref$11, _ref$12, _ref$13, _ref$14, _ref$15, _ref$16, _ref$17, _ref$18, _ref$19, _ref$2, _ref$20, _ref$21, _ref$22, _ref$23, _ref$24, _ref$25, _ref$26, _ref$27, _ref$28, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tuple, _tuple$1, _tuple$10, _tuple$11, _tuple$12, _tuple$13, _tuple$14, _tuple$15, _tuple$16, _tuple$17, _tuple$18, _tuple$19, _tuple$2, _tuple$20, _tuple$21, _tuple$22, _tuple$23, _tuple$24, _tuple$25, _tuple$26, _tuple$27, _tuple$28, _tuple$29, _tuple$3, _tuple$30, _tuple$31, _tuple$32, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, _v, _v$1, _v$2, _v$3, assignments, b, b$1, b$2, basic, basic$1, basic$2, c, c1, c2, call, call$1, collectIndexedElements, d, d$1, d$2, e, e$1, e$10, e$11, e$12, e$13, e$14, e$15, e$16, e$2, e$3, e$4, e$5, e$6, e$7, e$8, e$9, element, element$1, element$2, elements, elements$1, expr, exprType, externalizeArgs, externalizeExpr, f, f$1, f$2, f$3, fields, fields$1, fun, globalRef, i, i$1, i$2, id, id$1, id$2, isBasic, isBasic$1, isCall, isCall$1, isInterface, isKeyValue, isPointer, isTuple, isTuple$1, isTuple$2, isUnary, j, jsTag, jsTag$1, key, keyVar, kve, kve$1, list, mapVar, methodName, names, newSel, o, o$1, o$2, o$3, o$4, o$5, obj, obj$1, obj$2, obj$3, obj$4, obj$5, objVar, objVar$1, ok, ok$1, ok$10, ok$11, ok$12, ok$13, ok$14, ok$15, ok$2, ok$3, ok$4, ok$5, ok$6, ok$7, ok$8, ok$9, op, pattern, plainFun, ptrType$18, r, recv, recv$1, resultVar, resultVar$1, sel, sel$1, sel$2, shift, sig, skipCase, skipCase$1, slice, t, t$1, t$10, t$11, t$12, t$2, t$3, t$4, t$5, t$6, t$7, t$8, t$9, t2, u, u$1, u$2, u$3, unary, value, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$24, x$25, x$26, x$27, x$28, x$29, x$3, x$30, x$31, x$32, x$33, x$4, x$5, x$6, x$7, x$8, x$9, y, zero, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$100 = $f._arg$100; _arg$101 = $f._arg$101; _arg$102 = $f._arg$102; _arg$103 = $f._arg$103; _arg$104 = $f._arg$104; _arg$105 = $f._arg$105; _arg$106 = $f._arg$106; _arg$107 = $f._arg$107; _arg$108 = $f._arg$108; _arg$109 = $f._arg$109; _arg$11 = $f._arg$11; _arg$110 = $f._arg$110; _arg$111 = $f._arg$111; _arg$112 = $f._arg$112; _arg$113 = $f._arg$113; _arg$114 = $f._arg$114; _arg$115 = $f._arg$115; _arg$116 = $f._arg$116; _arg$117 = $f._arg$117; _arg$118 = $f._arg$118; _arg$119 = $f._arg$119; _arg$12 = $f._arg$12; _arg$120 = $f._arg$120; _arg$121 = $f._arg$121; _arg$122 = $f._arg$122; _arg$123 = $f._arg$123; _arg$124 = $f._arg$124; _arg$125 = $f._arg$125; _arg$126 = $f._arg$126; _arg$127 = $f._arg$127; _arg$128 = $f._arg$128; _arg$129 = $f._arg$129; _arg$13 = $f._arg$13; _arg$130 = $f._arg$130; _arg$131 = $f._arg$131; _arg$132 = $f._arg$132; _arg$133 = $f._arg$133; _arg$134 = $f._arg$134; _arg$135 = $f._arg$135; _arg$136 = $f._arg$136; _arg$137 = $f._arg$137; _arg$138 = $f._arg$138; _arg$139 = $f._arg$139; _arg$14 = $f._arg$14; _arg$140 = $f._arg$140; _arg$141 = $f._arg$141; _arg$142 = $f._arg$142; _arg$143 = $f._arg$143; _arg$144 = $f._arg$144; _arg$145 = $f._arg$145; _arg$146 = $f._arg$146; _arg$147 = $f._arg$147; _arg$148 = $f._arg$148; _arg$149 = $f._arg$149; _arg$15 = $f._arg$15; _arg$150 = $f._arg$150; _arg$151 = $f._arg$151; _arg$152 = $f._arg$152; _arg$153 = $f._arg$153; _arg$154 = $f._arg$154; _arg$155 = $f._arg$155; _arg$156 = $f._arg$156; _arg$157 = $f._arg$157; _arg$158 = $f._arg$158; _arg$159 = $f._arg$159; _arg$16 = $f._arg$16; _arg$160 = $f._arg$160; _arg$161 = $f._arg$161; _arg$162 = $f._arg$162; _arg$163 = $f._arg$163; _arg$164 = $f._arg$164; _arg$165 = $f._arg$165; _arg$166 = $f._arg$166; _arg$167 = $f._arg$167; _arg$168 = $f._arg$168; _arg$169 = $f._arg$169; _arg$17 = $f._arg$17; _arg$170 = $f._arg$170; _arg$171 = $f._arg$171; _arg$172 = $f._arg$172; _arg$173 = $f._arg$173; _arg$174 = $f._arg$174; _arg$175 = $f._arg$175; _arg$176 = $f._arg$176; _arg$177 = $f._arg$177; _arg$178 = $f._arg$178; _arg$179 = $f._arg$179; _arg$18 = $f._arg$18; _arg$180 = $f._arg$180; _arg$181 = $f._arg$181; _arg$182 = $f._arg$182; _arg$183 = $f._arg$183; _arg$184 = $f._arg$184; _arg$185 = $f._arg$185; _arg$186 = $f._arg$186; _arg$187 = $f._arg$187; _arg$188 = $f._arg$188; _arg$189 = $f._arg$189; _arg$19 = $f._arg$19; _arg$190 = $f._arg$190; _arg$191 = $f._arg$191; _arg$192 = $f._arg$192; _arg$193 = $f._arg$193; _arg$194 = $f._arg$194; _arg$195 = $f._arg$195; _arg$196 = $f._arg$196; _arg$197 = $f._arg$197; _arg$198 = $f._arg$198; _arg$199 = $f._arg$199; _arg$2 = $f._arg$2; _arg$20 = $f._arg$20; _arg$200 = $f._arg$200; _arg$201 = $f._arg$201; _arg$202 = $f._arg$202; _arg$21 = $f._arg$21; _arg$22 = $f._arg$22; _arg$23 = $f._arg$23; _arg$24 = $f._arg$24; _arg$25 = $f._arg$25; _arg$26 = $f._arg$26; _arg$27 = $f._arg$27; _arg$28 = $f._arg$28; _arg$29 = $f._arg$29; _arg$3 = $f._arg$3; _arg$30 = $f._arg$30; _arg$31 = $f._arg$31; _arg$32 = $f._arg$32; _arg$33 = $f._arg$33; _arg$34 = $f._arg$34; _arg$35 = $f._arg$35; _arg$36 = $f._arg$36; _arg$37 = $f._arg$37; _arg$38 = $f._arg$38; _arg$39 = $f._arg$39; _arg$4 = $f._arg$4; _arg$40 = $f._arg$40; _arg$41 = $f._arg$41; _arg$42 = $f._arg$42; _arg$43 = $f._arg$43; _arg$44 = $f._arg$44; _arg$45 = $f._arg$45; _arg$46 = $f._arg$46; _arg$47 = $f._arg$47; _arg$48 = $f._arg$48; _arg$49 = $f._arg$49; _arg$5 = $f._arg$5; _arg$50 = $f._arg$50; _arg$51 = $f._arg$51; _arg$52 = $f._arg$52; _arg$53 = $f._arg$53; _arg$54 = $f._arg$54; _arg$55 = $f._arg$55; _arg$56 = $f._arg$56; _arg$57 = $f._arg$57; _arg$58 = $f._arg$58; _arg$59 = $f._arg$59; _arg$6 = $f._arg$6; _arg$60 = $f._arg$60; _arg$61 = $f._arg$61; _arg$62 = $f._arg$62; _arg$63 = $f._arg$63; _arg$64 = $f._arg$64; _arg$65 = $f._arg$65; _arg$66 = $f._arg$66; _arg$67 = $f._arg$67; _arg$68 = $f._arg$68; _arg$69 = $f._arg$69; _arg$7 = $f._arg$7; _arg$70 = $f._arg$70; _arg$71 = $f._arg$71; _arg$72 = $f._arg$72; _arg$73 = $f._arg$73; _arg$74 = $f._arg$74; _arg$75 = $f._arg$75; _arg$76 = $f._arg$76; _arg$77 = $f._arg$77; _arg$78 = $f._arg$78; _arg$79 = $f._arg$79; _arg$8 = $f._arg$8; _arg$80 = $f._arg$80; _arg$81 = $f._arg$81; _arg$82 = $f._arg$82; _arg$83 = $f._arg$83; _arg$84 = $f._arg$84; _arg$85 = $f._arg$85; _arg$86 = $f._arg$86; _arg$87 = $f._arg$87; _arg$88 = $f._arg$88; _arg$89 = $f._arg$89; _arg$9 = $f._arg$9; _arg$90 = $f._arg$90; _arg$91 = $f._arg$91; _arg$92 = $f._arg$92; _arg$93 = $f._arg$93; _arg$94 = $f._arg$94; _arg$95 = $f._arg$95; _arg$96 = $f._arg$96; _arg$97 = $f._arg$97; _arg$98 = $f._arg$98; _arg$99 = $f._arg$99; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$10 = $f._entry$10; _entry$11 = $f._entry$11; _entry$12 = $f._entry$12; _entry$13 = $f._entry$13; _entry$14 = $f._entry$14; _entry$15 = $f._entry$15; _entry$16 = $f._entry$16; _entry$17 = $f._entry$17; _entry$18 = $f._entry$18; _entry$19 = $f._entry$19; _entry$2 = $f._entry$2; _entry$20 = $f._entry$20; _entry$21 = $f._entry$21; _entry$22 = $f._entry$22; _entry$23 = $f._entry$23; _entry$24 = $f._entry$24; _entry$25 = $f._entry$25; _entry$26 = $f._entry$26; _entry$27 = $f._entry$27; _entry$28 = $f._entry$28; _entry$29 = $f._entry$29; _entry$3 = $f._entry$3; _entry$30 = $f._entry$30; _entry$31 = $f._entry$31; _entry$32 = $f._entry$32; _entry$33 = $f._entry$33; _entry$34 = $f._entry$34; _entry$35 = $f._entry$35; _entry$36 = $f._entry$36; _entry$37 = $f._entry$37; _entry$38 = $f._entry$38; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _entry$7 = $f._entry$7; _entry$8 = $f._entry$8; _entry$9 = $f._entry$9; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _keys = $f._keys; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$100 = $f._r$100; _r$101 = $f._r$101; _r$102 = $f._r$102; _r$103 = $f._r$103; _r$104 = $f._r$104; _r$105 = $f._r$105; _r$106 = $f._r$106; _r$107 = $f._r$107; _r$108 = $f._r$108; _r$109 = $f._r$109; _r$11 = $f._r$11; _r$110 = $f._r$110; _r$111 = $f._r$111; _r$112 = $f._r$112; _r$113 = $f._r$113; _r$114 = $f._r$114; _r$115 = $f._r$115; _r$116 = $f._r$116; _r$117 = $f._r$117; _r$118 = $f._r$118; _r$119 = $f._r$119; _r$12 = $f._r$12; _r$120 = $f._r$120; _r$121 = $f._r$121; _r$122 = $f._r$122; _r$123 = $f._r$123; _r$124 = $f._r$124; _r$125 = $f._r$125; _r$126 = $f._r$126; _r$127 = $f._r$127; _r$128 = $f._r$128; _r$129 = $f._r$129; _r$13 = $f._r$13; _r$130 = $f._r$130; _r$131 = $f._r$131; _r$132 = $f._r$132; _r$133 = $f._r$133; _r$134 = $f._r$134; _r$135 = $f._r$135; _r$136 = $f._r$136; _r$137 = $f._r$137; _r$138 = $f._r$138; _r$139 = $f._r$139; _r$14 = $f._r$14; _r$140 = $f._r$140; _r$141 = $f._r$141; _r$142 = $f._r$142; _r$143 = $f._r$143; _r$144 = $f._r$144; _r$145 = $f._r$145; _r$146 = $f._r$146; _r$147 = $f._r$147; _r$148 = $f._r$148; _r$149 = $f._r$149; _r$15 = $f._r$15; _r$150 = $f._r$150; _r$151 = $f._r$151; _r$152 = $f._r$152; _r$153 = $f._r$153; _r$154 = $f._r$154; _r$155 = $f._r$155; _r$156 = $f._r$156; _r$157 = $f._r$157; _r$158 = $f._r$158; _r$159 = $f._r$159; _r$16 = $f._r$16; _r$160 = $f._r$160; _r$161 = $f._r$161; _r$162 = $f._r$162; _r$163 = $f._r$163; _r$164 = $f._r$164; _r$165 = $f._r$165; _r$166 = $f._r$166; _r$167 = $f._r$167; _r$168 = $f._r$168; _r$169 = $f._r$169; _r$17 = $f._r$17; _r$170 = $f._r$170; _r$171 = $f._r$171; _r$172 = $f._r$172; _r$173 = $f._r$173; _r$174 = $f._r$174; _r$175 = $f._r$175; _r$176 = $f._r$176; _r$177 = $f._r$177; _r$178 = $f._r$178; _r$179 = $f._r$179; _r$18 = $f._r$18; _r$180 = $f._r$180; _r$181 = $f._r$181; _r$182 = $f._r$182; _r$183 = $f._r$183; _r$184 = $f._r$184; _r$185 = $f._r$185; _r$186 = $f._r$186; _r$187 = $f._r$187; _r$188 = $f._r$188; _r$189 = $f._r$189; _r$19 = $f._r$19; _r$190 = $f._r$190; _r$191 = $f._r$191; _r$192 = $f._r$192; _r$193 = $f._r$193; _r$194 = $f._r$194; _r$195 = $f._r$195; _r$196 = $f._r$196; _r$197 = $f._r$197; _r$198 = $f._r$198; _r$199 = $f._r$199; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$200 = $f._r$200; _r$201 = $f._r$201; _r$202 = $f._r$202; _r$203 = $f._r$203; _r$204 = $f._r$204; _r$205 = $f._r$205; _r$206 = $f._r$206; _r$207 = $f._r$207; _r$208 = $f._r$208; _r$209 = $f._r$209; _r$21 = $f._r$21; _r$210 = $f._r$210; _r$211 = $f._r$211; _r$212 = $f._r$212; _r$213 = $f._r$213; _r$214 = $f._r$214; _r$215 = $f._r$215; _r$216 = $f._r$216; _r$217 = $f._r$217; _r$218 = $f._r$218; _r$219 = $f._r$219; _r$22 = $f._r$22; _r$220 = $f._r$220; _r$221 = $f._r$221; _r$222 = $f._r$222; _r$223 = $f._r$223; _r$224 = $f._r$224; _r$225 = $f._r$225; _r$226 = $f._r$226; _r$227 = $f._r$227; _r$228 = $f._r$228; _r$229 = $f._r$229; _r$23 = $f._r$23; _r$230 = $f._r$230; _r$231 = $f._r$231; _r$232 = $f._r$232; _r$233 = $f._r$233; _r$234 = $f._r$234; _r$235 = $f._r$235; _r$236 = $f._r$236; _r$237 = $f._r$237; _r$238 = $f._r$238; _r$239 = $f._r$239; _r$24 = $f._r$24; _r$240 = $f._r$240; _r$241 = $f._r$241; _r$242 = $f._r$242; _r$243 = $f._r$243; _r$244 = $f._r$244; _r$245 = $f._r$245; _r$246 = $f._r$246; _r$247 = $f._r$247; _r$248 = $f._r$248; _r$249 = $f._r$249; _r$25 = $f._r$25; _r$250 = $f._r$250; _r$251 = $f._r$251; _r$252 = $f._r$252; _r$253 = $f._r$253; _r$254 = $f._r$254; _r$255 = $f._r$255; _r$256 = $f._r$256; _r$257 = $f._r$257; _r$258 = $f._r$258; _r$259 = $f._r$259; _r$26 = $f._r$26; _r$260 = $f._r$260; _r$261 = $f._r$261; _r$262 = $f._r$262; _r$263 = $f._r$263; _r$264 = $f._r$264; _r$265 = $f._r$265; _r$266 = $f._r$266; _r$267 = $f._r$267; _r$268 = $f._r$268; _r$269 = $f._r$269; _r$27 = $f._r$27; _r$270 = $f._r$270; _r$271 = $f._r$271; _r$272 = $f._r$272; _r$273 = $f._r$273; _r$274 = $f._r$274; _r$275 = $f._r$275; _r$276 = $f._r$276; _r$277 = $f._r$277; _r$278 = $f._r$278; _r$279 = $f._r$279; _r$28 = $f._r$28; _r$280 = $f._r$280; _r$281 = $f._r$281; _r$282 = $f._r$282; _r$283 = $f._r$283; _r$284 = $f._r$284; _r$285 = $f._r$285; _r$286 = $f._r$286; _r$287 = $f._r$287; _r$288 = $f._r$288; _r$289 = $f._r$289; _r$29 = $f._r$29; _r$290 = $f._r$290; _r$291 = $f._r$291; _r$292 = $f._r$292; _r$293 = $f._r$293; _r$294 = $f._r$294; _r$295 = $f._r$295; _r$296 = $f._r$296; _r$297 = $f._r$297; _r$298 = $f._r$298; _r$299 = $f._r$299; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$300 = $f._r$300; _r$301 = $f._r$301; _r$302 = $f._r$302; _r$303 = $f._r$303; _r$304 = $f._r$304; _r$305 = $f._r$305; _r$306 = $f._r$306; _r$307 = $f._r$307; _r$308 = $f._r$308; _r$309 = $f._r$309; _r$31 = $f._r$31; _r$310 = $f._r$310; _r$311 = $f._r$311; _r$312 = $f._r$312; _r$313 = $f._r$313; _r$314 = $f._r$314; _r$315 = $f._r$315; _r$316 = $f._r$316; _r$317 = $f._r$317; _r$318 = $f._r$318; _r$319 = $f._r$319; _r$32 = $f._r$32; _r$320 = $f._r$320; _r$321 = $f._r$321; _r$322 = $f._r$322; _r$323 = $f._r$323; _r$324 = $f._r$324; _r$325 = $f._r$325; _r$326 = $f._r$326; _r$327 = $f._r$327; _r$328 = $f._r$328; _r$329 = $f._r$329; _r$33 = $f._r$33; _r$330 = $f._r$330; _r$331 = $f._r$331; _r$332 = $f._r$332; _r$333 = $f._r$333; _r$334 = $f._r$334; _r$335 = $f._r$335; _r$336 = $f._r$336; _r$337 = $f._r$337; _r$338 = $f._r$338; _r$339 = $f._r$339; _r$34 = $f._r$34; _r$340 = $f._r$340; _r$341 = $f._r$341; _r$342 = $f._r$342; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$4 = $f._r$4; _r$40 = $f._r$40; _r$41 = $f._r$41; _r$42 = $f._r$42; _r$43 = $f._r$43; _r$44 = $f._r$44; _r$45 = $f._r$45; _r$46 = $f._r$46; _r$47 = $f._r$47; _r$48 = $f._r$48; _r$49 = $f._r$49; _r$5 = $f._r$5; _r$50 = $f._r$50; _r$51 = $f._r$51; _r$52 = $f._r$52; _r$53 = $f._r$53; _r$54 = $f._r$54; _r$55 = $f._r$55; _r$56 = $f._r$56; _r$57 = $f._r$57; _r$58 = $f._r$58; _r$59 = $f._r$59; _r$6 = $f._r$6; _r$60 = $f._r$60; _r$61 = $f._r$61; _r$62 = $f._r$62; _r$63 = $f._r$63; _r$64 = $f._r$64; _r$65 = $f._r$65; _r$66 = $f._r$66; _r$67 = $f._r$67; _r$68 = $f._r$68; _r$69 = $f._r$69; _r$7 = $f._r$7; _r$70 = $f._r$70; _r$71 = $f._r$71; _r$72 = $f._r$72; _r$73 = $f._r$73; _r$74 = $f._r$74; _r$75 = $f._r$75; _r$76 = $f._r$76; _r$77 = $f._r$77; _r$78 = $f._r$78; _r$79 = $f._r$79; _r$8 = $f._r$8; _r$80 = $f._r$80; _r$81 = $f._r$81; _r$82 = $f._r$82; _r$83 = $f._r$83; _r$84 = $f._r$84; _r$85 = $f._r$85; _r$86 = $f._r$86; _r$87 = $f._r$87; _r$88 = $f._r$88; _r$89 = $f._r$89; _r$9 = $f._r$9; _r$90 = $f._r$90; _r$91 = $f._r$91; _r$92 = $f._r$92; _r$93 = $f._r$93; _r$94 = $f._r$94; _r$95 = $f._r$95; _r$96 = $f._r$96; _r$97 = $f._r$97; _r$98 = $f._r$98; _r$99 = $f._r$99; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$10 = $f._ref$10; _ref$11 = $f._ref$11; _ref$12 = $f._ref$12; _ref$13 = $f._ref$13; _ref$14 = $f._ref$14; _ref$15 = $f._ref$15; _ref$16 = $f._ref$16; _ref$17 = $f._ref$17; _ref$18 = $f._ref$18; _ref$19 = $f._ref$19; _ref$2 = $f._ref$2; _ref$20 = $f._ref$20; _ref$21 = $f._ref$21; _ref$22 = $f._ref$22; _ref$23 = $f._ref$23; _ref$24 = $f._ref$24; _ref$25 = $f._ref$25; _ref$26 = $f._ref$26; _ref$27 = $f._ref$27; _ref$28 = $f._ref$28; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$11 = $f._tuple$11; _tuple$12 = $f._tuple$12; _tuple$13 = $f._tuple$13; _tuple$14 = $f._tuple$14; _tuple$15 = $f._tuple$15; _tuple$16 = $f._tuple$16; _tuple$17 = $f._tuple$17; _tuple$18 = $f._tuple$18; _tuple$19 = $f._tuple$19; _tuple$2 = $f._tuple$2; _tuple$20 = $f._tuple$20; _tuple$21 = $f._tuple$21; _tuple$22 = $f._tuple$22; _tuple$23 = $f._tuple$23; _tuple$24 = $f._tuple$24; _tuple$25 = $f._tuple$25; _tuple$26 = $f._tuple$26; _tuple$27 = $f._tuple$27; _tuple$28 = $f._tuple$28; _tuple$29 = $f._tuple$29; _tuple$3 = $f._tuple$3; _tuple$30 = $f._tuple$30; _tuple$31 = $f._tuple$31; _tuple$32 = $f._tuple$32; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; _v$3 = $f._v$3; assignments = $f.assignments; b = $f.b; b$1 = $f.b$1; b$2 = $f.b$2; basic = $f.basic; basic$1 = $f.basic$1; basic$2 = $f.basic$2; c = $f.c; c1 = $f.c1; c2 = $f.c2; call = $f.call; call$1 = $f.call$1; collectIndexedElements = $f.collectIndexedElements; d = $f.d; d$1 = $f.d$1; d$2 = $f.d$2; e = $f.e; e$1 = $f.e$1; e$10 = $f.e$10; e$11 = $f.e$11; e$12 = $f.e$12; e$13 = $f.e$13; e$14 = $f.e$14; e$15 = $f.e$15; e$16 = $f.e$16; e$2 = $f.e$2; e$3 = $f.e$3; e$4 = $f.e$4; e$5 = $f.e$5; e$6 = $f.e$6; e$7 = $f.e$7; e$8 = $f.e$8; e$9 = $f.e$9; element = $f.element; element$1 = $f.element$1; element$2 = $f.element$2; elements = $f.elements; elements$1 = $f.elements$1; expr = $f.expr; exprType = $f.exprType; externalizeArgs = $f.externalizeArgs; externalizeExpr = $f.externalizeExpr; f = $f.f; f$1 = $f.f$1; f$2 = $f.f$2; f$3 = $f.f$3; fields = $f.fields; fields$1 = $f.fields$1; fun = $f.fun; globalRef = $f.globalRef; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; id = $f.id; id$1 = $f.id$1; id$2 = $f.id$2; isBasic = $f.isBasic; isBasic$1 = $f.isBasic$1; isCall = $f.isCall; isCall$1 = $f.isCall$1; isInterface = $f.isInterface; isKeyValue = $f.isKeyValue; isPointer = $f.isPointer; isTuple = $f.isTuple; isTuple$1 = $f.isTuple$1; isTuple$2 = $f.isTuple$2; isUnary = $f.isUnary; j = $f.j; jsTag = $f.jsTag; jsTag$1 = $f.jsTag$1; key = $f.key; keyVar = $f.keyVar; kve = $f.kve; kve$1 = $f.kve$1; list = $f.list; mapVar = $f.mapVar; methodName = $f.methodName; names = $f.names; newSel = $f.newSel; o = $f.o; o$1 = $f.o$1; o$2 = $f.o$2; o$3 = $f.o$3; o$4 = $f.o$4; o$5 = $f.o$5; obj = $f.obj; obj$1 = $f.obj$1; obj$2 = $f.obj$2; obj$3 = $f.obj$3; obj$4 = $f.obj$4; obj$5 = $f.obj$5; objVar = $f.objVar; objVar$1 = $f.objVar$1; ok = $f.ok; ok$1 = $f.ok$1; ok$10 = $f.ok$10; ok$11 = $f.ok$11; ok$12 = $f.ok$12; ok$13 = $f.ok$13; ok$14 = $f.ok$14; ok$15 = $f.ok$15; ok$2 = $f.ok$2; ok$3 = $f.ok$3; ok$4 = $f.ok$4; ok$5 = $f.ok$5; ok$6 = $f.ok$6; ok$7 = $f.ok$7; ok$8 = $f.ok$8; ok$9 = $f.ok$9; op = $f.op; pattern = $f.pattern; plainFun = $f.plainFun; ptrType$18 = $f.ptrType$18; r = $f.r; recv = $f.recv; recv$1 = $f.recv$1; resultVar = $f.resultVar; resultVar$1 = $f.resultVar$1; sel = $f.sel; sel$1 = $f.sel$1; sel$2 = $f.sel$2; shift = $f.shift; sig = $f.sig; skipCase = $f.skipCase; skipCase$1 = $f.skipCase$1; slice = $f.slice; t = $f.t; t$1 = $f.t$1; t$10 = $f.t$10; t$11 = $f.t$11; t$12 = $f.t$12; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; t$8 = $f.t$8; t$9 = $f.t$9; t2 = $f.t2; u = $f.u; u$1 = $f.u$1; u$2 = $f.u$2; u$3 = $f.u$3; unary = $f.unary; value = $f.value; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$17 = $f.x$17; x$18 = $f.x$18; x$19 = $f.x$19; x$2 = $f.x$2; x$20 = $f.x$20; x$21 = $f.x$21; x$22 = $f.x$22; x$23 = $f.x$23; x$24 = $f.x$24; x$25 = $f.x$25; x$26 = $f.x$26; x$27 = $f.x$27; x$28 = $f.x$28; x$29 = $f.x$29; x$3 = $f.x$3; x$30 = $f.x$30; x$31 = $f.x$31; x$32 = $f.x$32; x$33 = $f.x$33; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; y = $f.y; zero = $f.zero; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = [c];
- e = [e];
- externalizeExpr = [externalizeExpr];
- recv = [recv];
- c[0] = this;
- exprType = (_entry = c[0].p.Info.Info.Types[ast.Expr.keyFor(expr)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type;
- value = (_entry$1 = c[0].p.Info.Info.Types[ast.Expr.keyFor(expr)], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(value, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(value, $ifaceNil))) { */ case 1:
- _r = exprType.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- basic = $assertType(_r, ptrType$3);
- /* */ if (isBoolean(basic)) { $s = 4; continue; }
- /* */ if (isInteger(basic)) { $s = 5; continue; }
- /* */ if (isFloat(basic)) { $s = 6; continue; }
- /* */ if (isComplex(basic)) { $s = 7; continue; }
- /* */ if (isString(basic)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (isBoolean(basic)) { */ case 4:
- _r$1 = exact.BoolVal(value); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = strconv.FormatBool(_r$1); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg = new $String(_r$2);
- _r$3 = c[0].formatExpr("%s", new sliceType$5([_arg])); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 10; continue;
- /* } else if (isInteger(basic)) { */ case 5:
- /* */ if (is64Bit(basic)) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (is64Bit(basic)) { */ case 14:
- /* */ if (basic.Kind() === 6) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (basic.Kind() === 6) { */ case 16:
- _r$4 = exact.Int64Val(value); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; d = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- $panic(new $String("could not get exact uint"));
- }
- _r$5 = c[0].typeName(exprType); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$5);
- _arg$2 = new $String(strconv.FormatInt($shiftRightInt64(d, 32), 10));
- _arg$3 = new $String(strconv.FormatUint((x = new $Uint64(d.$high, d.$low), new $Uint64(x.$high & 0, (x.$low & 4294967295) >>> 0)), 10));
- _r$6 = c[0].formatExpr("new %s(%s, %s)", new sliceType$5([_arg$1, _arg$2, _arg$3])); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- /* } */ case 17:
- _r$7 = exact.Uint64Val(value); /* */ $s = 21; case 21: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _tuple$1 = _r$7; d$1 = _tuple$1[0]; ok$1 = _tuple$1[1];
- if (!ok$1) {
- $panic(new $String("could not get exact uint"));
- }
- _r$8 = c[0].typeName(exprType); /* */ $s = 22; case 22: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$4 = new $String(_r$8);
- _arg$5 = new $String(strconv.FormatUint($shiftRightUint64(d$1, 32), 10));
- _arg$6 = new $String(strconv.FormatUint(new $Uint64(d$1.$high & 0, (d$1.$low & 4294967295) >>> 0), 10));
- _r$9 = c[0].formatExpr("new %s(%s, %s)", new sliceType$5([_arg$4, _arg$5, _arg$6])); /* */ $s = 23; case 23: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- return _r$9;
- /* } */ case 15:
- _r$10 = exact.Int64Val(value); /* */ $s = 24; case 24: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _tuple$2 = _r$10; d$2 = _tuple$2[0]; ok$2 = _tuple$2[1];
- if (!ok$2) {
- $panic(new $String("could not get exact int"));
- }
- _r$11 = c[0].formatExpr("%s", new sliceType$5([new $String(strconv.FormatInt(d$2, 10))])); /* */ $s = 25; case 25: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- $s = 10; continue;
- /* } else if (isFloat(basic)) { */ case 6:
- _r$12 = exact.Float64Val(value); /* */ $s = 26; case 26: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _tuple$3 = _r$12; f = _tuple$3[0];
- _r$13 = c[0].formatExpr("%s", new sliceType$5([new $String(strconv.FormatFloat(f, 103, -1, 64))])); /* */ $s = 27; case 27: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- return _r$13;
- $s = 10; continue;
- /* } else if (isComplex(basic)) { */ case 7:
- _r$14 = exact.Real(value); /* */ $s = 28; case 28: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _r$15 = exact.Float64Val(_r$14); /* */ $s = 29; case 29: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _tuple$4 = _r$15; r = _tuple$4[0];
- _r$16 = exact.Imag(value); /* */ $s = 30; case 30: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _r$17 = exact.Float64Val(_r$16); /* */ $s = 31; case 31: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _tuple$5 = _r$17; i = _tuple$5[0];
- if (basic.Kind() === 23) {
- exprType = types.Typ[16];
- }
- _r$18 = c[0].typeName(exprType); /* */ $s = 32; case 32: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _arg$7 = new $String(_r$18);
- _arg$8 = new $String(strconv.FormatFloat(r, 103, -1, 64));
- _arg$9 = new $String(strconv.FormatFloat(i, 103, -1, 64));
- _r$19 = c[0].formatExpr("new %s(%s, %s)", new sliceType$5([_arg$7, _arg$8, _arg$9])); /* */ $s = 33; case 33: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- return _r$19;
- $s = 10; continue;
- /* } else if (isString(basic)) { */ case 8:
- _r$20 = exact.StringVal(value); /* */ $s = 34; case 34: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- _r$21 = encodeString(_r$20); /* */ $s = 35; case 35: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- _arg$10 = new $String(_r$21);
- _r$22 = c[0].formatExpr("%s", new sliceType$5([_arg$10])); /* */ $s = 36; case 36: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- $s = 10; continue;
- /* } else { */ case 9:
- _r$23 = basic.String(); /* */ $s = 37; case 37: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- $panic(new $String("Unhandled constant type: " + _r$23));
- /* } */ case 10:
- /* } */ case 2:
- obj = $ifaceNil;
- _ref = expr;
- if ($assertType(_ref, ptrType$4, true)[1]) {
- e$1 = _ref.$val;
- obj = (_entry$2 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(e$1.Sel)], _entry$2 !== undefined ? _entry$2.v : $ifaceNil);
- } else if ($assertType(_ref, ptrType$5, true)[1]) {
- e$2 = _ref.$val;
- obj = (_entry$3 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(e$2)], _entry$3 !== undefined ? _entry$3.v : $ifaceNil);
- if ($interfaceIsEqual(obj, $ifaceNil)) {
- obj = (_entry$4 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(e$2)], _entry$4 !== undefined ? _entry$4.v : $ifaceNil);
- }
- }
- if (!(!($interfaceIsEqual(obj, $ifaceNil)))) { _v = false; $s = 40; continue s; }
- _r$24 = obj.Pkg(); /* */ $s = 41; case 41: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$25 = typesutil.IsJsPackage(_r$24); /* */ $s = 42; case 42: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _v = _r$25; case 40:
- /* */ if (_v) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (_v) { */ case 38:
- _r$26 = obj.Name(); /* */ $s = 43; case 43: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _ref$1 = _r$26;
- /* */ if (_ref$1 === "Global") { $s = 44; continue; }
- /* */ if (_ref$1 === "Module") { $s = 45; continue; }
- /* */ if (_ref$1 === "Undefined") { $s = 46; continue; }
- /* */ $s = 47; continue;
- /* if (_ref$1 === "Global") { */ case 44:
- _r$27 = c[0].formatExpr("$global", new sliceType$5([])); /* */ $s = 48; case 48: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- return _r$27;
- $s = 47; continue;
- /* } else if (_ref$1 === "Module") { */ case 45:
- _r$28 = c[0].formatExpr("$module", new sliceType$5([])); /* */ $s = 49; case 49: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- return _r$28;
- $s = 47; continue;
- /* } else if (_ref$1 === "Undefined") { */ case 46:
- _r$29 = c[0].formatExpr("undefined", new sliceType$5([])); /* */ $s = 50; case 50: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- return _r$29;
- /* } */ case 47:
- /* } */ case 39:
- _ref$2 = expr;
- /* */ if ($assertType(_ref$2, ptrType$6, true)[1]) { $s = 51; continue; }
- /* */ if ($assertType(_ref$2, ptrType$7, true)[1]) { $s = 52; continue; }
- /* */ if ($assertType(_ref$2, ptrType$8, true)[1]) { $s = 53; continue; }
- /* */ if ($assertType(_ref$2, ptrType$9, true)[1]) { $s = 54; continue; }
- /* */ if ($assertType(_ref$2, ptrType$10, true)[1]) { $s = 55; continue; }
- /* */ if ($assertType(_ref$2, ptrType$11, true)[1]) { $s = 56; continue; }
- /* */ if ($assertType(_ref$2, ptrType$12, true)[1]) { $s = 57; continue; }
- /* */ if ($assertType(_ref$2, ptrType$4, true)[1]) { $s = 58; continue; }
- /* */ if ($assertType(_ref$2, ptrType$13, true)[1]) { $s = 59; continue; }
- /* */ if ($assertType(_ref$2, ptrType$14, true)[1]) { $s = 60; continue; }
- /* */ if ($assertType(_ref$2, ptrType$15, true)[1]) { $s = 61; continue; }
- /* */ if ($assertType(_ref$2, ptrType$5, true)[1]) { $s = 62; continue; }
- /* */ if ($assertType(_ref$2, ptrType$16, true)[1]) { $s = 63; continue; }
- /* */ if (_ref$2 === $ifaceNil) { $s = 64; continue; }
- /* */ $s = 65; continue;
- /* if ($assertType(_ref$2, ptrType$6, true)[1]) { */ case 51:
- e[0] = _ref$2.$val;
- _tuple$6 = $assertType(exprType, ptrType$17, true); ptrType$18 = _tuple$6[0]; isPointer = _tuple$6[1];
- if (isPointer) {
- exprType = ptrType$18.Elem();
- }
- collectIndexedElements = (function(c, e, externalizeExpr, recv) { return function $b(elementType) {
- var $ptr, _entry$5, _i, _r$30, _r$31, _r$32, _r$33, _ref$3, _tuple$7, _tuple$8, element, elementType, elements, i$1, isKve, key, kve, ok$3, zero, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry$5 = $f._entry$5; _i = $f._i; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _ref$3 = $f._ref$3; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; element = $f.element; elementType = $f.elementType; elements = $f.elements; i$1 = $f.i$1; isKve = $f.isKve; key = $f.key; kve = $f.kve; ok$3 = $f.ok$3; zero = $f.zero; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- elements = sliceType.nil;
- i$1 = 0;
- _r$30 = c[0].zeroValue(elementType); /* */ $s = 1; case 1: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- zero = _r$30;
- _ref$3 = e[0].Elts;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref$3.$length)) { break; } */ if(!(_i < _ref$3.$length)) { $s = 3; continue; }
- element = ((_i < 0 || _i >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i]);
- _tuple$7 = $assertType(element, ptrType$19, true); kve = _tuple$7[0]; isKve = _tuple$7[1];
- /* */ if (isKve) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (isKve) { */ case 4:
- _r$31 = exact.Int64Val((_entry$5 = c[0].p.Info.Info.Types[ast.Expr.keyFor(kve.Key)], _entry$5 !== undefined ? _entry$5.v : new types.TypeAndValue.ptr()).Value); /* */ $s = 6; case 6: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- _tuple$8 = _r$31; key = _tuple$8[0]; ok$3 = _tuple$8[1];
- if (!ok$3) {
- $panic(new $String("could not get exact int"));
- }
- i$1 = ((key.$low + ((key.$high >> 31) * 4294967296)) >> 0);
- element = kve.Value;
- /* } */ case 5:
- while (true) {
- if (!(elements.$length <= i$1)) { break; }
- elements = $append(elements, zero);
- }
- _r$32 = c[0].translateImplicitConversionWithCloning(element, elementType); /* */ $s = 7; case 7: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _r$33 = _r$32.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- ((i$1 < 0 || i$1 >= elements.$length) ? $throwRuntimeError("index out of range") : elements.$array[elements.$offset + i$1] = _r$33);
- i$1 = i$1 + (1) >> 0;
- _i++;
- /* } */ $s = 2; continue; case 3:
- return elements;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry$5 = _entry$5; $f._i = _i; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._ref$3 = _ref$3; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f.element = element; $f.elementType = elementType; $f.elements = elements; $f.i$1 = i$1; $f.isKve = isKve; $f.key = key; $f.kve = kve; $f.ok$3 = ok$3; $f.zero = zero; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, e, externalizeExpr, recv);
- _r$30 = exprType.Underlying(); /* */ $s = 67; case 67: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _ref$3 = _r$30;
- /* */ if ($assertType(_ref$3, ptrType$20, true)[1]) { $s = 68; continue; }
- /* */ if ($assertType(_ref$3, ptrType$21, true)[1]) { $s = 69; continue; }
- /* */ if ($assertType(_ref$3, ptrType$22, true)[1]) { $s = 70; continue; }
- /* */ if ($assertType(_ref$3, ptrType$23, true)[1]) { $s = 71; continue; }
- /* */ $s = 72; continue;
- /* if ($assertType(_ref$3, ptrType$20, true)[1]) { */ case 68:
- t = _ref$3.$val;
- _r$31 = collectIndexedElements(t.Elem()); /* */ $s = 74; case 74: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- elements = _r$31;
- /* */ if (elements.$length === 0) { $s = 75; continue; }
- /* */ $s = 76; continue;
- /* if (elements.$length === 0) { */ case 75:
- _r$32 = c[0].zeroValue(t); /* */ $s = 77; case 77: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _arg$11 = new $String(_r$32);
- _r$33 = c[0].formatExpr("%s", new sliceType$5([_arg$11])); /* */ $s = 78; case 78: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- return _r$33;
- /* } */ case 76:
- _r$34 = c[0].zeroValue(t.Elem()); /* */ $s = 79; case 79: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- zero = _r$34;
- while (true) {
- if (!(elements.$length < ((x$1 = t.Len(), x$1.$low + ((x$1.$high >> 31) * 4294967296)) >> 0))) { break; }
- elements = $append(elements, zero);
- }
- _r$35 = typeKind(t.Elem()); /* */ $s = 80; case 80: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- _arg$12 = new $String(_r$35);
- _arg$13 = new $String(strings.Join(elements, ", "));
- _r$36 = c[0].formatExpr("$toNativeArray(%s, [%s])", new sliceType$5([_arg$12, _arg$13])); /* */ $s = 81; case 81: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- return _r$36;
- $s = 73; continue;
- /* } else if ($assertType(_ref$3, ptrType$21, true)[1]) { */ case 69:
- t$1 = _ref$3.$val;
- _r$37 = c[0].typeName(exprType); /* */ $s = 82; case 82: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- _arg$14 = new $String(_r$37);
- _r$38 = collectIndexedElements(t$1.Elem()); /* */ $s = 83; case 83: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- _r$39 = strings.Join(_r$38, ", "); /* */ $s = 84; case 84: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- _arg$15 = new $String(_r$39);
- _r$40 = c[0].formatExpr("new %s([%s])", new sliceType$5([_arg$14, _arg$15])); /* */ $s = 85; case 85: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- return _r$40;
- $s = 73; continue;
- /* } else if ($assertType(_ref$3, ptrType$22, true)[1]) { */ case 70:
- t$2 = _ref$3.$val;
- _r$41 = c[0].newVariable("_map"); /* */ $s = 86; case 86: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- mapVar = _r$41;
- _r$42 = c[0].newVariable("_key"); /* */ $s = 87; case 87: if($c) { $c = false; _r$42 = _r$42.$blk(); } if (_r$42 && _r$42.$blk !== undefined) { break s; }
- keyVar = _r$42;
- assignments = "";
- _ref$4 = e[0].Elts;
- _i = 0;
- /* while (true) { */ case 88:
- /* if (!(_i < _ref$4.$length)) { break; } */ if(!(_i < _ref$4.$length)) { $s = 89; continue; }
- element = ((_i < 0 || _i >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i]);
- kve = $assertType(element, ptrType$19);
- _arg$16 = new $String(keyVar);
- _r$43 = c[0].translateImplicitConversionWithCloning(kve.Key, t$2.Key()); /* */ $s = 90; case 90: if($c) { $c = false; _r$43 = _r$43.$blk(); } if (_r$43 && _r$43.$blk !== undefined) { break s; }
- _arg$17 = _r$43;
- _arg$18 = new $String(mapVar);
- _r$44 = c[0].typeName(t$2.Key()); /* */ $s = 91; case 91: if($c) { $c = false; _r$44 = _r$44.$blk(); } if (_r$44 && _r$44.$blk !== undefined) { break s; }
- _arg$19 = new $String(_r$44);
- _arg$20 = new $String(keyVar);
- _arg$21 = new $String(keyVar);
- _r$45 = c[0].translateImplicitConversionWithCloning(kve.Value, t$2.Elem()); /* */ $s = 92; case 92: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- _arg$22 = _r$45;
- _r$46 = c[0].formatExpr("%s = %s, %s[%s.keyFor(%s)] = { k: %s, v: %s }, ", new sliceType$5([_arg$16, _arg$17, _arg$18, _arg$19, _arg$20, _arg$21, _arg$22])); /* */ $s = 93; case 93: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- _r$47 = _r$46.String(); /* */ $s = 94; case 94: if($c) { $c = false; _r$47 = _r$47.$blk(); } if (_r$47 && _r$47.$blk !== undefined) { break s; }
- assignments = assignments + (_r$47);
- _i++;
- /* } */ $s = 88; continue; case 89:
- _r$48 = c[0].formatExpr("(%s = new $Map(), %s%s)", new sliceType$5([new $String(mapVar), new $String(assignments), new $String(mapVar)])); /* */ $s = 95; case 95: if($c) { $c = false; _r$48 = _r$48.$blk(); } if (_r$48 && _r$48.$blk !== undefined) { break s; }
- return _r$48;
- $s = 73; continue;
- /* } else if ($assertType(_ref$3, ptrType$23, true)[1]) { */ case 71:
- t$3 = _ref$3.$val;
- elements$1 = $makeSlice(sliceType, t$3.NumFields());
- isKeyValue = true;
- if (!((e[0].Elts.$length === 0))) {
- _tuple$7 = $assertType((x$2 = e[0].Elts, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])), ptrType$19, true); isKeyValue = _tuple$7[1];
- }
- /* */ if (!isKeyValue) { $s = 96; continue; }
- /* */ $s = 97; continue;
- /* if (!isKeyValue) { */ case 96:
- _ref$5 = e[0].Elts;
- _i$1 = 0;
- /* while (true) { */ case 98:
- /* if (!(_i$1 < _ref$5.$length)) { break; } */ if(!(_i$1 < _ref$5.$length)) { $s = 99; continue; }
- i$1 = _i$1;
- element$1 = ((_i$1 < 0 || _i$1 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$1]);
- _r$49 = c[0].translateImplicitConversionWithCloning(element$1, t$3.Field(i$1).object.Type()); /* */ $s = 100; case 100: if($c) { $c = false; _r$49 = _r$49.$blk(); } if (_r$49 && _r$49.$blk !== undefined) { break s; }
- _r$50 = _r$49.String(); /* */ $s = 101; case 101: if($c) { $c = false; _r$50 = _r$50.$blk(); } if (_r$50 && _r$50.$blk !== undefined) { break s; }
- ((i$1 < 0 || i$1 >= elements$1.$length) ? $throwRuntimeError("index out of range") : elements$1.$array[elements$1.$offset + i$1] = _r$50);
- _i$1++;
- /* } */ $s = 98; continue; case 99:
- /* } */ case 97:
- /* */ if (isKeyValue) { $s = 102; continue; }
- /* */ $s = 103; continue;
- /* if (isKeyValue) { */ case 102:
- _ref$6 = elements$1;
- _i$2 = 0;
- /* while (true) { */ case 104:
- /* if (!(_i$2 < _ref$6.$length)) { break; } */ if(!(_i$2 < _ref$6.$length)) { $s = 105; continue; }
- i$2 = _i$2;
- _r$51 = c[0].zeroValue(t$3.Field(i$2).object.Type()); /* */ $s = 106; case 106: if($c) { $c = false; _r$51 = _r$51.$blk(); } if (_r$51 && _r$51.$blk !== undefined) { break s; }
- ((i$2 < 0 || i$2 >= elements$1.$length) ? $throwRuntimeError("index out of range") : elements$1.$array[elements$1.$offset + i$2] = _r$51);
- _i$2++;
- /* } */ $s = 104; continue; case 105:
- _ref$7 = e[0].Elts;
- _i$3 = 0;
- /* while (true) { */ case 107:
- /* if (!(_i$3 < _ref$7.$length)) { break; } */ if(!(_i$3 < _ref$7.$length)) { $s = 108; continue; }
- element$2 = ((_i$3 < 0 || _i$3 >= _ref$7.$length) ? $throwRuntimeError("index out of range") : _ref$7.$array[_ref$7.$offset + _i$3]);
- kve$1 = $assertType(element$2, ptrType$19);
- _ref$8 = elements$1;
- _i$4 = 0;
- /* while (true) { */ case 109:
- /* if (!(_i$4 < _ref$8.$length)) { break; } */ if(!(_i$4 < _ref$8.$length)) { $s = 110; continue; }
- j = _i$4;
- /* */ if ($assertType(kve$1.Key, ptrType$5).Name === t$3.Field(j).object.Name()) { $s = 111; continue; }
- /* */ $s = 112; continue;
- /* if ($assertType(kve$1.Key, ptrType$5).Name === t$3.Field(j).object.Name()) { */ case 111:
- _r$52 = c[0].translateImplicitConversionWithCloning(kve$1.Value, t$3.Field(j).object.Type()); /* */ $s = 113; case 113: if($c) { $c = false; _r$52 = _r$52.$blk(); } if (_r$52 && _r$52.$blk !== undefined) { break s; }
- _r$53 = _r$52.String(); /* */ $s = 114; case 114: if($c) { $c = false; _r$53 = _r$53.$blk(); } if (_r$53 && _r$53.$blk !== undefined) { break s; }
- ((j < 0 || j >= elements$1.$length) ? $throwRuntimeError("index out of range") : elements$1.$array[elements$1.$offset + j] = _r$53);
- /* break; */ $s = 110; continue;
- /* } */ case 112:
- _i$4++;
- /* } */ $s = 109; continue; case 110:
- _i$3++;
- /* } */ $s = 107; continue; case 108:
- /* } */ case 103:
- _r$54 = c[0].typeName(exprType); /* */ $s = 115; case 115: if($c) { $c = false; _r$54 = _r$54.$blk(); } if (_r$54 && _r$54.$blk !== undefined) { break s; }
- _arg$23 = new $String(_r$54);
- _arg$24 = new $String(strings.Join(elements$1, ", "));
- _r$55 = c[0].formatExpr("new %s.ptr(%s)", new sliceType$5([_arg$23, _arg$24])); /* */ $s = 116; case 116: if($c) { $c = false; _r$55 = _r$55.$blk(); } if (_r$55 && _r$55.$blk !== undefined) { break s; }
- return _r$55;
- $s = 73; continue;
- /* } else { */ case 72:
- t$4 = _ref$3;
- _r$56 = fmt.Sprintf("Unhandled CompositeLit type: %T\n", new sliceType$5([t$4])); /* */ $s = 117; case 117: if($c) { $c = false; _r$56 = _r$56.$blk(); } if (_r$56 && _r$56.$blk !== undefined) { break s; }
- $panic(new $String(_r$56));
- /* } */ case 73:
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$7, true)[1]) { */ case 52:
- e$3 = _ref$2.$val;
- _r$57 = translateFunction(e$3.Type, sliceType$6.nil, e$3.Body, c[0], $assertType(exprType, ptrType$24), (_entry$5 = c[0].p.Info.FuncLitInfos[ptrType$7.keyFor(e$3)], _entry$5 !== undefined ? _entry$5.v : ptrType$25.nil), ""); /* */ $s = 118; case 118: if($c) { $c = false; _r$57 = _r$57.$blk(); } if (_r$57 && _r$57.$blk !== undefined) { break s; }
- _tuple$8 = _r$57; fun = _tuple$8[1];
- /* */ if (!(($keys(c[0].p.escapingVars).length === 0))) { $s = 119; continue; }
- /* */ $s = 120; continue;
- /* if (!(($keys(c[0].p.escapingVars).length === 0))) { */ case 119:
- names = $makeSlice(sliceType, 0, $keys(c[0].p.escapingVars).length);
- _ref$9 = c[0].p.escapingVars;
- _i$5 = 0;
- _keys = $keys(_ref$9);
- while (true) {
- if (!(_i$5 < _keys.length)) { break; }
- _entry$6 = _ref$9[_keys[_i$5]];
- if (_entry$6 === undefined) {
- _i$5++;
- continue;
- }
- obj$1 = _entry$6.k;
- names = $append(names, (_entry$7 = c[0].p.objectNames[types.Object.keyFor(obj$1)], _entry$7 !== undefined ? _entry$7.v : ""));
- _i$5++;
- }
- $r = sort.Strings(names); /* */ $s = 121; case 121: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- list = strings.Join(names, ", ");
- _r$58 = c[0].formatExpr("(function(%s) { return %s; })(%s)", new sliceType$5([new $String(list), new $String(fun), new $String(list)])); /* */ $s = 122; case 122: if($c) { $c = false; _r$58 = _r$58.$blk(); } if (_r$58 && _r$58.$blk !== undefined) { break s; }
- return _r$58;
- /* } */ case 120:
- _r$59 = c[0].formatExpr("(%s)", new sliceType$5([new $String(fun)])); /* */ $s = 123; case 123: if($c) { $c = false; _r$59 = _r$59.$blk(); } if (_r$59 && _r$59.$blk !== undefined) { break s; }
- return _r$59;
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$8, true)[1]) { */ case 53:
- e$4 = _ref$2.$val;
- t$5 = (_entry$8 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$4.X)], _entry$8 !== undefined ? _entry$8.v : new types.TypeAndValue.ptr()).Type;
- _ref$10 = e$4.Op;
- /* */ if (_ref$10 === 17) { $s = 124; continue; }
- /* */ if (_ref$10 === 36) { $s = 125; continue; }
- /* */ $s = 126; continue;
- /* if (_ref$10 === 17) { */ case 124:
- /* */ if (typesutil.IsJsObject(exprType)) { $s = 127; continue; }
- /* */ $s = 128; continue;
- /* if (typesutil.IsJsObject(exprType)) { */ case 127:
- _r$60 = c[0].formatExpr("%e.object", new sliceType$5([e$4.X])); /* */ $s = 129; case 129: if($c) { $c = false; _r$60 = _r$60.$blk(); } if (_r$60 && _r$60.$blk !== undefined) { break s; }
- return _r$60;
- /* } */ case 128:
- _r$61 = t$5.Underlying(); /* */ $s = 130; case 130: if($c) { $c = false; _r$61 = _r$61.$blk(); } if (_r$61 && _r$61.$blk !== undefined) { break s; }
- _ref$11 = _r$61;
- /* */ if ($assertType(_ref$11, ptrType$23, true)[1] || $assertType(_ref$11, ptrType$20, true)[1]) { $s = 131; continue; }
- /* */ $s = 132; continue;
- /* if ($assertType(_ref$11, ptrType$23, true)[1] || $assertType(_ref$11, ptrType$20, true)[1]) { */ case 131:
- _r$62 = c[0].translateExpr(e$4.X); /* */ $s = 133; case 133: if($c) { $c = false; _r$62 = _r$62.$blk(); } if (_r$62 && _r$62.$blk !== undefined) { break s; }
- return _r$62;
- /* } */ case 132:
- _ref$12 = astutil.RemoveParens(e$4.X);
- /* */ if ($assertType(_ref$12, ptrType$6, true)[1]) { $s = 134; continue; }
- /* */ if ($assertType(_ref$12, ptrType$5, true)[1]) { $s = 135; continue; }
- /* */ if ($assertType(_ref$12, ptrType$4, true)[1]) { $s = 136; continue; }
- /* */ if ($assertType(_ref$12, ptrType$11, true)[1]) { $s = 137; continue; }
- /* */ if ($assertType(_ref$12, ptrType$14, true)[1]) { $s = 138; continue; }
- /* */ $s = 139; continue;
- /* if ($assertType(_ref$12, ptrType$6, true)[1]) { */ case 134:
- x$3 = _ref$12.$val;
- _arg$25 = x$3;
- _r$63 = c[0].typeName((_entry$9 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$4)], _entry$9 !== undefined ? _entry$9.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 141; case 141: if($c) { $c = false; _r$63 = _r$63.$blk(); } if (_r$63 && _r$63.$blk !== undefined) { break s; }
- _arg$26 = new $String(_r$63);
- _r$64 = c[0].formatExpr("$newDataPointer(%e, %s)", new sliceType$5([_arg$25, _arg$26])); /* */ $s = 142; case 142: if($c) { $c = false; _r$64 = _r$64.$blk(); } if (_r$64 && _r$64.$blk !== undefined) { break s; }
- return _r$64;
- $s = 140; continue;
- /* } else if ($assertType(_ref$12, ptrType$5, true)[1]) { */ case 135:
- x$4 = _ref$12.$val;
- obj$2 = $assertType((_entry$10 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(x$4)], _entry$10 !== undefined ? _entry$10.v : $ifaceNil), ptrType$26);
- /* */ if ((_entry$11 = c[0].p.escapingVars[ptrType$26.keyFor(obj$2)], _entry$11 !== undefined ? _entry$11.v : false)) { $s = 143; continue; }
- /* */ $s = 144; continue;
- /* if ((_entry$11 = c[0].p.escapingVars[ptrType$26.keyFor(obj$2)], _entry$11 !== undefined ? _entry$11.v : false)) { */ case 143:
- _arg$27 = new $String((_entry$12 = c[0].p.objectNames[types.Object.keyFor(obj$2)], _entry$12 !== undefined ? _entry$12.v : ""));
- _r$65 = c[0].typeName(exprType); /* */ $s = 145; case 145: if($c) { $c = false; _r$65 = _r$65.$blk(); } if (_r$65 && _r$65.$blk !== undefined) { break s; }
- _arg$28 = new $String(_r$65);
- _r$66 = c[0].formatExpr("(%1s.$ptr || (%1s.$ptr = new %2s(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, %1s)))", new sliceType$5([_arg$27, _arg$28])); /* */ $s = 146; case 146: if($c) { $c = false; _r$66 = _r$66.$blk(); } if (_r$66 && _r$66.$blk !== undefined) { break s; }
- return _r$66;
- /* } */ case 144:
- _r$67 = c[0].varPtrName(obj$2); /* */ $s = 147; case 147: if($c) { $c = false; _r$67 = _r$67.$blk(); } if (_r$67 && _r$67.$blk !== undefined) { break s; }
- _arg$29 = new $String(_r$67);
- _r$68 = c[0].typeName(exprType); /* */ $s = 148; case 148: if($c) { $c = false; _r$68 = _r$68.$blk(); } if (_r$68 && _r$68.$blk !== undefined) { break s; }
- _arg$30 = new $String(_r$68);
- _r$69 = c[0].objectName(obj$2); /* */ $s = 149; case 149: if($c) { $c = false; _r$69 = _r$69.$blk(); } if (_r$69 && _r$69.$blk !== undefined) { break s; }
- _arg$31 = new $String(_r$69);
- _r$70 = c[0].translateAssign(x$4, "$v", exprType, false); /* */ $s = 150; case 150: if($c) { $c = false; _r$70 = _r$70.$blk(); } if (_r$70 && _r$70.$blk !== undefined) { break s; }
- _arg$32 = new $String(_r$70);
- _r$71 = c[0].formatExpr("(%1s || (%1s = new %2s(function() { return %3s; }, function($v) { %4s })))", new sliceType$5([_arg$29, _arg$30, _arg$31, _arg$32])); /* */ $s = 151; case 151: if($c) { $c = false; _r$71 = _r$71.$blk(); } if (_r$71 && _r$71.$blk !== undefined) { break s; }
- return _r$71;
- $s = 140; continue;
- /* } else if ($assertType(_ref$12, ptrType$4, true)[1]) { */ case 136:
- x$5 = _ref$12.$val;
- _tuple$9 = (_entry$13 = c[0].p.Info.Info.Selections[ptrType$4.keyFor(x$5)], _entry$13 !== undefined ? [_entry$13.v, true] : [ptrType$27.nil, false]); sel = _tuple$9[0]; ok$3 = _tuple$9[1];
- /* */ if (!ok$3) { $s = 152; continue; }
- /* */ $s = 153; continue;
- /* if (!ok$3) { */ case 152:
- obj$3 = $assertType((_entry$14 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(x$5.Sel)], _entry$14 !== undefined ? _entry$14.v : $ifaceNil), ptrType$26);
- _r$72 = c[0].varPtrName(obj$3); /* */ $s = 154; case 154: if($c) { $c = false; _r$72 = _r$72.$blk(); } if (_r$72 && _r$72.$blk !== undefined) { break s; }
- _arg$33 = new $String(_r$72);
- _r$73 = c[0].typeName(exprType); /* */ $s = 155; case 155: if($c) { $c = false; _r$73 = _r$73.$blk(); } if (_r$73 && _r$73.$blk !== undefined) { break s; }
- _arg$34 = new $String(_r$73);
- _r$74 = c[0].objectName(obj$3); /* */ $s = 156; case 156: if($c) { $c = false; _r$74 = _r$74.$blk(); } if (_r$74 && _r$74.$blk !== undefined) { break s; }
- _arg$35 = new $String(_r$74);
- _r$75 = c[0].translateAssign(x$5, "$v", exprType, false); /* */ $s = 157; case 157: if($c) { $c = false; _r$75 = _r$75.$blk(); } if (_r$75 && _r$75.$blk !== undefined) { break s; }
- _arg$36 = new $String(_r$75);
- _r$76 = c[0].formatExpr("(%1s || (%1s = new %2s(function() { return %3s; }, function($v) { %4s })))", new sliceType$5([_arg$33, _arg$34, _arg$35, _arg$36])); /* */ $s = 158; case 158: if($c) { $c = false; _r$76 = _r$76.$blk(); } if (_r$76 && _r$76.$blk !== undefined) { break s; }
- return _r$76;
- /* } */ case 153:
- newSel = new ast.SelectorExpr.ptr(c[0].newIdent("this.$target", (_entry$15 = c[0].p.Info.Info.Types[ast.Expr.keyFor(x$5.X)], _entry$15 !== undefined ? _entry$15.v : new types.TypeAndValue.ptr()).Type), x$5.Sel);
- _key = newSel; (c[0].p.Info.Info.Selections || $throwRuntimeError("assignment to entry in nil map"))[ptrType$4.keyFor(_key)] = { k: _key, v: sel };
- _arg$37 = x$5.X;
- _arg$38 = new $String(x$5.Sel.Name);
- _r$77 = c[0].typeName(exprType); /* */ $s = 159; case 159: if($c) { $c = false; _r$77 = _r$77.$blk(); } if (_r$77 && _r$77.$blk !== undefined) { break s; }
- _arg$39 = new $String(_r$77);
- _arg$40 = newSel;
- _r$78 = c[0].translateAssign(newSel, "$v", exprType, false); /* */ $s = 160; case 160: if($c) { $c = false; _r$78 = _r$78.$blk(); } if (_r$78 && _r$78.$blk !== undefined) { break s; }
- _arg$41 = new $String(_r$78);
- _r$79 = c[0].formatExpr("(%1e.$ptr_%2s || (%1e.$ptr_%2s = new %3s(function() { return %4e; }, function($v) { %5s }, %1e)))", new sliceType$5([_arg$37, _arg$38, _arg$39, _arg$40, _arg$41])); /* */ $s = 161; case 161: if($c) { $c = false; _r$79 = _r$79.$blk(); } if (_r$79 && _r$79.$blk !== undefined) { break s; }
- return _r$79;
- $s = 140; continue;
- /* } else if ($assertType(_ref$12, ptrType$11, true)[1]) { */ case 137:
- x$6 = _ref$12.$val;
- _r$80 = (_entry$16 = c[0].p.Info.Info.Types[ast.Expr.keyFor(x$6.X)], _entry$16 !== undefined ? _entry$16.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 162; case 162: if($c) { $c = false; _r$80 = _r$80.$blk(); } if (_r$80 && _r$80.$blk !== undefined) { break s; }
- _tuple$10 = $assertType(_r$80, ptrType$21, true); ok$4 = _tuple$10[1];
- /* */ if (ok$4) { $s = 163; continue; }
- /* */ $s = 164; continue;
- /* if (ok$4) { */ case 163:
- _arg$42 = x$6.X;
- _arg$43 = x$6.Index;
- _r$81 = c[0].typeName(exprType); /* */ $s = 165; case 165: if($c) { $c = false; _r$81 = _r$81.$blk(); } if (_r$81 && _r$81.$blk !== undefined) { break s; }
- _arg$44 = new $String(_r$81);
- _r$82 = c[0].formatExpr("$indexPtr(%1e.$array, %1e.$offset + %2e, %3s)", new sliceType$5([_arg$42, _arg$43, _arg$44])); /* */ $s = 166; case 166: if($c) { $c = false; _r$82 = _r$82.$blk(); } if (_r$82 && _r$82.$blk !== undefined) { break s; }
- return _r$82;
- /* } */ case 164:
- _arg$45 = x$6.X;
- _arg$46 = x$6.Index;
- _r$83 = c[0].typeName(exprType); /* */ $s = 167; case 167: if($c) { $c = false; _r$83 = _r$83.$blk(); } if (_r$83 && _r$83.$blk !== undefined) { break s; }
- _arg$47 = new $String(_r$83);
- _r$84 = c[0].formatExpr("$indexPtr(%e, %e, %s)", new sliceType$5([_arg$45, _arg$46, _arg$47])); /* */ $s = 168; case 168: if($c) { $c = false; _r$84 = _r$84.$blk(); } if (_r$84 && _r$84.$blk !== undefined) { break s; }
- return _r$84;
- $s = 140; continue;
- /* } else if ($assertType(_ref$12, ptrType$14, true)[1]) { */ case 138:
- x$7 = _ref$12.$val;
- _r$85 = c[0].translateExpr(x$7.X); /* */ $s = 169; case 169: if($c) { $c = false; _r$85 = _r$85.$blk(); } if (_r$85 && _r$85.$blk !== undefined) { break s; }
- return _r$85;
- $s = 140; continue;
- /* } else { */ case 139:
- x$8 = _ref$12;
- _r$86 = fmt.Sprintf("Unhandled: %T\n", new sliceType$5([x$8])); /* */ $s = 170; case 170: if($c) { $c = false; _r$86 = _r$86.$blk(); } if (_r$86 && _r$86.$blk !== undefined) { break s; }
- $panic(new $String(_r$86));
- /* } */ case 140:
- $s = 126; continue;
- /* } else if (_ref$10 === 36) { */ case 125:
- call = new ast.CallExpr.ptr(c[0].newIdent("$recv", types.NewSignature(ptrType$26.nil, types.NewTuple(new sliceType$8([types.NewVar(0, ptrType$28.nil, "", t$5)])), types.NewTuple(new sliceType$8([types.NewVar(0, ptrType$28.nil, "", exprType), types.NewVar(0, ptrType$28.nil, "", types.Typ[1])])), false)), 0, new sliceType$7([e$4.X]), 0, 0);
- _key$1 = call; (c[0].FuncInfo.Blocking || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$1)] = { k: _key$1, v: true };
- _tuple$11 = $assertType(exprType, ptrType$29, true); isTuple = _tuple$11[1];
- /* */ if (isTuple) { $s = 171; continue; }
- /* */ $s = 172; continue;
- /* if (isTuple) { */ case 171:
- _r$87 = c[0].formatExpr("%e", new sliceType$5([call])); /* */ $s = 173; case 173: if($c) { $c = false; _r$87 = _r$87.$blk(); } if (_r$87 && _r$87.$blk !== undefined) { break s; }
- return _r$87;
- /* } */ case 172:
- _r$88 = c[0].formatExpr("%e[0]", new sliceType$5([call])); /* */ $s = 174; case 174: if($c) { $c = false; _r$88 = _r$88.$blk(); } if (_r$88 && _r$88.$blk !== undefined) { break s; }
- return _r$88;
- /* } */ case 126:
- _r$89 = t$5.Underlying(); /* */ $s = 175; case 175: if($c) { $c = false; _r$89 = _r$89.$blk(); } if (_r$89 && _r$89.$blk !== undefined) { break s; }
- basic$1 = $assertType(_r$89, ptrType$3);
- _ref$13 = e$4.Op;
- /* */ if (_ref$13 === 12) { $s = 176; continue; }
- /* */ if (_ref$13 === 13) { $s = 177; continue; }
- /* */ if (_ref$13 === 19) { $s = 178; continue; }
- /* */ if (_ref$13 === 43) { $s = 179; continue; }
- /* */ $s = 180; continue;
- /* if (_ref$13 === 12) { */ case 176:
- _r$90 = c[0].translateExpr(e$4.X); /* */ $s = 182; case 182: if($c) { $c = false; _r$90 = _r$90.$blk(); } if (_r$90 && _r$90.$blk !== undefined) { break s; }
- return _r$90;
- $s = 181; continue;
- /* } else if (_ref$13 === 13) { */ case 177:
- /* */ if (is64Bit(basic$1)) { $s = 183; continue; }
- /* */ if (isComplex(basic$1)) { $s = 184; continue; }
- /* */ if (isUnsigned(basic$1)) { $s = 185; continue; }
- /* */ $s = 186; continue;
- /* if (is64Bit(basic$1)) { */ case 183:
- _r$91 = c[0].typeName(t$5); /* */ $s = 188; case 188: if($c) { $c = false; _r$91 = _r$91.$blk(); } if (_r$91 && _r$91.$blk !== undefined) { break s; }
- _arg$48 = new $String(_r$91);
- _arg$49 = e$4.X;
- _r$92 = c[0].formatExpr("new %1s(-%2h, -%2l)", new sliceType$5([_arg$48, _arg$49])); /* */ $s = 189; case 189: if($c) { $c = false; _r$92 = _r$92.$blk(); } if (_r$92 && _r$92.$blk !== undefined) { break s; }
- return _r$92;
- $s = 187; continue;
- /* } else if (isComplex(basic$1)) { */ case 184:
- _r$93 = c[0].typeName(t$5); /* */ $s = 190; case 190: if($c) { $c = false; _r$93 = _r$93.$blk(); } if (_r$93 && _r$93.$blk !== undefined) { break s; }
- _arg$50 = new $String(_r$93);
- _arg$51 = e$4.X;
- _r$94 = c[0].formatExpr("new %1s(-%2r, -%2i)", new sliceType$5([_arg$50, _arg$51])); /* */ $s = 191; case 191: if($c) { $c = false; _r$94 = _r$94.$blk(); } if (_r$94 && _r$94.$blk !== undefined) { break s; }
- return _r$94;
- $s = 187; continue;
- /* } else if (isUnsigned(basic$1)) { */ case 185:
- _r$95 = c[0].formatExpr("-%e", new sliceType$5([e$4.X])); /* */ $s = 192; case 192: if($c) { $c = false; _r$95 = _r$95.$blk(); } if (_r$95 && _r$95.$blk !== undefined) { break s; }
- _r$96 = c[0].fixNumber(_r$95, basic$1); /* */ $s = 193; case 193: if($c) { $c = false; _r$96 = _r$96.$blk(); } if (_r$96 && _r$96.$blk !== undefined) { break s; }
- return _r$96;
- $s = 187; continue;
- /* } else { */ case 186:
- _r$97 = c[0].formatExpr("-%e", new sliceType$5([e$4.X])); /* */ $s = 194; case 194: if($c) { $c = false; _r$97 = _r$97.$blk(); } if (_r$97 && _r$97.$blk !== undefined) { break s; }
- return _r$97;
- /* } */ case 187:
- $s = 181; continue;
- /* } else if (_ref$13 === 19) { */ case 178:
- /* */ if (is64Bit(basic$1)) { $s = 195; continue; }
- /* */ $s = 196; continue;
- /* if (is64Bit(basic$1)) { */ case 195:
- _r$98 = c[0].typeName(t$5); /* */ $s = 197; case 197: if($c) { $c = false; _r$98 = _r$98.$blk(); } if (_r$98 && _r$98.$blk !== undefined) { break s; }
- _arg$52 = new $String(_r$98);
- _arg$53 = e$4.X;
- _r$99 = c[0].formatExpr("new %1s(~%2h, ~%2l >>> 0)", new sliceType$5([_arg$52, _arg$53])); /* */ $s = 198; case 198: if($c) { $c = false; _r$99 = _r$99.$blk(); } if (_r$99 && _r$99.$blk !== undefined) { break s; }
- return _r$99;
- /* } */ case 196:
- _r$100 = c[0].formatExpr("~%e", new sliceType$5([e$4.X])); /* */ $s = 199; case 199: if($c) { $c = false; _r$100 = _r$100.$blk(); } if (_r$100 && _r$100.$blk !== undefined) { break s; }
- _r$101 = c[0].fixNumber(_r$100, basic$1); /* */ $s = 200; case 200: if($c) { $c = false; _r$101 = _r$101.$blk(); } if (_r$101 && _r$101.$blk !== undefined) { break s; }
- return _r$101;
- $s = 181; continue;
- /* } else if (_ref$13 === 43) { */ case 179:
- _r$102 = c[0].formatExpr("!%e", new sliceType$5([e$4.X])); /* */ $s = 201; case 201: if($c) { $c = false; _r$102 = _r$102.$blk(); } if (_r$102 && _r$102.$blk !== undefined) { break s; }
- return _r$102;
- $s = 181; continue;
- /* } else { */ case 180:
- $panic(new token.Token(e$4.Op));
- /* } */ case 181:
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$9, true)[1]) { */ case 54:
- e$5 = _ref$2.$val;
- /* */ if (e$5.Op === 44) { $s = 202; continue; }
- /* */ $s = 203; continue;
- /* if (e$5.Op === 44) { */ case 202:
- _r$103 = c[0].translateExpr(new ast.BinaryExpr.ptr(e$5.X, 0, 39, e$5.Y)); /* */ $s = 204; case 204: if($c) { $c = false; _r$103 = _r$103.$blk(); } if (_r$103 && _r$103.$blk !== undefined) { break s; }
- _arg$54 = _r$103;
- _r$104 = c[0].formatExpr("!(%s)", new sliceType$5([_arg$54])); /* */ $s = 205; case 205: if($c) { $c = false; _r$104 = _r$104.$blk(); } if (_r$104 && _r$104.$blk !== undefined) { break s; }
- return _r$104;
- /* } */ case 203:
- t$6 = (_entry$17 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$5.X)], _entry$17 !== undefined ? _entry$17.v : new types.TypeAndValue.ptr()).Type;
- t2 = (_entry$18 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$5.Y)], _entry$18 !== undefined ? _entry$18.v : new types.TypeAndValue.ptr()).Type;
- _r$105 = t2.Underlying(); /* */ $s = 206; case 206: if($c) { $c = false; _r$105 = _r$105.$blk(); } if (_r$105 && _r$105.$blk !== undefined) { break s; }
- _tuple$12 = $assertType(_r$105, ptrType$30, true); isInterface = _tuple$12[1];
- if (isInterface) { _v$1 = true; $s = 209; continue s; }
- _r$106 = types.Identical(t$6, types.Typ[25]); /* */ $s = 210; case 210: if($c) { $c = false; _r$106 = _r$106.$blk(); } if (_r$106 && _r$106.$blk !== undefined) { break s; }
- _v$1 = _r$106; case 209:
- /* */ if (_v$1) { $s = 207; continue; }
- /* */ $s = 208; continue;
- /* if (_v$1) { */ case 207:
- t$6 = t2;
- /* } */ case 208:
- _r$107 = t$6.Underlying(); /* */ $s = 211; case 211: if($c) { $c = false; _r$107 = _r$107.$blk(); } if (_r$107 && _r$107.$blk !== undefined) { break s; }
- _tuple$13 = $assertType(_r$107, ptrType$3, true); basic$2 = _tuple$13[0]; isBasic = _tuple$13[1];
- /* */ if (isBasic && isNumeric(basic$2)) { $s = 212; continue; }
- /* */ $s = 213; continue;
- /* if (isBasic && isNumeric(basic$2)) { */ case 212:
- /* */ if (is64Bit(basic$2)) { $s = 214; continue; }
- /* */ $s = 215; continue;
- /* if (is64Bit(basic$2)) { */ case 214:
- _ref$14 = e$5.Op;
- /* */ if (_ref$14 === 14) { $s = 216; continue; }
- /* */ if (_ref$14 === 15) { $s = 217; continue; }
- /* */ if (_ref$14 === 16) { $s = 218; continue; }
- /* */ if (_ref$14 === 20) { $s = 219; continue; }
- /* */ if (_ref$14 === 21) { $s = 220; continue; }
- /* */ if (_ref$14 === 39) { $s = 221; continue; }
- /* */ if (_ref$14 === 40) { $s = 222; continue; }
- /* */ if (_ref$14 === 45) { $s = 223; continue; }
- /* */ if (_ref$14 === 41) { $s = 224; continue; }
- /* */ if (_ref$14 === 46) { $s = 225; continue; }
- /* */ if (_ref$14 === 12 || _ref$14 === 13) { $s = 226; continue; }
- /* */ if (_ref$14 === 17 || _ref$14 === 18 || _ref$14 === 19) { $s = 227; continue; }
- /* */ if (_ref$14 === 22) { $s = 228; continue; }
- /* */ $s = 229; continue;
- /* if (_ref$14 === 14) { */ case 216:
- _r$108 = c[0].formatExpr("$mul64(%e, %e)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 231; case 231: if($c) { $c = false; _r$108 = _r$108.$blk(); } if (_r$108 && _r$108.$blk !== undefined) { break s; }
- return _r$108;
- $s = 230; continue;
- /* } else if (_ref$14 === 15) { */ case 217:
- _r$109 = c[0].formatExpr("$div64(%e, %e, false)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 232; case 232: if($c) { $c = false; _r$109 = _r$109.$blk(); } if (_r$109 && _r$109.$blk !== undefined) { break s; }
- return _r$109;
- $s = 230; continue;
- /* } else if (_ref$14 === 16) { */ case 218:
- _r$110 = c[0].formatExpr("$div64(%e, %e, true)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 233; case 233: if($c) { $c = false; _r$110 = _r$110.$blk(); } if (_r$110 && _r$110.$blk !== undefined) { break s; }
- return _r$110;
- $s = 230; continue;
- /* } else if (_ref$14 === 20) { */ case 219:
- _r$111 = c[0].formatExpr("$shiftLeft64(%e, %f)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 234; case 234: if($c) { $c = false; _r$111 = _r$111.$blk(); } if (_r$111 && _r$111.$blk !== undefined) { break s; }
- return _r$111;
- $s = 230; continue;
- /* } else if (_ref$14 === 21) { */ case 220:
- _r$112 = toJavaScriptType(basic$2); /* */ $s = 235; case 235: if($c) { $c = false; _r$112 = _r$112.$blk(); } if (_r$112 && _r$112.$blk !== undefined) { break s; }
- _arg$55 = new $String(_r$112);
- _arg$56 = e$5.X;
- _arg$57 = e$5.Y;
- _r$113 = c[0].formatExpr("$shiftRight%s(%e, %f)", new sliceType$5([_arg$55, _arg$56, _arg$57])); /* */ $s = 236; case 236: if($c) { $c = false; _r$113 = _r$113.$blk(); } if (_r$113 && _r$113.$blk !== undefined) { break s; }
- return _r$113;
- $s = 230; continue;
- /* } else if (_ref$14 === 39) { */ case 221:
- _r$114 = c[0].formatExpr("(%1h === %2h && %1l === %2l)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 237; case 237: if($c) { $c = false; _r$114 = _r$114.$blk(); } if (_r$114 && _r$114.$blk !== undefined) { break s; }
- return _r$114;
- $s = 230; continue;
- /* } else if (_ref$14 === 40) { */ case 222:
- _r$115 = c[0].formatExpr("(%1h < %2h || (%1h === %2h && %1l < %2l))", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 238; case 238: if($c) { $c = false; _r$115 = _r$115.$blk(); } if (_r$115 && _r$115.$blk !== undefined) { break s; }
- return _r$115;
- $s = 230; continue;
- /* } else if (_ref$14 === 45) { */ case 223:
- _r$116 = c[0].formatExpr("(%1h < %2h || (%1h === %2h && %1l <= %2l))", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 239; case 239: if($c) { $c = false; _r$116 = _r$116.$blk(); } if (_r$116 && _r$116.$blk !== undefined) { break s; }
- return _r$116;
- $s = 230; continue;
- /* } else if (_ref$14 === 41) { */ case 224:
- _r$117 = c[0].formatExpr("(%1h > %2h || (%1h === %2h && %1l > %2l))", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 240; case 240: if($c) { $c = false; _r$117 = _r$117.$blk(); } if (_r$117 && _r$117.$blk !== undefined) { break s; }
- return _r$117;
- $s = 230; continue;
- /* } else if (_ref$14 === 46) { */ case 225:
- _r$118 = c[0].formatExpr("(%1h > %2h || (%1h === %2h && %1l >= %2l))", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 241; case 241: if($c) { $c = false; _r$118 = _r$118.$blk(); } if (_r$118 && _r$118.$blk !== undefined) { break s; }
- return _r$118;
- $s = 230; continue;
- /* } else if (_ref$14 === 12 || _ref$14 === 13) { */ case 226:
- _arg$58 = e$5.X;
- _arg$59 = e$5.Y;
- _r$119 = c[0].typeName(t$6); /* */ $s = 242; case 242: if($c) { $c = false; _r$119 = _r$119.$blk(); } if (_r$119 && _r$119.$blk !== undefined) { break s; }
- _arg$60 = new $String(_r$119);
- _arg$61 = new token.Token(e$5.Op);
- _r$120 = c[0].formatExpr("new %3s(%1h %4t %2h, %1l %4t %2l)", new sliceType$5([_arg$58, _arg$59, _arg$60, _arg$61])); /* */ $s = 243; case 243: if($c) { $c = false; _r$120 = _r$120.$blk(); } if (_r$120 && _r$120.$blk !== undefined) { break s; }
- return _r$120;
- $s = 230; continue;
- /* } else if (_ref$14 === 17 || _ref$14 === 18 || _ref$14 === 19) { */ case 227:
- _arg$62 = e$5.X;
- _arg$63 = e$5.Y;
- _r$121 = c[0].typeName(t$6); /* */ $s = 244; case 244: if($c) { $c = false; _r$121 = _r$121.$blk(); } if (_r$121 && _r$121.$blk !== undefined) { break s; }
- _arg$64 = new $String(_r$121);
- _arg$65 = new token.Token(e$5.Op);
- _r$122 = c[0].formatExpr("new %3s(%1h %4t %2h, (%1l %4t %2l) >>> 0)", new sliceType$5([_arg$62, _arg$63, _arg$64, _arg$65])); /* */ $s = 245; case 245: if($c) { $c = false; _r$122 = _r$122.$blk(); } if (_r$122 && _r$122.$blk !== undefined) { break s; }
- return _r$122;
- $s = 230; continue;
- /* } else if (_ref$14 === 22) { */ case 228:
- _arg$66 = e$5.X;
- _arg$67 = e$5.Y;
- _r$123 = c[0].typeName(t$6); /* */ $s = 246; case 246: if($c) { $c = false; _r$123 = _r$123.$blk(); } if (_r$123 && _r$123.$blk !== undefined) { break s; }
- _arg$68 = new $String(_r$123);
- _r$124 = c[0].formatExpr("new %3s(%1h & ~%2h, (%1l & ~%2l) >>> 0)", new sliceType$5([_arg$66, _arg$67, _arg$68])); /* */ $s = 247; case 247: if($c) { $c = false; _r$124 = _r$124.$blk(); } if (_r$124 && _r$124.$blk !== undefined) { break s; }
- return _r$124;
- $s = 230; continue;
- /* } else { */ case 229:
- $panic(new token.Token(e$5.Op));
- /* } */ case 230:
- /* } */ case 215:
- /* */ if (isComplex(basic$2)) { $s = 248; continue; }
- /* */ $s = 249; continue;
- /* if (isComplex(basic$2)) { */ case 248:
- _ref$15 = e$5.Op;
- /* */ if (_ref$15 === 39) { $s = 250; continue; }
- /* */ if (_ref$15 === 12 || _ref$15 === 13) { $s = 251; continue; }
- /* */ if (_ref$15 === 14) { $s = 252; continue; }
- /* */ if (_ref$15 === 15) { $s = 253; continue; }
- /* */ $s = 254; continue;
- /* if (_ref$15 === 39) { */ case 250:
- _r$125 = c[0].formatExpr("(%1r === %2r && %1i === %2i)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 256; case 256: if($c) { $c = false; _r$125 = _r$125.$blk(); } if (_r$125 && _r$125.$blk !== undefined) { break s; }
- return _r$125;
- $s = 255; continue;
- /* } else if (_ref$15 === 12 || _ref$15 === 13) { */ case 251:
- _arg$69 = e$5.X;
- _arg$70 = e$5.Y;
- _r$126 = c[0].typeName(t$6); /* */ $s = 257; case 257: if($c) { $c = false; _r$126 = _r$126.$blk(); } if (_r$126 && _r$126.$blk !== undefined) { break s; }
- _arg$71 = new $String(_r$126);
- _arg$72 = new token.Token(e$5.Op);
- _r$127 = c[0].formatExpr("new %3s(%1r %4t %2r, %1i %4t %2i)", new sliceType$5([_arg$69, _arg$70, _arg$71, _arg$72])); /* */ $s = 258; case 258: if($c) { $c = false; _r$127 = _r$127.$blk(); } if (_r$127 && _r$127.$blk !== undefined) { break s; }
- return _r$127;
- $s = 255; continue;
- /* } else if (_ref$15 === 14) { */ case 252:
- _arg$73 = e$5.X;
- _arg$74 = e$5.Y;
- _r$128 = c[0].typeName(t$6); /* */ $s = 259; case 259: if($c) { $c = false; _r$128 = _r$128.$blk(); } if (_r$128 && _r$128.$blk !== undefined) { break s; }
- _arg$75 = new $String(_r$128);
- _r$129 = c[0].formatExpr("new %3s(%1r * %2r - %1i * %2i, %1r * %2i + %1i * %2r)", new sliceType$5([_arg$73, _arg$74, _arg$75])); /* */ $s = 260; case 260: if($c) { $c = false; _r$129 = _r$129.$blk(); } if (_r$129 && _r$129.$blk !== undefined) { break s; }
- return _r$129;
- $s = 255; continue;
- /* } else if (_ref$15 === 15) { */ case 253:
- _r$130 = c[0].formatExpr("$divComplex(%e, %e)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 261; case 261: if($c) { $c = false; _r$130 = _r$130.$blk(); } if (_r$130 && _r$130.$blk !== undefined) { break s; }
- return _r$130;
- $s = 255; continue;
- /* } else { */ case 254:
- $panic(new token.Token(e$5.Op));
- /* } */ case 255:
- /* } */ case 249:
- _ref$16 = e$5.Op;
- /* */ if (_ref$16 === 39) { $s = 262; continue; }
- /* */ if (_ref$16 === 40 || _ref$16 === 45 || _ref$16 === 41 || _ref$16 === 46) { $s = 263; continue; }
- /* */ if (_ref$16 === 12 || _ref$16 === 13) { $s = 264; continue; }
- /* */ if (_ref$16 === 14) { $s = 265; continue; }
- /* */ if (_ref$16 === 15) { $s = 266; continue; }
- /* */ if (_ref$16 === 16) { $s = 267; continue; }
- /* */ if (_ref$16 === 20 || _ref$16 === 21) { $s = 268; continue; }
- /* */ if (_ref$16 === 17 || _ref$16 === 18) { $s = 269; continue; }
- /* */ if (_ref$16 === 22) { $s = 270; continue; }
- /* */ if (_ref$16 === 19) { $s = 271; continue; }
- /* */ $s = 272; continue;
- /* if (_ref$16 === 39) { */ case 262:
- _r$131 = c[0].formatParenExpr("%e === %e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 274; case 274: if($c) { $c = false; _r$131 = _r$131.$blk(); } if (_r$131 && _r$131.$blk !== undefined) { break s; }
- return _r$131;
- $s = 273; continue;
- /* } else if (_ref$16 === 40 || _ref$16 === 45 || _ref$16 === 41 || _ref$16 === 46) { */ case 263:
- _r$132 = c[0].formatExpr("%e %t %e", new sliceType$5([e$5.X, new token.Token(e$5.Op), e$5.Y])); /* */ $s = 275; case 275: if($c) { $c = false; _r$132 = _r$132.$blk(); } if (_r$132 && _r$132.$blk !== undefined) { break s; }
- return _r$132;
- $s = 273; continue;
- /* } else if (_ref$16 === 12 || _ref$16 === 13) { */ case 264:
- _r$133 = c[0].formatExpr("%e %t %e", new sliceType$5([e$5.X, new token.Token(e$5.Op), e$5.Y])); /* */ $s = 276; case 276: if($c) { $c = false; _r$133 = _r$133.$blk(); } if (_r$133 && _r$133.$blk !== undefined) { break s; }
- _r$134 = c[0].fixNumber(_r$133, basic$2); /* */ $s = 277; case 277: if($c) { $c = false; _r$134 = _r$134.$blk(); } if (_r$134 && _r$134.$blk !== undefined) { break s; }
- return _r$134;
- $s = 273; continue;
- /* } else if (_ref$16 === 14) { */ case 265:
- _ref$17 = basic$2.Kind();
- /* */ if (_ref$17 === 5) { $s = 278; continue; }
- /* */ if (_ref$17 === 10 || _ref$17 === 12) { $s = 279; continue; }
- /* */ $s = 280; continue;
- /* if (_ref$17 === 5) { */ case 278:
- _r$135 = c[0].formatParenExpr("(((%1e >>> 16 << 16) * %2e >> 0) + (%1e << 16 >>> 16) * %2e) >> 0", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 281; case 281: if($c) { $c = false; _r$135 = _r$135.$blk(); } if (_r$135 && _r$135.$blk !== undefined) { break s; }
- return _r$135;
- $s = 280; continue;
- /* } else if (_ref$17 === 10 || _ref$17 === 12) { */ case 279:
- _r$136 = c[0].formatParenExpr("(((%1e >>> 16 << 16) * %2e >>> 0) + (%1e << 16 >>> 16) * %2e) >>> 0", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 282; case 282: if($c) { $c = false; _r$136 = _r$136.$blk(); } if (_r$136 && _r$136.$blk !== undefined) { break s; }
- return _r$136;
- /* } */ case 280:
- _r$137 = c[0].formatExpr("%e * %e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 283; case 283: if($c) { $c = false; _r$137 = _r$137.$blk(); } if (_r$137 && _r$137.$blk !== undefined) { break s; }
- _r$138 = c[0].fixNumber(_r$137, basic$2); /* */ $s = 284; case 284: if($c) { $c = false; _r$138 = _r$138.$blk(); } if (_r$138 && _r$138.$blk !== undefined) { break s; }
- return _r$138;
- $s = 273; continue;
- /* } else if (_ref$16 === 15) { */ case 266:
- /* */ if (isInteger(basic$2)) { $s = 285; continue; }
- /* */ $s = 286; continue;
- /* if (isInteger(basic$2)) { */ case 285:
- shift = ">>";
- if (isUnsigned(basic$2)) {
- shift = ">>>";
- }
- _r$139 = c[0].newVariable("_q"); /* */ $s = 287; case 287: if($c) { $c = false; _r$139 = _r$139.$blk(); } if (_r$139 && _r$139.$blk !== undefined) { break s; }
- _arg$76 = new $String(_r$139);
- _arg$77 = e$5.X;
- _arg$78 = e$5.Y;
- _arg$79 = new $String(shift);
- _r$140 = c[0].formatExpr("(%1s = %2e / %3e, (%1s === %1s && %1s !== 1/0 && %1s !== -1/0) ? %1s %4s 0 : $throwRuntimeError(\"integer divide by zero\"))", new sliceType$5([_arg$76, _arg$77, _arg$78, _arg$79])); /* */ $s = 288; case 288: if($c) { $c = false; _r$140 = _r$140.$blk(); } if (_r$140 && _r$140.$blk !== undefined) { break s; }
- return _r$140;
- /* } */ case 286:
- /* */ if (basic$2.Kind() === 13) { $s = 289; continue; }
- /* */ $s = 290; continue;
- /* if (basic$2.Kind() === 13) { */ case 289:
- _r$141 = c[0].formatExpr("%e / %e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 291; case 291: if($c) { $c = false; _r$141 = _r$141.$blk(); } if (_r$141 && _r$141.$blk !== undefined) { break s; }
- _r$142 = c[0].fixNumber(_r$141, basic$2); /* */ $s = 292; case 292: if($c) { $c = false; _r$142 = _r$142.$blk(); } if (_r$142 && _r$142.$blk !== undefined) { break s; }
- return _r$142;
- /* } */ case 290:
- _r$143 = c[0].formatExpr("%e / %e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 293; case 293: if($c) { $c = false; _r$143 = _r$143.$blk(); } if (_r$143 && _r$143.$blk !== undefined) { break s; }
- return _r$143;
- $s = 273; continue;
- /* } else if (_ref$16 === 16) { */ case 267:
- _r$144 = c[0].newVariable("_r"); /* */ $s = 294; case 294: if($c) { $c = false; _r$144 = _r$144.$blk(); } if (_r$144 && _r$144.$blk !== undefined) { break s; }
- _arg$80 = new $String(_r$144);
- _arg$81 = e$5.X;
- _arg$82 = e$5.Y;
- _r$145 = c[0].formatExpr("(%1s = %2e %% %3e, %1s === %1s ? %1s : $throwRuntimeError(\"integer divide by zero\"))", new sliceType$5([_arg$80, _arg$81, _arg$82])); /* */ $s = 295; case 295: if($c) { $c = false; _r$145 = _r$145.$blk(); } if (_r$145 && _r$145.$blk !== undefined) { break s; }
- return _r$145;
- $s = 273; continue;
- /* } else if (_ref$16 === 20 || _ref$16 === 21) { */ case 268:
- op = new token.Token(e$5.Op).String();
- if ((e$5.Op === 21) && isUnsigned(basic$2)) {
- op = ">>>";
- }
- /* */ if (!($interfaceIsEqual((_entry$19 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$5.Y)], _entry$19 !== undefined ? _entry$19.v : new types.TypeAndValue.ptr()).Value, $ifaceNil))) { $s = 296; continue; }
- /* */ $s = 297; continue;
- /* if (!($interfaceIsEqual((_entry$19 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$5.Y)], _entry$19 !== undefined ? _entry$19.v : new types.TypeAndValue.ptr()).Value, $ifaceNil))) { */ case 296:
- _r$146 = c[0].formatExpr("%e %s %e", new sliceType$5([e$5.X, new $String(op), e$5.Y])); /* */ $s = 298; case 298: if($c) { $c = false; _r$146 = _r$146.$blk(); } if (_r$146 && _r$146.$blk !== undefined) { break s; }
- _r$147 = c[0].fixNumber(_r$146, basic$2); /* */ $s = 299; case 299: if($c) { $c = false; _r$147 = _r$147.$blk(); } if (_r$147 && _r$147.$blk !== undefined) { break s; }
- return _r$147;
- /* } */ case 297:
- /* */ if ((e$5.Op === 21) && !isUnsigned(basic$2)) { $s = 300; continue; }
- /* */ $s = 301; continue;
- /* if ((e$5.Op === 21) && !isUnsigned(basic$2)) { */ case 300:
- _r$148 = c[0].formatParenExpr("%e >> $min(%e, 31)", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 302; case 302: if($c) { $c = false; _r$148 = _r$148.$blk(); } if (_r$148 && _r$148.$blk !== undefined) { break s; }
- _r$149 = c[0].fixNumber(_r$148, basic$2); /* */ $s = 303; case 303: if($c) { $c = false; _r$149 = _r$149.$blk(); } if (_r$149 && _r$149.$blk !== undefined) { break s; }
- return _r$149;
- /* } */ case 301:
- _r$150 = c[0].newVariable("y"); /* */ $s = 304; case 304: if($c) { $c = false; _r$150 = _r$150.$blk(); } if (_r$150 && _r$150.$blk !== undefined) { break s; }
- y = _r$150;
- _arg$83 = new $String(y);
- _r$151 = c[0].translateImplicitConversion(e$5.Y, types.Typ[7]); /* */ $s = 305; case 305: if($c) { $c = false; _r$151 = _r$151.$blk(); } if (_r$151 && _r$151.$blk !== undefined) { break s; }
- _arg$84 = _r$151;
- _arg$85 = new $String(y);
- _arg$86 = e$5.X;
- _arg$87 = new $String(op);
- _arg$88 = new $String(y);
- _r$152 = c[0].formatExpr("(%s = %s, %s < 32 ? (%e %s %s) : 0)", new sliceType$5([_arg$83, _arg$84, _arg$85, _arg$86, _arg$87, _arg$88])); /* */ $s = 306; case 306: if($c) { $c = false; _r$152 = _r$152.$blk(); } if (_r$152 && _r$152.$blk !== undefined) { break s; }
- _r$153 = c[0].fixNumber(_r$152, basic$2); /* */ $s = 307; case 307: if($c) { $c = false; _r$153 = _r$153.$blk(); } if (_r$153 && _r$153.$blk !== undefined) { break s; }
- return _r$153;
- $s = 273; continue;
- /* } else if (_ref$16 === 17 || _ref$16 === 18) { */ case 269:
- /* */ if (isUnsigned(basic$2)) { $s = 308; continue; }
- /* */ $s = 309; continue;
- /* if (isUnsigned(basic$2)) { */ case 308:
- _r$154 = c[0].formatParenExpr("(%e %t %e) >>> 0", new sliceType$5([e$5.X, new token.Token(e$5.Op), e$5.Y])); /* */ $s = 310; case 310: if($c) { $c = false; _r$154 = _r$154.$blk(); } if (_r$154 && _r$154.$blk !== undefined) { break s; }
- return _r$154;
- /* } */ case 309:
- _r$155 = c[0].formatParenExpr("%e %t %e", new sliceType$5([e$5.X, new token.Token(e$5.Op), e$5.Y])); /* */ $s = 311; case 311: if($c) { $c = false; _r$155 = _r$155.$blk(); } if (_r$155 && _r$155.$blk !== undefined) { break s; }
- return _r$155;
- $s = 273; continue;
- /* } else if (_ref$16 === 22) { */ case 270:
- _r$156 = c[0].formatParenExpr("%e & ~%e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 312; case 312: if($c) { $c = false; _r$156 = _r$156.$blk(); } if (_r$156 && _r$156.$blk !== undefined) { break s; }
- _r$157 = c[0].fixNumber(_r$156, basic$2); /* */ $s = 313; case 313: if($c) { $c = false; _r$157 = _r$157.$blk(); } if (_r$157 && _r$157.$blk !== undefined) { break s; }
- return _r$157;
- $s = 273; continue;
- /* } else if (_ref$16 === 19) { */ case 271:
- _r$158 = c[0].formatParenExpr("%e ^ %e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 314; case 314: if($c) { $c = false; _r$158 = _r$158.$blk(); } if (_r$158 && _r$158.$blk !== undefined) { break s; }
- _r$159 = c[0].fixNumber(_r$158, basic$2); /* */ $s = 315; case 315: if($c) { $c = false; _r$159 = _r$159.$blk(); } if (_r$159 && _r$159.$blk !== undefined) { break s; }
- return _r$159;
- $s = 273; continue;
- /* } else { */ case 272:
- $panic(new token.Token(e$5.Op));
- /* } */ case 273:
- /* } */ case 213:
- _ref$18 = e$5.Op;
- /* */ if (_ref$18 === 12 || _ref$18 === 40 || _ref$18 === 45 || _ref$18 === 41 || _ref$18 === 46) { $s = 316; continue; }
- /* */ if (_ref$18 === 34) { $s = 317; continue; }
- /* */ if (_ref$18 === 35) { $s = 318; continue; }
- /* */ if (_ref$18 === 39) { $s = 319; continue; }
- /* */ $s = 320; continue;
- /* if (_ref$18 === 12 || _ref$18 === 40 || _ref$18 === 45 || _ref$18 === 41 || _ref$18 === 46) { */ case 316:
- _r$160 = c[0].formatExpr("%e %t %e", new sliceType$5([e$5.X, new token.Token(e$5.Op), e$5.Y])); /* */ $s = 322; case 322: if($c) { $c = false; _r$160 = _r$160.$blk(); } if (_r$160 && _r$160.$blk !== undefined) { break s; }
- return _r$160;
- $s = 321; continue;
- /* } else if (_ref$18 === 34) { */ case 317:
- /* */ if ((_entry$20 = c[0].FuncInfo.Blocking[ast.Node.keyFor(e$5.Y)], _entry$20 !== undefined ? _entry$20.v : false)) { $s = 323; continue; }
- /* */ $s = 324; continue;
- /* if ((_entry$20 = c[0].FuncInfo.Blocking[ast.Node.keyFor(e$5.Y)], _entry$20 !== undefined ? _entry$20.v : false)) { */ case 323:
- skipCase = c[0].caseCounter;
- c[0].caseCounter = c[0].caseCounter + (1) >> 0;
- _r$161 = c[0].newVariable("_v"); /* */ $s = 325; case 325: if($c) { $c = false; _r$161 = _r$161.$blk(); } if (_r$161 && _r$161.$blk !== undefined) { break s; }
- resultVar = _r$161;
- _r$162 = c[0].translateExpr(e$5.X); /* */ $s = 326; case 326: if($c) { $c = false; _r$162 = _r$162.$blk(); } if (_r$162 && _r$162.$blk !== undefined) { break s; }
- _arg$89 = _r$162;
- _arg$90 = new $String(resultVar);
- _arg$91 = new $Int(skipCase);
- $r = c[0].Printf("if (!(%s)) { %s = false; $s = %d; continue s; }", new sliceType$5([_arg$89, _arg$90, _arg$91])); /* */ $s = 327; case 327: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _arg$92 = new $String(resultVar);
- _r$163 = c[0].translateExpr(e$5.Y); /* */ $s = 328; case 328: if($c) { $c = false; _r$163 = _r$163.$blk(); } if (_r$163 && _r$163.$blk !== undefined) { break s; }
- _arg$93 = _r$163;
- _arg$94 = new $Int(skipCase);
- $r = c[0].Printf("%s = %s; case %d:", new sliceType$5([_arg$92, _arg$93, _arg$94])); /* */ $s = 329; case 329: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$164 = c[0].formatExpr("%s", new sliceType$5([new $String(resultVar)])); /* */ $s = 330; case 330: if($c) { $c = false; _r$164 = _r$164.$blk(); } if (_r$164 && _r$164.$blk !== undefined) { break s; }
- return _r$164;
- /* } */ case 324:
- _r$165 = c[0].formatExpr("%e && %e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 331; case 331: if($c) { $c = false; _r$165 = _r$165.$blk(); } if (_r$165 && _r$165.$blk !== undefined) { break s; }
- return _r$165;
- $s = 321; continue;
- /* } else if (_ref$18 === 35) { */ case 318:
- /* */ if ((_entry$21 = c[0].FuncInfo.Blocking[ast.Node.keyFor(e$5.Y)], _entry$21 !== undefined ? _entry$21.v : false)) { $s = 332; continue; }
- /* */ $s = 333; continue;
- /* if ((_entry$21 = c[0].FuncInfo.Blocking[ast.Node.keyFor(e$5.Y)], _entry$21 !== undefined ? _entry$21.v : false)) { */ case 332:
- skipCase$1 = c[0].caseCounter;
- c[0].caseCounter = c[0].caseCounter + (1) >> 0;
- _r$166 = c[0].newVariable("_v"); /* */ $s = 334; case 334: if($c) { $c = false; _r$166 = _r$166.$blk(); } if (_r$166 && _r$166.$blk !== undefined) { break s; }
- resultVar$1 = _r$166;
- _r$167 = c[0].translateExpr(e$5.X); /* */ $s = 335; case 335: if($c) { $c = false; _r$167 = _r$167.$blk(); } if (_r$167 && _r$167.$blk !== undefined) { break s; }
- _arg$95 = _r$167;
- _arg$96 = new $String(resultVar$1);
- _arg$97 = new $Int(skipCase$1);
- $r = c[0].Printf("if (%s) { %s = true; $s = %d; continue s; }", new sliceType$5([_arg$95, _arg$96, _arg$97])); /* */ $s = 336; case 336: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _arg$98 = new $String(resultVar$1);
- _r$168 = c[0].translateExpr(e$5.Y); /* */ $s = 337; case 337: if($c) { $c = false; _r$168 = _r$168.$blk(); } if (_r$168 && _r$168.$blk !== undefined) { break s; }
- _arg$99 = _r$168;
- _arg$100 = new $Int(skipCase$1);
- $r = c[0].Printf("%s = %s; case %d:", new sliceType$5([_arg$98, _arg$99, _arg$100])); /* */ $s = 338; case 338: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$169 = c[0].formatExpr("%s", new sliceType$5([new $String(resultVar$1)])); /* */ $s = 339; case 339: if($c) { $c = false; _r$169 = _r$169.$blk(); } if (_r$169 && _r$169.$blk !== undefined) { break s; }
- return _r$169;
- /* } */ case 333:
- _r$170 = c[0].formatExpr("%e || %e", new sliceType$5([e$5.X, e$5.Y])); /* */ $s = 340; case 340: if($c) { $c = false; _r$170 = _r$170.$blk(); } if (_r$170 && _r$170.$blk !== undefined) { break s; }
- return _r$170;
- $s = 321; continue;
- /* } else if (_ref$18 === 39) { */ case 319:
- _r$171 = t$6.Underlying(); /* */ $s = 341; case 341: if($c) { $c = false; _r$171 = _r$171.$blk(); } if (_r$171 && _r$171.$blk !== undefined) { break s; }
- _ref$19 = _r$171;
- /* */ if ($assertType(_ref$19, ptrType$20, true)[1] || $assertType(_ref$19, ptrType$23, true)[1]) { $s = 342; continue; }
- /* */ if ($assertType(_ref$19, ptrType$30, true)[1]) { $s = 343; continue; }
- /* */ if ($assertType(_ref$19, ptrType$17, true)[1]) { $s = 344; continue; }
- /* */ if ($assertType(_ref$19, ptrType$3, true)[1]) { $s = 345; continue; }
- /* */ $s = 346; continue;
- /* if ($assertType(_ref$19, ptrType$20, true)[1] || $assertType(_ref$19, ptrType$23, true)[1]) { */ case 342:
- u = _ref$19;
- _arg$101 = e$5.X;
- _arg$102 = e$5.Y;
- _r$172 = c[0].typeName(t$6); /* */ $s = 347; case 347: if($c) { $c = false; _r$172 = _r$172.$blk(); } if (_r$172 && _r$172.$blk !== undefined) { break s; }
- _arg$103 = new $String(_r$172);
- _r$173 = c[0].formatExpr("$equal(%e, %e, %s)", new sliceType$5([_arg$101, _arg$102, _arg$103])); /* */ $s = 348; case 348: if($c) { $c = false; _r$173 = _r$173.$blk(); } if (_r$173 && _r$173.$blk !== undefined) { break s; }
- return _r$173;
- $s = 346; continue;
- /* } else if ($assertType(_ref$19, ptrType$30, true)[1]) { */ case 343:
- u$1 = _ref$19.$val;
- _r$174 = c[0].translateImplicitConversion(e$5.X, t$6); /* */ $s = 349; case 349: if($c) { $c = false; _r$174 = _r$174.$blk(); } if (_r$174 && _r$174.$blk !== undefined) { break s; }
- _arg$104 = _r$174;
- _r$175 = c[0].translateImplicitConversion(e$5.Y, t$6); /* */ $s = 350; case 350: if($c) { $c = false; _r$175 = _r$175.$blk(); } if (_r$175 && _r$175.$blk !== undefined) { break s; }
- _arg$105 = _r$175;
- _r$176 = c[0].formatExpr("$interfaceIsEqual(%s, %s)", new sliceType$5([_arg$104, _arg$105])); /* */ $s = 351; case 351: if($c) { $c = false; _r$176 = _r$176.$blk(); } if (_r$176 && _r$176.$blk !== undefined) { break s; }
- return _r$176;
- $s = 346; continue;
- /* } else if ($assertType(_ref$19, ptrType$17, true)[1]) { */ case 344:
- u$2 = _ref$19.$val;
- _r$177 = u$2.Elem().Underlying(); /* */ $s = 352; case 352: if($c) { $c = false; _r$177 = _r$177.$blk(); } if (_r$177 && _r$177.$blk !== undefined) { break s; }
- _tuple$14 = $assertType(_r$177, ptrType$20, true); ok$5 = _tuple$14[1];
- /* */ if (ok$5) { $s = 353; continue; }
- /* */ $s = 354; continue;
- /* if (ok$5) { */ case 353:
- _r$178 = c[0].translateImplicitConversion(e$5.X, t$6); /* */ $s = 355; case 355: if($c) { $c = false; _r$178 = _r$178.$blk(); } if (_r$178 && _r$178.$blk !== undefined) { break s; }
- _arg$106 = _r$178;
- _r$179 = c[0].translateImplicitConversion(e$5.Y, t$6); /* */ $s = 356; case 356: if($c) { $c = false; _r$179 = _r$179.$blk(); } if (_r$179 && _r$179.$blk !== undefined) { break s; }
- _arg$107 = _r$179;
- _r$180 = c[0].typeName(u$2.Elem()); /* */ $s = 357; case 357: if($c) { $c = false; _r$180 = _r$180.$blk(); } if (_r$180 && _r$180.$blk !== undefined) { break s; }
- _arg$108 = new $String(_r$180);
- _r$181 = c[0].formatExpr("$equal(%s, %s, %s)", new sliceType$5([_arg$106, _arg$107, _arg$108])); /* */ $s = 358; case 358: if($c) { $c = false; _r$181 = _r$181.$blk(); } if (_r$181 && _r$181.$blk !== undefined) { break s; }
- return _r$181;
- /* } */ case 354:
- $s = 346; continue;
- /* } else if ($assertType(_ref$19, ptrType$3, true)[1]) { */ case 345:
- u$3 = _ref$19.$val;
- /* */ if (isBoolean(u$3)) { $s = 359; continue; }
- /* */ $s = 360; continue;
- /* if (isBoolean(u$3)) { */ case 359:
- _r$182 = analysis.BoolValue(e$5.X, c[0].p.Info.Info); /* */ $s = 361; case 361: if($c) { $c = false; _r$182 = _r$182.$blk(); } if (_r$182 && _r$182.$blk !== undefined) { break s; }
- _tuple$15 = _r$182; b = _tuple$15[0]; ok$6 = _tuple$15[1];
- /* */ if (ok$6 && b) { $s = 362; continue; }
- /* */ $s = 363; continue;
- /* if (ok$6 && b) { */ case 362:
- _r$183 = c[0].translateExpr(e$5.Y); /* */ $s = 364; case 364: if($c) { $c = false; _r$183 = _r$183.$blk(); } if (_r$183 && _r$183.$blk !== undefined) { break s; }
- return _r$183;
- /* } */ case 363:
- _r$184 = analysis.BoolValue(e$5.Y, c[0].p.Info.Info); /* */ $s = 365; case 365: if($c) { $c = false; _r$184 = _r$184.$blk(); } if (_r$184 && _r$184.$blk !== undefined) { break s; }
- _tuple$16 = _r$184; b$1 = _tuple$16[0]; ok$7 = _tuple$16[1];
- /* */ if (ok$7 && b$1) { $s = 366; continue; }
- /* */ $s = 367; continue;
- /* if (ok$7 && b$1) { */ case 366:
- _r$185 = c[0].translateExpr(e$5.X); /* */ $s = 368; case 368: if($c) { $c = false; _r$185 = _r$185.$blk(); } if (_r$185 && _r$185.$blk !== undefined) { break s; }
- return _r$185;
- /* } */ case 367:
- /* } */ case 360:
- /* } */ case 346:
- _r$186 = c[0].translateImplicitConversion(e$5.X, t$6); /* */ $s = 369; case 369: if($c) { $c = false; _r$186 = _r$186.$blk(); } if (_r$186 && _r$186.$blk !== undefined) { break s; }
- _arg$109 = _r$186;
- _r$187 = c[0].translateImplicitConversion(e$5.Y, t$6); /* */ $s = 370; case 370: if($c) { $c = false; _r$187 = _r$187.$blk(); } if (_r$187 && _r$187.$blk !== undefined) { break s; }
- _arg$110 = _r$187;
- _r$188 = c[0].formatExpr("%s === %s", new sliceType$5([_arg$109, _arg$110])); /* */ $s = 371; case 371: if($c) { $c = false; _r$188 = _r$188.$blk(); } if (_r$188 && _r$188.$blk !== undefined) { break s; }
- return _r$188;
- $s = 321; continue;
- /* } else { */ case 320:
- $panic(new token.Token(e$5.Op));
- /* } */ case 321:
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$10, true)[1]) { */ case 55:
- e$6 = _ref$2.$val;
- _r$189 = c[0].formatParenExpr("%e", new sliceType$5([e$6.X])); /* */ $s = 372; case 372: if($c) { $c = false; _r$189 = _r$189.$blk(); } if (_r$189 && _r$189.$blk !== undefined) { break s; }
- return _r$189;
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$11, true)[1]) { */ case 56:
- e$7 = _ref$2.$val;
- _r$190 = (_entry$22 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$7.X)], _entry$22 !== undefined ? _entry$22.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 373; case 373: if($c) { $c = false; _r$190 = _r$190.$blk(); } if (_r$190 && _r$190.$blk !== undefined) { break s; }
- _ref$20 = _r$190;
- /* */ if ($assertType(_ref$20, ptrType$20, true)[1] || $assertType(_ref$20, ptrType$17, true)[1]) { $s = 374; continue; }
- /* */ if ($assertType(_ref$20, ptrType$21, true)[1]) { $s = 375; continue; }
- /* */ if ($assertType(_ref$20, ptrType$22, true)[1]) { $s = 376; continue; }
- /* */ if ($assertType(_ref$20, ptrType$3, true)[1]) { $s = 377; continue; }
- /* */ $s = 378; continue;
- /* if ($assertType(_ref$20, ptrType$20, true)[1] || $assertType(_ref$20, ptrType$17, true)[1]) { */ case 374:
- t$7 = _ref$20;
- pattern = rangeCheck("%1e[%2f]", !($interfaceIsEqual((_entry$23 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$7.Index)], _entry$23 !== undefined ? _entry$23.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)), true);
- _tuple$17 = $assertType(t$7, ptrType$17, true); ok$8 = _tuple$17[1];
- if (ok$8) {
- pattern = "(%1e.nilCheck, " + pattern + ")";
- }
- _r$191 = c[0].formatExpr(pattern, new sliceType$5([e$7.X, e$7.Index])); /* */ $s = 380; case 380: if($c) { $c = false; _r$191 = _r$191.$blk(); } if (_r$191 && _r$191.$blk !== undefined) { break s; }
- return _r$191;
- $s = 379; continue;
- /* } else if ($assertType(_ref$20, ptrType$21, true)[1]) { */ case 375:
- t$8 = _ref$20.$val;
- _r$192 = c[0].formatExpr(rangeCheck("%1e.$array[%1e.$offset + %2f]", !($interfaceIsEqual((_entry$24 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$7.Index)], _entry$24 !== undefined ? _entry$24.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)), false), new sliceType$5([e$7.X, e$7.Index])); /* */ $s = 381; case 381: if($c) { $c = false; _r$192 = _r$192.$blk(); } if (_r$192 && _r$192.$blk !== undefined) { break s; }
- return _r$192;
- $s = 379; continue;
- /* } else if ($assertType(_ref$20, ptrType$22, true)[1]) { */ case 376:
- t$9 = _ref$20.$val;
- /* */ if (typesutil.IsJsObject((_entry$25 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$7.Index)], _entry$25 !== undefined ? _entry$25.v : new types.TypeAndValue.ptr()).Type)) { $s = 382; continue; }
- /* */ $s = 383; continue;
- /* if (typesutil.IsJsObject((_entry$25 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$7.Index)], _entry$25 !== undefined ? _entry$25.v : new types.TypeAndValue.ptr()).Type)) { */ case 382:
- _r$193 = e$7.Index.Pos(); /* */ $s = 384; case 384: if($c) { $c = false; _r$193 = _r$193.$blk(); } if (_r$193 && _r$193.$blk !== undefined) { break s; }
- c[0].p.errList = $append(c[0].p.errList, (x$9 = new types.Error.ptr(c[0].p.fileSet, _r$193, "cannot use js.Object as map key", false), new x$9.constructor.elem(x$9)));
- /* } */ case 383:
- _r$194 = c[0].typeName(t$9.Key()); /* */ $s = 385; case 385: if($c) { $c = false; _r$194 = _r$194.$blk(); } if (_r$194 && _r$194.$blk !== undefined) { break s; }
- _arg$111 = new $String(_r$194);
- _r$195 = c[0].translateImplicitConversion(e$7.Index, t$9.Key()); /* */ $s = 386; case 386: if($c) { $c = false; _r$195 = _r$195.$blk(); } if (_r$195 && _r$195.$blk !== undefined) { break s; }
- _arg$112 = _r$195;
- _r$196 = fmt.Sprintf("%s.keyFor(%s)", new sliceType$5([_arg$111, _arg$112])); /* */ $s = 387; case 387: if($c) { $c = false; _r$196 = _r$196.$blk(); } if (_r$196 && _r$196.$blk !== undefined) { break s; }
- key = _r$196;
- _tuple$18 = $assertType(exprType, ptrType$29, true); isTuple$1 = _tuple$18[1];
- /* */ if (isTuple$1) { $s = 388; continue; }
- /* */ $s = 389; continue;
- /* if (isTuple$1) { */ case 388:
- _r$197 = c[0].newVariable("_entry"); /* */ $s = 390; case 390: if($c) { $c = false; _r$197 = _r$197.$blk(); } if (_r$197 && _r$197.$blk !== undefined) { break s; }
- _arg$113 = new $String(_r$197);
- _arg$114 = e$7.X;
- _arg$115 = new $String(key);
- _r$198 = c[0].zeroValue(t$9.Elem()); /* */ $s = 391; case 391: if($c) { $c = false; _r$198 = _r$198.$blk(); } if (_r$198 && _r$198.$blk !== undefined) { break s; }
- _arg$116 = new $String(_r$198);
- _r$199 = c[0].formatExpr("(%1s = %2e[%3s], %1s !== undefined ? [%1s.v, true] : [%4s, false])", new sliceType$5([_arg$113, _arg$114, _arg$115, _arg$116])); /* */ $s = 392; case 392: if($c) { $c = false; _r$199 = _r$199.$blk(); } if (_r$199 && _r$199.$blk !== undefined) { break s; }
- return _r$199;
- /* } */ case 389:
- _r$200 = c[0].newVariable("_entry"); /* */ $s = 393; case 393: if($c) { $c = false; _r$200 = _r$200.$blk(); } if (_r$200 && _r$200.$blk !== undefined) { break s; }
- _arg$117 = new $String(_r$200);
- _arg$118 = e$7.X;
- _arg$119 = new $String(key);
- _r$201 = c[0].zeroValue(t$9.Elem()); /* */ $s = 394; case 394: if($c) { $c = false; _r$201 = _r$201.$blk(); } if (_r$201 && _r$201.$blk !== undefined) { break s; }
- _arg$120 = new $String(_r$201);
- _r$202 = c[0].formatExpr("(%1s = %2e[%3s], %1s !== undefined ? %1s.v : %4s)", new sliceType$5([_arg$117, _arg$118, _arg$119, _arg$120])); /* */ $s = 395; case 395: if($c) { $c = false; _r$202 = _r$202.$blk(); } if (_r$202 && _r$202.$blk !== undefined) { break s; }
- return _r$202;
- $s = 379; continue;
- /* } else if ($assertType(_ref$20, ptrType$3, true)[1]) { */ case 377:
- t$10 = _ref$20.$val;
- _r$203 = c[0].formatExpr("%e.charCodeAt(%f)", new sliceType$5([e$7.X, e$7.Index])); /* */ $s = 396; case 396: if($c) { $c = false; _r$203 = _r$203.$blk(); } if (_r$203 && _r$203.$blk !== undefined) { break s; }
- return _r$203;
- $s = 379; continue;
- /* } else { */ case 378:
- t$11 = _ref$20;
- _r$204 = fmt.Sprintf("Unhandled IndexExpr: %T\n", new sliceType$5([t$11])); /* */ $s = 397; case 397: if($c) { $c = false; _r$204 = _r$204.$blk(); } if (_r$204 && _r$204.$blk !== undefined) { break s; }
- $panic(new $String(_r$204));
- /* } */ case 379:
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$12, true)[1]) { */ case 57:
- e$8 = _ref$2.$val;
- _r$205 = (_entry$26 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$8.X)], _entry$26 !== undefined ? _entry$26.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 398; case 398: if($c) { $c = false; _r$205 = _r$205.$blk(); } if (_r$205 && _r$205.$blk !== undefined) { break s; }
- _tuple$19 = $assertType(_r$205, ptrType$3, true); b$2 = _tuple$19[0]; isBasic$1 = _tuple$19[1];
- /* */ if (isBasic$1 && isString(b$2)) { $s = 399; continue; }
- /* */ $s = 400; continue;
- /* if (isBasic$1 && isString(b$2)) { */ case 399:
- /* */ if ($interfaceIsEqual(e$8.Low, $ifaceNil) && $interfaceIsEqual(e$8.High, $ifaceNil)) { $s = 401; continue; }
- /* */ if ($interfaceIsEqual(e$8.Low, $ifaceNil)) { $s = 402; continue; }
- /* */ if ($interfaceIsEqual(e$8.High, $ifaceNil)) { $s = 403; continue; }
- /* */ $s = 404; continue;
- /* if ($interfaceIsEqual(e$8.Low, $ifaceNil) && $interfaceIsEqual(e$8.High, $ifaceNil)) { */ case 401:
- _r$206 = c[0].translateExpr(e$8.X); /* */ $s = 406; case 406: if($c) { $c = false; _r$206 = _r$206.$blk(); } if (_r$206 && _r$206.$blk !== undefined) { break s; }
- return _r$206;
- $s = 405; continue;
- /* } else if ($interfaceIsEqual(e$8.Low, $ifaceNil)) { */ case 402:
- _r$207 = c[0].formatExpr("%e.substring(0, %f)", new sliceType$5([e$8.X, e$8.High])); /* */ $s = 407; case 407: if($c) { $c = false; _r$207 = _r$207.$blk(); } if (_r$207 && _r$207.$blk !== undefined) { break s; }
- return _r$207;
- $s = 405; continue;
- /* } else if ($interfaceIsEqual(e$8.High, $ifaceNil)) { */ case 403:
- _r$208 = c[0].formatExpr("%e.substring(%f)", new sliceType$5([e$8.X, e$8.Low])); /* */ $s = 408; case 408: if($c) { $c = false; _r$208 = _r$208.$blk(); } if (_r$208 && _r$208.$blk !== undefined) { break s; }
- return _r$208;
- $s = 405; continue;
- /* } else { */ case 404:
- _r$209 = c[0].formatExpr("%e.substring(%f, %f)", new sliceType$5([e$8.X, e$8.Low, e$8.High])); /* */ $s = 409; case 409: if($c) { $c = false; _r$209 = _r$209.$blk(); } if (_r$209 && _r$209.$blk !== undefined) { break s; }
- return _r$209;
- /* } */ case 405:
- /* } */ case 400:
- _r$210 = c[0].translateConversionToSlice(e$8.X, exprType); /* */ $s = 410; case 410: if($c) { $c = false; _r$210 = _r$210.$blk(); } if (_r$210 && _r$210.$blk !== undefined) { break s; }
- slice = _r$210;
- /* */ if ($interfaceIsEqual(e$8.Low, $ifaceNil) && $interfaceIsEqual(e$8.High, $ifaceNil)) { $s = 411; continue; }
- /* */ if ($interfaceIsEqual(e$8.Low, $ifaceNil)) { $s = 412; continue; }
- /* */ if ($interfaceIsEqual(e$8.High, $ifaceNil)) { $s = 413; continue; }
- /* */ $s = 414; continue;
- /* if ($interfaceIsEqual(e$8.Low, $ifaceNil) && $interfaceIsEqual(e$8.High, $ifaceNil)) { */ case 411:
- _r$211 = c[0].formatExpr("%s", new sliceType$5([slice])); /* */ $s = 416; case 416: if($c) { $c = false; _r$211 = _r$211.$blk(); } if (_r$211 && _r$211.$blk !== undefined) { break s; }
- return _r$211;
- $s = 415; continue;
- /* } else if ($interfaceIsEqual(e$8.Low, $ifaceNil)) { */ case 412:
- /* */ if (!($interfaceIsEqual(e$8.Max, $ifaceNil))) { $s = 417; continue; }
- /* */ $s = 418; continue;
- /* if (!($interfaceIsEqual(e$8.Max, $ifaceNil))) { */ case 417:
- _r$212 = c[0].formatExpr("$subslice(%s, 0, %f, %f)", new sliceType$5([slice, e$8.High, e$8.Max])); /* */ $s = 419; case 419: if($c) { $c = false; _r$212 = _r$212.$blk(); } if (_r$212 && _r$212.$blk !== undefined) { break s; }
- return _r$212;
- /* } */ case 418:
- _r$213 = c[0].formatExpr("$subslice(%s, 0, %f)", new sliceType$5([slice, e$8.High])); /* */ $s = 420; case 420: if($c) { $c = false; _r$213 = _r$213.$blk(); } if (_r$213 && _r$213.$blk !== undefined) { break s; }
- return _r$213;
- $s = 415; continue;
- /* } else if ($interfaceIsEqual(e$8.High, $ifaceNil)) { */ case 413:
- _r$214 = c[0].formatExpr("$subslice(%s, %f)", new sliceType$5([slice, e$8.Low])); /* */ $s = 421; case 421: if($c) { $c = false; _r$214 = _r$214.$blk(); } if (_r$214 && _r$214.$blk !== undefined) { break s; }
- return _r$214;
- $s = 415; continue;
- /* } else { */ case 414:
- /* */ if (!($interfaceIsEqual(e$8.Max, $ifaceNil))) { $s = 422; continue; }
- /* */ $s = 423; continue;
- /* if (!($interfaceIsEqual(e$8.Max, $ifaceNil))) { */ case 422:
- _r$215 = c[0].formatExpr("$subslice(%s, %f, %f, %f)", new sliceType$5([slice, e$8.Low, e$8.High, e$8.Max])); /* */ $s = 424; case 424: if($c) { $c = false; _r$215 = _r$215.$blk(); } if (_r$215 && _r$215.$blk !== undefined) { break s; }
- return _r$215;
- /* } */ case 423:
- _r$216 = c[0].formatExpr("$subslice(%s, %f, %f)", new sliceType$5([slice, e$8.Low, e$8.High])); /* */ $s = 425; case 425: if($c) { $c = false; _r$216 = _r$216.$blk(); } if (_r$216 && _r$216.$blk !== undefined) { break s; }
- return _r$216;
- /* } */ case 415:
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$4, true)[1]) { */ case 58:
- e$9 = _ref$2.$val;
- _tuple$20 = (_entry$27 = c[0].p.Info.Info.Selections[ptrType$4.keyFor(e$9)], _entry$27 !== undefined ? [_entry$27.v, true] : [ptrType$27.nil, false]); sel$1 = _tuple$20[0]; ok$9 = _tuple$20[1];
- /* */ if (!ok$9) { $s = 426; continue; }
- /* */ $s = 427; continue;
- /* if (!ok$9) { */ case 426:
- _r$217 = c[0].objectName(obj); /* */ $s = 428; case 428: if($c) { $c = false; _r$217 = _r$217.$blk(); } if (_r$217 && _r$217.$blk !== undefined) { break s; }
- _arg$121 = new $String(_r$217);
- _r$218 = c[0].formatExpr("%s", new sliceType$5([_arg$121])); /* */ $s = 429; case 429: if($c) { $c = false; _r$218 = _r$218.$blk(); } if (_r$218 && _r$218.$blk !== undefined) { break s; }
- return _r$218;
- /* } */ case 427:
- _ref$21 = sel$1.Kind();
- /* */ if (_ref$21 === 0) { $s = 430; continue; }
- /* */ if (_ref$21 === 1) { $s = 431; continue; }
- /* */ if (_ref$21 === 2) { $s = 432; continue; }
- /* */ $s = 433; continue;
- /* if (_ref$21 === 0) { */ case 430:
- _arg$122 = sel$1;
- _r$219 = e$9.Pos(); /* */ $s = 434; case 434: if($c) { $c = false; _r$219 = _r$219.$blk(); } if (_r$219 && _r$219.$blk !== undefined) { break s; }
- _arg$123 = _r$219;
- _r$220 = c[0].translateSelection(_arg$122, _arg$123); /* */ $s = 435; case 435: if($c) { $c = false; _r$220 = _r$220.$blk(); } if (_r$220 && _r$220.$blk !== undefined) { break s; }
- _tuple$21 = _r$220; fields = _tuple$21[0]; jsTag = _tuple$21[1];
- /* */ if (!(jsTag === "")) { $s = 436; continue; }
- /* */ $s = 437; continue;
- /* if (!(jsTag === "")) { */ case 436:
- _r$221 = sel$1.Type(); /* */ $s = 438; case 438: if($c) { $c = false; _r$221 = _r$221.$blk(); } if (_r$221 && _r$221.$blk !== undefined) { break s; }
- _tuple$22 = $assertType(_r$221, ptrType$24, true); ok$10 = _tuple$22[1];
- /* */ if (ok$10) { $s = 439; continue; }
- /* */ $s = 440; continue;
- /* if (ok$10) { */ case 439:
- _arg$124 = e$9.X;
- _arg$125 = new $String(strings.Join(fields, "."));
- _arg$126 = new $String(jsTag);
- _r$222 = sel$1.Type(); /* */ $s = 441; case 441: if($c) { $c = false; _r$222 = _r$222.$blk(); } if (_r$222 && _r$222.$blk !== undefined) { break s; }
- _r$223 = c[0].typeName(_r$222); /* */ $s = 442; case 442: if($c) { $c = false; _r$223 = _r$223.$blk(); } if (_r$223 && _r$223.$blk !== undefined) { break s; }
- _arg$127 = new $String(_r$223);
- _r$224 = c[0].formatExpr("$internalize(%1e.%2s.%3s, %4s, %1e.%2s)", new sliceType$5([_arg$124, _arg$125, _arg$126, _arg$127])); /* */ $s = 443; case 443: if($c) { $c = false; _r$224 = _r$224.$blk(); } if (_r$224 && _r$224.$blk !== undefined) { break s; }
- return _r$224;
- /* } */ case 440:
- _r$225 = c[0].formatExpr("%e.%s.%s", new sliceType$5([e$9.X, new $String(strings.Join(fields, ".")), new $String(jsTag)])); /* */ $s = 444; case 444: if($c) { $c = false; _r$225 = _r$225.$blk(); } if (_r$225 && _r$225.$blk !== undefined) { break s; }
- _arg$128 = _r$225;
- _r$226 = sel$1.Type(); /* */ $s = 445; case 445: if($c) { $c = false; _r$226 = _r$226.$blk(); } if (_r$226 && _r$226.$blk !== undefined) { break s; }
- _arg$129 = _r$226;
- _r$227 = c[0].internalize(_arg$128, _arg$129); /* */ $s = 446; case 446: if($c) { $c = false; _r$227 = _r$227.$blk(); } if (_r$227 && _r$227.$blk !== undefined) { break s; }
- return _r$227;
- /* } */ case 437:
- _r$228 = c[0].formatExpr("%e.%s", new sliceType$5([e$9.X, new $String(strings.Join(fields, "."))])); /* */ $s = 447; case 447: if($c) { $c = false; _r$228 = _r$228.$blk(); } if (_r$228 && _r$228.$blk !== undefined) { break s; }
- return _r$228;
- $s = 433; continue;
- /* } else if (_ref$21 === 1) { */ case 431:
- _r$229 = c[0].makeReceiver(e$9.X, sel$1); /* */ $s = 448; case 448: if($c) { $c = false; _r$229 = _r$229.$blk(); } if (_r$229 && _r$229.$blk !== undefined) { break s; }
- recv$1 = _r$229;
- _r$230 = c[0].formatExpr("$methodVal(%s, \"%s\")", new sliceType$5([recv$1, new $String($assertType(sel$1.Obj(), ptrType$32).object.Name())])); /* */ $s = 449; case 449: if($c) { $c = false; _r$230 = _r$230.$blk(); } if (_r$230 && _r$230.$blk !== undefined) { break s; }
- return _r$230;
- $s = 433; continue;
- /* } else if (_ref$21 === 2) { */ case 432:
- _r$231 = sel$1.Obj().Exported(); /* */ $s = 452; case 452: if($c) { $c = false; _r$231 = _r$231.$blk(); } if (_r$231 && _r$231.$blk !== undefined) { break s; }
- /* */ if (!_r$231) { $s = 450; continue; }
- /* */ $s = 451; continue;
- /* if (!_r$231) { */ case 450:
- _key$2 = sel$1.Obj(); (c[0].p.dependencies || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key$2)] = { k: _key$2, v: true };
- /* } */ case 451:
- _r$232 = c[0].typeName(sel$1.Recv()); /* */ $s = 453; case 453: if($c) { $c = false; _r$232 = _r$232.$blk(); } if (_r$232 && _r$232.$blk !== undefined) { break s; }
- _arg$130 = new $String(_r$232);
- _arg$131 = new $String($assertType(sel$1.Obj(), ptrType$32).object.Name());
- _r$233 = c[0].formatExpr("$methodExpr(%s.prototype.%s)", new sliceType$5([_arg$130, _arg$131])); /* */ $s = 454; case 454: if($c) { $c = false; _r$233 = _r$233.$blk(); } if (_r$233 && _r$233.$blk !== undefined) { break s; }
- return _r$233;
- /* } */ case 433:
- $panic(new $String(""));
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$13, true)[1]) { */ case 59:
- e$10 = _ref$2.$val;
- plainFun = astutil.RemoveParens(e$10.Fun);
- /* */ if (astutil.IsTypeExpr(plainFun, c[0].p.Info.Info)) { $s = 455; continue; }
- /* */ $s = 456; continue;
- /* if (astutil.IsTypeExpr(plainFun, c[0].p.Info.Info)) { */ case 455:
- _r$234 = c[0].translateConversion((x$10 = e$10.Args, (0 >= x$10.$length ? $throwRuntimeError("index out of range") : x$10.$array[x$10.$offset + 0])), (_entry$28 = c[0].p.Info.Info.Types[ast.Expr.keyFor(plainFun)], _entry$28 !== undefined ? _entry$28.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 457; case 457: if($c) { $c = false; _r$234 = _r$234.$blk(); } if (_r$234 && _r$234.$blk !== undefined) { break s; }
- _arg$132 = _r$234;
- _r$235 = c[0].formatExpr("%s", new sliceType$5([_arg$132])); /* */ $s = 458; case 458: if($c) { $c = false; _r$235 = _r$235.$blk(); } if (_r$235 && _r$235.$blk !== undefined) { break s; }
- return _r$235;
- /* } */ case 456:
- _r$236 = (_entry$29 = c[0].p.Info.Info.Types[ast.Expr.keyFor(plainFun)], _entry$29 !== undefined ? _entry$29.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 459; case 459: if($c) { $c = false; _r$236 = _r$236.$blk(); } if (_r$236 && _r$236.$blk !== undefined) { break s; }
- sig = $assertType(_r$236, ptrType$24);
- _ref$22 = plainFun;
- /* */ if ($assertType(_ref$22, ptrType$5, true)[1]) { $s = 460; continue; }
- /* */ if ($assertType(_ref$22, ptrType$4, true)[1]) { $s = 461; continue; }
- /* */ $s = 462; continue;
- /* if ($assertType(_ref$22, ptrType$5, true)[1]) { */ case 460:
- f$1 = _ref$22.$val;
- obj$4 = (_entry$30 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(f$1)], _entry$30 !== undefined ? _entry$30.v : $ifaceNil);
- _tuple$23 = $assertType(obj$4, ptrType$33, true); o = _tuple$23[0]; ok$11 = _tuple$23[1];
- /* */ if (ok$11) { $s = 464; continue; }
- /* */ $s = 465; continue;
- /* if (ok$11) { */ case 464:
- _r$237 = c[0].translateBuiltin(o.object.Name(), e$10.Args, new token.Pos(e$10.Ellipsis).IsValid(), exprType); /* */ $s = 466; case 466: if($c) { $c = false; _r$237 = _r$237.$blk(); } if (_r$237 && _r$237.$blk !== undefined) { break s; }
- return _r$237;
- /* } */ case 465:
- _r$238 = obj$4.Pkg(); /* */ $s = 470; case 470: if($c) { $c = false; _r$238 = _r$238.$blk(); } if (_r$238 && _r$238.$blk !== undefined) { break s; }
- _r$239 = typesutil.IsJsPackage(_r$238); /* */ $s = 471; case 471: if($c) { $c = false; _r$239 = _r$239.$blk(); } if (_r$239 && _r$239.$blk !== undefined) { break s; }
- if (!(_r$239)) { _v$2 = false; $s = 469; continue s; }
- _r$240 = obj$4.Name(); /* */ $s = 472; case 472: if($c) { $c = false; _r$240 = _r$240.$blk(); } if (_r$240 && _r$240.$blk !== undefined) { break s; }
- _v$2 = _r$240 === "InternalObject"; case 469:
- /* */ if (_v$2) { $s = 467; continue; }
- /* */ $s = 468; continue;
- /* if (_v$2) { */ case 467:
- _r$241 = c[0].translateExpr((x$11 = e$10.Args, (0 >= x$11.$length ? $throwRuntimeError("index out of range") : x$11.$array[x$11.$offset + 0]))); /* */ $s = 473; case 473: if($c) { $c = false; _r$241 = _r$241.$blk(); } if (_r$241 && _r$241.$blk !== undefined) { break s; }
- return _r$241;
- /* } */ case 468:
- _arg$133 = e$10;
- _arg$134 = sig;
- _r$242 = c[0].translateExpr(f$1); /* */ $s = 474; case 474: if($c) { $c = false; _r$242 = _r$242.$blk(); } if (_r$242 && _r$242.$blk !== undefined) { break s; }
- _arg$135 = _r$242;
- _r$243 = c[0].translateCall(_arg$133, _arg$134, _arg$135); /* */ $s = 475; case 475: if($c) { $c = false; _r$243 = _r$243.$blk(); } if (_r$243 && _r$243.$blk !== undefined) { break s; }
- _arg$136 = new $String(_r$243);
- _r$244 = c[0].formatExpr("%s", new sliceType$5([_arg$136])); /* */ $s = 476; case 476: if($c) { $c = false; _r$244 = _r$244.$blk(); } if (_r$244 && _r$244.$blk !== undefined) { break s; }
- return _r$244;
- $s = 463; continue;
- /* } else if ($assertType(_ref$22, ptrType$4, true)[1]) { */ case 461:
- f$2 = _ref$22.$val;
- _tuple$24 = (_entry$31 = c[0].p.Info.Info.Selections[ptrType$4.keyFor(f$2)], _entry$31 !== undefined ? [_entry$31.v, true] : [ptrType$27.nil, false]); sel$2 = _tuple$24[0]; ok$12 = _tuple$24[1];
- /* */ if (!ok$12) { $s = 477; continue; }
- /* */ $s = 478; continue;
- /* if (!ok$12) { */ case 477:
- obj$5 = (_entry$32 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(f$2.Sel)], _entry$32 !== undefined ? _entry$32.v : $ifaceNil);
- _r$245 = obj$5.Pkg(); /* */ $s = 481; case 481: if($c) { $c = false; _r$245 = _r$245.$blk(); } if (_r$245 && _r$245.$blk !== undefined) { break s; }
- _r$246 = typesutil.IsJsPackage(_r$245); /* */ $s = 482; case 482: if($c) { $c = false; _r$246 = _r$246.$blk(); } if (_r$246 && _r$246.$blk !== undefined) { break s; }
- /* */ if (_r$246) { $s = 479; continue; }
- /* */ $s = 480; continue;
- /* if (_r$246) { */ case 479:
- _r$247 = obj$5.Name(); /* */ $s = 483; case 483: if($c) { $c = false; _r$247 = _r$247.$blk(); } if (_r$247 && _r$247.$blk !== undefined) { break s; }
- _ref$23 = _r$247;
- /* */ if (_ref$23 === "Debugger") { $s = 484; continue; }
- /* */ if (_ref$23 === "InternalObject") { $s = 485; continue; }
- /* */ if (_ref$23 === "MakeFunc") { $s = 486; continue; }
- /* */ $s = 487; continue;
- /* if (_ref$23 === "Debugger") { */ case 484:
- _r$248 = c[0].formatExpr("debugger", new sliceType$5([])); /* */ $s = 488; case 488: if($c) { $c = false; _r$248 = _r$248.$blk(); } if (_r$248 && _r$248.$blk !== undefined) { break s; }
- return _r$248;
- $s = 487; continue;
- /* } else if (_ref$23 === "InternalObject") { */ case 485:
- _r$249 = c[0].translateExpr((x$12 = e$10.Args, (0 >= x$12.$length ? $throwRuntimeError("index out of range") : x$12.$array[x$12.$offset + 0]))); /* */ $s = 489; case 489: if($c) { $c = false; _r$249 = _r$249.$blk(); } if (_r$249 && _r$249.$blk !== undefined) { break s; }
- return _r$249;
- $s = 487; continue;
- /* } else if (_ref$23 === "MakeFunc") { */ case 486:
- _r$250 = c[0].formatExpr("(function() { return $externalize(%e(this, new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))), $emptyInterface); })", new sliceType$5([(x$13 = e$10.Args, (0 >= x$13.$length ? $throwRuntimeError("index out of range") : x$13.$array[x$13.$offset + 0]))])); /* */ $s = 490; case 490: if($c) { $c = false; _r$250 = _r$250.$blk(); } if (_r$250 && _r$250.$blk !== undefined) { break s; }
- return _r$250;
- /* } */ case 487:
- /* } */ case 480:
- _arg$137 = e$10;
- _arg$138 = sig;
- _r$251 = c[0].translateExpr(f$2); /* */ $s = 491; case 491: if($c) { $c = false; _r$251 = _r$251.$blk(); } if (_r$251 && _r$251.$blk !== undefined) { break s; }
- _arg$139 = _r$251;
- _r$252 = c[0].translateCall(_arg$137, _arg$138, _arg$139); /* */ $s = 492; case 492: if($c) { $c = false; _r$252 = _r$252.$blk(); } if (_r$252 && _r$252.$blk !== undefined) { break s; }
- _arg$140 = new $String(_r$252);
- _r$253 = c[0].formatExpr("%s", new sliceType$5([_arg$140])); /* */ $s = 493; case 493: if($c) { $c = false; _r$253 = _r$253.$blk(); } if (_r$253 && _r$253.$blk !== undefined) { break s; }
- return _r$253;
- /* } */ case 478:
- externalizeExpr[0] = (function(c, e, externalizeExpr, recv) { return function $b(e$11) {
- var $ptr, _entry$33, _r$254, _r$255, _r$256, _r$257, e$11, t$12, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry$33 = $f._entry$33; _r$254 = $f._r$254; _r$255 = $f._r$255; _r$256 = $f._r$256; _r$257 = $f._r$257; e$11 = $f.e$11; t$12 = $f.t$12; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t$12 = (_entry$33 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$11)], _entry$33 !== undefined ? _entry$33.v : new types.TypeAndValue.ptr()).Type;
- _r$254 = types.Identical(t$12, types.Typ[25]); /* */ $s = 3; case 3: if($c) { $c = false; _r$254 = _r$254.$blk(); } if (_r$254 && _r$254.$blk !== undefined) { break s; }
- /* */ if (_r$254) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r$254) { */ case 1:
- return "null";
- /* } */ case 2:
- _r$255 = c[0].translateExpr(e$11); /* */ $s = 4; case 4: if($c) { $c = false; _r$255 = _r$255.$blk(); } if (_r$255 && _r$255.$blk !== undefined) { break s; }
- _r$256 = _r$255.String(); /* */ $s = 5; case 5: if($c) { $c = false; _r$256 = _r$256.$blk(); } if (_r$256 && _r$256.$blk !== undefined) { break s; }
- _r$257 = c[0].externalize(_r$256, t$12); /* */ $s = 6; case 6: if($c) { $c = false; _r$257 = _r$257.$blk(); } if (_r$257 && _r$257.$blk !== undefined) { break s; }
- return _r$257;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry$33 = _entry$33; $f._r$254 = _r$254; $f._r$255 = _r$255; $f._r$256 = _r$256; $f._r$257 = _r$257; $f.e$11 = e$11; $f.t$12 = t$12; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, e, externalizeExpr, recv);
- externalizeArgs = (function(c, e, externalizeExpr, recv) { return function $b(args) {
- var $ptr, _i$6, _r$254, _ref$24, arg, args, i$3, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i$6 = $f._i$6; _r$254 = $f._r$254; _ref$24 = $f._ref$24; arg = $f.arg; args = $f.args; i$3 = $f.i$3; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- s = $makeSlice(sliceType, args.$length);
- _ref$24 = args;
- _i$6 = 0;
- /* while (true) { */ case 1:
- /* if (!(_i$6 < _ref$24.$length)) { break; } */ if(!(_i$6 < _ref$24.$length)) { $s = 2; continue; }
- i$3 = _i$6;
- arg = ((_i$6 < 0 || _i$6 >= _ref$24.$length) ? $throwRuntimeError("index out of range") : _ref$24.$array[_ref$24.$offset + _i$6]);
- _r$254 = externalizeExpr[0](arg); /* */ $s = 3; case 3: if($c) { $c = false; _r$254 = _r$254.$blk(); } if (_r$254 && _r$254.$blk !== undefined) { break s; }
- ((i$3 < 0 || i$3 >= s.$length) ? $throwRuntimeError("index out of range") : s.$array[s.$offset + i$3] = _r$254);
- _i$6++;
- /* } */ $s = 1; continue; case 2:
- return strings.Join(s, ", ");
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._i$6 = _i$6; $f._r$254 = _r$254; $f._ref$24 = _ref$24; $f.arg = arg; $f.args = args; $f.i$3 = i$3; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, e, externalizeExpr, recv);
- _ref$24 = sel$2.Kind();
- /* */ if (_ref$24 === 1) { $s = 494; continue; }
- /* */ if (_ref$24 === 0) { $s = 495; continue; }
- /* */ $s = 496; continue;
- /* if (_ref$24 === 1) { */ case 494:
- _r$254 = c[0].makeReceiver(f$2.X, sel$2); /* */ $s = 498; case 498: if($c) { $c = false; _r$254 = _r$254.$blk(); } if (_r$254 && _r$254.$blk !== undefined) { break s; }
- recv[0] = _r$254;
- _r$255 = sel$2.Obj().Pkg(); /* */ $s = 501; case 501: if($c) { $c = false; _r$255 = _r$255.$blk(); } if (_r$255 && _r$255.$blk !== undefined) { break s; }
- _r$256 = typesutil.IsJsPackage(_r$255); /* */ $s = 502; case 502: if($c) { $c = false; _r$256 = _r$256.$blk(); } if (_r$256 && _r$256.$blk !== undefined) { break s; }
- /* */ if (_r$256) { $s = 499; continue; }
- /* */ $s = 500; continue;
- /* if (_r$256) { */ case 499:
- globalRef = (function(c, e, externalizeExpr, recv) { return function(id) {
- var $ptr, id;
- if (recv[0].String() === "$global" && (id.charCodeAt(0) === 36)) {
- return id;
- }
- return recv[0].String() + "." + id;
- }; })(c, e, externalizeExpr, recv);
- _r$257 = sel$2.Obj().Name(); /* */ $s = 503; case 503: if($c) { $c = false; _r$257 = _r$257.$blk(); } if (_r$257 && _r$257.$blk !== undefined) { break s; }
- _ref$25 = _r$257;
- /* */ if (_ref$25 === "Get") { $s = 504; continue; }
- /* */ if (_ref$25 === "Set") { $s = 505; continue; }
- /* */ if (_ref$25 === "Delete") { $s = 506; continue; }
- /* */ if (_ref$25 === "Length") { $s = 507; continue; }
- /* */ if (_ref$25 === "Index") { $s = 508; continue; }
- /* */ if (_ref$25 === "SetIndex") { $s = 509; continue; }
- /* */ if (_ref$25 === "Call") { $s = 510; continue; }
- /* */ if (_ref$25 === "Invoke") { $s = 511; continue; }
- /* */ if (_ref$25 === "New") { $s = 512; continue; }
- /* */ if (_ref$25 === "Bool") { $s = 513; continue; }
- /* */ if (_ref$25 === "String") { $s = 514; continue; }
- /* */ if (_ref$25 === "Int") { $s = 515; continue; }
- /* */ if (_ref$25 === "Int64") { $s = 516; continue; }
- /* */ if (_ref$25 === "Uint64") { $s = 517; continue; }
- /* */ if (_ref$25 === "Float") { $s = 518; continue; }
- /* */ if (_ref$25 === "Interface") { $s = 519; continue; }
- /* */ if (_ref$25 === "Unsafe") { $s = 520; continue; }
- /* */ $s = 521; continue;
- /* if (_ref$25 === "Get") { */ case 504:
- _r$258 = c[0].identifierConstant((x$14 = e$10.Args, (0 >= x$14.$length ? $throwRuntimeError("index out of range") : x$14.$array[x$14.$offset + 0]))); /* */ $s = 523; case 523: if($c) { $c = false; _r$258 = _r$258.$blk(); } if (_r$258 && _r$258.$blk !== undefined) { break s; }
- _tuple$25 = _r$258; id = _tuple$25[0]; ok$13 = _tuple$25[1];
- /* */ if (ok$13) { $s = 524; continue; }
- /* */ $s = 525; continue;
- /* if (ok$13) { */ case 524:
- _r$259 = globalRef(id); /* */ $s = 526; case 526: if($c) { $c = false; _r$259 = _r$259.$blk(); } if (_r$259 && _r$259.$blk !== undefined) { break s; }
- _arg$141 = new $String(_r$259);
- _r$260 = c[0].formatExpr("%s", new sliceType$5([_arg$141])); /* */ $s = 527; case 527: if($c) { $c = false; _r$260 = _r$260.$blk(); } if (_r$260 && _r$260.$blk !== undefined) { break s; }
- return _r$260;
- /* } */ case 525:
- _r$261 = c[0].formatExpr("%s[$externalize(%e, $String)]", new sliceType$5([recv[0], (x$15 = e$10.Args, (0 >= x$15.$length ? $throwRuntimeError("index out of range") : x$15.$array[x$15.$offset + 0]))])); /* */ $s = 528; case 528: if($c) { $c = false; _r$261 = _r$261.$blk(); } if (_r$261 && _r$261.$blk !== undefined) { break s; }
- return _r$261;
- $s = 522; continue;
- /* } else if (_ref$25 === "Set") { */ case 505:
- _r$262 = c[0].identifierConstant((x$16 = e$10.Args, (0 >= x$16.$length ? $throwRuntimeError("index out of range") : x$16.$array[x$16.$offset + 0]))); /* */ $s = 529; case 529: if($c) { $c = false; _r$262 = _r$262.$blk(); } if (_r$262 && _r$262.$blk !== undefined) { break s; }
- _tuple$26 = _r$262; id$1 = _tuple$26[0]; ok$14 = _tuple$26[1];
- /* */ if (ok$14) { $s = 530; continue; }
- /* */ $s = 531; continue;
- /* if (ok$14) { */ case 530:
- _r$263 = globalRef(id$1); /* */ $s = 532; case 532: if($c) { $c = false; _r$263 = _r$263.$blk(); } if (_r$263 && _r$263.$blk !== undefined) { break s; }
- _arg$142 = new $String(_r$263);
- _r$264 = externalizeExpr[0]((x$17 = e$10.Args, (1 >= x$17.$length ? $throwRuntimeError("index out of range") : x$17.$array[x$17.$offset + 1]))); /* */ $s = 533; case 533: if($c) { $c = false; _r$264 = _r$264.$blk(); } if (_r$264 && _r$264.$blk !== undefined) { break s; }
- _arg$143 = new $String(_r$264);
- _r$265 = c[0].formatExpr("%s = %s", new sliceType$5([_arg$142, _arg$143])); /* */ $s = 534; case 534: if($c) { $c = false; _r$265 = _r$265.$blk(); } if (_r$265 && _r$265.$blk !== undefined) { break s; }
- return _r$265;
- /* } */ case 531:
- _arg$144 = recv[0];
- _arg$145 = (x$18 = e$10.Args, (0 >= x$18.$length ? $throwRuntimeError("index out of range") : x$18.$array[x$18.$offset + 0]));
- _r$266 = externalizeExpr[0]((x$19 = e$10.Args, (1 >= x$19.$length ? $throwRuntimeError("index out of range") : x$19.$array[x$19.$offset + 1]))); /* */ $s = 535; case 535: if($c) { $c = false; _r$266 = _r$266.$blk(); } if (_r$266 && _r$266.$blk !== undefined) { break s; }
- _arg$146 = new $String(_r$266);
- _r$267 = c[0].formatExpr("%s[$externalize(%e, $String)] = %s", new sliceType$5([_arg$144, _arg$145, _arg$146])); /* */ $s = 536; case 536: if($c) { $c = false; _r$267 = _r$267.$blk(); } if (_r$267 && _r$267.$blk !== undefined) { break s; }
- return _r$267;
- $s = 522; continue;
- /* } else if (_ref$25 === "Delete") { */ case 506:
- _r$268 = c[0].formatExpr("delete %s[$externalize(%e, $String)]", new sliceType$5([recv[0], (x$20 = e$10.Args, (0 >= x$20.$length ? $throwRuntimeError("index out of range") : x$20.$array[x$20.$offset + 0]))])); /* */ $s = 537; case 537: if($c) { $c = false; _r$268 = _r$268.$blk(); } if (_r$268 && _r$268.$blk !== undefined) { break s; }
- return _r$268;
- $s = 522; continue;
- /* } else if (_ref$25 === "Length") { */ case 507:
- _r$269 = c[0].formatExpr("$parseInt(%s.length)", new sliceType$5([recv[0]])); /* */ $s = 538; case 538: if($c) { $c = false; _r$269 = _r$269.$blk(); } if (_r$269 && _r$269.$blk !== undefined) { break s; }
- return _r$269;
- $s = 522; continue;
- /* } else if (_ref$25 === "Index") { */ case 508:
- _r$270 = c[0].formatExpr("%s[%e]", new sliceType$5([recv[0], (x$21 = e$10.Args, (0 >= x$21.$length ? $throwRuntimeError("index out of range") : x$21.$array[x$21.$offset + 0]))])); /* */ $s = 539; case 539: if($c) { $c = false; _r$270 = _r$270.$blk(); } if (_r$270 && _r$270.$blk !== undefined) { break s; }
- return _r$270;
- $s = 522; continue;
- /* } else if (_ref$25 === "SetIndex") { */ case 509:
- _arg$147 = recv[0];
- _arg$148 = (x$22 = e$10.Args, (0 >= x$22.$length ? $throwRuntimeError("index out of range") : x$22.$array[x$22.$offset + 0]));
- _r$271 = externalizeExpr[0]((x$23 = e$10.Args, (1 >= x$23.$length ? $throwRuntimeError("index out of range") : x$23.$array[x$23.$offset + 1]))); /* */ $s = 540; case 540: if($c) { $c = false; _r$271 = _r$271.$blk(); } if (_r$271 && _r$271.$blk !== undefined) { break s; }
- _arg$149 = new $String(_r$271);
- _r$272 = c[0].formatExpr("%s[%e] = %s", new sliceType$5([_arg$147, _arg$148, _arg$149])); /* */ $s = 541; case 541: if($c) { $c = false; _r$272 = _r$272.$blk(); } if (_r$272 && _r$272.$blk !== undefined) { break s; }
- return _r$272;
- $s = 522; continue;
- /* } else if (_ref$25 === "Call") { */ case 510:
- _r$273 = c[0].identifierConstant((x$24 = e$10.Args, (0 >= x$24.$length ? $throwRuntimeError("index out of range") : x$24.$array[x$24.$offset + 0]))); /* */ $s = 542; case 542: if($c) { $c = false; _r$273 = _r$273.$blk(); } if (_r$273 && _r$273.$blk !== undefined) { break s; }
- _tuple$27 = _r$273; id$2 = _tuple$27[0]; ok$15 = _tuple$27[1];
- /* */ if (ok$15) { $s = 543; continue; }
- /* */ $s = 544; continue;
- /* if (ok$15) { */ case 543:
- /* */ if (new token.Pos(e$10.Ellipsis).IsValid()) { $s = 545; continue; }
- /* */ $s = 546; continue;
- /* if (new token.Pos(e$10.Ellipsis).IsValid()) { */ case 545:
- _r$274 = c[0].newVariable("obj"); /* */ $s = 547; case 547: if($c) { $c = false; _r$274 = _r$274.$blk(); } if (_r$274 && _r$274.$blk !== undefined) { break s; }
- objVar = _r$274;
- _arg$150 = new $String(objVar);
- _arg$151 = recv[0];
- _arg$152 = new $String(objVar);
- _arg$153 = new $String(id$2);
- _arg$154 = new $String(objVar);
- _r$275 = externalizeExpr[0]((x$25 = e$10.Args, (1 >= x$25.$length ? $throwRuntimeError("index out of range") : x$25.$array[x$25.$offset + 1]))); /* */ $s = 548; case 548: if($c) { $c = false; _r$275 = _r$275.$blk(); } if (_r$275 && _r$275.$blk !== undefined) { break s; }
- _arg$155 = new $String(_r$275);
- _r$276 = c[0].formatExpr("(%s = %s, %s.%s.apply(%s, %s))", new sliceType$5([_arg$150, _arg$151, _arg$152, _arg$153, _arg$154, _arg$155])); /* */ $s = 549; case 549: if($c) { $c = false; _r$276 = _r$276.$blk(); } if (_r$276 && _r$276.$blk !== undefined) { break s; }
- return _r$276;
- /* } */ case 546:
- _r$277 = globalRef(id$2); /* */ $s = 550; case 550: if($c) { $c = false; _r$277 = _r$277.$blk(); } if (_r$277 && _r$277.$blk !== undefined) { break s; }
- _arg$156 = new $String(_r$277);
- _r$278 = externalizeArgs($subslice(e$10.Args, 1)); /* */ $s = 551; case 551: if($c) { $c = false; _r$278 = _r$278.$blk(); } if (_r$278 && _r$278.$blk !== undefined) { break s; }
- _arg$157 = new $String(_r$278);
- _r$279 = c[0].formatExpr("%s(%s)", new sliceType$5([_arg$156, _arg$157])); /* */ $s = 552; case 552: if($c) { $c = false; _r$279 = _r$279.$blk(); } if (_r$279 && _r$279.$blk !== undefined) { break s; }
- return _r$279;
- /* } */ case 544:
- /* */ if (new token.Pos(e$10.Ellipsis).IsValid()) { $s = 553; continue; }
- /* */ $s = 554; continue;
- /* if (new token.Pos(e$10.Ellipsis).IsValid()) { */ case 553:
- _r$280 = c[0].newVariable("obj"); /* */ $s = 555; case 555: if($c) { $c = false; _r$280 = _r$280.$blk(); } if (_r$280 && _r$280.$blk !== undefined) { break s; }
- objVar$1 = _r$280;
- _arg$158 = new $String(objVar$1);
- _arg$159 = recv[0];
- _arg$160 = new $String(objVar$1);
- _arg$161 = (x$26 = e$10.Args, (0 >= x$26.$length ? $throwRuntimeError("index out of range") : x$26.$array[x$26.$offset + 0]));
- _arg$162 = new $String(objVar$1);
- _r$281 = externalizeExpr[0]((x$27 = e$10.Args, (1 >= x$27.$length ? $throwRuntimeError("index out of range") : x$27.$array[x$27.$offset + 1]))); /* */ $s = 556; case 556: if($c) { $c = false; _r$281 = _r$281.$blk(); } if (_r$281 && _r$281.$blk !== undefined) { break s; }
- _arg$163 = new $String(_r$281);
- _r$282 = c[0].formatExpr("(%s = %s, %s[$externalize(%e, $String)].apply(%s, %s))", new sliceType$5([_arg$158, _arg$159, _arg$160, _arg$161, _arg$162, _arg$163])); /* */ $s = 557; case 557: if($c) { $c = false; _r$282 = _r$282.$blk(); } if (_r$282 && _r$282.$blk !== undefined) { break s; }
- return _r$282;
- /* } */ case 554:
- _arg$164 = recv[0];
- _arg$165 = (x$28 = e$10.Args, (0 >= x$28.$length ? $throwRuntimeError("index out of range") : x$28.$array[x$28.$offset + 0]));
- _r$283 = externalizeArgs($subslice(e$10.Args, 1)); /* */ $s = 558; case 558: if($c) { $c = false; _r$283 = _r$283.$blk(); } if (_r$283 && _r$283.$blk !== undefined) { break s; }
- _arg$166 = new $String(_r$283);
- _r$284 = c[0].formatExpr("%s[$externalize(%e, $String)](%s)", new sliceType$5([_arg$164, _arg$165, _arg$166])); /* */ $s = 559; case 559: if($c) { $c = false; _r$284 = _r$284.$blk(); } if (_r$284 && _r$284.$blk !== undefined) { break s; }
- return _r$284;
- $s = 522; continue;
- /* } else if (_ref$25 === "Invoke") { */ case 511:
- /* */ if (new token.Pos(e$10.Ellipsis).IsValid()) { $s = 560; continue; }
- /* */ $s = 561; continue;
- /* if (new token.Pos(e$10.Ellipsis).IsValid()) { */ case 560:
- _arg$167 = recv[0];
- _r$285 = externalizeExpr[0]((x$29 = e$10.Args, (0 >= x$29.$length ? $throwRuntimeError("index out of range") : x$29.$array[x$29.$offset + 0]))); /* */ $s = 562; case 562: if($c) { $c = false; _r$285 = _r$285.$blk(); } if (_r$285 && _r$285.$blk !== undefined) { break s; }
- _arg$168 = new $String(_r$285);
- _r$286 = c[0].formatExpr("%s.apply(undefined, %s)", new sliceType$5([_arg$167, _arg$168])); /* */ $s = 563; case 563: if($c) { $c = false; _r$286 = _r$286.$blk(); } if (_r$286 && _r$286.$blk !== undefined) { break s; }
- return _r$286;
- /* } */ case 561:
- _arg$169 = recv[0];
- _r$287 = externalizeArgs(e$10.Args); /* */ $s = 564; case 564: if($c) { $c = false; _r$287 = _r$287.$blk(); } if (_r$287 && _r$287.$blk !== undefined) { break s; }
- _arg$170 = new $String(_r$287);
- _r$288 = c[0].formatExpr("%s(%s)", new sliceType$5([_arg$169, _arg$170])); /* */ $s = 565; case 565: if($c) { $c = false; _r$288 = _r$288.$blk(); } if (_r$288 && _r$288.$blk !== undefined) { break s; }
- return _r$288;
- $s = 522; continue;
- /* } else if (_ref$25 === "New") { */ case 512:
- /* */ if (new token.Pos(e$10.Ellipsis).IsValid()) { $s = 566; continue; }
- /* */ $s = 567; continue;
- /* if (new token.Pos(e$10.Ellipsis).IsValid()) { */ case 566:
- _arg$171 = recv[0];
- _r$289 = externalizeExpr[0]((x$30 = e$10.Args, (0 >= x$30.$length ? $throwRuntimeError("index out of range") : x$30.$array[x$30.$offset + 0]))); /* */ $s = 568; case 568: if($c) { $c = false; _r$289 = _r$289.$blk(); } if (_r$289 && _r$289.$blk !== undefined) { break s; }
- _arg$172 = new $String(_r$289);
- _r$290 = c[0].formatExpr("new ($global.Function.prototype.bind.apply(%s, [undefined].concat(%s)))", new sliceType$5([_arg$171, _arg$172])); /* */ $s = 569; case 569: if($c) { $c = false; _r$290 = _r$290.$blk(); } if (_r$290 && _r$290.$blk !== undefined) { break s; }
- return _r$290;
- /* } */ case 567:
- _arg$173 = recv[0];
- _r$291 = externalizeArgs(e$10.Args); /* */ $s = 570; case 570: if($c) { $c = false; _r$291 = _r$291.$blk(); } if (_r$291 && _r$291.$blk !== undefined) { break s; }
- _arg$174 = new $String(_r$291);
- _r$292 = c[0].formatExpr("new (%s)(%s)", new sliceType$5([_arg$173, _arg$174])); /* */ $s = 571; case 571: if($c) { $c = false; _r$292 = _r$292.$blk(); } if (_r$292 && _r$292.$blk !== undefined) { break s; }
- return _r$292;
- $s = 522; continue;
- /* } else if (_ref$25 === "Bool") { */ case 513:
- _r$293 = c[0].internalize(recv[0], types.Typ[1]); /* */ $s = 572; case 572: if($c) { $c = false; _r$293 = _r$293.$blk(); } if (_r$293 && _r$293.$blk !== undefined) { break s; }
- return _r$293;
- $s = 522; continue;
- /* } else if (_ref$25 === "String") { */ case 514:
- _r$294 = c[0].internalize(recv[0], types.Typ[17]); /* */ $s = 573; case 573: if($c) { $c = false; _r$294 = _r$294.$blk(); } if (_r$294 && _r$294.$blk !== undefined) { break s; }
- return _r$294;
- $s = 522; continue;
- /* } else if (_ref$25 === "Int") { */ case 515:
- _r$295 = c[0].internalize(recv[0], types.Typ[2]); /* */ $s = 574; case 574: if($c) { $c = false; _r$295 = _r$295.$blk(); } if (_r$295 && _r$295.$blk !== undefined) { break s; }
- return _r$295;
- $s = 522; continue;
- /* } else if (_ref$25 === "Int64") { */ case 516:
- _r$296 = c[0].internalize(recv[0], types.Typ[6]); /* */ $s = 575; case 575: if($c) { $c = false; _r$296 = _r$296.$blk(); } if (_r$296 && _r$296.$blk !== undefined) { break s; }
- return _r$296;
- $s = 522; continue;
- /* } else if (_ref$25 === "Uint64") { */ case 517:
- _r$297 = c[0].internalize(recv[0], types.Typ[11]); /* */ $s = 576; case 576: if($c) { $c = false; _r$297 = _r$297.$blk(); } if (_r$297 && _r$297.$blk !== undefined) { break s; }
- return _r$297;
- $s = 522; continue;
- /* } else if (_ref$25 === "Float") { */ case 518:
- _r$298 = c[0].internalize(recv[0], types.Typ[14]); /* */ $s = 577; case 577: if($c) { $c = false; _r$298 = _r$298.$blk(); } if (_r$298 && _r$298.$blk !== undefined) { break s; }
- return _r$298;
- $s = 522; continue;
- /* } else if (_ref$25 === "Interface") { */ case 519:
- _arg$175 = recv[0];
- _r$299 = types.NewInterface(sliceType$9.nil, sliceType$10.nil); /* */ $s = 578; case 578: if($c) { $c = false; _r$299 = _r$299.$blk(); } if (_r$299 && _r$299.$blk !== undefined) { break s; }
- _arg$176 = _r$299;
- _r$300 = c[0].internalize(_arg$175, _arg$176); /* */ $s = 579; case 579: if($c) { $c = false; _r$300 = _r$300.$blk(); } if (_r$300 && _r$300.$blk !== undefined) { break s; }
- return _r$300;
- $s = 522; continue;
- /* } else if (_ref$25 === "Unsafe") { */ case 520:
- return recv[0];
- $s = 522; continue;
- /* } else { */ case 521:
- _r$301 = sel$2.Obj().Name(); /* */ $s = 580; case 580: if($c) { $c = false; _r$301 = _r$301.$blk(); } if (_r$301 && _r$301.$blk !== undefined) { break s; }
- $panic(new $String("Invalid js package object: " + _r$301));
- /* } */ case 522:
- /* } */ case 500:
- _r$302 = sel$2.Obj().Name(); /* */ $s = 581; case 581: if($c) { $c = false; _r$302 = _r$302.$blk(); } if (_r$302 && _r$302.$blk !== undefined) { break s; }
- methodName = _r$302;
- if ((_entry$33 = reservedKeywords[$String.keyFor(methodName)], _entry$33 !== undefined ? _entry$33.v : false)) {
- methodName = methodName + ("$");
- }
- _arg$177 = e$10;
- _arg$178 = sig;
- _r$303 = c[0].formatExpr("%s.%s", new sliceType$5([recv[0], new $String(methodName)])); /* */ $s = 582; case 582: if($c) { $c = false; _r$303 = _r$303.$blk(); } if (_r$303 && _r$303.$blk !== undefined) { break s; }
- _arg$179 = _r$303;
- _r$304 = c[0].translateCall(_arg$177, _arg$178, _arg$179); /* */ $s = 583; case 583: if($c) { $c = false; _r$304 = _r$304.$blk(); } if (_r$304 && _r$304.$blk !== undefined) { break s; }
- _arg$180 = new $String(_r$304);
- _r$305 = c[0].formatExpr("%s", new sliceType$5([_arg$180])); /* */ $s = 584; case 584: if($c) { $c = false; _r$305 = _r$305.$blk(); } if (_r$305 && _r$305.$blk !== undefined) { break s; }
- return _r$305;
- $s = 497; continue;
- /* } else if (_ref$24 === 0) { */ case 495:
- _arg$181 = sel$2;
- _r$306 = f$2.Pos(); /* */ $s = 585; case 585: if($c) { $c = false; _r$306 = _r$306.$blk(); } if (_r$306 && _r$306.$blk !== undefined) { break s; }
- _arg$182 = _r$306;
- _r$307 = c[0].translateSelection(_arg$181, _arg$182); /* */ $s = 586; case 586: if($c) { $c = false; _r$307 = _r$307.$blk(); } if (_r$307 && _r$307.$blk !== undefined) { break s; }
- _tuple$28 = _r$307; fields$1 = _tuple$28[0]; jsTag$1 = _tuple$28[1];
- /* */ if (!(jsTag$1 === "")) { $s = 587; continue; }
- /* */ $s = 588; continue;
- /* if (!(jsTag$1 === "")) { */ case 587:
- _arg$183 = f$2.X;
- _arg$184 = new $String(strings.Join(fields$1, "."));
- _arg$185 = new $String(jsTag$1);
- _r$308 = externalizeArgs(e$10.Args); /* */ $s = 589; case 589: if($c) { $c = false; _r$308 = _r$308.$blk(); } if (_r$308 && _r$308.$blk !== undefined) { break s; }
- _arg$186 = new $String(_r$308);
- _r$309 = c[0].formatExpr("%e.%s.%s(%s)", new sliceType$5([_arg$183, _arg$184, _arg$185, _arg$186])); /* */ $s = 590; case 590: if($c) { $c = false; _r$309 = _r$309.$blk(); } if (_r$309 && _r$309.$blk !== undefined) { break s; }
- call$1 = _r$309;
- _ref$26 = sig.Results().Len();
- /* */ if (_ref$26 === 0) { $s = 591; continue; }
- /* */ if (_ref$26 === 1) { $s = 592; continue; }
- /* */ $s = 593; continue;
- /* if (_ref$26 === 0) { */ case 591:
- return call$1;
- $s = 594; continue;
- /* } else if (_ref$26 === 1) { */ case 592:
- _r$310 = c[0].internalize(call$1, sig.Results().At(0).object.Type()); /* */ $s = 595; case 595: if($c) { $c = false; _r$310 = _r$310.$blk(); } if (_r$310 && _r$310.$blk !== undefined) { break s; }
- return _r$310;
- $s = 594; continue;
- /* } else { */ case 593:
- _r$311 = f$2.Pos(); /* */ $s = 596; case 596: if($c) { $c = false; _r$311 = _r$311.$blk(); } if (_r$311 && _r$311.$blk !== undefined) { break s; }
- c[0].p.errList = $append(c[0].p.errList, (x$31 = new types.Error.ptr(c[0].p.fileSet, _r$311, "field with js tag can not have func type with multiple results", false), new x$31.constructor.elem(x$31)));
- /* } */ case 594:
- /* } */ case 588:
- _arg$187 = e$10;
- _arg$188 = sig;
- _r$312 = c[0].formatExpr("%e.%s", new sliceType$5([f$2.X, new $String(strings.Join(fields$1, "."))])); /* */ $s = 597; case 597: if($c) { $c = false; _r$312 = _r$312.$blk(); } if (_r$312 && _r$312.$blk !== undefined) { break s; }
- _arg$189 = _r$312;
- _r$313 = c[0].translateCall(_arg$187, _arg$188, _arg$189); /* */ $s = 598; case 598: if($c) { $c = false; _r$313 = _r$313.$blk(); } if (_r$313 && _r$313.$blk !== undefined) { break s; }
- _arg$190 = new $String(_r$313);
- _r$314 = c[0].formatExpr("%s", new sliceType$5([_arg$190])); /* */ $s = 599; case 599: if($c) { $c = false; _r$314 = _r$314.$blk(); } if (_r$314 && _r$314.$blk !== undefined) { break s; }
- return _r$314;
- $s = 497; continue;
- /* } else { */ case 496:
- $panic(new $String(""));
- /* } */ case 497:
- $s = 463; continue;
- /* } else { */ case 462:
- f$3 = _ref$22;
- _arg$191 = e$10;
- _arg$192 = sig;
- _r$315 = c[0].translateExpr(plainFun); /* */ $s = 600; case 600: if($c) { $c = false; _r$315 = _r$315.$blk(); } if (_r$315 && _r$315.$blk !== undefined) { break s; }
- _arg$193 = _r$315;
- _r$316 = c[0].translateCall(_arg$191, _arg$192, _arg$193); /* */ $s = 601; case 601: if($c) { $c = false; _r$316 = _r$316.$blk(); } if (_r$316 && _r$316.$blk !== undefined) { break s; }
- _arg$194 = new $String(_r$316);
- _r$317 = c[0].formatExpr("%s", new sliceType$5([_arg$194])); /* */ $s = 602; case 602: if($c) { $c = false; _r$317 = _r$317.$blk(); } if (_r$317 && _r$317.$blk !== undefined) { break s; }
- return _r$317;
- /* } */ case 463:
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$14, true)[1]) { */ case 60:
- e$11 = _ref$2.$val;
- /* */ if (typesutil.IsJsObject((_entry$34 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$11.X)], _entry$34 !== undefined ? _entry$34.v : new types.TypeAndValue.ptr()).Type)) { $s = 603; continue; }
- /* */ $s = 604; continue;
- /* if (typesutil.IsJsObject((_entry$34 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$11.X)], _entry$34 !== undefined ? _entry$34.v : new types.TypeAndValue.ptr()).Type)) { */ case 603:
- _r$318 = c[0].formatExpr("new $jsObjectPtr(%e)", new sliceType$5([e$11.X])); /* */ $s = 605; case 605: if($c) { $c = false; _r$318 = _r$318.$blk(); } if (_r$318 && _r$318.$blk !== undefined) { break s; }
- return _r$318;
- /* } */ case 604:
- _tuple$29 = $assertType(e$11.X, ptrType$13, true); c1 = _tuple$29[0]; isCall = _tuple$29[1];
- /* */ if (isCall && (c1.Args.$length === 1)) { $s = 606; continue; }
- /* */ $s = 607; continue;
- /* if (isCall && (c1.Args.$length === 1)) { */ case 606:
- _tuple$30 = $assertType((x$32 = c1.Args, (0 >= x$32.$length ? $throwRuntimeError("index out of range") : x$32.$array[x$32.$offset + 0])), ptrType$13, true); c2 = _tuple$30[0]; isCall$1 = _tuple$30[1];
- if (!(isCall$1 && (c2.Args.$length === 1))) { _v$3 = false; $s = 610; continue s; }
- _r$319 = types.Identical((_entry$35 = c[0].p.Info.Info.Types[ast.Expr.keyFor(c2.Fun)], _entry$35 !== undefined ? _entry$35.v : new types.TypeAndValue.ptr()).Type, types.Typ[18]); /* */ $s = 611; case 611: if($c) { $c = false; _r$319 = _r$319.$blk(); } if (_r$319 && _r$319.$blk !== undefined) { break s; }
- _v$3 = _r$319; case 610:
- /* */ if (_v$3) { $s = 608; continue; }
- /* */ $s = 609; continue;
- /* if (_v$3) { */ case 608:
- _tuple$31 = $assertType((x$33 = c2.Args, (0 >= x$33.$length ? $throwRuntimeError("index out of range") : x$33.$array[x$33.$offset + 0])), ptrType$8, true); unary = _tuple$31[0]; isUnary = _tuple$31[1];
- /* */ if (isUnary && (unary.Op === 17)) { $s = 612; continue; }
- /* */ $s = 613; continue;
- /* if (isUnary && (unary.Op === 17)) { */ case 612:
- _r$320 = c[0].translateExpr(unary.X); /* */ $s = 614; case 614: if($c) { $c = false; _r$320 = _r$320.$blk(); } if (_r$320 && _r$320.$blk !== undefined) { break s; }
- return _r$320;
- /* } */ case 613:
- /* } */ case 609:
- /* } */ case 607:
- _r$321 = exprType.Underlying(); /* */ $s = 615; case 615: if($c) { $c = false; _r$321 = _r$321.$blk(); } if (_r$321 && _r$321.$blk !== undefined) { break s; }
- _ref$27 = _r$321;
- /* */ if ($assertType(_ref$27, ptrType$23, true)[1] || $assertType(_ref$27, ptrType$20, true)[1]) { $s = 616; continue; }
- /* */ $s = 617; continue;
- /* if ($assertType(_ref$27, ptrType$23, true)[1] || $assertType(_ref$27, ptrType$20, true)[1]) { */ case 616:
- _r$322 = c[0].translateExpr(e$11.X); /* */ $s = 618; case 618: if($c) { $c = false; _r$322 = _r$322.$blk(); } if (_r$322 && _r$322.$blk !== undefined) { break s; }
- return _r$322;
- /* } */ case 617:
- _r$323 = c[0].formatExpr("%e.$get()", new sliceType$5([e$11.X])); /* */ $s = 619; case 619: if($c) { $c = false; _r$323 = _r$323.$blk(); } if (_r$323 && _r$323.$blk !== undefined) { break s; }
- return _r$323;
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$15, true)[1]) { */ case 61:
- e$12 = _ref$2.$val;
- /* */ if ($interfaceIsEqual(e$12.Type, $ifaceNil)) { $s = 620; continue; }
- /* */ $s = 621; continue;
- /* if ($interfaceIsEqual(e$12.Type, $ifaceNil)) { */ case 620:
- _r$324 = c[0].translateExpr(e$12.X); /* */ $s = 622; case 622: if($c) { $c = false; _r$324 = _r$324.$blk(); } if (_r$324 && _r$324.$blk !== undefined) { break s; }
- return _r$324;
- /* } */ case 621:
- t$12 = (_entry$36 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$12.Type)], _entry$36 !== undefined ? _entry$36.v : new types.TypeAndValue.ptr()).Type;
- _tuple$32 = $assertType(exprType, ptrType$29, true); isTuple$2 = _tuple$32[1];
- /* */ if (isTuple$2) { $s = 623; continue; }
- /* */ $s = 624; continue;
- /* if (isTuple$2) { */ case 623:
- _arg$195 = e$12.X;
- _r$325 = c[0].typeName(t$12); /* */ $s = 625; case 625: if($c) { $c = false; _r$325 = _r$325.$blk(); } if (_r$325 && _r$325.$blk !== undefined) { break s; }
- _arg$196 = new $String(_r$325);
- _r$326 = c[0].formatExpr("$assertType(%e, %s, true)", new sliceType$5([_arg$195, _arg$196])); /* */ $s = 626; case 626: if($c) { $c = false; _r$326 = _r$326.$blk(); } if (_r$326 && _r$326.$blk !== undefined) { break s; }
- return _r$326;
- /* } */ case 624:
- _arg$197 = e$12.X;
- _r$327 = c[0].typeName(t$12); /* */ $s = 627; case 627: if($c) { $c = false; _r$327 = _r$327.$blk(); } if (_r$327 && _r$327.$blk !== undefined) { break s; }
- _arg$198 = new $String(_r$327);
- _r$328 = c[0].formatExpr("$assertType(%e, %s)", new sliceType$5([_arg$197, _arg$198])); /* */ $s = 628; case 628: if($c) { $c = false; _r$328 = _r$328.$blk(); } if (_r$328 && _r$328.$blk !== undefined) { break s; }
- return _r$328;
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$5, true)[1]) { */ case 62:
- e$13 = _ref$2.$val;
- if (e$13.Name === "_") {
- $panic(new $String("Tried to translate underscore identifier."));
- }
- _ref$28 = obj;
- /* */ if ($assertType(_ref$28, ptrType$26, true)[1] || $assertType(_ref$28, ptrType$35, true)[1]) { $s = 629; continue; }
- /* */ if ($assertType(_ref$28, ptrType$32, true)[1]) { $s = 630; continue; }
- /* */ if ($assertType(_ref$28, ptrType$36, true)[1]) { $s = 631; continue; }
- /* */ if ($assertType(_ref$28, ptrType$37, true)[1]) { $s = 632; continue; }
- /* */ $s = 633; continue;
- /* if ($assertType(_ref$28, ptrType$26, true)[1] || $assertType(_ref$28, ptrType$35, true)[1]) { */ case 629:
- o$1 = _ref$28;
- _r$329 = c[0].objectName(o$1); /* */ $s = 635; case 635: if($c) { $c = false; _r$329 = _r$329.$blk(); } if (_r$329 && _r$329.$blk !== undefined) { break s; }
- _arg$199 = new $String(_r$329);
- _r$330 = c[0].formatExpr("%s", new sliceType$5([_arg$199])); /* */ $s = 636; case 636: if($c) { $c = false; _r$330 = _r$330.$blk(); } if (_r$330 && _r$330.$blk !== undefined) { break s; }
- return _r$330;
- $s = 634; continue;
- /* } else if ($assertType(_ref$28, ptrType$32, true)[1]) { */ case 630:
- o$2 = _ref$28.$val;
- _r$331 = c[0].objectName(o$2); /* */ $s = 637; case 637: if($c) { $c = false; _r$331 = _r$331.$blk(); } if (_r$331 && _r$331.$blk !== undefined) { break s; }
- _arg$200 = new $String(_r$331);
- _r$332 = c[0].formatExpr("%s", new sliceType$5([_arg$200])); /* */ $s = 638; case 638: if($c) { $c = false; _r$332 = _r$332.$blk(); } if (_r$332 && _r$332.$blk !== undefined) { break s; }
- return _r$332;
- $s = 634; continue;
- /* } else if ($assertType(_ref$28, ptrType$36, true)[1]) { */ case 631:
- o$3 = _ref$28.$val;
- _r$333 = c[0].typeName(o$3.object.Type()); /* */ $s = 639; case 639: if($c) { $c = false; _r$333 = _r$333.$blk(); } if (_r$333 && _r$333.$blk !== undefined) { break s; }
- _arg$201 = new $String(_r$333);
- _r$334 = c[0].formatExpr("%s", new sliceType$5([_arg$201])); /* */ $s = 640; case 640: if($c) { $c = false; _r$334 = _r$334.$blk(); } if (_r$334 && _r$334.$blk !== undefined) { break s; }
- return _r$334;
- $s = 634; continue;
- /* } else if ($assertType(_ref$28, ptrType$37, true)[1]) { */ case 632:
- o$4 = _ref$28.$val;
- _r$335 = c[0].zeroValue((_entry$37 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$13)], _entry$37 !== undefined ? _entry$37.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 641; case 641: if($c) { $c = false; _r$335 = _r$335.$blk(); } if (_r$335 && _r$335.$blk !== undefined) { break s; }
- _arg$202 = new $String(_r$335);
- _r$336 = c[0].formatExpr("%s", new sliceType$5([_arg$202])); /* */ $s = 642; case 642: if($c) { $c = false; _r$336 = _r$336.$blk(); } if (_r$336 && _r$336.$blk !== undefined) { break s; }
- return _r$336;
- $s = 634; continue;
- /* } else { */ case 633:
- o$5 = _ref$28;
- _r$337 = fmt.Sprintf("Unhandled object: %T\n", new sliceType$5([o$5])); /* */ $s = 643; case 643: if($c) { $c = false; _r$337 = _r$337.$blk(); } if (_r$337 && _r$337.$blk !== undefined) { break s; }
- $panic(new $String(_r$337));
- /* } */ case 634:
- $s = 66; continue;
- /* } else if ($assertType(_ref$2, ptrType$16, true)[1]) { */ case 63:
- e$14 = _ref$2.$val;
- _r$338 = isWrapped((_entry$38 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$14)], _entry$38 !== undefined ? _entry$38.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 646; case 646: if($c) { $c = false; _r$338 = _r$338.$blk(); } if (_r$338 && _r$338.$blk !== undefined) { break s; }
- /* */ if (_r$338) { $s = 644; continue; }
- /* */ $s = 645; continue;
- /* if (_r$338) { */ case 644:
- _r$339 = c[0].formatExpr("this.$val", new sliceType$5([])); /* */ $s = 647; case 647: if($c) { $c = false; _r$339 = _r$339.$blk(); } if (_r$339 && _r$339.$blk !== undefined) { break s; }
- return _r$339;
- /* } */ case 645:
- _r$340 = c[0].formatExpr("this", new sliceType$5([])); /* */ $s = 648; case 648: if($c) { $c = false; _r$340 = _r$340.$blk(); } if (_r$340 && _r$340.$blk !== undefined) { break s; }
- return _r$340;
- $s = 66; continue;
- /* } else if (_ref$2 === $ifaceNil) { */ case 64:
- e$15 = _ref$2;
- _r$341 = c[0].formatExpr("", new sliceType$5([])); /* */ $s = 649; case 649: if($c) { $c = false; _r$341 = _r$341.$blk(); } if (_r$341 && _r$341.$blk !== undefined) { break s; }
- return _r$341;
- $s = 66; continue;
- /* } else { */ case 65:
- e$16 = _ref$2;
- _r$342 = fmt.Sprintf("Unhandled expression: %T\n", new sliceType$5([e$16])); /* */ $s = 650; case 650: if($c) { $c = false; _r$342 = _r$342.$blk(); } if (_r$342 && _r$342.$blk !== undefined) { break s; }
- $panic(new $String(_r$342));
- /* } */ case 66:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateExpr }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$100 = _arg$100; $f._arg$101 = _arg$101; $f._arg$102 = _arg$102; $f._arg$103 = _arg$103; $f._arg$104 = _arg$104; $f._arg$105 = _arg$105; $f._arg$106 = _arg$106; $f._arg$107 = _arg$107; $f._arg$108 = _arg$108; $f._arg$109 = _arg$109; $f._arg$11 = _arg$11; $f._arg$110 = _arg$110; $f._arg$111 = _arg$111; $f._arg$112 = _arg$112; $f._arg$113 = _arg$113; $f._arg$114 = _arg$114; $f._arg$115 = _arg$115; $f._arg$116 = _arg$116; $f._arg$117 = _arg$117; $f._arg$118 = _arg$118; $f._arg$119 = _arg$119; $f._arg$12 = _arg$12; $f._arg$120 = _arg$120; $f._arg$121 = _arg$121; $f._arg$122 = _arg$122; $f._arg$123 = _arg$123; $f._arg$124 = _arg$124; $f._arg$125 = _arg$125; $f._arg$126 = _arg$126; $f._arg$127 = _arg$127; $f._arg$128 = _arg$128; $f._arg$129 = _arg$129; $f._arg$13 = _arg$13; $f._arg$130 = _arg$130; $f._arg$131 = _arg$131; $f._arg$132 = _arg$132; $f._arg$133 = _arg$133; $f._arg$134 = _arg$134; $f._arg$135 = _arg$135; $f._arg$136 = _arg$136; $f._arg$137 = _arg$137; $f._arg$138 = _arg$138; $f._arg$139 = _arg$139; $f._arg$14 = _arg$14; $f._arg$140 = _arg$140; $f._arg$141 = _arg$141; $f._arg$142 = _arg$142; $f._arg$143 = _arg$143; $f._arg$144 = _arg$144; $f._arg$145 = _arg$145; $f._arg$146 = _arg$146; $f._arg$147 = _arg$147; $f._arg$148 = _arg$148; $f._arg$149 = _arg$149; $f._arg$15 = _arg$15; $f._arg$150 = _arg$150; $f._arg$151 = _arg$151; $f._arg$152 = _arg$152; $f._arg$153 = _arg$153; $f._arg$154 = _arg$154; $f._arg$155 = _arg$155; $f._arg$156 = _arg$156; $f._arg$157 = _arg$157; $f._arg$158 = _arg$158; $f._arg$159 = _arg$159; $f._arg$16 = _arg$16; $f._arg$160 = _arg$160; $f._arg$161 = _arg$161; $f._arg$162 = _arg$162; $f._arg$163 = _arg$163; $f._arg$164 = _arg$164; $f._arg$165 = _arg$165; $f._arg$166 = _arg$166; $f._arg$167 = _arg$167; $f._arg$168 = _arg$168; $f._arg$169 = _arg$169; $f._arg$17 = _arg$17; $f._arg$170 = _arg$170; $f._arg$171 = _arg$171; $f._arg$172 = _arg$172; $f._arg$173 = _arg$173; $f._arg$174 = _arg$174; $f._arg$175 = _arg$175; $f._arg$176 = _arg$176; $f._arg$177 = _arg$177; $f._arg$178 = _arg$178; $f._arg$179 = _arg$179; $f._arg$18 = _arg$18; $f._arg$180 = _arg$180; $f._arg$181 = _arg$181; $f._arg$182 = _arg$182; $f._arg$183 = _arg$183; $f._arg$184 = _arg$184; $f._arg$185 = _arg$185; $f._arg$186 = _arg$186; $f._arg$187 = _arg$187; $f._arg$188 = _arg$188; $f._arg$189 = _arg$189; $f._arg$19 = _arg$19; $f._arg$190 = _arg$190; $f._arg$191 = _arg$191; $f._arg$192 = _arg$192; $f._arg$193 = _arg$193; $f._arg$194 = _arg$194; $f._arg$195 = _arg$195; $f._arg$196 = _arg$196; $f._arg$197 = _arg$197; $f._arg$198 = _arg$198; $f._arg$199 = _arg$199; $f._arg$2 = _arg$2; $f._arg$20 = _arg$20; $f._arg$200 = _arg$200; $f._arg$201 = _arg$201; $f._arg$202 = _arg$202; $f._arg$21 = _arg$21; $f._arg$22 = _arg$22; $f._arg$23 = _arg$23; $f._arg$24 = _arg$24; $f._arg$25 = _arg$25; $f._arg$26 = _arg$26; $f._arg$27 = _arg$27; $f._arg$28 = _arg$28; $f._arg$29 = _arg$29; $f._arg$3 = _arg$3; $f._arg$30 = _arg$30; $f._arg$31 = _arg$31; $f._arg$32 = _arg$32; $f._arg$33 = _arg$33; $f._arg$34 = _arg$34; $f._arg$35 = _arg$35; $f._arg$36 = _arg$36; $f._arg$37 = _arg$37; $f._arg$38 = _arg$38; $f._arg$39 = _arg$39; $f._arg$4 = _arg$4; $f._arg$40 = _arg$40; $f._arg$41 = _arg$41; $f._arg$42 = _arg$42; $f._arg$43 = _arg$43; $f._arg$44 = _arg$44; $f._arg$45 = _arg$45; $f._arg$46 = _arg$46; $f._arg$47 = _arg$47; $f._arg$48 = _arg$48; $f._arg$49 = _arg$49; $f._arg$5 = _arg$5; $f._arg$50 = _arg$50; $f._arg$51 = _arg$51; $f._arg$52 = _arg$52; $f._arg$53 = _arg$53; $f._arg$54 = _arg$54; $f._arg$55 = _arg$55; $f._arg$56 = _arg$56; $f._arg$57 = _arg$57; $f._arg$58 = _arg$58; $f._arg$59 = _arg$59; $f._arg$6 = _arg$6; $f._arg$60 = _arg$60; $f._arg$61 = _arg$61; $f._arg$62 = _arg$62; $f._arg$63 = _arg$63; $f._arg$64 = _arg$64; $f._arg$65 = _arg$65; $f._arg$66 = _arg$66; $f._arg$67 = _arg$67; $f._arg$68 = _arg$68; $f._arg$69 = _arg$69; $f._arg$7 = _arg$7; $f._arg$70 = _arg$70; $f._arg$71 = _arg$71; $f._arg$72 = _arg$72; $f._arg$73 = _arg$73; $f._arg$74 = _arg$74; $f._arg$75 = _arg$75; $f._arg$76 = _arg$76; $f._arg$77 = _arg$77; $f._arg$78 = _arg$78; $f._arg$79 = _arg$79; $f._arg$8 = _arg$8; $f._arg$80 = _arg$80; $f._arg$81 = _arg$81; $f._arg$82 = _arg$82; $f._arg$83 = _arg$83; $f._arg$84 = _arg$84; $f._arg$85 = _arg$85; $f._arg$86 = _arg$86; $f._arg$87 = _arg$87; $f._arg$88 = _arg$88; $f._arg$89 = _arg$89; $f._arg$9 = _arg$9; $f._arg$90 = _arg$90; $f._arg$91 = _arg$91; $f._arg$92 = _arg$92; $f._arg$93 = _arg$93; $f._arg$94 = _arg$94; $f._arg$95 = _arg$95; $f._arg$96 = _arg$96; $f._arg$97 = _arg$97; $f._arg$98 = _arg$98; $f._arg$99 = _arg$99; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$10 = _entry$10; $f._entry$11 = _entry$11; $f._entry$12 = _entry$12; $f._entry$13 = _entry$13; $f._entry$14 = _entry$14; $f._entry$15 = _entry$15; $f._entry$16 = _entry$16; $f._entry$17 = _entry$17; $f._entry$18 = _entry$18; $f._entry$19 = _entry$19; $f._entry$2 = _entry$2; $f._entry$20 = _entry$20; $f._entry$21 = _entry$21; $f._entry$22 = _entry$22; $f._entry$23 = _entry$23; $f._entry$24 = _entry$24; $f._entry$25 = _entry$25; $f._entry$26 = _entry$26; $f._entry$27 = _entry$27; $f._entry$28 = _entry$28; $f._entry$29 = _entry$29; $f._entry$3 = _entry$3; $f._entry$30 = _entry$30; $f._entry$31 = _entry$31; $f._entry$32 = _entry$32; $f._entry$33 = _entry$33; $f._entry$34 = _entry$34; $f._entry$35 = _entry$35; $f._entry$36 = _entry$36; $f._entry$37 = _entry$37; $f._entry$38 = _entry$38; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._entry$7 = _entry$7; $f._entry$8 = _entry$8; $f._entry$9 = _entry$9; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._keys = _keys; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$100 = _r$100; $f._r$101 = _r$101; $f._r$102 = _r$102; $f._r$103 = _r$103; $f._r$104 = _r$104; $f._r$105 = _r$105; $f._r$106 = _r$106; $f._r$107 = _r$107; $f._r$108 = _r$108; $f._r$109 = _r$109; $f._r$11 = _r$11; $f._r$110 = _r$110; $f._r$111 = _r$111; $f._r$112 = _r$112; $f._r$113 = _r$113; $f._r$114 = _r$114; $f._r$115 = _r$115; $f._r$116 = _r$116; $f._r$117 = _r$117; $f._r$118 = _r$118; $f._r$119 = _r$119; $f._r$12 = _r$12; $f._r$120 = _r$120; $f._r$121 = _r$121; $f._r$122 = _r$122; $f._r$123 = _r$123; $f._r$124 = _r$124; $f._r$125 = _r$125; $f._r$126 = _r$126; $f._r$127 = _r$127; $f._r$128 = _r$128; $f._r$129 = _r$129; $f._r$13 = _r$13; $f._r$130 = _r$130; $f._r$131 = _r$131; $f._r$132 = _r$132; $f._r$133 = _r$133; $f._r$134 = _r$134; $f._r$135 = _r$135; $f._r$136 = _r$136; $f._r$137 = _r$137; $f._r$138 = _r$138; $f._r$139 = _r$139; $f._r$14 = _r$14; $f._r$140 = _r$140; $f._r$141 = _r$141; $f._r$142 = _r$142; $f._r$143 = _r$143; $f._r$144 = _r$144; $f._r$145 = _r$145; $f._r$146 = _r$146; $f._r$147 = _r$147; $f._r$148 = _r$148; $f._r$149 = _r$149; $f._r$15 = _r$15; $f._r$150 = _r$150; $f._r$151 = _r$151; $f._r$152 = _r$152; $f._r$153 = _r$153; $f._r$154 = _r$154; $f._r$155 = _r$155; $f._r$156 = _r$156; $f._r$157 = _r$157; $f._r$158 = _r$158; $f._r$159 = _r$159; $f._r$16 = _r$16; $f._r$160 = _r$160; $f._r$161 = _r$161; $f._r$162 = _r$162; $f._r$163 = _r$163; $f._r$164 = _r$164; $f._r$165 = _r$165; $f._r$166 = _r$166; $f._r$167 = _r$167; $f._r$168 = _r$168; $f._r$169 = _r$169; $f._r$17 = _r$17; $f._r$170 = _r$170; $f._r$171 = _r$171; $f._r$172 = _r$172; $f._r$173 = _r$173; $f._r$174 = _r$174; $f._r$175 = _r$175; $f._r$176 = _r$176; $f._r$177 = _r$177; $f._r$178 = _r$178; $f._r$179 = _r$179; $f._r$18 = _r$18; $f._r$180 = _r$180; $f._r$181 = _r$181; $f._r$182 = _r$182; $f._r$183 = _r$183; $f._r$184 = _r$184; $f._r$185 = _r$185; $f._r$186 = _r$186; $f._r$187 = _r$187; $f._r$188 = _r$188; $f._r$189 = _r$189; $f._r$19 = _r$19; $f._r$190 = _r$190; $f._r$191 = _r$191; $f._r$192 = _r$192; $f._r$193 = _r$193; $f._r$194 = _r$194; $f._r$195 = _r$195; $f._r$196 = _r$196; $f._r$197 = _r$197; $f._r$198 = _r$198; $f._r$199 = _r$199; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$200 = _r$200; $f._r$201 = _r$201; $f._r$202 = _r$202; $f._r$203 = _r$203; $f._r$204 = _r$204; $f._r$205 = _r$205; $f._r$206 = _r$206; $f._r$207 = _r$207; $f._r$208 = _r$208; $f._r$209 = _r$209; $f._r$21 = _r$21; $f._r$210 = _r$210; $f._r$211 = _r$211; $f._r$212 = _r$212; $f._r$213 = _r$213; $f._r$214 = _r$214; $f._r$215 = _r$215; $f._r$216 = _r$216; $f._r$217 = _r$217; $f._r$218 = _r$218; $f._r$219 = _r$219; $f._r$22 = _r$22; $f._r$220 = _r$220; $f._r$221 = _r$221; $f._r$222 = _r$222; $f._r$223 = _r$223; $f._r$224 = _r$224; $f._r$225 = _r$225; $f._r$226 = _r$226; $f._r$227 = _r$227; $f._r$228 = _r$228; $f._r$229 = _r$229; $f._r$23 = _r$23; $f._r$230 = _r$230; $f._r$231 = _r$231; $f._r$232 = _r$232; $f._r$233 = _r$233; $f._r$234 = _r$234; $f._r$235 = _r$235; $f._r$236 = _r$236; $f._r$237 = _r$237; $f._r$238 = _r$238; $f._r$239 = _r$239; $f._r$24 = _r$24; $f._r$240 = _r$240; $f._r$241 = _r$241; $f._r$242 = _r$242; $f._r$243 = _r$243; $f._r$244 = _r$244; $f._r$245 = _r$245; $f._r$246 = _r$246; $f._r$247 = _r$247; $f._r$248 = _r$248; $f._r$249 = _r$249; $f._r$25 = _r$25; $f._r$250 = _r$250; $f._r$251 = _r$251; $f._r$252 = _r$252; $f._r$253 = _r$253; $f._r$254 = _r$254; $f._r$255 = _r$255; $f._r$256 = _r$256; $f._r$257 = _r$257; $f._r$258 = _r$258; $f._r$259 = _r$259; $f._r$26 = _r$26; $f._r$260 = _r$260; $f._r$261 = _r$261; $f._r$262 = _r$262; $f._r$263 = _r$263; $f._r$264 = _r$264; $f._r$265 = _r$265; $f._r$266 = _r$266; $f._r$267 = _r$267; $f._r$268 = _r$268; $f._r$269 = _r$269; $f._r$27 = _r$27; $f._r$270 = _r$270; $f._r$271 = _r$271; $f._r$272 = _r$272; $f._r$273 = _r$273; $f._r$274 = _r$274; $f._r$275 = _r$275; $f._r$276 = _r$276; $f._r$277 = _r$277; $f._r$278 = _r$278; $f._r$279 = _r$279; $f._r$28 = _r$28; $f._r$280 = _r$280; $f._r$281 = _r$281; $f._r$282 = _r$282; $f._r$283 = _r$283; $f._r$284 = _r$284; $f._r$285 = _r$285; $f._r$286 = _r$286; $f._r$287 = _r$287; $f._r$288 = _r$288; $f._r$289 = _r$289; $f._r$29 = _r$29; $f._r$290 = _r$290; $f._r$291 = _r$291; $f._r$292 = _r$292; $f._r$293 = _r$293; $f._r$294 = _r$294; $f._r$295 = _r$295; $f._r$296 = _r$296; $f._r$297 = _r$297; $f._r$298 = _r$298; $f._r$299 = _r$299; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$300 = _r$300; $f._r$301 = _r$301; $f._r$302 = _r$302; $f._r$303 = _r$303; $f._r$304 = _r$304; $f._r$305 = _r$305; $f._r$306 = _r$306; $f._r$307 = _r$307; $f._r$308 = _r$308; $f._r$309 = _r$309; $f._r$31 = _r$31; $f._r$310 = _r$310; $f._r$311 = _r$311; $f._r$312 = _r$312; $f._r$313 = _r$313; $f._r$314 = _r$314; $f._r$315 = _r$315; $f._r$316 = _r$316; $f._r$317 = _r$317; $f._r$318 = _r$318; $f._r$319 = _r$319; $f._r$32 = _r$32; $f._r$320 = _r$320; $f._r$321 = _r$321; $f._r$322 = _r$322; $f._r$323 = _r$323; $f._r$324 = _r$324; $f._r$325 = _r$325; $f._r$326 = _r$326; $f._r$327 = _r$327; $f._r$328 = _r$328; $f._r$329 = _r$329; $f._r$33 = _r$33; $f._r$330 = _r$330; $f._r$331 = _r$331; $f._r$332 = _r$332; $f._r$333 = _r$333; $f._r$334 = _r$334; $f._r$335 = _r$335; $f._r$336 = _r$336; $f._r$337 = _r$337; $f._r$338 = _r$338; $f._r$339 = _r$339; $f._r$34 = _r$34; $f._r$340 = _r$340; $f._r$341 = _r$341; $f._r$342 = _r$342; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$4 = _r$4; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._r$42 = _r$42; $f._r$43 = _r$43; $f._r$44 = _r$44; $f._r$45 = _r$45; $f._r$46 = _r$46; $f._r$47 = _r$47; $f._r$48 = _r$48; $f._r$49 = _r$49; $f._r$5 = _r$5; $f._r$50 = _r$50; $f._r$51 = _r$51; $f._r$52 = _r$52; $f._r$53 = _r$53; $f._r$54 = _r$54; $f._r$55 = _r$55; $f._r$56 = _r$56; $f._r$57 = _r$57; $f._r$58 = _r$58; $f._r$59 = _r$59; $f._r$6 = _r$6; $f._r$60 = _r$60; $f._r$61 = _r$61; $f._r$62 = _r$62; $f._r$63 = _r$63; $f._r$64 = _r$64; $f._r$65 = _r$65; $f._r$66 = _r$66; $f._r$67 = _r$67; $f._r$68 = _r$68; $f._r$69 = _r$69; $f._r$7 = _r$7; $f._r$70 = _r$70; $f._r$71 = _r$71; $f._r$72 = _r$72; $f._r$73 = _r$73; $f._r$74 = _r$74; $f._r$75 = _r$75; $f._r$76 = _r$76; $f._r$77 = _r$77; $f._r$78 = _r$78; $f._r$79 = _r$79; $f._r$8 = _r$8; $f._r$80 = _r$80; $f._r$81 = _r$81; $f._r$82 = _r$82; $f._r$83 = _r$83; $f._r$84 = _r$84; $f._r$85 = _r$85; $f._r$86 = _r$86; $f._r$87 = _r$87; $f._r$88 = _r$88; $f._r$89 = _r$89; $f._r$9 = _r$9; $f._r$90 = _r$90; $f._r$91 = _r$91; $f._r$92 = _r$92; $f._r$93 = _r$93; $f._r$94 = _r$94; $f._r$95 = _r$95; $f._r$96 = _r$96; $f._r$97 = _r$97; $f._r$98 = _r$98; $f._r$99 = _r$99; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$10 = _ref$10; $f._ref$11 = _ref$11; $f._ref$12 = _ref$12; $f._ref$13 = _ref$13; $f._ref$14 = _ref$14; $f._ref$15 = _ref$15; $f._ref$16 = _ref$16; $f._ref$17 = _ref$17; $f._ref$18 = _ref$18; $f._ref$19 = _ref$19; $f._ref$2 = _ref$2; $f._ref$20 = _ref$20; $f._ref$21 = _ref$21; $f._ref$22 = _ref$22; $f._ref$23 = _ref$23; $f._ref$24 = _ref$24; $f._ref$25 = _ref$25; $f._ref$26 = _ref$26; $f._ref$27 = _ref$27; $f._ref$28 = _ref$28; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$11 = _tuple$11; $f._tuple$12 = _tuple$12; $f._tuple$13 = _tuple$13; $f._tuple$14 = _tuple$14; $f._tuple$15 = _tuple$15; $f._tuple$16 = _tuple$16; $f._tuple$17 = _tuple$17; $f._tuple$18 = _tuple$18; $f._tuple$19 = _tuple$19; $f._tuple$2 = _tuple$2; $f._tuple$20 = _tuple$20; $f._tuple$21 = _tuple$21; $f._tuple$22 = _tuple$22; $f._tuple$23 = _tuple$23; $f._tuple$24 = _tuple$24; $f._tuple$25 = _tuple$25; $f._tuple$26 = _tuple$26; $f._tuple$27 = _tuple$27; $f._tuple$28 = _tuple$28; $f._tuple$29 = _tuple$29; $f._tuple$3 = _tuple$3; $f._tuple$30 = _tuple$30; $f._tuple$31 = _tuple$31; $f._tuple$32 = _tuple$32; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f._v$3 = _v$3; $f.assignments = assignments; $f.b = b; $f.b$1 = b$1; $f.b$2 = b$2; $f.basic = basic; $f.basic$1 = basic$1; $f.basic$2 = basic$2; $f.c = c; $f.c1 = c1; $f.c2 = c2; $f.call = call; $f.call$1 = call$1; $f.collectIndexedElements = collectIndexedElements; $f.d = d; $f.d$1 = d$1; $f.d$2 = d$2; $f.e = e; $f.e$1 = e$1; $f.e$10 = e$10; $f.e$11 = e$11; $f.e$12 = e$12; $f.e$13 = e$13; $f.e$14 = e$14; $f.e$15 = e$15; $f.e$16 = e$16; $f.e$2 = e$2; $f.e$3 = e$3; $f.e$4 = e$4; $f.e$5 = e$5; $f.e$6 = e$6; $f.e$7 = e$7; $f.e$8 = e$8; $f.e$9 = e$9; $f.element = element; $f.element$1 = element$1; $f.element$2 = element$2; $f.elements = elements; $f.elements$1 = elements$1; $f.expr = expr; $f.exprType = exprType; $f.externalizeArgs = externalizeArgs; $f.externalizeExpr = externalizeExpr; $f.f = f; $f.f$1 = f$1; $f.f$2 = f$2; $f.f$3 = f$3; $f.fields = fields; $f.fields$1 = fields$1; $f.fun = fun; $f.globalRef = globalRef; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.id = id; $f.id$1 = id$1; $f.id$2 = id$2; $f.isBasic = isBasic; $f.isBasic$1 = isBasic$1; $f.isCall = isCall; $f.isCall$1 = isCall$1; $f.isInterface = isInterface; $f.isKeyValue = isKeyValue; $f.isPointer = isPointer; $f.isTuple = isTuple; $f.isTuple$1 = isTuple$1; $f.isTuple$2 = isTuple$2; $f.isUnary = isUnary; $f.j = j; $f.jsTag = jsTag; $f.jsTag$1 = jsTag$1; $f.key = key; $f.keyVar = keyVar; $f.kve = kve; $f.kve$1 = kve$1; $f.list = list; $f.mapVar = mapVar; $f.methodName = methodName; $f.names = names; $f.newSel = newSel; $f.o = o; $f.o$1 = o$1; $f.o$2 = o$2; $f.o$3 = o$3; $f.o$4 = o$4; $f.o$5 = o$5; $f.obj = obj; $f.obj$1 = obj$1; $f.obj$2 = obj$2; $f.obj$3 = obj$3; $f.obj$4 = obj$4; $f.obj$5 = obj$5; $f.objVar = objVar; $f.objVar$1 = objVar$1; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$10 = ok$10; $f.ok$11 = ok$11; $f.ok$12 = ok$12; $f.ok$13 = ok$13; $f.ok$14 = ok$14; $f.ok$15 = ok$15; $f.ok$2 = ok$2; $f.ok$3 = ok$3; $f.ok$4 = ok$4; $f.ok$5 = ok$5; $f.ok$6 = ok$6; $f.ok$7 = ok$7; $f.ok$8 = ok$8; $f.ok$9 = ok$9; $f.op = op; $f.pattern = pattern; $f.plainFun = plainFun; $f.ptrType$18 = ptrType$18; $f.r = r; $f.recv = recv; $f.recv$1 = recv$1; $f.resultVar = resultVar; $f.resultVar$1 = resultVar$1; $f.sel = sel; $f.sel$1 = sel$1; $f.sel$2 = sel$2; $f.shift = shift; $f.sig = sig; $f.skipCase = skipCase; $f.skipCase$1 = skipCase$1; $f.slice = slice; $f.t = t; $f.t$1 = t$1; $f.t$10 = t$10; $f.t$11 = t$11; $f.t$12 = t$12; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.t$8 = t$8; $f.t$9 = t$9; $f.t2 = t2; $f.u = u; $f.u$1 = u$1; $f.u$2 = u$2; $f.u$3 = u$3; $f.unary = unary; $f.value = value; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$17 = x$17; $f.x$18 = x$18; $f.x$19 = x$19; $f.x$2 = x$2; $f.x$20 = x$20; $f.x$21 = x$21; $f.x$22 = x$22; $f.x$23 = x$23; $f.x$24 = x$24; $f.x$25 = x$25; $f.x$26 = x$26; $f.x$27 = x$27; $f.x$28 = x$28; $f.x$29 = x$29; $f.x$3 = x$3; $f.x$30 = x$30; $f.x$31 = x$31; $f.x$32 = x$32; $f.x$33 = x$33; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.y = y; $f.zero = zero; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateExpr = function(expr) { return this.$val.translateExpr(expr); };
- funcContext.ptr.prototype.translateCall = function(e, sig, fun) {
- var $ptr, _entry, _r, _r$1, _r$2, args, c, e, fun, resumeCase, returnVar, sig, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; args = $f.args; c = $f.c; e = $f.e; fun = $f.fun; resumeCase = $f.resumeCase; returnVar = $f.returnVar; sig = $f.sig; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = c.translateArgs(sig, e.Args, new token.Pos(e.Ellipsis).IsValid(), false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- args = _r;
- /* */ if ((_entry = c.FuncInfo.Blocking[ast.Node.keyFor(e)], _entry !== undefined ? _entry.v : false)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ((_entry = c.FuncInfo.Blocking[ast.Node.keyFor(e)], _entry !== undefined ? _entry.v : false)) { */ case 2:
- resumeCase = c.caseCounter;
- c.caseCounter = c.caseCounter + (1) >> 0;
- returnVar = "$r";
- /* */ if (!((sig.Results().Len() === 0))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!((sig.Results().Len() === 0))) { */ case 4:
- _r$1 = c.newVariable("_r"); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- returnVar = _r$1;
- /* } */ case 5:
- $r = c.Printf("%[1]s = %[2]s(%[3]s); /* */ $s = %[4]d; case %[4]d: if($c) { $c = false; %[1]s = %[1]s.$blk(); } if (%[1]s && %[1]s.$blk !== undefined) { break s; }", new sliceType$5([new $String(returnVar), fun, new $String(strings.Join(args, ", ")), new $Int(resumeCase)])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!((sig.Results().Len() === 0))) {
- return returnVar;
- }
- return "";
- /* } */ case 3:
- _r$2 = fmt.Sprintf("%s(%s)", new sliceType$5([fun, new $String(strings.Join(args, ", "))])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateCall }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.args = args; $f.c = c; $f.e = e; $f.fun = fun; $f.resumeCase = resumeCase; $f.returnVar = returnVar; $f.sig = sig; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateCall = function(e, sig, fun) { return this.$val.translateCall(e, sig, fun); };
- funcContext.ptr.prototype.makeReceiver = function(x, sel) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _i, _key, _r, _r$1, _r$10, _r$11, _r$12, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, _tuple$1, _tuple$2, c, index, isPointer, isPtr, methodsRecvType, pointerExpected, ptr, recv, recvType, s, sel, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _i = $f._i; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; c = $f.c; index = $f.index; isPointer = $f.isPointer; isPtr = $f.isPtr; methodsRecvType = $f.methodsRecvType; pointerExpected = $f.pointerExpected; ptr = $f.ptr; recv = $f.recv; recvType = $f.recvType; s = $f.s; sel = $f.sel; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = sel.Obj().Exported(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (!_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!_r) { */ case 1:
- _key = sel.Obj(); (c.p.dependencies || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key)] = { k: _key, v: true };
- /* } */ case 2:
- recvType = sel.Recv();
- _r$1 = recvType.Underlying(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$1, ptrType$17, true); isPointer = _tuple[1];
- _r$2 = sel.Obj().Type(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = $assertType(_r$2, ptrType$24).Recv(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = _r$3.object.Type(); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- methodsRecvType = _r$4;
- _tuple$1 = $assertType(methodsRecvType, ptrType$17, true); pointerExpected = _tuple$1[1];
- recv = ptrType$38.nil;
- /* */ if (!isPointer && pointerExpected) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!isPointer && pointerExpected) { */ case 8:
- _r$5 = c.translateExpr(c.setType(new ast.UnaryExpr.ptr(0, 17, x), types.NewPointer(recvType))); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- recv = _r$5;
- $s = 10; continue;
- /* } else { */ case 9:
- _r$6 = c.translateExpr(x); /* */ $s = 12; case 12: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- recv = _r$6;
- /* } */ case 10:
- _ref = $subslice(sel.Index(), 0, (sel.Index().$length - 1 >> 0));
- _i = 0;
- /* while (true) { */ case 13:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 14; continue; }
- index = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple$2 = $assertType(recvType, ptrType$17, true); ptr = _tuple$2[0]; isPtr = _tuple$2[1];
- if (isPtr) {
- recvType = ptr.Elem();
- }
- _r$7 = recvType.Underlying(); /* */ $s = 15; case 15: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- s = $assertType(_r$7, ptrType$23);
- _arg = recv;
- _r$8 = fieldName(s, index); /* */ $s = 16; case 16: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$8);
- _r$9 = c.formatExpr("%s.%s", new sliceType$5([_arg, _arg$1])); /* */ $s = 17; case 17: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- recv = _r$9;
- recvType = s.Field(index).object.Type();
- _i++;
- /* } */ $s = 13; continue; case 14:
- _r$10 = isWrapped(methodsRecvType); /* */ $s = 20; case 20: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- /* */ if (_r$10) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (_r$10) { */ case 18:
- _r$11 = c.typeName(methodsRecvType); /* */ $s = 21; case 21: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$11);
- _arg$3 = recv;
- _r$12 = c.formatExpr("new %s(%s)", new sliceType$5([_arg$2, _arg$3])); /* */ $s = 22; case 22: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- recv = _r$12;
- /* } */ case 19:
- return recv;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.makeReceiver }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._i = _i; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.c = c; $f.index = index; $f.isPointer = isPointer; $f.isPtr = isPtr; $f.methodsRecvType = methodsRecvType; $f.pointerExpected = pointerExpected; $f.ptr = ptr; $f.recv = recv; $f.recvType = recvType; $f.s = s; $f.sel = sel; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.makeReceiver = function(x, sel) { return this.$val.makeReceiver(x, sel); };
- funcContext.ptr.prototype.translateBuiltin = function(name, args, ellipsis, typ) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$16, _arg$17, _arg$18, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _entry, _entry$1, _entry$2, _entry$3, _entry$4, _entry$5, _entry$6, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$37, _r$38, _r$39, _r$4, _r$40, _r$41, _r$42, _r$43, _r$44, _r$45, _r$46, _r$47, _r$48, _r$49, _r$5, _r$50, _r$51, _r$52, _r$53, _r$54, _r$55, _r$56, _r$57, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, _v, argType, argType$1, argType$10, argType$11, argType$12, argType$2, argType$3, argType$4, argType$5, argType$6, argType$7, argType$8, argType$9, args, basic, c, ellipsis, isBasic, keyType, length, name, sliceType$11, t, t$1, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$16 = $f._arg$16; _arg$17 = $f._arg$17; _arg$18 = $f._arg$18; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$4 = $f._r$4; _r$40 = $f._r$40; _r$41 = $f._r$41; _r$42 = $f._r$42; _r$43 = $f._r$43; _r$44 = $f._r$44; _r$45 = $f._r$45; _r$46 = $f._r$46; _r$47 = $f._r$47; _r$48 = $f._r$48; _r$49 = $f._r$49; _r$5 = $f._r$5; _r$50 = $f._r$50; _r$51 = $f._r$51; _r$52 = $f._r$52; _r$53 = $f._r$53; _r$54 = $f._r$54; _r$55 = $f._r$55; _r$56 = $f._r$56; _r$57 = $f._r$57; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; _v = $f._v; argType = $f.argType; argType$1 = $f.argType$1; argType$10 = $f.argType$10; argType$11 = $f.argType$11; argType$12 = $f.argType$12; argType$2 = $f.argType$2; argType$3 = $f.argType$3; argType$4 = $f.argType$4; argType$5 = $f.argType$5; argType$6 = $f.argType$6; argType$7 = $f.argType$7; argType$8 = $f.argType$8; argType$9 = $f.argType$9; args = $f.args; basic = $f.basic; c = $f.c; ellipsis = $f.ellipsis; isBasic = $f.isBasic; keyType = $f.keyType; length = $f.length; name = $f.name; sliceType$11 = $f.sliceType$11; t = $f.t; t$1 = $f.t$1; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _ref = name;
- /* */ if (_ref === "new") { $s = 1; continue; }
- /* */ if (_ref === "make") { $s = 2; continue; }
- /* */ if (_ref === "len") { $s = 3; continue; }
- /* */ if (_ref === "cap") { $s = 4; continue; }
- /* */ if (_ref === "panic") { $s = 5; continue; }
- /* */ if (_ref === "append") { $s = 6; continue; }
- /* */ if (_ref === "delete") { $s = 7; continue; }
- /* */ if (_ref === "copy") { $s = 8; continue; }
- /* */ if (_ref === "print" || _ref === "println") { $s = 9; continue; }
- /* */ if (_ref === "complex") { $s = 10; continue; }
- /* */ if (_ref === "real") { $s = 11; continue; }
- /* */ if (_ref === "imag") { $s = 12; continue; }
- /* */ if (_ref === "recover") { $s = 13; continue; }
- /* */ if (_ref === "close") { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (_ref === "new") { */ case 1:
- t = $assertType(typ, ptrType$17);
- if (!(c.p.Info.Pkg.Path() === "syscall")) { _v = false; $s = 19; continue s; }
- _r = t.Elem().Underlying(); /* */ $s = 20; case 20: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = types.Identical(_r, types.Typ[12]); /* */ $s = 21; case 21: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1; case 19:
- /* */ if (_v) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (_v) { */ case 17:
- _r$2 = c.formatExpr("new Uint8Array(8)", new sliceType$5([])); /* */ $s = 22; case 22: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* } */ case 18:
- _r$3 = t.Elem().Underlying(); /* */ $s = 23; case 23: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _ref$1 = _r$3;
- /* */ if ($assertType(_ref$1, ptrType$23, true)[1] || $assertType(_ref$1, ptrType$20, true)[1]) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if ($assertType(_ref$1, ptrType$23, true)[1] || $assertType(_ref$1, ptrType$20, true)[1]) { */ case 24:
- _r$4 = c.zeroValue(t.Elem()); /* */ $s = 27; case 27: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg = new $String(_r$4);
- _r$5 = c.formatExpr("%s", new sliceType$5([_arg])); /* */ $s = 28; case 28: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- $s = 26; continue;
- /* } else { */ case 25:
- _r$6 = c.zeroValue(t.Elem()); /* */ $s = 29; case 29: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$6);
- _r$7 = c.typeName(t); /* */ $s = 30; case 30: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$7);
- _r$8 = c.formatExpr("$newDataPointer(%s, %s)", new sliceType$5([_arg$1, _arg$2])); /* */ $s = 31; case 31: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- return _r$8;
- /* } */ case 26:
- $s = 16; continue;
- /* } else if (_ref === "make") { */ case 2:
- _r$9 = (_entry = c.p.Info.Info.Types[ast.Expr.keyFor((0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]))], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 32; case 32: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _ref$2 = _r$9;
- /* */ if ($assertType(_ref$2, ptrType$21, true)[1]) { $s = 33; continue; }
- /* */ if ($assertType(_ref$2, ptrType$22, true)[1]) { $s = 34; continue; }
- /* */ if ($assertType(_ref$2, ptrType$39, true)[1]) { $s = 35; continue; }
- /* */ $s = 36; continue;
- /* if ($assertType(_ref$2, ptrType$21, true)[1]) { */ case 33:
- argType = _ref$2.$val;
- _r$10 = c.typeName((_entry$1 = c.p.Info.Info.Types[ast.Expr.keyFor((0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]))], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 38; case 38: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- t$1 = _r$10;
- /* */ if (args.$length === 3) { $s = 39; continue; }
- /* */ $s = 40; continue;
- /* if (args.$length === 3) { */ case 39:
- _r$11 = c.formatExpr("$makeSlice(%s, %f, %f)", new sliceType$5([new $String(t$1), (1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1]), (2 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 2])])); /* */ $s = 41; case 41: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- /* } */ case 40:
- _r$12 = c.formatExpr("$makeSlice(%s, %f)", new sliceType$5([new $String(t$1), (1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1])])); /* */ $s = 42; case 42: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- return _r$12;
- $s = 37; continue;
- /* } else if ($assertType(_ref$2, ptrType$22, true)[1]) { */ case 34:
- argType$1 = _ref$2.$val;
- _r$13 = c.formatExpr("new $Map()", new sliceType$5([])); /* */ $s = 43; case 43: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- return _r$13;
- $s = 37; continue;
- /* } else if ($assertType(_ref$2, ptrType$39, true)[1]) { */ case 35:
- argType$2 = _ref$2.$val;
- length = "0";
- /* */ if (args.$length === 2) { $s = 44; continue; }
- /* */ $s = 45; continue;
- /* if (args.$length === 2) { */ case 44:
- _r$14 = c.translateExpr((1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1])); /* */ $s = 46; case 46: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _r$15 = _r$14.String(); /* */ $s = 47; case 47: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- length = _r$15;
- /* } */ case 45:
- _r$16 = c.typeName((_entry$2 = c.p.Info.Info.Types[ast.Expr.keyFor((0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]))], _entry$2 !== undefined ? _entry$2.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 48; case 48: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _arg$3 = new $String(_r$16);
- _arg$4 = new $String(length);
- _r$17 = c.formatExpr("new %s(%s)", new sliceType$5([_arg$3, _arg$4])); /* */ $s = 49; case 49: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- return _r$17;
- $s = 37; continue;
- /* } else { */ case 36:
- argType$3 = _ref$2;
- _r$18 = fmt.Sprintf("Unhandled make type: %T\n", new sliceType$5([argType$3])); /* */ $s = 50; case 50: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- $panic(new $String(_r$18));
- /* } */ case 37:
- $s = 16; continue;
- /* } else if (_ref === "len") { */ case 3:
- _r$19 = (_entry$3 = c.p.Info.Info.Types[ast.Expr.keyFor((0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]))], _entry$3 !== undefined ? _entry$3.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 51; case 51: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- _ref$3 = _r$19;
- /* */ if ($assertType(_ref$3, ptrType$3, true)[1]) { $s = 52; continue; }
- /* */ if ($assertType(_ref$3, ptrType$21, true)[1]) { $s = 53; continue; }
- /* */ if ($assertType(_ref$3, ptrType$17, true)[1]) { $s = 54; continue; }
- /* */ if ($assertType(_ref$3, ptrType$22, true)[1]) { $s = 55; continue; }
- /* */ if ($assertType(_ref$3, ptrType$39, true)[1]) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if ($assertType(_ref$3, ptrType$3, true)[1]) { */ case 52:
- argType$4 = _ref$3.$val;
- _r$20 = c.formatExpr("%e.length", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 59; case 59: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- return _r$20;
- $s = 58; continue;
- /* } else if ($assertType(_ref$3, ptrType$21, true)[1]) { */ case 53:
- argType$5 = _ref$3.$val;
- _r$21 = c.formatExpr("%e.$length", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 60; case 60: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- return _r$21;
- $s = 58; continue;
- /* } else if ($assertType(_ref$3, ptrType$17, true)[1]) { */ case 54:
- argType$6 = _ref$3.$val;
- _r$22 = c.formatExpr("(%e, %d)", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]), $assertType(argType$6.Elem(), ptrType$20).Len()])); /* */ $s = 61; case 61: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- $s = 58; continue;
- /* } else if ($assertType(_ref$3, ptrType$22, true)[1]) { */ case 55:
- argType$7 = _ref$3.$val;
- _r$23 = c.formatExpr("$keys(%e).length", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 62; case 62: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23;
- $s = 58; continue;
- /* } else if ($assertType(_ref$3, ptrType$39, true)[1]) { */ case 56:
- argType$8 = _ref$3.$val;
- _r$24 = c.formatExpr("%e.$buffer.length", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 63; case 63: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- return _r$24;
- $s = 58; continue;
- /* } else { */ case 57:
- argType$9 = _ref$3;
- _r$25 = fmt.Sprintf("Unhandled len type: %T\n", new sliceType$5([argType$9])); /* */ $s = 64; case 64: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- $panic(new $String(_r$25));
- /* } */ case 58:
- $s = 16; continue;
- /* } else if (_ref === "cap") { */ case 4:
- _r$26 = (_entry$4 = c.p.Info.Info.Types[ast.Expr.keyFor((0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]))], _entry$4 !== undefined ? _entry$4.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 65; case 65: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _ref$4 = _r$26;
- /* */ if ($assertType(_ref$4, ptrType$21, true)[1] || $assertType(_ref$4, ptrType$39, true)[1]) { $s = 66; continue; }
- /* */ if ($assertType(_ref$4, ptrType$17, true)[1]) { $s = 67; continue; }
- /* */ $s = 68; continue;
- /* if ($assertType(_ref$4, ptrType$21, true)[1] || $assertType(_ref$4, ptrType$39, true)[1]) { */ case 66:
- argType$10 = _ref$4;
- _r$27 = c.formatExpr("%e.$capacity", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 70; case 70: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- return _r$27;
- $s = 69; continue;
- /* } else if ($assertType(_ref$4, ptrType$17, true)[1]) { */ case 67:
- argType$11 = _ref$4.$val;
- _r$28 = c.formatExpr("(%e, %d)", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]), $assertType(argType$11.Elem(), ptrType$20).Len()])); /* */ $s = 71; case 71: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- return _r$28;
- $s = 69; continue;
- /* } else { */ case 68:
- argType$12 = _ref$4;
- _r$29 = fmt.Sprintf("Unhandled cap type: %T\n", new sliceType$5([argType$12])); /* */ $s = 72; case 72: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- $panic(new $String(_r$29));
- /* } */ case 69:
- $s = 16; continue;
- /* } else if (_ref === "panic") { */ case 5:
- _arg$5 = (0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]);
- _r$30 = types.NewInterface(sliceType$9.nil, sliceType$10.nil); /* */ $s = 73; case 73: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _arg$6 = _r$30;
- _r$31 = c.translateImplicitConversion(_arg$5, _arg$6); /* */ $s = 74; case 74: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- _arg$7 = _r$31;
- _r$32 = c.formatExpr("$panic(%s)", new sliceType$5([_arg$7])); /* */ $s = 75; case 75: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- return _r$32;
- $s = 16; continue;
- /* } else if (_ref === "append") { */ case 6:
- /* */ if (args.$length === 1) { $s = 76; continue; }
- /* */ $s = 77; continue;
- /* if (args.$length === 1) { */ case 76:
- _r$33 = c.translateExpr((0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])); /* */ $s = 78; case 78: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- return _r$33;
- /* } */ case 77:
- /* */ if (ellipsis) { $s = 79; continue; }
- /* */ $s = 80; continue;
- /* if (ellipsis) { */ case 79:
- _arg$8 = (0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]);
- _r$34 = c.translateConversionToSlice((1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1]), typ); /* */ $s = 81; case 81: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- _arg$9 = _r$34;
- _r$35 = c.formatExpr("$appendSlice(%e, %s)", new sliceType$5([_arg$8, _arg$9])); /* */ $s = 82; case 82: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- return _r$35;
- /* } */ case 80:
- _r$36 = typ.Underlying(); /* */ $s = 83; case 83: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- sliceType$11 = $assertType(_r$36, ptrType$21);
- _arg$10 = (0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]);
- _r$37 = c.translateExprSlice($subslice(args, 1), sliceType$11.Elem()); /* */ $s = 84; case 84: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- _r$38 = strings.Join(_r$37, ", "); /* */ $s = 85; case 85: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- _arg$11 = new $String(_r$38);
- _r$39 = c.formatExpr("$append(%e, %s)", new sliceType$5([_arg$10, _arg$11])); /* */ $s = 86; case 86: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- return _r$39;
- $s = 16; continue;
- /* } else if (_ref === "delete") { */ case 7:
- _r$40 = (_entry$5 = c.p.Info.Info.Types[ast.Expr.keyFor((0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]))], _entry$5 !== undefined ? _entry$5.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 87; case 87: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- _r$41 = $assertType(_r$40, ptrType$22).Key(); /* */ $s = 88; case 88: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- keyType = _r$41;
- _arg$12 = (0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]);
- _r$42 = c.typeName(keyType); /* */ $s = 89; case 89: if($c) { $c = false; _r$42 = _r$42.$blk(); } if (_r$42 && _r$42.$blk !== undefined) { break s; }
- _arg$13 = new $String(_r$42);
- _r$43 = c.translateImplicitConversion((1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1]), keyType); /* */ $s = 90; case 90: if($c) { $c = false; _r$43 = _r$43.$blk(); } if (_r$43 && _r$43.$blk !== undefined) { break s; }
- _arg$14 = _r$43;
- _r$44 = c.formatExpr("delete %e[%s.keyFor(%s)]", new sliceType$5([_arg$12, _arg$13, _arg$14])); /* */ $s = 91; case 91: if($c) { $c = false; _r$44 = _r$44.$blk(); } if (_r$44 && _r$44.$blk !== undefined) { break s; }
- return _r$44;
- $s = 16; continue;
- /* } else if (_ref === "copy") { */ case 8:
- _r$45 = (_entry$6 = c.p.Info.Info.Types[ast.Expr.keyFor((1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1]))], _entry$6 !== undefined ? _entry$6.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 92; case 92: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$45, ptrType$3, true); basic = _tuple[0]; isBasic = _tuple[1];
- /* */ if (isBasic && isString(basic)) { $s = 93; continue; }
- /* */ $s = 94; continue;
- /* if (isBasic && isString(basic)) { */ case 93:
- _r$46 = c.formatExpr("$copyString(%e, %e)", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]), (1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1])])); /* */ $s = 95; case 95: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- return _r$46;
- /* } */ case 94:
- _r$47 = c.formatExpr("$copySlice(%e, %e)", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]), (1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1])])); /* */ $s = 96; case 96: if($c) { $c = false; _r$47 = _r$47.$blk(); } if (_r$47 && _r$47.$blk !== undefined) { break s; }
- return _r$47;
- $s = 16; continue;
- /* } else if (_ref === "print" || _ref === "println") { */ case 9:
- _r$48 = c.translateExprSlice(args, $ifaceNil); /* */ $s = 97; case 97: if($c) { $c = false; _r$48 = _r$48.$blk(); } if (_r$48 && _r$48.$blk !== undefined) { break s; }
- _r$49 = strings.Join(_r$48, ", "); /* */ $s = 98; case 98: if($c) { $c = false; _r$49 = _r$49.$blk(); } if (_r$49 && _r$49.$blk !== undefined) { break s; }
- _arg$15 = new $String(_r$49);
- _r$50 = c.formatExpr("console.log(%s)", new sliceType$5([_arg$15])); /* */ $s = 99; case 99: if($c) { $c = false; _r$50 = _r$50.$blk(); } if (_r$50 && _r$50.$blk !== undefined) { break s; }
- return _r$50;
- $s = 16; continue;
- /* } else if (_ref === "complex") { */ case 10:
- _r$51 = c.typeName(typ); /* */ $s = 100; case 100: if($c) { $c = false; _r$51 = _r$51.$blk(); } if (_r$51 && _r$51.$blk !== undefined) { break s; }
- _arg$16 = new $String(_r$51);
- _arg$17 = (0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0]);
- _arg$18 = (1 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 1]);
- _r$52 = c.formatExpr("new %s(%e, %e)", new sliceType$5([_arg$16, _arg$17, _arg$18])); /* */ $s = 101; case 101: if($c) { $c = false; _r$52 = _r$52.$blk(); } if (_r$52 && _r$52.$blk !== undefined) { break s; }
- return _r$52;
- $s = 16; continue;
- /* } else if (_ref === "real") { */ case 11:
- _r$53 = c.formatExpr("%e.$real", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 102; case 102: if($c) { $c = false; _r$53 = _r$53.$blk(); } if (_r$53 && _r$53.$blk !== undefined) { break s; }
- return _r$53;
- $s = 16; continue;
- /* } else if (_ref === "imag") { */ case 12:
- _r$54 = c.formatExpr("%e.$imag", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 103; case 103: if($c) { $c = false; _r$54 = _r$54.$blk(); } if (_r$54 && _r$54.$blk !== undefined) { break s; }
- return _r$54;
- $s = 16; continue;
- /* } else if (_ref === "recover") { */ case 13:
- _r$55 = c.formatExpr("$recover()", new sliceType$5([])); /* */ $s = 104; case 104: if($c) { $c = false; _r$55 = _r$55.$blk(); } if (_r$55 && _r$55.$blk !== undefined) { break s; }
- return _r$55;
- $s = 16; continue;
- /* } else if (_ref === "close") { */ case 14:
- _r$56 = c.formatExpr("$close(%e)", new sliceType$5([(0 >= args.$length ? $throwRuntimeError("index out of range") : args.$array[args.$offset + 0])])); /* */ $s = 105; case 105: if($c) { $c = false; _r$56 = _r$56.$blk(); } if (_r$56 && _r$56.$blk !== undefined) { break s; }
- return _r$56;
- $s = 16; continue;
- /* } else { */ case 15:
- _r$57 = fmt.Sprintf("Unhandled builtin: %s\n", new sliceType$5([new $String(name)])); /* */ $s = 106; case 106: if($c) { $c = false; _r$57 = _r$57.$blk(); } if (_r$57 && _r$57.$blk !== undefined) { break s; }
- $panic(new $String(_r$57));
- /* } */ case 16:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateBuiltin }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$16 = _arg$16; $f._arg$17 = _arg$17; $f._arg$18 = _arg$18; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$4 = _r$4; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._r$42 = _r$42; $f._r$43 = _r$43; $f._r$44 = _r$44; $f._r$45 = _r$45; $f._r$46 = _r$46; $f._r$47 = _r$47; $f._r$48 = _r$48; $f._r$49 = _r$49; $f._r$5 = _r$5; $f._r$50 = _r$50; $f._r$51 = _r$51; $f._r$52 = _r$52; $f._r$53 = _r$53; $f._r$54 = _r$54; $f._r$55 = _r$55; $f._r$56 = _r$56; $f._r$57 = _r$57; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f._v = _v; $f.argType = argType; $f.argType$1 = argType$1; $f.argType$10 = argType$10; $f.argType$11 = argType$11; $f.argType$12 = argType$12; $f.argType$2 = argType$2; $f.argType$3 = argType$3; $f.argType$4 = argType$4; $f.argType$5 = argType$5; $f.argType$6 = argType$6; $f.argType$7 = argType$7; $f.argType$8 = argType$8; $f.argType$9 = argType$9; $f.args = args; $f.basic = basic; $f.c = c; $f.ellipsis = ellipsis; $f.isBasic = isBasic; $f.keyType = keyType; $f.length = length; $f.name = name; $f.sliceType$11 = sliceType$11; $f.t = t; $f.t$1 = t$1; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateBuiltin = function(name, args, ellipsis, typ) { return this.$val.translateBuiltin(name, args, ellipsis, typ); };
- funcContext.ptr.prototype.identifierConstant = function(expr) {
- var $ptr, _entry, _i, _r, _ref, _rune, c, c$1, expr, i, s, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _r = $f._r; _ref = $f._ref; _rune = $f._rune; c = $f.c; c$1 = $f.c$1; expr = $f.expr; i = $f.i; s = $f.s; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- val = (_entry = c.p.Info.Info.Types[ast.Expr.keyFor(expr)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Value;
- if ($interfaceIsEqual(val, $ifaceNil)) {
- return ["", false];
- }
- _r = exact.StringVal(val); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- s = _r;
- if (s.length === 0) {
- return ["", false];
- }
- _ref = s;
- _i = 0;
- while (true) {
- if (!(_i < _ref.length)) { break; }
- _rune = $decodeRune(_ref, _i);
- i = _i;
- c$1 = _rune[0];
- if (!((c$1 >= 97 && c$1 <= 122) || (c$1 >= 65 && c$1 <= 90) || (i > 0 && c$1 >= 48 && c$1 <= 57) || (c$1 === 95) || (c$1 === 36))) {
- return ["", false];
- }
- _i += _rune[1];
- }
- return [s, true];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.identifierConstant }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._rune = _rune; $f.c = c; $f.c$1 = c$1; $f.expr = expr; $f.i = i; $f.s = s; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.identifierConstant = function(expr) { return this.$val.identifierConstant(expr); };
- funcContext.ptr.prototype.translateExprSlice = function(exprs, desiredType) {
- var $ptr, _i, _r, _r$1, _ref, c, desiredType, expr, exprs, i, parts, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; c = $f.c; desiredType = $f.desiredType; expr = $f.expr; exprs = $f.exprs; i = $f.i; parts = $f.parts; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- parts = $makeSlice(sliceType, exprs.$length);
- _ref = exprs;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- expr = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = c.translateImplicitConversion(expr, desiredType); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.String(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ((i < 0 || i >= parts.$length) ? $throwRuntimeError("index out of range") : parts.$array[parts.$offset + i] = _r$1);
- _i++;
- /* } */ $s = 1; continue; case 2:
- return parts;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateExprSlice }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.c = c; $f.desiredType = desiredType; $f.expr = expr; $f.exprs = exprs; $f.i = i; $f.parts = parts; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateExprSlice = function(exprs, desiredType) { return this.$val.translateExprSlice(exprs, desiredType); };
- funcContext.ptr.prototype.translateConversion = function(expr, desiredType) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$16, _arg$17, _arg$18, _arg$19, _arg$2, _arg$20, _arg$21, _arg$22, _arg$23, _arg$24, _arg$25, _arg$26, _arg$27, _arg$28, _arg$29, _arg$3, _arg$30, _arg$31, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _entry, _entry$1, _entry$2, _entry$3, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$37, _r$38, _r$39, _r$4, _r$40, _r$41, _r$42, _r$43, _r$44, _r$45, _r$46, _r$47, _r$48, _r$49, _r$5, _r$50, _r$51, _r$52, _r$53, _r$54, _r$55, _r$56, _r$57, _r$58, _r$59, _r$6, _r$60, _r$61, _r$62, _r$63, _r$64, _r$65, _r$66, _r$67, _r$68, _r$69, _r$7, _r$70, _r$71, _r$72, _r$73, _r$74, _r$75, _r$76, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _tuple, _tuple$1, _tuple$10, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, _tuple$9, _v, _v$1, _v$2, array, array$1, basicExprType, c, call, call$1, desiredType, et, et$1, et$2, et$3, et$4, expr, exprType, exprTypeElem, getterConv, id, ident, indexExpr, isCall, isIdent, isIndexExpr, isNamed, isPtr, isPtr$1, isStruct, isStruct$1, isUnary, named, ok, ok$1, ptr, ptr$1, ptrVar, s, s$1, setterConv, t, t$1, t$2, t$3, target, target$1, unary, value, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$16 = $f._arg$16; _arg$17 = $f._arg$17; _arg$18 = $f._arg$18; _arg$19 = $f._arg$19; _arg$2 = $f._arg$2; _arg$20 = $f._arg$20; _arg$21 = $f._arg$21; _arg$22 = $f._arg$22; _arg$23 = $f._arg$23; _arg$24 = $f._arg$24; _arg$25 = $f._arg$25; _arg$26 = $f._arg$26; _arg$27 = $f._arg$27; _arg$28 = $f._arg$28; _arg$29 = $f._arg$29; _arg$3 = $f._arg$3; _arg$30 = $f._arg$30; _arg$31 = $f._arg$31; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$4 = $f._r$4; _r$40 = $f._r$40; _r$41 = $f._r$41; _r$42 = $f._r$42; _r$43 = $f._r$43; _r$44 = $f._r$44; _r$45 = $f._r$45; _r$46 = $f._r$46; _r$47 = $f._r$47; _r$48 = $f._r$48; _r$49 = $f._r$49; _r$5 = $f._r$5; _r$50 = $f._r$50; _r$51 = $f._r$51; _r$52 = $f._r$52; _r$53 = $f._r$53; _r$54 = $f._r$54; _r$55 = $f._r$55; _r$56 = $f._r$56; _r$57 = $f._r$57; _r$58 = $f._r$58; _r$59 = $f._r$59; _r$6 = $f._r$6; _r$60 = $f._r$60; _r$61 = $f._r$61; _r$62 = $f._r$62; _r$63 = $f._r$63; _r$64 = $f._r$64; _r$65 = $f._r$65; _r$66 = $f._r$66; _r$67 = $f._r$67; _r$68 = $f._r$68; _r$69 = $f._r$69; _r$7 = $f._r$7; _r$70 = $f._r$70; _r$71 = $f._r$71; _r$72 = $f._r$72; _r$73 = $f._r$73; _r$74 = $f._r$74; _r$75 = $f._r$75; _r$76 = $f._r$76; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$10 = $f._tuple$10; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; _tuple$9 = $f._tuple$9; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; array = $f.array; array$1 = $f.array$1; basicExprType = $f.basicExprType; c = $f.c; call = $f.call; call$1 = $f.call$1; desiredType = $f.desiredType; et = $f.et; et$1 = $f.et$1; et$2 = $f.et$2; et$3 = $f.et$3; et$4 = $f.et$4; expr = $f.expr; exprType = $f.exprType; exprTypeElem = $f.exprTypeElem; getterConv = $f.getterConv; id = $f.id; ident = $f.ident; indexExpr = $f.indexExpr; isCall = $f.isCall; isIdent = $f.isIdent; isIndexExpr = $f.isIndexExpr; isNamed = $f.isNamed; isPtr = $f.isPtr; isPtr$1 = $f.isPtr$1; isStruct = $f.isStruct; isStruct$1 = $f.isStruct$1; isUnary = $f.isUnary; named = $f.named; ok = $f.ok; ok$1 = $f.ok$1; ptr = $f.ptr; ptr$1 = $f.ptr$1; ptrVar = $f.ptrVar; s = $f.s; s$1 = $f.s$1; setterConv = $f.setterConv; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; target = $f.target; target$1 = $f.target$1; unary = $f.unary; value = $f.value; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- array = [array];
- c = [c];
- expr = [expr];
- s = [s];
- target = [target];
- c[0] = this;
- exprType = (_entry = c[0].p.Info.Info.Types[ast.Expr.keyFor(expr[0])], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type;
- _r = types.Identical(exprType, desiredType); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r) { */ case 1:
- _r$1 = c[0].translateExpr(expr[0]); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* } */ case 2:
- /* */ if (c[0].p.Info.Pkg.Path() === "reflect") { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (c[0].p.Info.Pkg.Path() === "reflect") { */ case 5:
- _tuple = $assertType(expr[0], ptrType$13, true); call = _tuple[0]; isCall = _tuple[1];
- if (!(isCall)) { _v = false; $s = 9; continue s; }
- _r$2 = types.Identical((_entry$1 = c[0].p.Info.Info.Types[ast.Expr.keyFor(call.Fun)], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Type, types.Typ[18]); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2; case 9:
- /* */ if (_v) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (_v) { */ case 7:
- _tuple$1 = $assertType(desiredType, ptrType$17, true); ptr = _tuple$1[0]; isPtr = _tuple$1[1];
- /* */ if (isPtr) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (isPtr) { */ case 11:
- _tuple$2 = $assertType(ptr.Elem(), ptrType$34, true); named = _tuple$2[0]; isNamed = _tuple$2[1];
- /* */ if (isNamed) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (isNamed) { */ case 13:
- _ref = named.Obj().object.Name();
- /* */ if (_ref === "arrayType" || _ref === "chanType" || _ref === "funcType" || _ref === "interfaceType" || _ref === "mapType" || _ref === "ptrType" || _ref === "sliceType" || _ref === "structType") { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_ref === "arrayType" || _ref === "chanType" || _ref === "funcType" || _ref === "interfaceType" || _ref === "mapType" || _ref === "ptrType" || _ref === "sliceType" || _ref === "structType") { */ case 15:
- _r$3 = c[0].formatExpr("%e.kindType", new sliceType$5([(x = call.Args, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0]))])); /* */ $s = 18; case 18: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 17; continue;
- /* } else { */ case 16:
- _r$4 = c[0].translateExpr(expr[0]); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- /* } */ case 17:
- /* } */ case 14:
- /* } */ case 12:
- /* } */ case 8:
- /* } */ case 6:
- _r$5 = desiredType.Underlying(); /* */ $s = 20; case 20: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _ref$1 = _r$5;
- /* */ if ($assertType(_ref$1, ptrType$3, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref$1, ptrType$21, true)[1]) { $s = 22; continue; }
- /* */ if ($assertType(_ref$1, ptrType$17, true)[1]) { $s = 23; continue; }
- /* */ if ($assertType(_ref$1, ptrType$30, true)[1]) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if ($assertType(_ref$1, ptrType$3, true)[1]) { */ case 21:
- t = _ref$1.$val;
- /* */ if (isInteger(t)) { $s = 26; continue; }
- /* */ if (isFloat(t)) { $s = 27; continue; }
- /* */ if (isComplex(t)) { $s = 28; continue; }
- /* */ if (isString(t)) { $s = 29; continue; }
- /* */ if (t.Kind() === 18) { $s = 30; continue; }
- /* */ $s = 31; continue;
- /* if (isInteger(t)) { */ case 26:
- _r$6 = exprType.Underlying(); /* */ $s = 32; case 32: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- basicExprType = $assertType(_r$6, ptrType$3);
- /* */ if (is64Bit(t)) { $s = 33; continue; }
- /* */ if (is64Bit(basicExprType)) { $s = 34; continue; }
- /* */ if (isFloat(basicExprType)) { $s = 35; continue; }
- _r$7 = types.Identical(exprType, types.Typ[18]); /* */ $s = 39; case 39: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- /* */ if (_r$7) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (is64Bit(t)) { */ case 33:
- /* */ if (!is64Bit(basicExprType)) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if (!is64Bit(basicExprType)) { */ case 40:
- /* */ if (basicExprType.Kind() === 12) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (basicExprType.Kind() === 12) { */ case 42:
- _r$8 = c[0].typeName(desiredType); /* */ $s = 44; case 44: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg = new $String(_r$8);
- _arg$1 = expr[0];
- _r$9 = c[0].formatExpr("new %1s(0, %2e.constructor === Number ? %2e : 1)", new sliceType$5([_arg, _arg$1])); /* */ $s = 45; case 45: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- return _r$9;
- /* } */ case 43:
- _r$10 = c[0].typeName(desiredType); /* */ $s = 46; case 46: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$10);
- _arg$3 = expr[0];
- _r$11 = c[0].formatExpr("new %s(0, %e)", new sliceType$5([_arg$2, _arg$3])); /* */ $s = 47; case 47: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- /* } */ case 41:
- _r$12 = c[0].typeName(desiredType); /* */ $s = 48; case 48: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _arg$4 = new $String(_r$12);
- _arg$5 = expr[0];
- _r$13 = c[0].formatExpr("new %1s(%2h, %2l)", new sliceType$5([_arg$4, _arg$5])); /* */ $s = 49; case 49: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- return _r$13;
- $s = 38; continue;
- /* } else if (is64Bit(basicExprType)) { */ case 34:
- /* */ if (!isUnsigned(t) && !isUnsigned(basicExprType)) { $s = 50; continue; }
- /* */ $s = 51; continue;
- /* if (!isUnsigned(t) && !isUnsigned(basicExprType)) { */ case 50:
- _r$14 = c[0].formatParenExpr("%1l + ((%1h >> 31) * 4294967296)", new sliceType$5([expr[0]])); /* */ $s = 52; case 52: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _r$15 = c[0].fixNumber(_r$14, t); /* */ $s = 53; case 53: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- return _r$15;
- /* } */ case 51:
- _r$16 = c[0].translateExpr(expr[0]); /* */ $s = 54; case 54: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _arg$6 = _r$16;
- _r$17 = c[0].formatExpr("%s.$low", new sliceType$5([_arg$6])); /* */ $s = 55; case 55: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _r$18 = c[0].fixNumber(_r$17, t); /* */ $s = 56; case 56: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- return _r$18;
- $s = 38; continue;
- /* } else if (isFloat(basicExprType)) { */ case 35:
- _r$19 = c[0].formatParenExpr("%e >> 0", new sliceType$5([expr[0]])); /* */ $s = 57; case 57: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- return _r$19;
- $s = 38; continue;
- /* } else if (_r$7) { */ case 36:
- _r$20 = c[0].translateExpr(expr[0]); /* */ $s = 58; case 58: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- return _r$20;
- $s = 38; continue;
- /* } else { */ case 37:
- _r$21 = c[0].translateExpr(expr[0]); /* */ $s = 59; case 59: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- _r$22 = c[0].fixNumber(_r$21, t); /* */ $s = 60; case 60: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- return _r$22;
- /* } */ case 38:
- $s = 31; continue;
- /* } else if (isFloat(t)) { */ case 27:
- if (!(t.Kind() === 13)) { _v$1 = false; $s = 63; continue s; }
- _r$23 = exprType.Underlying(); /* */ $s = 64; case 64: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _r$24 = $assertType(_r$23, ptrType$3).Kind(); /* */ $s = 65; case 65: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _v$1 = _r$24 === 14; case 63:
- /* */ if (_v$1) { $s = 61; continue; }
- /* */ $s = 62; continue;
- /* if (_v$1) { */ case 61:
- _r$25 = c[0].formatExpr("$fround(%e)", new sliceType$5([expr[0]])); /* */ $s = 66; case 66: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- return _r$25;
- /* } */ case 62:
- _r$26 = c[0].formatExpr("%f", new sliceType$5([expr[0]])); /* */ $s = 67; case 67: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- return _r$26;
- $s = 31; continue;
- /* } else if (isComplex(t)) { */ case 28:
- _r$27 = c[0].typeName(desiredType); /* */ $s = 68; case 68: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _arg$7 = new $String(_r$27);
- _arg$8 = expr[0];
- _r$28 = c[0].formatExpr("new %1s(%2r, %2i)", new sliceType$5([_arg$7, _arg$8])); /* */ $s = 69; case 69: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- return _r$28;
- $s = 31; continue;
- /* } else if (isString(t)) { */ case 29:
- _r$29 = c[0].translateExpr(expr[0]); /* */ $s = 70; case 70: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- value = _r$29;
- _r$30 = exprType.Underlying(); /* */ $s = 71; case 71: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _ref$2 = _r$30;
- /* */ if ($assertType(_ref$2, ptrType$3, true)[1]) { $s = 72; continue; }
- /* */ if ($assertType(_ref$2, ptrType$21, true)[1]) { $s = 73; continue; }
- /* */ $s = 74; continue;
- /* if ($assertType(_ref$2, ptrType$3, true)[1]) { */ case 72:
- et = _ref$2.$val;
- /* */ if (is64Bit(et)) { $s = 76; continue; }
- /* */ $s = 77; continue;
- /* if (is64Bit(et)) { */ case 76:
- _r$31 = c[0].formatExpr("%s.$low", new sliceType$5([value])); /* */ $s = 78; case 78: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- value = _r$31;
- /* } */ case 77:
- /* */ if (isNumeric(et)) { $s = 79; continue; }
- /* */ $s = 80; continue;
- /* if (isNumeric(et)) { */ case 79:
- _r$32 = c[0].formatExpr("$encodeRune(%s)", new sliceType$5([value])); /* */ $s = 81; case 81: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- return _r$32;
- /* } */ case 80:
- return value;
- $s = 75; continue;
- /* } else if ($assertType(_ref$2, ptrType$21, true)[1]) { */ case 73:
- et$1 = _ref$2.$val;
- _r$33 = et$1.Elem().Underlying(); /* */ $s = 84; case 84: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- _r$34 = types.Identical(_r$33, types.Typ[5]); /* */ $s = 85; case 85: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- /* */ if (_r$34) { $s = 82; continue; }
- /* */ $s = 83; continue;
- /* if (_r$34) { */ case 82:
- _r$35 = c[0].formatExpr("$runesToString(%s)", new sliceType$5([value])); /* */ $s = 86; case 86: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- return _r$35;
- /* } */ case 83:
- _r$36 = c[0].formatExpr("$bytesToString(%s)", new sliceType$5([value])); /* */ $s = 87; case 87: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- return _r$36;
- $s = 75; continue;
- /* } else { */ case 74:
- et$2 = _ref$2;
- _r$37 = fmt.Sprintf("Unhandled conversion: %v\n", new sliceType$5([et$2])); /* */ $s = 88; case 88: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- $panic(new $String(_r$37));
- /* } */ case 75:
- $s = 31; continue;
- /* } else if (t.Kind() === 18) { */ case 30:
- _tuple$3 = $assertType(expr[0], ptrType$8, true); unary = _tuple$3[0]; isUnary = _tuple$3[1];
- /* */ if (isUnary && (unary.Op === 17)) { $s = 89; continue; }
- /* */ $s = 90; continue;
- /* if (isUnary && (unary.Op === 17)) { */ case 89:
- _tuple$4 = $assertType(unary.X, ptrType$11, true); indexExpr = _tuple$4[0]; isIndexExpr = _tuple$4[1];
- /* */ if (isIndexExpr) { $s = 91; continue; }
- /* */ $s = 92; continue;
- /* if (isIndexExpr) { */ case 91:
- _r$38 = c[0].translateConversionToSlice(indexExpr.X, types.NewSlice(types.Typ[8])); /* */ $s = 93; case 93: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- _arg$9 = _r$38;
- _r$39 = c[0].formatExpr("$sliceToArray(%s)", new sliceType$5([_arg$9])); /* */ $s = 94; case 94: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- return _r$39;
- /* } */ case 92:
- _tuple$5 = $assertType(unary.X, ptrType$5, true); ident = _tuple$5[0]; isIdent = _tuple$5[1];
- /* */ if (isIdent && ident.Name === "_zero") { $s = 95; continue; }
- /* */ $s = 96; continue;
- /* if (isIdent && ident.Name === "_zero") { */ case 95:
- _r$40 = c[0].formatExpr("new Uint8Array(0)", new sliceType$5([])); /* */ $s = 97; case 97: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- return _r$40;
- /* } */ case 96:
- /* } */ case 90:
- _tuple$6 = $assertType((_entry$2 = c[0].p.Info.Info.Types[ast.Expr.keyFor(expr[0])], _entry$2 !== undefined ? _entry$2.v : new types.TypeAndValue.ptr()).Type, ptrType$17, true); ptr$1 = _tuple$6[0]; isPtr$1 = _tuple$6[1];
- /* */ if (c[0].p.Info.Pkg.Path() === "syscall" && isPtr$1) { $s = 98; continue; }
- /* */ $s = 99; continue;
- /* if (c[0].p.Info.Pkg.Path() === "syscall" && isPtr$1) { */ case 98:
- _r$41 = ptr$1.Elem().Underlying(); /* */ $s = 100; case 100: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- _tuple$7 = $assertType(_r$41, ptrType$23, true); s[0] = _tuple$7[0]; isStruct = _tuple$7[1];
- /* */ if (isStruct) { $s = 101; continue; }
- /* */ $s = 102; continue;
- /* if (isStruct) { */ case 101:
- _r$42 = c[0].newVariable("_array"); /* */ $s = 103; case 103: if($c) { $c = false; _r$42 = _r$42.$blk(); } if (_r$42 && _r$42.$blk !== undefined) { break s; }
- array[0] = _r$42;
- _r$43 = c[0].newVariable("_struct"); /* */ $s = 104; case 104: if($c) { $c = false; _r$43 = _r$43.$blk(); } if (_r$43 && _r$43.$blk !== undefined) { break s; }
- target[0] = _r$43;
- _arg$10 = new $String(array[0]);
- _r$44 = sizes32.Sizeof(s[0]); /* */ $s = 105; case 105: if($c) { $c = false; _r$44 = _r$44.$blk(); } if (_r$44 && _r$44.$blk !== undefined) { break s; }
- _arg$11 = _r$44;
- $r = c[0].Printf("%s = new Uint8Array(%d);", new sliceType$5([_arg$10, _arg$11])); /* */ $s = 106; case 106: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].Delayed((function(array, c, expr, s, target) { return function $b() {
- var $ptr, _arg$12, _arg$13, _arg$14, _r$45, _r$46, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _r$45 = $f._r$45; _r$46 = $f._r$46; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _arg$12 = new $String(target[0]);
- _r$45 = c[0].translateExpr(expr[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- _arg$13 = _r$45;
- _r$46 = c[0].loadStruct(array[0], target[0], s[0]); /* */ $s = 2; case 2: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- _arg$14 = new $String(_r$46);
- $r = c[0].Printf("%s = %s, %s;", new sliceType$5([_arg$12, _arg$13, _arg$14])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._r$45 = _r$45; $f._r$46 = _r$46; $f.$s = $s; $f.$r = $r; return $f;
- }; })(array, c, expr, s, target)); /* */ $s = 107; case 107: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$45 = c[0].formatExpr("%s", new sliceType$5([new $String(array[0])])); /* */ $s = 108; case 108: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- return _r$45;
- /* } */ case 102:
- /* } */ case 99:
- _tuple$8 = $assertType(expr[0], ptrType$13, true); call$1 = _tuple$8[0]; ok = _tuple$8[1];
- /* */ if (ok) { $s = 109; continue; }
- /* */ $s = 110; continue;
- /* if (ok) { */ case 109:
- _tuple$9 = $assertType(call$1.Fun, ptrType$5, true); id = _tuple$9[0]; ok$1 = _tuple$9[1];
- /* */ if (ok$1 && id.Name === "new") { $s = 111; continue; }
- /* */ $s = 112; continue;
- /* if (ok$1 && id.Name === "new") { */ case 111:
- _r$46 = sizes32.Sizeof((_entry$3 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$2 = call$1.Args, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])))], _entry$3 !== undefined ? _entry$3.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 113; case 113: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- _arg$12 = new $Int(((x$1 = _r$46, x$1.$low + ((x$1.$high >> 31) * 4294967296)) >> 0));
- _r$47 = c[0].formatExpr("new Uint8Array(%d)", new sliceType$5([_arg$12])); /* */ $s = 114; case 114: if($c) { $c = false; _r$47 = _r$47.$blk(); } if (_r$47 && _r$47.$blk !== undefined) { break s; }
- return _r$47;
- /* } */ case 112:
- /* } */ case 110:
- /* } */ case 31:
- $s = 25; continue;
- /* } else if ($assertType(_ref$1, ptrType$21, true)[1]) { */ case 22:
- t$1 = _ref$1.$val;
- _r$48 = exprType.Underlying(); /* */ $s = 115; case 115: if($c) { $c = false; _r$48 = _r$48.$blk(); } if (_r$48 && _r$48.$blk !== undefined) { break s; }
- _ref$3 = _r$48;
- /* */ if ($assertType(_ref$3, ptrType$3, true)[1]) { $s = 116; continue; }
- /* */ if ($assertType(_ref$3, ptrType$20, true)[1] || $assertType(_ref$3, ptrType$17, true)[1]) { $s = 117; continue; }
- /* */ $s = 118; continue;
- /* if ($assertType(_ref$3, ptrType$3, true)[1]) { */ case 116:
- et$3 = _ref$3.$val;
- /* */ if (isString(et$3)) { $s = 119; continue; }
- /* */ $s = 120; continue;
- /* if (isString(et$3)) { */ case 119:
- _r$49 = t$1.Elem().Underlying(); /* */ $s = 123; case 123: if($c) { $c = false; _r$49 = _r$49.$blk(); } if (_r$49 && _r$49.$blk !== undefined) { break s; }
- _r$50 = types.Identical(_r$49, types.Typ[5]); /* */ $s = 124; case 124: if($c) { $c = false; _r$50 = _r$50.$blk(); } if (_r$50 && _r$50.$blk !== undefined) { break s; }
- /* */ if (_r$50) { $s = 121; continue; }
- /* */ $s = 122; continue;
- /* if (_r$50) { */ case 121:
- _r$51 = c[0].typeName(desiredType); /* */ $s = 125; case 125: if($c) { $c = false; _r$51 = _r$51.$blk(); } if (_r$51 && _r$51.$blk !== undefined) { break s; }
- _arg$13 = new $String(_r$51);
- _arg$14 = expr[0];
- _r$52 = c[0].formatExpr("new %s($stringToRunes(%e))", new sliceType$5([_arg$13, _arg$14])); /* */ $s = 126; case 126: if($c) { $c = false; _r$52 = _r$52.$blk(); } if (_r$52 && _r$52.$blk !== undefined) { break s; }
- return _r$52;
- /* } */ case 122:
- _r$53 = c[0].typeName(desiredType); /* */ $s = 127; case 127: if($c) { $c = false; _r$53 = _r$53.$blk(); } if (_r$53 && _r$53.$blk !== undefined) { break s; }
- _arg$15 = new $String(_r$53);
- _arg$16 = expr[0];
- _r$54 = c[0].formatExpr("new %s($stringToBytes(%e))", new sliceType$5([_arg$15, _arg$16])); /* */ $s = 128; case 128: if($c) { $c = false; _r$54 = _r$54.$blk(); } if (_r$54 && _r$54.$blk !== undefined) { break s; }
- return _r$54;
- /* } */ case 120:
- $s = 118; continue;
- /* } else if ($assertType(_ref$3, ptrType$20, true)[1] || $assertType(_ref$3, ptrType$17, true)[1]) { */ case 117:
- et$4 = _ref$3;
- _r$55 = c[0].typeName(desiredType); /* */ $s = 129; case 129: if($c) { $c = false; _r$55 = _r$55.$blk(); } if (_r$55 && _r$55.$blk !== undefined) { break s; }
- _arg$17 = new $String(_r$55);
- _arg$18 = expr[0];
- _r$56 = c[0].formatExpr("new %s(%e)", new sliceType$5([_arg$17, _arg$18])); /* */ $s = 130; case 130: if($c) { $c = false; _r$56 = _r$56.$blk(); } if (_r$56 && _r$56.$blk !== undefined) { break s; }
- return _r$56;
- /* } */ case 118:
- $s = 25; continue;
- /* } else if ($assertType(_ref$1, ptrType$17, true)[1]) { */ case 23:
- t$2 = _ref$1.$val;
- _r$57 = t$2.Elem().Underlying(); /* */ $s = 131; case 131: if($c) { $c = false; _r$57 = _r$57.$blk(); } if (_r$57 && _r$57.$blk !== undefined) { break s; }
- _tuple$10 = $assertType(_r$57, ptrType$23, true); s$1 = _tuple$10[0]; isStruct$1 = _tuple$10[1];
- /* */ if (isStruct$1) { $s = 132; continue; }
- /* */ $s = 133; continue;
- /* if (isStruct$1) { */ case 132:
- if (!(c[0].p.Info.Pkg.Path() === "syscall")) { _v$2 = false; $s = 136; continue s; }
- _r$58 = types.Identical(exprType, types.Typ[18]); /* */ $s = 137; case 137: if($c) { $c = false; _r$58 = _r$58.$blk(); } if (_r$58 && _r$58.$blk !== undefined) { break s; }
- _v$2 = _r$58; case 136:
- /* */ if (_v$2) { $s = 134; continue; }
- /* */ $s = 135; continue;
- /* if (_v$2) { */ case 134:
- _r$59 = c[0].newVariable("_array"); /* */ $s = 138; case 138: if($c) { $c = false; _r$59 = _r$59.$blk(); } if (_r$59 && _r$59.$blk !== undefined) { break s; }
- array$1 = _r$59;
- _r$60 = c[0].newVariable("_struct"); /* */ $s = 139; case 139: if($c) { $c = false; _r$60 = _r$60.$blk(); } if (_r$60 && _r$60.$blk !== undefined) { break s; }
- target$1 = _r$60;
- _arg$19 = new $String(array$1);
- _arg$20 = expr[0];
- _arg$21 = new $String(target$1);
- _r$61 = c[0].zeroValue(t$2.Elem()); /* */ $s = 140; case 140: if($c) { $c = false; _r$61 = _r$61.$blk(); } if (_r$61 && _r$61.$blk !== undefined) { break s; }
- _arg$22 = new $String(_r$61);
- _r$62 = c[0].loadStruct(array$1, target$1, s$1); /* */ $s = 141; case 141: if($c) { $c = false; _r$62 = _r$62.$blk(); } if (_r$62 && _r$62.$blk !== undefined) { break s; }
- _arg$23 = new $String(_r$62);
- _arg$24 = new $String(target$1);
- _r$63 = c[0].formatExpr("(%s = %e, %s = %s, %s, %s)", new sliceType$5([_arg$19, _arg$20, _arg$21, _arg$22, _arg$23, _arg$24])); /* */ $s = 142; case 142: if($c) { $c = false; _r$63 = _r$63.$blk(); } if (_r$63 && _r$63.$blk !== undefined) { break s; }
- return _r$63;
- /* } */ case 135:
- _arg$25 = expr[0];
- _r$64 = c[0].typeName(t$2); /* */ $s = 143; case 143: if($c) { $c = false; _r$64 = _r$64.$blk(); } if (_r$64 && _r$64.$blk !== undefined) { break s; }
- _arg$26 = new $String(_r$64);
- _r$65 = c[0].formatExpr("$pointerOfStructConversion(%e, %s)", new sliceType$5([_arg$25, _arg$26])); /* */ $s = 144; case 144: if($c) { $c = false; _r$65 = _r$65.$blk(); } if (_r$65 && _r$65.$blk !== undefined) { break s; }
- return _r$65;
- /* } */ case 133:
- _r$66 = types.Identical(exprType, types.Typ[18]); /* */ $s = 147; case 147: if($c) { $c = false; _r$66 = _r$66.$blk(); } if (_r$66 && _r$66.$blk !== undefined) { break s; }
- /* */ if (!_r$66) { $s = 145; continue; }
- /* */ $s = 146; continue;
- /* if (!_r$66) { */ case 145:
- _r$67 = exprType.Underlying(); /* */ $s = 148; case 148: if($c) { $c = false; _r$67 = _r$67.$blk(); } if (_r$67 && _r$67.$blk !== undefined) { break s; }
- _r$68 = $assertType(_r$67, ptrType$17).Elem(); /* */ $s = 149; case 149: if($c) { $c = false; _r$68 = _r$68.$blk(); } if (_r$68 && _r$68.$blk !== undefined) { break s; }
- exprTypeElem = _r$68;
- _r$69 = c[0].newVariable("_ptr"); /* */ $s = 150; case 150: if($c) { $c = false; _r$69 = _r$69.$blk(); } if (_r$69 && _r$69.$blk !== undefined) { break s; }
- ptrVar = _r$69;
- _r$70 = c[0].translateConversion(c[0].setType(new ast.StarExpr.ptr(0, c[0].newIdent(ptrVar, exprType)), exprTypeElem), t$2.Elem()); /* */ $s = 151; case 151: if($c) { $c = false; _r$70 = _r$70.$blk(); } if (_r$70 && _r$70.$blk !== undefined) { break s; }
- getterConv = _r$70;
- _r$71 = c[0].translateConversion(c[0].newIdent("$v", t$2.Elem()), exprTypeElem); /* */ $s = 152; case 152: if($c) { $c = false; _r$71 = _r$71.$blk(); } if (_r$71 && _r$71.$blk !== undefined) { break s; }
- setterConv = _r$71;
- _arg$27 = new $String(ptrVar);
- _arg$28 = expr[0];
- _r$72 = c[0].typeName(desiredType); /* */ $s = 153; case 153: if($c) { $c = false; _r$72 = _r$72.$blk(); } if (_r$72 && _r$72.$blk !== undefined) { break s; }
- _arg$29 = new $String(_r$72);
- _arg$30 = getterConv;
- _arg$31 = setterConv;
- _r$73 = c[0].formatExpr("(%1s = %2e, new %3s(function() { return %4s; }, function($v) { %1s.$set(%5s); }, %1s.$target))", new sliceType$5([_arg$27, _arg$28, _arg$29, _arg$30, _arg$31])); /* */ $s = 154; case 154: if($c) { $c = false; _r$73 = _r$73.$blk(); } if (_r$73 && _r$73.$blk !== undefined) { break s; }
- return _r$73;
- /* } */ case 146:
- $s = 25; continue;
- /* } else if ($assertType(_ref$1, ptrType$30, true)[1]) { */ case 24:
- t$3 = _ref$1.$val;
- _r$74 = types.Identical(exprType, types.Typ[18]); /* */ $s = 157; case 157: if($c) { $c = false; _r$74 = _r$74.$blk(); } if (_r$74 && _r$74.$blk !== undefined) { break s; }
- /* */ if (_r$74) { $s = 155; continue; }
- /* */ $s = 156; continue;
- /* if (_r$74) { */ case 155:
- _r$75 = c[0].translateExpr(expr[0]); /* */ $s = 158; case 158: if($c) { $c = false; _r$75 = _r$75.$blk(); } if (_r$75 && _r$75.$blk !== undefined) { break s; }
- return _r$75;
- /* } */ case 156:
- /* } */ case 25:
- _r$76 = c[0].translateImplicitConversionWithCloning(expr[0], desiredType); /* */ $s = 159; case 159: if($c) { $c = false; _r$76 = _r$76.$blk(); } if (_r$76 && _r$76.$blk !== undefined) { break s; }
- return _r$76;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateConversion }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$16 = _arg$16; $f._arg$17 = _arg$17; $f._arg$18 = _arg$18; $f._arg$19 = _arg$19; $f._arg$2 = _arg$2; $f._arg$20 = _arg$20; $f._arg$21 = _arg$21; $f._arg$22 = _arg$22; $f._arg$23 = _arg$23; $f._arg$24 = _arg$24; $f._arg$25 = _arg$25; $f._arg$26 = _arg$26; $f._arg$27 = _arg$27; $f._arg$28 = _arg$28; $f._arg$29 = _arg$29; $f._arg$3 = _arg$3; $f._arg$30 = _arg$30; $f._arg$31 = _arg$31; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$4 = _r$4; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._r$42 = _r$42; $f._r$43 = _r$43; $f._r$44 = _r$44; $f._r$45 = _r$45; $f._r$46 = _r$46; $f._r$47 = _r$47; $f._r$48 = _r$48; $f._r$49 = _r$49; $f._r$5 = _r$5; $f._r$50 = _r$50; $f._r$51 = _r$51; $f._r$52 = _r$52; $f._r$53 = _r$53; $f._r$54 = _r$54; $f._r$55 = _r$55; $f._r$56 = _r$56; $f._r$57 = _r$57; $f._r$58 = _r$58; $f._r$59 = _r$59; $f._r$6 = _r$6; $f._r$60 = _r$60; $f._r$61 = _r$61; $f._r$62 = _r$62; $f._r$63 = _r$63; $f._r$64 = _r$64; $f._r$65 = _r$65; $f._r$66 = _r$66; $f._r$67 = _r$67; $f._r$68 = _r$68; $f._r$69 = _r$69; $f._r$7 = _r$7; $f._r$70 = _r$70; $f._r$71 = _r$71; $f._r$72 = _r$72; $f._r$73 = _r$73; $f._r$74 = _r$74; $f._r$75 = _r$75; $f._r$76 = _r$76; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$10 = _tuple$10; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f._tuple$9 = _tuple$9; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.array = array; $f.array$1 = array$1; $f.basicExprType = basicExprType; $f.c = c; $f.call = call; $f.call$1 = call$1; $f.desiredType = desiredType; $f.et = et; $f.et$1 = et$1; $f.et$2 = et$2; $f.et$3 = et$3; $f.et$4 = et$4; $f.expr = expr; $f.exprType = exprType; $f.exprTypeElem = exprTypeElem; $f.getterConv = getterConv; $f.id = id; $f.ident = ident; $f.indexExpr = indexExpr; $f.isCall = isCall; $f.isIdent = isIdent; $f.isIndexExpr = isIndexExpr; $f.isNamed = isNamed; $f.isPtr = isPtr; $f.isPtr$1 = isPtr$1; $f.isStruct = isStruct; $f.isStruct$1 = isStruct$1; $f.isUnary = isUnary; $f.named = named; $f.ok = ok; $f.ok$1 = ok$1; $f.ptr = ptr; $f.ptr$1 = ptr$1; $f.ptrVar = ptrVar; $f.s = s; $f.s$1 = s$1; $f.setterConv = setterConv; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.target = target; $f.target$1 = target$1; $f.unary = unary; $f.value = value; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateConversion = function(expr, desiredType) { return this.$val.translateConversion(expr, desiredType); };
- funcContext.ptr.prototype.translateImplicitConversionWithCloning = function(expr, desiredType) {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _ref, _ref$1, c, desiredType, expr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; c = $f.c; desiredType = $f.desiredType; expr = $f.expr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = desiredType.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$23, true)[1] || $assertType(_ref, ptrType$20, true)[1]) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($assertType(_ref, ptrType$23, true)[1] || $assertType(_ref, ptrType$20, true)[1]) { */ case 2:
- _ref$1 = expr;
- /* */ if (_ref$1 === $ifaceNil || $assertType(_ref$1, ptrType$6, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref$1 === $ifaceNil || $assertType(_ref$1, ptrType$6, true)[1]) { */ case 4:
- $s = 6; continue;
- /* } else { */ case 5:
- _arg = expr;
- _r$1 = c.typeName(desiredType); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$1);
- _r$2 = c.formatExpr("$clone(%e, %s)", new sliceType$5([_arg, _arg$1])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* } */ case 6:
- /* } */ case 3:
- _r$3 = c.translateImplicitConversion(expr, desiredType); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateImplicitConversionWithCloning }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f.c = c; $f.desiredType = desiredType; $f.expr = expr; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateImplicitConversionWithCloning = function(expr, desiredType) { return this.$val.translateImplicitConversionWithCloning(expr, desiredType); };
- funcContext.ptr.prototype.translateImplicitConversion = function(expr, desiredType) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _entry, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _tuple, _tuple$1, basicExprType, c, desiredType, expr, exprType, isBasicExpr, isStruct, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; basicExprType = $f.basicExprType; c = $f.c; desiredType = $f.desiredType; expr = $f.expr; exprType = $f.exprType; isBasicExpr = $f.isBasicExpr; isStruct = $f.isStruct; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- /* */ if ($interfaceIsEqual(desiredType, $ifaceNil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ($interfaceIsEqual(desiredType, $ifaceNil)) { */ case 1:
- _r = c.translateExpr(expr); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- /* */ if ($interfaceIsEqual(expr, $ifaceNil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($interfaceIsEqual(expr, $ifaceNil)) { */ case 4:
- _r$1 = c.zeroValue(desiredType); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg = new $String(_r$1);
- _r$2 = c.formatExpr("%s", new sliceType$5([_arg])); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* } */ case 5:
- exprType = (_entry = c.p.Info.Info.Types[ast.Expr.keyFor(expr)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type;
- _r$3 = types.Identical(exprType, desiredType); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- /* */ if (_r$3) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_r$3) { */ case 8:
- _r$4 = c.translateExpr(expr); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- /* } */ case 9:
- _r$5 = exprType.Underlying(); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$5, ptrType$3, true); basicExprType = _tuple[0]; isBasicExpr = _tuple[1];
- /* */ if (isBasicExpr && (basicExprType.Kind() === 25)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (isBasicExpr && (basicExprType.Kind() === 25)) { */ case 13:
- _r$6 = c.zeroValue(desiredType); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$6);
- _r$7 = c.formatExpr("%s", new sliceType$5([_arg$1])); /* */ $s = 16; case 16: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7;
- /* } */ case 14:
- _r$8 = desiredType.Underlying(); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _ref = _r$8;
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if ($assertType(_ref, ptrType$21, true)[1]) { */ case 18:
- _r$9 = c.typeName(desiredType); /* */ $s = 21; case 21: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$9);
- _arg$3 = expr;
- _r$10 = c.formatExpr("$subslice(new %1s(%2e.$array), %2e.$offset, %2e.$offset + %2e.$length)", new sliceType$5([_arg$2, _arg$3])); /* */ $s = 22; case 22: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- return _r$10;
- $s = 20; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 19:
- /* */ if (typesutil.IsJsObject(exprType)) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (typesutil.IsJsObject(exprType)) { */ case 23:
- _r$11 = c.formatExpr("new $jsObjectPtr(%e)", new sliceType$5([expr])); /* */ $s = 25; case 25: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- /* } */ case 24:
- _r$12 = isWrapped(exprType); /* */ $s = 28; case 28: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- /* */ if (_r$12) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (_r$12) { */ case 26:
- _r$13 = c.typeName(exprType); /* */ $s = 29; case 29: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _arg$4 = new $String(_r$13);
- _arg$5 = expr;
- _r$14 = c.formatExpr("new %s(%e)", new sliceType$5([_arg$4, _arg$5])); /* */ $s = 30; case 30: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- return _r$14;
- /* } */ case 27:
- _r$15 = exprType.Underlying(); /* */ $s = 31; case 31: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r$15, ptrType$23, true); isStruct = _tuple$1[1];
- /* */ if (isStruct) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (isStruct) { */ case 32:
- _r$16 = c.formatExpr("new %1e.constructor.elem(%1e)", new sliceType$5([expr])); /* */ $s = 34; case 34: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- return _r$16;
- /* } */ case 33:
- /* } */ case 20:
- _r$17 = c.translateExpr(expr); /* */ $s = 35; case 35: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- return _r$17;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateImplicitConversion }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.basicExprType = basicExprType; $f.c = c; $f.desiredType = desiredType; $f.expr = expr; $f.exprType = exprType; $f.isBasicExpr = isBasicExpr; $f.isStruct = isStruct; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateImplicitConversion = function(expr, desiredType) { return this.$val.translateImplicitConversion(expr, desiredType); };
- funcContext.ptr.prototype.translateConversionToSlice = function(expr, desiredType) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _entry, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, c, desiredType, expr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _entry = $f._entry; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; c = $f.c; desiredType = $f.desiredType; expr = $f.expr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = (_entry = c.p.Info.Info.Types[ast.Expr.keyFor(expr)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1] || $assertType(_ref, ptrType$17, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- _r$1 = c.typeName(desiredType); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg = new $String(_r$1);
- _arg$1 = expr;
- _r$2 = c.formatExpr("new %s($stringToBytes(%e))", new sliceType$5([_arg, _arg$1])); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1] || $assertType(_ref, ptrType$17, true)[1]) { */ case 3:
- _r$3 = c.typeName(desiredType); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$3);
- _arg$3 = expr;
- _r$4 = c.formatExpr("new %s(%e)", new sliceType$5([_arg$2, _arg$3])); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- /* } */ case 4:
- _r$5 = c.translateExpr(expr); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateConversionToSlice }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._entry = _entry; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.c = c; $f.desiredType = desiredType; $f.expr = expr; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateConversionToSlice = function(expr, desiredType) { return this.$val.translateConversionToSlice(expr, desiredType); };
- funcContext.ptr.prototype.loadStruct = function(array, target, s) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, array, c, code, collectFields, field, fields, i, offsets, s, t, t$1, target, view, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; array = $f.array; c = $f.c; code = $f.code; collectFields = $f.collectFields; field = $f.field; fields = $f.fields; i = $f.i; offsets = $f.offsets; s = $f.s; t = $f.t; t$1 = $f.t$1; target = $f.target; view = $f.view; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- collectFields = [collectFields];
- fields = [fields];
- c = this;
- _r = c.newVariable("_view"); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- view = _r;
- _r$1 = fmt.Sprintf("%s = new DataView(%s.buffer, %s.byteOffset)", new sliceType$5([new $String(view), new $String(array), new $String(array)])); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- code = _r$1;
- fields[0] = sliceType$8.nil;
- collectFields[0] = $throwNilPointerError;
- collectFields[0] = (function(collectFields, fields) { return function $b(s$1, path) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _r$2, _r$3, _r$4, _r$5, _tuple, field, fs, i, isStruct, path, s$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _tuple = $f._tuple; field = $f.field; fs = $f.fs; i = $f.i; isStruct = $f.isStruct; path = $f.path; s$1 = $f.s$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < s$1.NumFields())) { break; } */ if(!(i < s$1.NumFields())) { $s = 2; continue; }
- field = s$1.Field(i);
- _r$2 = field.object.Type().Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$2, ptrType$23, true); fs = _tuple[0]; isStruct = _tuple[1];
- /* */ if (isStruct) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (isStruct) { */ case 4:
- _arg = fs;
- _r$3 = fieldName(s$1, i); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$1 = path + "." + _r$3;
- $r = collectFields[0](_arg, _arg$1); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* continue; */ $s = 1; continue;
- /* } */ case 5:
- _arg$2 = ptrType$28.nil;
- _r$4 = fieldName(s$1, i); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$3 = path + "." + _r$4;
- _arg$4 = field.object.Type();
- _r$5 = types.NewVar(0, _arg$2, _arg$3, _arg$4); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- fields[0] = $append(fields[0], _r$5);
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._tuple = _tuple; $f.field = field; $f.fs = fs; $f.i = i; $f.isStruct = isStruct; $f.path = path; $f.s$1 = s$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(collectFields, fields);
- $r = collectFields[0](s, target); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$2 = sizes32.Offsetsof(fields[0]); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- offsets = _r$2;
- _ref = fields[0];
- _i = 0;
- /* while (true) { */ case 5:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 6; continue; }
- i = _i;
- field = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$3 = field.object.Type().Underlying(); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _ref$1 = _r$3;
- /* */ if ($assertType(_ref$1, ptrType$3, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref$1, ptrType$20, true)[1]) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* switch (0) { default: if ($assertType(_ref$1, ptrType$3, true)[1]) { */ case 8:
- t = _ref$1.$val;
- /* */ if (isNumeric(t)) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (isNumeric(t)) { */ case 11:
- /* */ if (is64Bit(t)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (is64Bit(t)) { */ case 13:
- _arg = new $String(field.object.Name());
- _r$4 = c.typeName(field.object.Type()); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$4);
- _arg$2 = new $String(view);
- _arg$3 = (x = ((i < 0 || i >= offsets.$length) ? $throwRuntimeError("index out of range") : offsets.$array[offsets.$offset + i]), new $Int64(x.$high + 0, x.$low + 4));
- _arg$4 = new $String(view);
- _arg$5 = ((i < 0 || i >= offsets.$length) ? $throwRuntimeError("index out of range") : offsets.$array[offsets.$offset + i]);
- _r$5 = fmt.Sprintf(", %s = new %s(%s.getUint32(%d, true), %s.getUint32(%d, true))", new sliceType$5([_arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5])); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- code = code + (_r$5);
- /* break; */ $s = 10; continue;
- /* } */ case 14:
- _arg$6 = new $String(field.object.Name());
- _arg$7 = new $String(view);
- _r$6 = toJavaScriptType(t); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _arg$8 = new $String(_r$6);
- _arg$9 = ((i < 0 || i >= offsets.$length) ? $throwRuntimeError("index out of range") : offsets.$array[offsets.$offset + i]);
- _r$7 = fmt.Sprintf(", %s = %s.get%s(%d, true)", new sliceType$5([_arg$6, _arg$7, _arg$8, _arg$9])); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- code = code + (_r$7);
- /* } */ case 12:
- $s = 10; continue;
- /* } else if ($assertType(_ref$1, ptrType$20, true)[1]) { */ case 9:
- t$1 = _ref$1.$val;
- _arg$10 = new $String(field.object.Name());
- _r$8 = typeKind(t$1.Elem()); /* */ $s = 19; case 19: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$11 = new $String(_r$8);
- _arg$12 = new $String(array);
- _arg$13 = new $String(array);
- _arg$14 = ((i < 0 || i >= offsets.$length) ? $throwRuntimeError("index out of range") : offsets.$array[offsets.$offset + i]);
- _arg$15 = new $String(array);
- _r$9 = fmt.Sprintf(", %s = new ($nativeArray(%s))(%s.buffer, $min(%s.byteOffset + %d, %s.buffer.byteLength))", new sliceType$5([_arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15])); /* */ $s = 20; case 20: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- code = code + (_r$9);
- /* } } */ case 10:
- _i++;
- /* } */ $s = 5; continue; case 6:
- return code;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.loadStruct }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f.array = array; $f.c = c; $f.code = code; $f.collectFields = collectFields; $f.field = field; $f.fields = fields; $f.i = i; $f.offsets = offsets; $f.s = s; $f.t = t; $f.t$1 = t$1; $f.target = target; $f.view = view; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.loadStruct = function(array, target, s) { return this.$val.loadStruct(array, target, s); };
- funcContext.ptr.prototype.fixNumber = function(value, basic) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, basic, c, value, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; basic = $f.basic; c = $f.c; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _ref = basic.Kind();
- /* */ if (_ref === 3) { $s = 1; continue; }
- /* */ if (_ref === 8) { $s = 2; continue; }
- /* */ if (_ref === 4) { $s = 3; continue; }
- /* */ if (_ref === 9) { $s = 4; continue; }
- /* */ if (_ref === 5 || _ref === 2) { $s = 5; continue; }
- /* */ if (_ref === 10 || _ref === 7 || _ref === 12) { $s = 6; continue; }
- /* */ if (_ref === 13) { $s = 7; continue; }
- /* */ if (_ref === 14) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref === 3) { */ case 1:
- _r = c.formatParenExpr("%s << 24 >> 24", new sliceType$5([value])); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- $s = 10; continue;
- /* } else if (_ref === 8) { */ case 2:
- _r$1 = c.formatParenExpr("%s << 24 >>> 24", new sliceType$5([value])); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 10; continue;
- /* } else if (_ref === 4) { */ case 3:
- _r$2 = c.formatParenExpr("%s << 16 >> 16", new sliceType$5([value])); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- $s = 10; continue;
- /* } else if (_ref === 9) { */ case 4:
- _r$3 = c.formatParenExpr("%s << 16 >>> 16", new sliceType$5([value])); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 10; continue;
- /* } else if (_ref === 5 || _ref === 2) { */ case 5:
- _r$4 = c.formatParenExpr("%s >> 0", new sliceType$5([value])); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- $s = 10; continue;
- /* } else if (_ref === 10 || _ref === 7 || _ref === 12) { */ case 6:
- _r$5 = c.formatParenExpr("%s >>> 0", new sliceType$5([value])); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$5;
- $s = 10; continue;
- /* } else if (_ref === 13) { */ case 7:
- _r$6 = c.formatExpr("$fround(%s)", new sliceType$5([value])); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- $s = 10; continue;
- /* } else if (_ref === 14) { */ case 8:
- return value;
- $s = 10; continue;
- /* } else { */ case 9:
- $panic(new $Int((basic.Kind() >> 0)));
- /* } */ case 10:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.fixNumber }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f.basic = basic; $f.c = c; $f.value = value; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.fixNumber = function(value, basic) { return this.$val.fixNumber(value, basic); };
- funcContext.ptr.prototype.internalize = function(s, t) {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, c, s, t, u, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; c = $f.c; s = $f.s; t = $f.t; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- if (typesutil.IsJsObject(t)) {
- return s;
- }
- _r = t.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- u = _ref.$val;
- /* */ if (isBoolean(u)) { $s = 4; continue; }
- /* */ if (isInteger(u) && !is64Bit(u)) { $s = 5; continue; }
- /* */ if (isFloat(u)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (isBoolean(u)) { */ case 4:
- _r$1 = c.formatExpr("!!(%s)", new sliceType$5([s])); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 7; continue;
- /* } else if (isInteger(u) && !is64Bit(u)) { */ case 5:
- _r$2 = c.formatExpr("$parseInt(%s)", new sliceType$5([s])); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = c.fixNumber(_r$2, u); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 7; continue;
- /* } else if (isFloat(u)) { */ case 6:
- _r$4 = c.formatExpr("$parseFloat(%s)", new sliceType$5([s])); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- /* } */ case 7:
- /* } */ case 3:
- _arg = s;
- _r$5 = c.typeName(t); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$5);
- _r$6 = c.formatExpr("$internalize(%s, %s)", new sliceType$5([_arg, _arg$1])); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.internalize }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f.c = c; $f.s = s; $f.t = t; $f.u = u; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.internalize = function(s, t) { return this.$val.internalize(s, t); };
- funcContext.ptr.prototype.formatExpr = function(format, a) {
- var $ptr, _r, a, c, format, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; a = $f.a; c = $f.c; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = c.formatExprInternal(format, a, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.formatExpr }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.c = c; $f.format = format; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.formatExpr = function(format, a) { return this.$val.formatExpr(format, a); };
- funcContext.ptr.prototype.formatParenExpr = function(format, a) {
- var $ptr, _r, a, c, format, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; a = $f.a; c = $f.c; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = c.formatExprInternal(format, a, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.formatParenExpr }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.c = c; $f.format = format; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.formatParenExpr = function(format, a) { return this.$val.formatParenExpr(format, a); };
- funcContext.ptr.prototype.formatExprInternal = function(format, a, parens) {
- var $ptr, _entry, _i, _r, _r$1, _r$2, _r$3, _ref, _tuple, a, c, counts, e, format, hasAssignments, i, isIdent, out, parens, processFormat, v, val, vars, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _tuple = $f._tuple; a = $f.a; c = $f.c; counts = $f.counts; e = $f.e; format = $f.format; hasAssignments = $f.hasAssignments; i = $f.i; isIdent = $f.isIdent; out = $f.out; parens = $f.parens; processFormat = $f.processFormat; v = $f.v; val = $f.val; vars = $f.vars; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- a = [a];
- c = [c];
- counts = [counts];
- format = [format];
- out = [out];
- vars = [vars];
- c[0] = this;
- processFormat = (function(a, c, counts, format, out, vars) { return function $b(f) {
- var $ptr, b, f, i, k, n, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; b = $f.b; f = $f.f; i = $f.i; k = $f.k; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < format[0].length)) { break; } */ if(!(i < format[0].length)) { $s = 2; continue; }
- b = format[0].charCodeAt(i);
- /* */ if (b === 37) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (b === 37) { */ case 3:
- i = i + (1) >> 0;
- k = format[0].charCodeAt(i);
- if (k >= 48 && k <= 57) {
- n = (((k - 48 << 24 >>> 24) - 1 << 24 >>> 24) >> 0);
- i = i + (1) >> 0;
- k = format[0].charCodeAt(i);
- }
- $r = f(0, k, n); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = n + (1) >> 0;
- i = i + (1) >> 0;
- /* continue; */ $s = 1; continue;
- /* } */ case 4:
- $r = f(b, 0, 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.b = b; $f.f = f; $f.i = i; $f.k = k; $f.n = n; $f.$s = $s; $f.$r = $r; return $f;
- }; })(a, c, counts, format, out, vars);
- counts[0] = $makeSlice(sliceType$11, a[0].$length);
- $r = processFormat((function(a, c, counts, format, out, vars) { return function(b, k, n) {
- var $ptr, _ref, b, k, n;
- _ref = k;
- if (_ref === 101 || _ref === 102 || _ref === 104 || _ref === 108 || _ref === 114 || _ref === 105) {
- ((n < 0 || n >= counts[0].$length) ? $throwRuntimeError("index out of range") : counts[0].$array[counts[0].$offset + n] = ((n < 0 || n >= counts[0].$length) ? $throwRuntimeError("index out of range") : counts[0].$array[counts[0].$offset + n]) + (1) >> 0);
- }
- }; })(a, c, counts, format, out, vars)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- out[0] = bytes.NewBuffer(sliceType$4.nil);
- vars[0] = $makeSlice(sliceType, a[0].$length);
- hasAssignments = false;
- _ref = a[0];
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- i = _i;
- e = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (((i < 0 || i >= counts[0].$length) ? $throwRuntimeError("index out of range") : counts[0].$array[counts[0].$offset + i]) <= 1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (((i < 0 || i >= counts[0].$length) ? $throwRuntimeError("index out of range") : counts[0].$array[counts[0].$offset + i]) <= 1) { */ case 4:
- _i++;
- /* continue; */ $s = 2; continue;
- /* } */ case 5:
- _tuple = $assertType(e, ptrType$5, true); isIdent = _tuple[1];
- /* */ if (isIdent) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (isIdent) { */ case 6:
- _i++;
- /* continue; */ $s = 2; continue;
- /* } */ case 7:
- val = (_entry = c[0].p.Info.Info.Types[ast.Expr.keyFor($assertType(e, ast.Expr))], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(val, $ifaceNil))) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!($interfaceIsEqual(val, $ifaceNil))) { */ case 8:
- _i++;
- /* continue; */ $s = 2; continue;
- /* } */ case 9:
- if (!hasAssignments) {
- hasAssignments = true;
- out[0].WriteByte(40);
- parens = false;
- }
- _r = c[0].newVariable("x"); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- v = _r;
- _r$1 = c[0].translateExpr($assertType(e, ast.Expr)); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = _r$1.String(); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = out[0].WriteString(v + " = " + _r$2 + ", "); /* */ $s = 13; case 13: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- ((i < 0 || i >= vars[0].$length) ? $throwRuntimeError("index out of range") : vars[0].$array[vars[0].$offset + i] = v);
- _i++;
- /* } */ $s = 2; continue; case 3:
- $r = processFormat((function(a, c, counts, format, out, vars) { return function $b(b, k, n) {
- var $ptr, _entry$1, _entry$2, _entry$3, _entry$4, _entry$5, _entry$6, _entry$7, _entry$8, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref$1, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, b, d, d$1, d$2, e$1, e$2, e$3, e$4, i$1, k, n, ok, r, val$1, val$2, val$3, val$4, val$5, val$6, writeExpr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _entry$7 = $f._entry$7; _entry$8 = $f._entry$8; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref$1 = $f._ref$1; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; b = $f.b; d = $f.d; d$1 = $f.d$1; d$2 = $f.d$2; e$1 = $f.e$1; e$2 = $f.e$2; e$3 = $f.e$3; e$4 = $f.e$4; i$1 = $f.i$1; k = $f.k; n = $f.n; ok = $f.ok; r = $f.r; val$1 = $f.val$1; val$2 = $f.val$2; val$3 = $f.val$3; val$4 = $f.val$4; val$5 = $f.val$5; val$6 = $f.val$6; writeExpr = $f.writeExpr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = [n];
- writeExpr = (function(a, c, counts, format, n, out, vars) { return function $b(suffix) {
- var $ptr, _r$4, _r$5, _r$6, suffix, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; suffix = $f.suffix; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (!(((n[0] < 0 || n[0] >= vars[0].$length) ? $throwRuntimeError("index out of range") : vars[0].$array[vars[0].$offset + n[0]]) === "")) {
- out[0].WriteString(((n[0] < 0 || n[0] >= vars[0].$length) ? $throwRuntimeError("index out of range") : vars[0].$array[vars[0].$offset + n[0]]) + suffix);
- return;
- }
- _r$4 = c[0].translateExpr($assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ast.Expr)); /* */ $s = 1; case 1: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = _r$4.StringWithParens(); /* */ $s = 2; case 2: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = out[0].WriteString(_r$5 + suffix); /* */ $s = 3; case 3: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f.suffix = suffix; $f.$s = $s; $f.$r = $r; return $f;
- }; })(a, c, counts, format, n, out, vars);
- _ref$1 = k;
- /* */ if (_ref$1 === 0) { $s = 1; continue; }
- /* */ if (_ref$1 === 115) { $s = 2; continue; }
- /* */ if (_ref$1 === 100) { $s = 3; continue; }
- /* */ if (_ref$1 === 116) { $s = 4; continue; }
- /* */ if (_ref$1 === 101) { $s = 5; continue; }
- /* */ if (_ref$1 === 102) { $s = 6; continue; }
- /* */ if (_ref$1 === 104) { $s = 7; continue; }
- /* */ if (_ref$1 === 108) { $s = 8; continue; }
- /* */ if (_ref$1 === 114) { $s = 9; continue; }
- /* */ if (_ref$1 === 105) { $s = 10; continue; }
- /* */ if (_ref$1 === 37) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_ref$1 === 0) { */ case 1:
- out[0].WriteByte(b);
- $s = 13; continue;
- /* } else if (_ref$1 === 115) { */ case 2:
- _tuple$1 = $assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ptrType$38, true); e$1 = _tuple$1[0]; ok = _tuple$1[1];
- if (ok) {
- out[0].WriteString(e$1.StringWithParens());
- return;
- }
- out[0].WriteString($assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), $String));
- $s = 13; continue;
- /* } else if (_ref$1 === 100) { */ case 3:
- out[0].WriteString(strconv.Itoa($assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), $Int)));
- $s = 13; continue;
- /* } else if (_ref$1 === 116) { */ case 4:
- out[0].WriteString(new token.Token($assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), token.Token)).String());
- $s = 13; continue;
- /* } else if (_ref$1 === 101) { */ case 5:
- e$2 = $assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ast.Expr);
- val$1 = (_entry$1 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$2)], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(val$1, $ifaceNil))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!($interfaceIsEqual(val$1, $ifaceNil))) { */ case 14:
- _r$4 = c[0].translateExpr(e$2); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = _r$4.String(); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = out[0].WriteString(_r$5); /* */ $s = 18; case 18: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- return;
- /* } */ case 15:
- $r = writeExpr(""); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 13; continue;
- /* } else if (_ref$1 === 102) { */ case 6:
- e$3 = $assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ast.Expr);
- val$2 = (_entry$2 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$3)], _entry$2 !== undefined ? _entry$2.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(val$2, $ifaceNil))) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (!($interfaceIsEqual(val$2, $ifaceNil))) { */ case 20:
- _r$7 = exact.Int64Val(val$2); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _tuple$2 = _r$7; d = _tuple$2[0];
- out[0].WriteString(strconv.FormatInt(d, 10));
- return;
- /* } */ case 21:
- _r$8 = (_entry$3 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$3)], _entry$3 !== undefined ? _entry$3.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 25; case 25: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = is64Bit($assertType(_r$8, ptrType$3)); /* */ $s = 26; case 26: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- /* */ if (_r$9) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_r$9) { */ case 23:
- out[0].WriteString("$flatten64(");
- $r = writeExpr(""); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- out[0].WriteString(")");
- return;
- /* } */ case 24:
- $r = writeExpr(""); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 13; continue;
- /* } else if (_ref$1 === 104) { */ case 7:
- e$4 = $assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ast.Expr);
- val$3 = (_entry$4 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$4)], _entry$4 !== undefined ? _entry$4.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(val$3, $ifaceNil))) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (!($interfaceIsEqual(val$3, $ifaceNil))) { */ case 29:
- _r$10 = exact.Uint64Val(val$3); /* */ $s = 31; case 31: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _tuple$3 = _r$10; d$1 = _tuple$3[0];
- _r$11 = (_entry$5 = c[0].p.Info.Info.Types[ast.Expr.keyFor(e$4)], _entry$5 !== undefined ? _entry$5.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 34; case 34: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$12 = $assertType(_r$11, ptrType$3).Kind(); /* */ $s = 35; case 35: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- /* */ if (_r$12 === 6) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* if (_r$12 === 6) { */ case 32:
- out[0].WriteString(strconv.FormatInt($shiftRightInt64(new $Int64(d$1.$high, d$1.$low), 32), 10));
- return;
- /* } */ case 33:
- out[0].WriteString(strconv.FormatUint($shiftRightUint64(d$1, 32), 10));
- return;
- /* } */ case 30:
- $r = writeExpr(".$high"); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 13; continue;
- /* } else if (_ref$1 === 108) { */ case 8:
- val$4 = (_entry$6 = c[0].p.Info.Info.Types[ast.Expr.keyFor($assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ast.Expr))], _entry$6 !== undefined ? _entry$6.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(val$4, $ifaceNil))) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (!($interfaceIsEqual(val$4, $ifaceNil))) { */ case 37:
- _r$13 = exact.Uint64Val(val$4); /* */ $s = 39; case 39: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _tuple$4 = _r$13; d$2 = _tuple$4[0];
- out[0].WriteString(strconv.FormatUint(new $Uint64(d$2.$high & 0, (d$2.$low & 4294967295) >>> 0), 10));
- return;
- /* } */ case 38:
- $r = writeExpr(".$low"); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 13; continue;
- /* } else if (_ref$1 === 114) { */ case 9:
- val$5 = (_entry$7 = c[0].p.Info.Info.Types[ast.Expr.keyFor($assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ast.Expr))], _entry$7 !== undefined ? _entry$7.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(val$5, $ifaceNil))) { $s = 41; continue; }
- /* */ $s = 42; continue;
- /* if (!($interfaceIsEqual(val$5, $ifaceNil))) { */ case 41:
- _r$14 = exact.Real(val$5); /* */ $s = 43; case 43: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _r$15 = exact.Float64Val(_r$14); /* */ $s = 44; case 44: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _tuple$5 = _r$15; r = _tuple$5[0];
- out[0].WriteString(strconv.FormatFloat(r, 103, -1, 64));
- return;
- /* } */ case 42:
- $r = writeExpr(".$real"); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 13; continue;
- /* } else if (_ref$1 === 105) { */ case 10:
- val$6 = (_entry$8 = c[0].p.Info.Info.Types[ast.Expr.keyFor($assertType(((n[0] < 0 || n[0] >= a[0].$length) ? $throwRuntimeError("index out of range") : a[0].$array[a[0].$offset + n[0]]), ast.Expr))], _entry$8 !== undefined ? _entry$8.v : new types.TypeAndValue.ptr()).Value;
- /* */ if (!($interfaceIsEqual(val$6, $ifaceNil))) { $s = 46; continue; }
- /* */ $s = 47; continue;
- /* if (!($interfaceIsEqual(val$6, $ifaceNil))) { */ case 46:
- _r$16 = exact.Imag(val$6); /* */ $s = 48; case 48: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _r$17 = exact.Float64Val(_r$16); /* */ $s = 49; case 49: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _tuple$6 = _r$17; i$1 = _tuple$6[0];
- out[0].WriteString(strconv.FormatFloat(i$1, 103, -1, 64));
- return;
- /* } */ case 47:
- $r = writeExpr(".$imag"); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 13; continue;
- /* } else if (_ref$1 === 37) { */ case 11:
- out[0].WriteRune(37);
- $s = 13; continue;
- /* } else { */ case 12:
- _r$18 = fmt.Sprintf("formatExpr: %%%c%d", new sliceType$5([new $Uint8(k), new $Int(n[0])])); /* */ $s = 51; case 51: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- $panic(new $String(_r$18));
- /* } */ case 13:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._entry$7 = _entry$7; $f._entry$8 = _entry$8; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref$1 = _ref$1; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f.b = b; $f.d = d; $f.d$1 = d$1; $f.d$2 = d$2; $f.e$1 = e$1; $f.e$2 = e$2; $f.e$3 = e$3; $f.e$4 = e$4; $f.i$1 = i$1; $f.k = k; $f.n = n; $f.ok = ok; $f.r = r; $f.val$1 = val$1; $f.val$2 = val$2; $f.val$3 = val$3; $f.val$4 = val$4; $f.val$5 = val$5; $f.val$6 = val$6; $f.writeExpr = writeExpr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(a, c, counts, format, out, vars)); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (hasAssignments) {
- out[0].WriteByte(41);
- }
- return new expression.ptr(out[0].String(), parens);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.formatExprInternal }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._tuple = _tuple; $f.a = a; $f.c = c; $f.counts = counts; $f.e = e; $f.format = format; $f.hasAssignments = hasAssignments; $f.i = i; $f.isIdent = isIdent; $f.out = out; $f.parens = parens; $f.processFormat = processFormat; $f.v = v; $f.val = val; $f.vars = vars; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.formatExprInternal = function(format, a, parens) { return this.$val.formatExprInternal(format, a, parens); };
- NewImportContext = function(importFunc) {
- var $ptr, _key, _map, importFunc;
- return new ImportContext.ptr((_map = new $Map(), _key = "unsafe", _map[$String.keyFor(_key)] = { k: _key, v: types.Unsafe }, _map), importFunc);
- };
- $pkg.NewImportContext = NewImportContext;
- Compile = function(importPath, files, fileSet, importContext, minify) {
- var $ptr, _entry, _entry$1, _entry$10, _entry$11, _entry$12, _entry$2, _entry$3, _entry$4, _entry$5, _entry$6, _entry$7, _entry$8, _entry$9, _i, _i$1, _i$10, _i$11, _i$12, _i$13, _i$14, _i$15, _i$16, _i$2, _i$3, _i$4, _i$5, _i$6, _i$7, _i$8, _i$9, _key, _key$1, _key$10, _key$2, _key$3, _key$4, _key$5, _key$6, _key$7, _key$8, _key$9, _keys, _map, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$10, _ref$11, _ref$12, _ref$13, _ref$14, _ref$15, _ref$16, _ref$17, _ref$18, _ref$19, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, allDecls, c, call, call$1, collectDependencies, config, d, d$1, d$2, d$3, d$4, d$5, d$6, d$7, decl, encodedFileSet, err, err$1, errList, exportData, file, fileSet, files, fun, funcDecls, funcInfo, functions, i, id, id$1, ident, impPath, importContext, importDecls, importError, importPath, importedPaths, importedPkg, init$1, init$2, isBlocking, isPointer, isPtr, last, lhs, mainFunc, minify, name, name$1, namedRecvType, o, o$1, o$2, o$3, o$4, o$5, o$6, ok, ok$1, pkgInfo, pos, previousErr, ptr, ptr$1, recvType, recvType$1, sig, spec, spec$1, t, typeDecls, typeName, typesInfo, typesPkg, varDecls, vars, varsWithInit, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$10 = $f._entry$10; _entry$11 = $f._entry$11; _entry$12 = $f._entry$12; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _entry$7 = $f._entry$7; _entry$8 = $f._entry$8; _entry$9 = $f._entry$9; _i = $f._i; _i$1 = $f._i$1; _i$10 = $f._i$10; _i$11 = $f._i$11; _i$12 = $f._i$12; _i$13 = $f._i$13; _i$14 = $f._i$14; _i$15 = $f._i$15; _i$16 = $f._i$16; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _i$7 = $f._i$7; _i$8 = $f._i$8; _i$9 = $f._i$9; _key = $f._key; _key$1 = $f._key$1; _key$10 = $f._key$10; _key$2 = $f._key$2; _key$3 = $f._key$3; _key$4 = $f._key$4; _key$5 = $f._key$5; _key$6 = $f._key$6; _key$7 = $f._key$7; _key$8 = $f._key$8; _key$9 = $f._key$9; _keys = $f._keys; _map = $f._map; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$10 = $f._ref$10; _ref$11 = $f._ref$11; _ref$12 = $f._ref$12; _ref$13 = $f._ref$13; _ref$14 = $f._ref$14; _ref$15 = $f._ref$15; _ref$16 = $f._ref$16; _ref$17 = $f._ref$17; _ref$18 = $f._ref$18; _ref$19 = $f._ref$19; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; allDecls = $f.allDecls; c = $f.c; call = $f.call; call$1 = $f.call$1; collectDependencies = $f.collectDependencies; config = $f.config; d = $f.d; d$1 = $f.d$1; d$2 = $f.d$2; d$3 = $f.d$3; d$4 = $f.d$4; d$5 = $f.d$5; d$6 = $f.d$6; d$7 = $f.d$7; decl = $f.decl; encodedFileSet = $f.encodedFileSet; err = $f.err; err$1 = $f.err$1; errList = $f.errList; exportData = $f.exportData; file = $f.file; fileSet = $f.fileSet; files = $f.files; fun = $f.fun; funcDecls = $f.funcDecls; funcInfo = $f.funcInfo; functions = $f.functions; i = $f.i; id = $f.id; id$1 = $f.id$1; ident = $f.ident; impPath = $f.impPath; importContext = $f.importContext; importDecls = $f.importDecls; importError = $f.importError; importPath = $f.importPath; importedPaths = $f.importedPaths; importedPkg = $f.importedPkg; init$1 = $f.init$1; init$2 = $f.init$2; isBlocking = $f.isBlocking; isPointer = $f.isPointer; isPtr = $f.isPtr; last = $f.last; lhs = $f.lhs; mainFunc = $f.mainFunc; minify = $f.minify; name = $f.name; name$1 = $f.name$1; namedRecvType = $f.namedRecvType; o = $f.o; o$1 = $f.o$1; o$2 = $f.o$2; o$3 = $f.o$3; o$4 = $f.o$4; o$5 = $f.o$5; o$6 = $f.o$6; ok = $f.ok; ok$1 = $f.ok$1; pkgInfo = $f.pkgInfo; pos = $f.pos; previousErr = $f.previousErr; ptr = $f.ptr; ptr$1 = $f.ptr$1; recvType = $f.recvType; recvType$1 = $f.recvType$1; sig = $f.sig; spec = $f.spec; spec$1 = $f.spec$1; t = $f.t; typeDecls = $f.typeDecls; typeName = $f.typeName; typesInfo = $f.typesInfo; typesPkg = $f.typesPkg; varDecls = $f.varDecls; vars = $f.vars; varsWithInit = $f.varsWithInit; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = [c];
- call = [call];
- errList = [errList];
- importContext = [importContext];
- importError = [importError];
- previousErr = [previousErr];
- typesInfo = new types.Info.ptr(new $Map(), new $Map(), new $Map(), new $Map(), new $Map(), new $Map(), sliceType$12.nil);
- importError[0] = $ifaceNil;
- errList[0] = ErrorList.nil;
- previousErr[0] = $ifaceNil;
- config = new types.Config.ptr(false, false, importContext[0].Packages, (function(c, call, errList, importContext, importError, previousErr) { return function $b(err) {
- var $ptr, _r, _r$1, _v, err, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _v = $f._v; err = $f.err; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (!(!($interfaceIsEqual(previousErr[0], $ifaceNil)))) { _v = false; $s = 3; continue s; }
- _r = previousErr[0].Error(); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = err.Error(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r === _r$1; case 3:
- /* */ if (_v) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v) { */ case 1:
- return;
- /* } */ case 2:
- errList[0] = $append(errList[0], err);
- previousErr[0] = err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._v = _v; $f.err = err; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, errList, importContext, importError, previousErr), (function(c, call, errList, importContext, importError, previousErr) { return function $b(param, path) {
- var $ptr, _entry, _r, _tuple, err, param, path, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; _tuple = $f._tuple; err = $f.err; param = $f.param; path = $f.path; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = importContext[0].Import(path); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- if ($interfaceIsEqual(importError[0], $ifaceNil)) {
- importError[0] = err;
- }
- return [ptrType$28.nil, err];
- /* } */ case 3:
- return [(_entry = importContext[0].Packages[$String.keyFor(path)], _entry !== undefined ? _entry.v : ptrType$28.nil), $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f._tuple = _tuple; $f.err = err; $f.param = param; $f.path = path; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, errList, importContext, importError, previousErr), sizes32, false);
- _r = config.Check(importPath, fileSet, files, typesInfo); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; typesPkg = _tuple[0]; err = _tuple[1];
- if (!($interfaceIsEqual(importError[0], $ifaceNil))) {
- return [ptrType.nil, importError[0]];
- }
- if (!(errList[0] === ErrorList.nil)) {
- if (errList[0].$length > 10) {
- pos = 0;
- _tuple$1 = $assertType((9 >= errList[0].$length ? $throwRuntimeError("index out of range") : errList[0].$array[errList[0].$offset + 9]), types.Error, true); last = $clone(_tuple$1[0], types.Error); ok = _tuple$1[1];
- if (ok) {
- pos = last.Pos;
- }
- errList[0] = $append($subslice(errList[0], 0, 10), (x = new types.Error.ptr(fileSet, pos, "too many errors", false), new x.constructor.elem(x)));
- }
- return [ptrType.nil, errList[0]];
- }
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [ptrType.nil, err];
- }
- _key = importPath; (importContext[0].Packages || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: typesPkg };
- _r$1 = importer.ExportData(typesPkg); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- exportData = _r$1;
- encodedFileSet = bytes.NewBuffer(sliceType$4.nil);
- _r$2 = fileSet.Write($methodVal(json.NewEncoder(encodedFileSet), "Encode")); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- err$1 = _r$2;
- /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 4:
- return [ptrType.nil, err$1];
- /* } */ case 5:
- isBlocking = (function(c, call, errList, importContext, importError, previousErr) { return function $b(f) {
- var $ptr, _i, _r$3, _r$4, _ref, _tuple$2, archive, d, err$2, f, fullName, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _tuple$2 = $f._tuple$2; archive = $f.archive; d = $f.d; err$2 = $f.err$2; f = $f.f; fullName = $f.fullName; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$3 = importContext[0].Import(f.object.Pkg().Path()); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$2 = _r$3; archive = _tuple$2[0]; err$2 = _tuple$2[1];
- if (!($interfaceIsEqual(err$2, $ifaceNil))) {
- $panic(err$2);
- }
- _r$4 = f.FullName(); /* */ $s = 2; case 2: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- fullName = _r$4;
- _ref = archive.Declarations;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- d = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (d.FullName === fullName) {
- return d.Blocking;
- }
- _i++;
- }
- $panic(new $String(fullName));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._i = _i; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._tuple$2 = _tuple$2; $f.archive = archive; $f.d = d; $f.err$2 = err$2; $f.f = f; $f.fullName = fullName; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, errList, importContext, importError, previousErr);
- _r$3 = analysis.AnalyzePkg(files, fileSet, typesInfo, typesPkg, isBlocking); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- pkgInfo = _r$3;
- c[0] = new funcContext.ptr(pkgInfo.InitFuncInfo, new pkgContext.ptr(pkgInfo, sliceType$13.nil, new $Map(), new $Map(), new $Map(), sliceType$13.nil, new typeutil.Map.ptr(), new $Map(), 1, new $Map(), minify, fileSet, ErrorList.nil), ptrType$42.nil, ptrType$24.nil, new $Map(), sliceType.nil, sliceType$7.nil, (_map = new $Map(), _key$1 = ptrType$44.nil, _map[ptrType$44.keyFor(_key$1)] = { k: _key$1, v: new flowData.ptr($throwNilPointerError, 0, 0) }, _map), 1, new $Map(), sliceType$4.nil, sliceType$4.nil, false, 0);
- _ref = reservedKeywords;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- name = _entry.k;
- _key$2 = name; (c[0].allVars || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$2)] = { k: _key$2, v: 1 };
- _i++;
- }
- importDecls = sliceType$2.nil;
- importedPaths = sliceType.nil;
- _ref$1 = typesPkg.Imports();
- _i$1 = 0;
- /* while (true) { */ case 7:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 8; continue; }
- importedPkg = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _r$4 = c[0].newVariableWithLevel(importedPkg.Name(), true); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _key$3 = importedPkg.Path(); (c[0].p.pkgVars || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$3)] = { k: _key$3, v: _r$4 };
- importedPaths = $append(importedPaths, importedPkg.Path());
- _i$1++;
- /* } */ $s = 7; continue; case 8:
- $r = sort.Strings(importedPaths); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$2 = importedPaths;
- _i$2 = 0;
- /* while (true) { */ case 11:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 12; continue; }
- call$1 = [call$1];
- impPath = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- _r$5 = fmt.Sprintf("%s.$init", new sliceType$5([new $String((_entry$1 = c[0].p.pkgVars[$String.keyFor(impPath)], _entry$1 !== undefined ? _entry$1.v : ""))])); /* */ $s = 13; case 13: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = c[0].newIdent(_r$5, types.NewSignature(ptrType$26.nil, ptrType$29.nil, ptrType$29.nil, false)); /* */ $s = 14; case 14: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- id = _r$6;
- call$1[0] = new ast.CallExpr.ptr(id, 0, sliceType$7.nil, 0, 0);
- _key$4 = call$1[0]; (c[0].FuncInfo.Blocking || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$4)] = { k: _key$4, v: true };
- _key$5 = call$1[0]; (c[0].FuncInfo.Flattened || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$5)] = { k: _key$5, v: true };
- _r$7 = fmt.Sprintf("\t%s = $packages[\"%s\"];\n", new sliceType$5([new $String((_entry$3 = c[0].p.pkgVars[$String.keyFor(impPath)], _entry$3 !== undefined ? _entry$3.v : "")), new $String(impPath)])); /* */ $s = 15; case 15: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$8 = c[0].CatchOutput(1, (function(c, call, call$1, errList, importContext, importError, previousErr) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = c[0].translateStmt(new ast.ExprStmt.ptr(call$1[0]), ptrType$44.nil); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, call$1, errList, importContext, importError, previousErr)); /* */ $s = 16; case 16: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- importDecls = $append(importDecls, new Decl.ptr("", new sliceType([(_entry$2 = c[0].p.pkgVars[$String.keyFor(impPath)], _entry$2 !== undefined ? _entry$2.v : "")]), new sliceType$4($stringToBytes(_r$7)), sliceType$4.nil, sliceType$4.nil, _r$8, "", "", sliceType.nil, false));
- _i$2++;
- /* } */ $s = 11; continue; case 12:
- functions = sliceType$14.nil;
- vars = sliceType$8.nil;
- _ref$3 = files;
- _i$3 = 0;
- /* while (true) { */ case 17:
- /* if (!(_i$3 < _ref$3.$length)) { break; } */ if(!(_i$3 < _ref$3.$length)) { $s = 18; continue; }
- file = ((_i$3 < 0 || _i$3 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$3]);
- _ref$4 = file.Decls;
- _i$4 = 0;
- /* while (true) { */ case 19:
- /* if (!(_i$4 < _ref$4.$length)) { break; } */ if(!(_i$4 < _ref$4.$length)) { $s = 20; continue; }
- decl = ((_i$4 < 0 || _i$4 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$4]);
- _ref$5 = decl;
- /* */ if ($assertType(_ref$5, ptrType$45, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref$5, ptrType$46, true)[1]) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if ($assertType(_ref$5, ptrType$45, true)[1]) { */ case 21:
- d = _ref$5.$val;
- sig = $assertType($assertType((_entry$4 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(d.Name)], _entry$4 !== undefined ? _entry$4.v : $ifaceNil), ptrType$32).object.Type(), ptrType$24);
- recvType = $ifaceNil;
- if (!(sig.Recv() === ptrType$26.nil)) {
- recvType = sig.Recv().object.Type();
- _tuple$2 = $assertType(recvType, ptrType$17, true); ptr = _tuple$2[0]; isPtr = _tuple$2[1];
- if (isPtr) {
- recvType = ptr.Elem();
- }
- }
- /* */ if (sig.Recv() === ptrType$26.nil) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (sig.Recv() === ptrType$26.nil) { */ case 24:
- _r$9 = c[0].objectName($assertType((_entry$5 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(d.Name)], _entry$5 !== undefined ? _entry$5.v : $ifaceNil), ptrType$32)); /* */ $s = 26; case 26: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$9;
- /* } */ case 25:
- if (!isBlank(d.Name)) {
- functions = $append(functions, d);
- }
- $s = 23; continue;
- /* } else if ($assertType(_ref$5, ptrType$46, true)[1]) { */ case 22:
- d$1 = _ref$5.$val;
- _ref$6 = d$1.Tok;
- /* */ if (_ref$6 === 84) { $s = 27; continue; }
- /* */ if (_ref$6 === 85) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (_ref$6 === 84) { */ case 27:
- _ref$7 = d$1.Specs;
- _i$5 = 0;
- /* while (true) { */ case 30:
- /* if (!(_i$5 < _ref$7.$length)) { break; } */ if(!(_i$5 < _ref$7.$length)) { $s = 31; continue; }
- spec = ((_i$5 < 0 || _i$5 >= _ref$7.$length) ? $throwRuntimeError("index out of range") : _ref$7.$array[_ref$7.$offset + _i$5]);
- o = $assertType((_entry$6 = c[0].p.Info.Info.Defs[ptrType$5.keyFor($assertType(spec, ptrType$47).Name)], _entry$6 !== undefined ? _entry$6.v : $ifaceNil), ptrType$36);
- c[0].p.typeNames = $append(c[0].p.typeNames, o);
- _r$10 = c[0].objectName(o); /* */ $s = 32; case 32: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$10;
- _i$5++;
- /* } */ $s = 30; continue; case 31:
- $s = 29; continue;
- /* } else if (_ref$6 === 85) { */ case 28:
- _ref$8 = d$1.Specs;
- _i$6 = 0;
- /* while (true) { */ case 33:
- /* if (!(_i$6 < _ref$8.$length)) { break; } */ if(!(_i$6 < _ref$8.$length)) { $s = 34; continue; }
- spec$1 = ((_i$6 < 0 || _i$6 >= _ref$8.$length) ? $throwRuntimeError("index out of range") : _ref$8.$array[_ref$8.$offset + _i$6]);
- _ref$9 = $assertType(spec$1, ptrType$48).Names;
- _i$7 = 0;
- /* while (true) { */ case 35:
- /* if (!(_i$7 < _ref$9.$length)) { break; } */ if(!(_i$7 < _ref$9.$length)) { $s = 36; continue; }
- name$1 = ((_i$7 < 0 || _i$7 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$7]);
- /* */ if (!isBlank(name$1)) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (!isBlank(name$1)) { */ case 37:
- o$1 = $assertType((_entry$7 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(name$1)], _entry$7 !== undefined ? _entry$7.v : $ifaceNil), ptrType$26);
- vars = $append(vars, o$1);
- _r$11 = c[0].objectName(o$1); /* */ $s = 39; case 39: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$11;
- /* } */ case 38:
- _i$7++;
- /* } */ $s = 35; continue; case 36:
- _i$6++;
- /* } */ $s = 33; continue; case 34:
- /* } */ case 29:
- /* } */ case 23:
- _i$4++;
- /* } */ $s = 19; continue; case 20:
- _i$3++;
- /* } */ $s = 17; continue; case 18:
- collectDependencies = (function(c, call, errList, importContext, importError, previousErr) { return function $b(f) {
- var $ptr, _entry$8, _i$8, _keys$1, _r$12, _r$13, _r$14, _ref$10, _tuple$3, deps, f, f$1, o$2, ok$1, qualifiedName, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry$8 = $f._entry$8; _i$8 = $f._i$8; _keys$1 = $f._keys$1; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _ref$10 = $f._ref$10; _tuple$3 = $f._tuple$3; deps = $f.deps; f = $f.f; f$1 = $f.f$1; o$2 = $f.o$2; ok$1 = $f.ok$1; qualifiedName = $f.qualifiedName; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c[0].p.dependencies = new $Map();
- $r = f(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- deps = sliceType.nil;
- _ref$10 = c[0].p.dependencies;
- _i$8 = 0;
- _keys$1 = $keys(_ref$10);
- /* while (true) { */ case 2:
- /* if (!(_i$8 < _keys$1.length)) { break; } */ if(!(_i$8 < _keys$1.length)) { $s = 3; continue; }
- _entry$8 = _ref$10[_keys$1[_i$8]];
- if (_entry$8 === undefined) {
- _i$8++;
- /* continue; */ $s = 2; continue;
- }
- o$2 = _entry$8.k;
- _r$12 = o$2.Pkg(); /* */ $s = 4; case 4: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _r$13 = _r$12.Path(); /* */ $s = 5; case 5: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _r$14 = o$2.Name(); /* */ $s = 6; case 6: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- qualifiedName = _r$13 + "." + _r$14;
- _tuple$3 = $assertType(o$2, ptrType$32, true); f$1 = _tuple$3[0]; ok$1 = _tuple$3[1];
- if (ok$1 && !($assertType(f$1.object.Type(), ptrType$24).Recv() === ptrType$26.nil)) {
- deps = $append(deps, qualifiedName + "~");
- _i$8++;
- /* continue; */ $s = 2; continue;
- }
- deps = $append(deps, qualifiedName);
- _i$8++;
- /* } */ $s = 2; continue; case 3:
- $r = sort.Strings(deps); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return deps;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry$8 = _entry$8; $f._i$8 = _i$8; $f._keys$1 = _keys$1; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._ref$10 = _ref$10; $f._tuple$3 = _tuple$3; $f.deps = deps; $f.f = f; $f.f$1 = f$1; $f.o$2 = o$2; $f.ok$1 = ok$1; $f.qualifiedName = qualifiedName; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, errList, importContext, importError, previousErr);
- varDecls = sliceType$2.nil;
- varsWithInit = new $Map();
- _ref$10 = c[0].p.Info.Info.InitOrder;
- _i$8 = 0;
- while (true) {
- if (!(_i$8 < _ref$10.$length)) { break; }
- init$1 = ((_i$8 < 0 || _i$8 >= _ref$10.$length) ? $throwRuntimeError("index out of range") : _ref$10.$array[_ref$10.$offset + _i$8]);
- _ref$11 = init$1.Lhs;
- _i$9 = 0;
- while (true) {
- if (!(_i$9 < _ref$11.$length)) { break; }
- o$2 = ((_i$9 < 0 || _i$9 >= _ref$11.$length) ? $throwRuntimeError("index out of range") : _ref$11.$array[_ref$11.$offset + _i$9]);
- _key$6 = o$2; (varsWithInit || $throwRuntimeError("assignment to entry in nil map"))[ptrType$26.keyFor(_key$6)] = { k: _key$6, v: true };
- _i$9++;
- }
- _i$8++;
- }
- _ref$12 = vars;
- _i$10 = 0;
- /* while (true) { */ case 40:
- /* if (!(_i$10 < _ref$12.$length)) { break; } */ if(!(_i$10 < _ref$12.$length)) { $s = 41; continue; }
- d$2 = [d$2];
- o$3 = ((_i$10 < 0 || _i$10 >= _ref$12.$length) ? $throwRuntimeError("index out of range") : _ref$12.$array[_ref$12.$offset + _i$10]);
- d$2[0] = $clone(new Decl.ptr(), Decl);
- /* */ if (!o$3.object.Exported()) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (!o$3.object.Exported()) { */ case 42:
- _r$12 = c[0].objectName(o$3); /* */ $s = 44; case 44: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- d$2[0].Vars = new sliceType([_r$12]);
- /* } */ case 43:
- /* */ if ((_entry$8 = c[0].p.Info.HasPointer[ptrType$26.keyFor(o$3)], _entry$8 !== undefined ? _entry$8.v : false)) { $s = 45; continue; }
- /* */ $s = 46; continue;
- /* if ((_entry$8 = c[0].p.Info.HasPointer[ptrType$26.keyFor(o$3)], _entry$8 !== undefined ? _entry$8.v : false)) { */ case 45:
- _r$13 = c[0].varPtrName(o$3); /* */ $s = 47; case 47: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- d$2[0].Vars = $append(d$2[0].Vars, _r$13);
- /* } */ case 46:
- _tuple$3 = (_entry$9 = varsWithInit[ptrType$26.keyFor(o$3)], _entry$9 !== undefined ? [_entry$9.v, true] : [false, false]); ok$1 = _tuple$3[1];
- /* */ if (!ok$1) { $s = 48; continue; }
- /* */ $s = 49; continue;
- /* if (!ok$1) { */ case 48:
- _r$14 = collectDependencies((function(c, call, d$2, errList, importContext, importError, previousErr) { return function $b() {
- var $ptr, _arg, _arg$1, _r$14, _r$15, _r$16, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$14 = c[0].objectName(o$3); /* */ $s = 1; case 1: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _arg = new $String(_r$14);
- _r$15 = c[0].zeroValue(o$3.object.Type()); /* */ $s = 2; case 2: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$15);
- _r$16 = fmt.Sprintf("\t\t%s = %s;\n", new sliceType$5([_arg, _arg$1])); /* */ $s = 3; case 3: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- d$2[0].InitCode = new sliceType$4($stringToBytes(_r$16));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$2, errList, importContext, importError, previousErr)); /* */ $s = 50; case 50: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- d$2[0].DceDeps = _r$14;
- /* } */ case 49:
- d$2[0].DceObjectFilter = o$3.object.Name();
- varDecls = $append(varDecls, d$2[0]);
- _i$10++;
- /* } */ $s = 40; continue; case 41:
- _ref$13 = c[0].p.Info.Info.InitOrder;
- _i$11 = 0;
- /* while (true) { */ case 51:
- /* if (!(_i$11 < _ref$13.$length)) { break; } */ if(!(_i$11 < _ref$13.$length)) { $s = 52; continue; }
- d$3 = [d$3];
- lhs = [lhs];
- init$2 = ((_i$11 < 0 || _i$11 >= _ref$13.$length) ? $throwRuntimeError("index out of range") : _ref$13.$array[_ref$13.$offset + _i$11]);
- lhs[0] = $makeSlice(sliceType$7, init$2.Lhs.$length);
- _ref$14 = init$2.Lhs;
- _i$12 = 0;
- while (true) {
- if (!(_i$12 < _ref$14.$length)) { break; }
- i = _i$12;
- o$4 = ((_i$12 < 0 || _i$12 >= _ref$14.$length) ? $throwRuntimeError("index out of range") : _ref$14.$array[_ref$14.$offset + _i$12]);
- ident = ast.NewIdent(o$4.object.Name());
- _key$7 = ident; (c[0].p.Info.Info.Defs || $throwRuntimeError("assignment to entry in nil map"))[ptrType$5.keyFor(_key$7)] = { k: _key$7, v: o$4 };
- ((i < 0 || i >= lhs[0].$length) ? $throwRuntimeError("index out of range") : lhs[0].$array[lhs[0].$offset + i] = c[0].setType(ident, o$4.object.Type()));
- _key$8 = o$4; (varsWithInit || $throwRuntimeError("assignment to entry in nil map"))[ptrType$26.keyFor(_key$8)] = { k: _key$8, v: true };
- _i$12++;
- }
- d$3[0] = $clone(new Decl.ptr(), Decl);
- _r$15 = collectDependencies((function(c, call, d$3, errList, importContext, importError, lhs, previousErr) { return function $b() {
- var $ptr, _r$15, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$15 = $f._r$15; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c[0].localVars = sliceType.nil;
- _r$15 = c[0].CatchOutput(1, (function(c, call, d$3, errList, importContext, importError, lhs, previousErr) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = c[0].translateStmt(new ast.AssignStmt.ptr(lhs[0], 0, 47, new sliceType$7([init$2.Rhs])), ptrType$44.nil); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$3, errList, importContext, importError, lhs, previousErr)); /* */ $s = 1; case 1: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- d$3[0].InitCode = _r$15;
- d$3[0].Vars = $appendSlice(d$3[0].Vars, c[0].localVars);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$15 = _r$15; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$3, errList, importContext, importError, lhs, previousErr)); /* */ $s = 53; case 53: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- d$3[0].DceDeps = _r$15;
- /* */ if (init$2.Lhs.$length === 1) { $s = 54; continue; }
- /* */ $s = 55; continue;
- /* if (init$2.Lhs.$length === 1) { */ case 54:
- _r$16 = analysis.HasSideEffect(init$2.Rhs, c[0].p.Info.Info); /* */ $s = 58; case 58: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- /* */ if (!_r$16) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if (!_r$16) { */ case 56:
- d$3[0].DceObjectFilter = (x$1 = init$2.Lhs, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])).object.Name();
- /* } */ case 57:
- /* } */ case 55:
- varDecls = $append(varDecls, d$3[0]);
- _i$11++;
- /* } */ $s = 51; continue; case 52:
- funcDecls = sliceType$2.nil;
- mainFunc = ptrType$32.nil;
- _ref$15 = functions;
- _i$13 = 0;
- /* while (true) { */ case 59:
- /* if (!(_i$13 < _ref$15.$length)) { break; } */ if(!(_i$13 < _ref$15.$length)) { $s = 60; continue; }
- d$4 = [d$4];
- funcInfo = [funcInfo];
- o$5 = [o$5];
- fun = ((_i$13 < 0 || _i$13 >= _ref$15.$length) ? $throwRuntimeError("index out of range") : _ref$15.$array[_ref$15.$offset + _i$13]);
- o$5[0] = $assertType((_entry$10 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(fun.Name)], _entry$10 !== undefined ? _entry$10.v : $ifaceNil), ptrType$32);
- funcInfo[0] = (_entry$11 = c[0].p.Info.FuncDeclInfos[ptrType$32.keyFor(o$5[0])], _entry$11 !== undefined ? _entry$11.v : ptrType$25.nil);
- _r$17 = o$5[0].FullName(); /* */ $s = 61; case 61: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- d$4[0] = new Decl.ptr(_r$17, sliceType.nil, sliceType$4.nil, sliceType$4.nil, sliceType$4.nil, sliceType$4.nil, "", "", sliceType.nil, !(($keys(funcInfo[0].Blocking).length === 0)));
- /* */ if (fun.Recv === ptrType$49.nil) { $s = 62; continue; }
- /* */ $s = 63; continue;
- /* if (fun.Recv === ptrType$49.nil) { */ case 62:
- _r$18 = c[0].objectName(o$5[0]); /* */ $s = 64; case 64: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- d$4[0].Vars = new sliceType([_r$18]);
- d$4[0].DceObjectFilter = o$5[0].object.Name();
- _ref$16 = o$5[0].object.Name();
- /* */ if (_ref$16 === "main") { $s = 65; continue; }
- /* */ if (_ref$16 === "init") { $s = 66; continue; }
- /* */ $s = 67; continue;
- /* if (_ref$16 === "main") { */ case 65:
- mainFunc = o$5[0];
- d$4[0].DceObjectFilter = "";
- $s = 67; continue;
- /* } else if (_ref$16 === "init") { */ case 66:
- _r$19 = c[0].CatchOutput(1, (function(c, call, d$4, errList, funcInfo, importContext, importError, o$5, previousErr) { return function $b() {
- var $ptr, _entry$12, _key$10, _key$9, call$2, id$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry$12 = $f._entry$12; _key$10 = $f._key$10; _key$9 = $f._key$9; call$2 = $f.call$2; id$1 = $f.id$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- id$1 = c[0].newIdent("", types.NewSignature(ptrType$26.nil, ptrType$29.nil, ptrType$29.nil, false));
- _key$9 = id$1; (c[0].p.Info.Info.Uses || $throwRuntimeError("assignment to entry in nil map"))[ptrType$5.keyFor(_key$9)] = { k: _key$9, v: o$5[0] };
- call$2 = new ast.CallExpr.ptr(id$1, 0, sliceType$7.nil, 0, 0);
- if (!(($keys((_entry$12 = c[0].p.Info.FuncDeclInfos[ptrType$32.keyFor(o$5[0])], _entry$12 !== undefined ? _entry$12.v : ptrType$25.nil).Blocking).length === 0))) {
- _key$10 = call$2; (c[0].FuncInfo.Blocking || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$10)] = { k: _key$10, v: true };
- }
- $r = c[0].translateStmt(new ast.ExprStmt.ptr(call$2), ptrType$44.nil); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry$12 = _entry$12; $f._key$10 = _key$10; $f._key$9 = _key$9; $f.call$2 = call$2; $f.id$1 = id$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$4, errList, funcInfo, importContext, importError, o$5, previousErr)); /* */ $s = 68; case 68: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- d$4[0].InitCode = _r$19;
- d$4[0].DceObjectFilter = "";
- /* } */ case 67:
- /* } */ case 63:
- if (!(fun.Recv === ptrType$49.nil)) {
- recvType$1 = $assertType(o$5[0].object.Type(), ptrType$24).Recv().object.Type();
- _tuple$4 = $assertType(recvType$1, ptrType$17, true); ptr$1 = _tuple$4[0]; isPointer = _tuple$4[1];
- _tuple$5 = $assertType(recvType$1, ptrType$34, true); namedRecvType = _tuple$5[0];
- if (isPointer) {
- namedRecvType = $assertType(ptr$1.Elem(), ptrType$34);
- }
- d$4[0].DceObjectFilter = namedRecvType.Obj().object.Name();
- if (!fun.Name.IsExported()) {
- d$4[0].DceMethodFilter = o$5[0].object.Name() + "~";
- }
- }
- _r$20 = collectDependencies((function(c, call, d$4, errList, funcInfo, importContext, importError, o$5, previousErr) { return function $b() {
- var $ptr, _r$20, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$20 = $f._r$20; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$20 = c[0].translateToplevelFunction(fun, funcInfo[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- d$4[0].DeclCode = _r$20;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$20 = _r$20; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$4, errList, funcInfo, importContext, importError, o$5, previousErr)); /* */ $s = 69; case 69: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- d$4[0].DceDeps = _r$20;
- funcDecls = $append(funcDecls, d$4[0]);
- _i$13++;
- /* } */ $s = 59; continue; case 60:
- /* */ if (typesPkg.Name() === "main") { $s = 70; continue; }
- /* */ $s = 71; continue;
- /* if (typesPkg.Name() === "main") { */ case 70:
- /* */ if (mainFunc === ptrType$32.nil) { $s = 72; continue; }
- /* */ $s = 73; continue;
- /* if (mainFunc === ptrType$32.nil) { */ case 72:
- _r$21 = fmt.Errorf("missing main function", new sliceType$5([])); /* */ $s = 74; case 74: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- return [ptrType.nil, _r$21];
- /* } */ case 73:
- id$1 = c[0].newIdent("", types.NewSignature(ptrType$26.nil, ptrType$29.nil, ptrType$29.nil, false));
- _key$9 = id$1; (c[0].p.Info.Info.Uses || $throwRuntimeError("assignment to entry in nil map"))[ptrType$5.keyFor(_key$9)] = { k: _key$9, v: mainFunc };
- call[0] = new ast.CallExpr.ptr(id$1, 0, sliceType$7.nil, 0, 0);
- if (!(($keys((_entry$12 = c[0].p.Info.FuncDeclInfos[ptrType$32.keyFor(mainFunc)], _entry$12 !== undefined ? _entry$12.v : ptrType$25.nil).Blocking).length === 0))) {
- _key$10 = call[0]; (c[0].FuncInfo.Blocking || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$10)] = { k: _key$10, v: true };
- }
- _r$22 = c[0].CatchOutput(1, (function(c, call, errList, importContext, importError, previousErr) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = c[0].translateStmt(new ast.ExprStmt.ptr(call[0]), ptrType$44.nil); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, errList, importContext, importError, previousErr)); /* */ $s = 75; case 75: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- funcDecls = $append(funcDecls, new Decl.ptr("", sliceType.nil, sliceType$4.nil, sliceType$4.nil, sliceType$4.nil, _r$22, "", "", sliceType.nil, false));
- /* } */ case 71:
- typeDecls = sliceType$2.nil;
- _ref$17 = c[0].p.typeNames;
- _i$14 = 0;
- /* while (true) { */ case 76:
- /* if (!(_i$14 < _ref$17.$length)) { break; } */ if(!(_i$14 < _ref$17.$length)) { $s = 77; continue; }
- d$5 = [d$5];
- o$6 = ((_i$14 < 0 || _i$14 >= _ref$17.$length) ? $throwRuntimeError("index out of range") : _ref$17.$array[_ref$17.$offset + _i$14]);
- _r$23 = c[0].objectName(o$6); /* */ $s = 78; case 78: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- typeName = _r$23;
- d$5[0] = new Decl.ptr("", new sliceType([typeName]), sliceType$4.nil, sliceType$4.nil, sliceType$4.nil, sliceType$4.nil, o$6.object.Name(), "", sliceType.nil, false);
- _r$24 = collectDependencies((function(c, call, d$5, errList, importContext, importError, previousErr) { return function $b() {
- var $ptr, _r$24, _r$25, _r$26, _r$27, _ref$18, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _ref$18 = $f._ref$18; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- t = [t];
- _r$24 = c[0].CatchOutput(0, (function(c, call, d$5, errList, importContext, importError, previousErr, t) { return function $b() {
- var $ptr, _arg, _arg$1, _arg$10, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _ref$18, constructor, i$1, i$2, i$3, lhs$1, params, size, t$1, t$2, typeName$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _ref$18 = $f._ref$18; constructor = $f.constructor; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; lhs$1 = $f.lhs$1; params = $f.params; size = $f.size; t$1 = $f.t$1; t$2 = $f.t$2; typeName$1 = $f.typeName$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$24 = c[0].objectName(o$6); /* */ $s = 1; case 1: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- typeName$1 = _r$24;
- lhs$1 = typeName$1;
- _r$25 = isPkgLevel(o$6); /* */ $s = 4; case 4: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- /* */ if (_r$25) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_r$25) { */ case 2:
- lhs$1 = lhs$1 + (" = $pkg." + o$6.object.Name());
- /* } */ case 3:
- size = new $Int64(0, 0);
- constructor = "null";
- _r$26 = o$6.object.Type().Underlying(); /* */ $s = 5; case 5: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _ref$18 = _r$26;
- /* */ if ($assertType(_ref$18, ptrType$23, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref$18, ptrType$3, true)[1] || $assertType(_ref$18, ptrType$20, true)[1] || $assertType(_ref$18, ptrType$21, true)[1] || $assertType(_ref$18, ptrType$39, true)[1] || $assertType(_ref$18, ptrType$24, true)[1] || $assertType(_ref$18, ptrType$30, true)[1] || $assertType(_ref$18, ptrType$17, true)[1] || $assertType(_ref$18, ptrType$22, true)[1]) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if ($assertType(_ref$18, ptrType$23, true)[1]) { */ case 6:
- t$1 = _ref$18.$val;
- params = $makeSlice(sliceType, t$1.NumFields());
- i$1 = 0;
- /* while (true) { */ case 9:
- /* if (!(i$1 < t$1.NumFields())) { break; } */ if(!(i$1 < t$1.NumFields())) { $s = 10; continue; }
- _r$27 = fieldName(t$1, i$1); /* */ $s = 11; case 11: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- ((i$1 < 0 || i$1 >= params.$length) ? $throwRuntimeError("index out of range") : params.$array[params.$offset + i$1] = _r$27 + "_");
- i$1 = i$1 + (1) >> 0;
- /* } */ $s = 9; continue; case 10:
- _r$28 = fmt.Sprintf("function(%s) {\n\t\tthis.$val = this;\n\t\tif (arguments.length === 0) {\n", new sliceType$5([new $String(strings.Join(params, ", "))])); /* */ $s = 12; case 12: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- constructor = _r$28;
- i$2 = 0;
- /* while (true) { */ case 13:
- /* if (!(i$2 < t$1.NumFields())) { break; } */ if(!(i$2 < t$1.NumFields())) { $s = 14; continue; }
- _r$29 = fieldName(t$1, i$2); /* */ $s = 15; case 15: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _arg = new $String(_r$29);
- _r$30 = c[0].zeroValue(t$1.Field(i$2).object.Type()); /* */ $s = 16; case 16: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$30);
- _r$31 = fmt.Sprintf("\t\t\tthis.%s = %s;\n", new sliceType$5([_arg, _arg$1])); /* */ $s = 17; case 17: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- constructor = constructor + (_r$31);
- i$2 = i$2 + (1) >> 0;
- /* } */ $s = 13; continue; case 14:
- constructor = constructor + ("\t\t\treturn;\n\t\t}\n");
- i$3 = 0;
- /* while (true) { */ case 18:
- /* if (!(i$3 < t$1.NumFields())) { break; } */ if(!(i$3 < t$1.NumFields())) { $s = 19; continue; }
- _r$32 = fieldName(t$1, i$3); /* */ $s = 20; case 20: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$32);
- _r$33 = fmt.Sprintf("\t\tthis.%[1]s = %[1]s_;\n", new sliceType$5([_arg$2])); /* */ $s = 21; case 21: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- constructor = constructor + (_r$33);
- i$3 = i$3 + (1) >> 0;
- /* } */ $s = 18; continue; case 19:
- constructor = constructor + ("\t}");
- $s = 8; continue;
- /* } else if ($assertType(_ref$18, ptrType$3, true)[1] || $assertType(_ref$18, ptrType$20, true)[1] || $assertType(_ref$18, ptrType$21, true)[1] || $assertType(_ref$18, ptrType$39, true)[1] || $assertType(_ref$18, ptrType$24, true)[1] || $assertType(_ref$18, ptrType$30, true)[1] || $assertType(_ref$18, ptrType$17, true)[1] || $assertType(_ref$18, ptrType$22, true)[1]) { */ case 7:
- t$2 = _ref$18;
- _r$34 = sizes32.Sizeof(t$2); /* */ $s = 22; case 22: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- size = _r$34;
- /* } */ case 8:
- _arg$3 = new $String(lhs$1);
- _arg$4 = size;
- _r$35 = typeKind(o$6.object.Type()); /* */ $s = 23; case 23: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- _arg$5 = new $String(_r$35);
- _arg$6 = new $String(o$6.object.Pkg().Name());
- _arg$7 = new $String(o$6.object.Name());
- _arg$8 = new $String(o$6.object.Name());
- _arg$9 = new $String(o$6.object.Pkg().Path());
- _arg$10 = new $String(constructor);
- $r = c[0].Printf("%s = $newType(%d, %s, \"%s.%s\", \"%s\", \"%s\", %s);", new sliceType$5([_arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _arg$10])); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._ref$18 = _ref$18; $f.constructor = constructor; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.lhs$1 = lhs$1; $f.params = params; $f.size = size; $f.t$1 = t$1; $f.t$2 = t$2; $f.typeName$1 = typeName$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$5, errList, importContext, importError, previousErr, t)); /* */ $s = 1; case 1: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- d$5[0].DeclCode = _r$24;
- _r$25 = c[0].CatchOutput(0, (function(c, call, d$5, errList, importContext, importError, previousErr, t) { return function $b() {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _entry$13, _r$25, _r$26, _r$27, _r$28, _r$29, _tuple$6, _tuple$7, entry, i$1, isInterface, isPtr$1, method, methods, name$2, named, pkgPath, ptrMethods, t$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _entry$13 = $f._entry$13; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; entry = $f.entry; i$1 = $f.i$1; isInterface = $f.isInterface; isPtr$1 = $f.isPtr$1; method = $f.method; methods = $f.methods; name$2 = $f.name$2; named = $f.named; pkgPath = $f.pkgPath; ptrMethods = $f.ptrMethods; t$1 = $f.t$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$25 = o$6.object.Type().Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _tuple$6 = $assertType(_r$25, ptrType$30, true); isInterface = _tuple$6[1];
- /* */ if (!isInterface) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!isInterface) { */ case 2:
- named = $assertType(o$6.object.Type(), ptrType$34);
- methods = sliceType.nil;
- ptrMethods = sliceType.nil;
- i$1 = 0;
- /* while (true) { */ case 4:
- /* if (!(i$1 < named.NumMethods())) { break; } */ if(!(i$1 < named.NumMethods())) { $s = 5; continue; }
- method = named.Method(i$1);
- name$2 = method.object.Name();
- if ((_entry$13 = reservedKeywords[$String.keyFor(name$2)], _entry$13 !== undefined ? _entry$13.v : false)) {
- name$2 = name$2 + ("$");
- }
- pkgPath = "";
- if (!method.object.Exported()) {
- pkgPath = method.object.Pkg().Path();
- }
- t$1 = $assertType(method.object.Type(), ptrType$24);
- _arg = new $String(name$2);
- _arg$1 = new $String(method.object.Name());
- _arg$2 = new $String(pkgPath);
- _r$26 = c[0].initArgs(t$1); /* */ $s = 6; case 6: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _arg$3 = new $String(_r$26);
- _r$27 = fmt.Sprintf("{prop: \"%s\", name: \"%s\", pkg: \"%s\", typ: $funcType(%s)}", new sliceType$5([_arg, _arg$1, _arg$2, _arg$3])); /* */ $s = 7; case 7: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- entry = _r$27;
- _tuple$7 = $assertType(t$1.Recv().object.Type(), ptrType$17, true); isPtr$1 = _tuple$7[1];
- if (isPtr$1) {
- ptrMethods = $append(ptrMethods, entry);
- i$1 = i$1 + (1) >> 0;
- /* continue; */ $s = 4; continue;
- }
- methods = $append(methods, entry);
- i$1 = i$1 + (1) >> 0;
- /* } */ $s = 4; continue; case 5:
- /* */ if (methods.$length > 0) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (methods.$length > 0) { */ case 8:
- _r$28 = c[0].typeName(o$6.object.Type()); /* */ $s = 10; case 10: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _arg$4 = new $String(_r$28);
- _arg$5 = new $String(strings.Join(methods, ", "));
- $r = c[0].Printf("%s.methods = [%s];", new sliceType$5([_arg$4, _arg$5])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- /* */ if (ptrMethods.$length > 0) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (ptrMethods.$length > 0) { */ case 12:
- _r$29 = c[0].typeName(types.NewPointer(o$6.object.Type())); /* */ $s = 14; case 14: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _arg$6 = new $String(_r$29);
- _arg$7 = new $String(strings.Join(ptrMethods, ", "));
- $r = c[0].Printf("%s.methods = [%s];", new sliceType$5([_arg$6, _arg$7])); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 13:
- /* } */ case 3:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._entry$13 = _entry$13; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f.entry = entry; $f.i$1 = i$1; $f.isInterface = isInterface; $f.isPtr$1 = isPtr$1; $f.method = method; $f.methods = methods; $f.name$2 = name$2; $f.named = named; $f.pkgPath = pkgPath; $f.ptrMethods = ptrMethods; $f.t$1 = t$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$5, errList, importContext, importError, previousErr, t)); /* */ $s = 2; case 2: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- d$5[0].MethodListCode = _r$25;
- _r$26 = o$6.object.Type().Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _ref$18 = _r$26;
- /* */ if ($assertType(_ref$18, ptrType$20, true)[1] || $assertType(_ref$18, ptrType$39, true)[1] || $assertType(_ref$18, ptrType$30, true)[1] || $assertType(_ref$18, ptrType$22, true)[1] || $assertType(_ref$18, ptrType$17, true)[1] || $assertType(_ref$18, ptrType$21, true)[1] || $assertType(_ref$18, ptrType$24, true)[1] || $assertType(_ref$18, ptrType$23, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref$18, ptrType$20, true)[1] || $assertType(_ref$18, ptrType$39, true)[1] || $assertType(_ref$18, ptrType$30, true)[1] || $assertType(_ref$18, ptrType$22, true)[1] || $assertType(_ref$18, ptrType$17, true)[1] || $assertType(_ref$18, ptrType$21, true)[1] || $assertType(_ref$18, ptrType$24, true)[1] || $assertType(_ref$18, ptrType$23, true)[1]) { */ case 4:
- t[0] = _ref$18;
- _r$27 = c[0].CatchOutput(0, (function(c, call, d$5, errList, importContext, importError, previousErr, t) { return function $b() {
- var $ptr, _arg, _arg$1, _r$27, _r$28, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r$27 = $f._r$27; _r$28 = $f._r$28; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$27 = c[0].objectName(o$6); /* */ $s = 1; case 1: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _arg = new $String(_r$27);
- _r$28 = c[0].initArgs(t[0]); /* */ $s = 2; case 2: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$28);
- $r = c[0].Printf("%s.init(%s);", new sliceType$5([_arg, _arg$1])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$27 = _r$27; $f._r$28 = _r$28; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$5, errList, importContext, importError, previousErr, t)); /* */ $s = 6; case 6: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- d$5[0].TypeInitCode = _r$27;
- /* } */ case 5:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._ref$18 = _ref$18; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$5, errList, importContext, importError, previousErr)); /* */ $s = 79; case 79: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- d$5[0].DceDeps = _r$24;
- typeDecls = $append(typeDecls, d$5[0]);
- _i$14++;
- /* } */ $s = 76; continue; case 77:
- _ref$18 = c[0].p.anonTypes;
- _i$15 = 0;
- /* while (true) { */ case 80:
- /* if (!(_i$15 < _ref$18.$length)) { break; } */ if(!(_i$15 < _ref$18.$length)) { $s = 81; continue; }
- d$6 = [d$6];
- t = ((_i$15 < 0 || _i$15 >= _ref$18.$length) ? $throwRuntimeError("index out of range") : _ref$18.$array[_ref$18.$offset + _i$15]);
- d$6[0] = new Decl.ptr("", new sliceType([t.object.Name()]), sliceType$4.nil, sliceType$4.nil, sliceType$4.nil, sliceType$4.nil, t.object.Name(), "", sliceType.nil, false);
- _r$25 = collectDependencies((function(c, call, d$6, errList, importContext, importError, previousErr) { return function $b() {
- var $ptr, _arg, _arg$1, _arg$2, _r$25, _r$26, _r$27, _r$28, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _arg = new $String(t.object.Name());
- _r$25 = typeKind(t.object.Type()); /* */ $s = 1; case 1: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _r$26 = strings.ToLower(_r$25.substring(5)); /* */ $s = 2; case 2: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$26);
- _r$27 = c[0].initArgs(t.object.Type()); /* */ $s = 3; case 3: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$27);
- _r$28 = fmt.Sprintf("\t%s = $%sType(%s);\n", new sliceType$5([_arg, _arg$1, _arg$2])); /* */ $s = 4; case 4: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- d$6[0].DeclCode = new sliceType$4($stringToBytes(_r$28));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, call, d$6, errList, importContext, importError, previousErr)); /* */ $s = 82; case 82: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- d$6[0].DceDeps = _r$25;
- typeDecls = $append(typeDecls, d$6[0]);
- _i$15++;
- /* } */ $s = 80; continue; case 81:
- allDecls = sliceType$2.nil;
- _ref$19 = $appendSlice($appendSlice($appendSlice(importDecls, typeDecls), varDecls), funcDecls);
- _i$16 = 0;
- while (true) {
- if (!(_i$16 < _ref$19.$length)) { break; }
- d$7 = ((_i$16 < 0 || _i$16 >= _ref$19.$length) ? $throwRuntimeError("index out of range") : _ref$19.$array[_ref$19.$offset + _i$16]);
- d$7.DeclCode = removeWhitespace(d$7.DeclCode, minify);
- d$7.MethodListCode = removeWhitespace(d$7.MethodListCode, minify);
- d$7.TypeInitCode = removeWhitespace(d$7.TypeInitCode, minify);
- d$7.InitCode = removeWhitespace(d$7.InitCode, minify);
- allDecls = $append(allDecls, d$7);
- _i$16++;
- }
- if (!((c[0].p.errList.$length === 0))) {
- return [ptrType.nil, c[0].p.errList];
- }
- return [new Archive.ptr(importPath, typesPkg.Name(), importedPaths, exportData, allDecls, encodedFileSet.Bytes(), minify, typesPkg), $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Compile }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$10 = _entry$10; $f._entry$11 = _entry$11; $f._entry$12 = _entry$12; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._entry$7 = _entry$7; $f._entry$8 = _entry$8; $f._entry$9 = _entry$9; $f._i = _i; $f._i$1 = _i$1; $f._i$10 = _i$10; $f._i$11 = _i$11; $f._i$12 = _i$12; $f._i$13 = _i$13; $f._i$14 = _i$14; $f._i$15 = _i$15; $f._i$16 = _i$16; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._i$7 = _i$7; $f._i$8 = _i$8; $f._i$9 = _i$9; $f._key = _key; $f._key$1 = _key$1; $f._key$10 = _key$10; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._key$4 = _key$4; $f._key$5 = _key$5; $f._key$6 = _key$6; $f._key$7 = _key$7; $f._key$8 = _key$8; $f._key$9 = _key$9; $f._keys = _keys; $f._map = _map; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$10 = _ref$10; $f._ref$11 = _ref$11; $f._ref$12 = _ref$12; $f._ref$13 = _ref$13; $f._ref$14 = _ref$14; $f._ref$15 = _ref$15; $f._ref$16 = _ref$16; $f._ref$17 = _ref$17; $f._ref$18 = _ref$18; $f._ref$19 = _ref$19; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f.allDecls = allDecls; $f.c = c; $f.call = call; $f.call$1 = call$1; $f.collectDependencies = collectDependencies; $f.config = config; $f.d = d; $f.d$1 = d$1; $f.d$2 = d$2; $f.d$3 = d$3; $f.d$4 = d$4; $f.d$5 = d$5; $f.d$6 = d$6; $f.d$7 = d$7; $f.decl = decl; $f.encodedFileSet = encodedFileSet; $f.err = err; $f.err$1 = err$1; $f.errList = errList; $f.exportData = exportData; $f.file = file; $f.fileSet = fileSet; $f.files = files; $f.fun = fun; $f.funcDecls = funcDecls; $f.funcInfo = funcInfo; $f.functions = functions; $f.i = i; $f.id = id; $f.id$1 = id$1; $f.ident = ident; $f.impPath = impPath; $f.importContext = importContext; $f.importDecls = importDecls; $f.importError = importError; $f.importPath = importPath; $f.importedPaths = importedPaths; $f.importedPkg = importedPkg; $f.init$1 = init$1; $f.init$2 = init$2; $f.isBlocking = isBlocking; $f.isPointer = isPointer; $f.isPtr = isPtr; $f.last = last; $f.lhs = lhs; $f.mainFunc = mainFunc; $f.minify = minify; $f.name = name; $f.name$1 = name$1; $f.namedRecvType = namedRecvType; $f.o = o; $f.o$1 = o$1; $f.o$2 = o$2; $f.o$3 = o$3; $f.o$4 = o$4; $f.o$5 = o$5; $f.o$6 = o$6; $f.ok = ok; $f.ok$1 = ok$1; $f.pkgInfo = pkgInfo; $f.pos = pos; $f.previousErr = previousErr; $f.ptr = ptr; $f.ptr$1 = ptr$1; $f.recvType = recvType; $f.recvType$1 = recvType$1; $f.sig = sig; $f.spec = spec; $f.spec$1 = spec$1; $f.t = t; $f.typeDecls = typeDecls; $f.typeName = typeName; $f.typesInfo = typesInfo; $f.typesPkg = typesPkg; $f.varDecls = varDecls; $f.vars = vars; $f.varsWithInit = varsWithInit; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Compile = Compile;
- funcContext.ptr.prototype.initArgs = function(ty) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$16, _arg$17, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _i, _i$1, _i$2, _i$3, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _ref$4, c, field, fields, i, i$1, i$2, i$3, method, methods, name, params, pkgPath, pkgPath$1, results, t, t$1, t$2, t$3, t$4, t$5, t$6, t$7, t$8, ty, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$16 = $f._arg$16; _arg$17 = $f._arg$17; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; c = $f.c; field = $f.field; fields = $f.fields; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; method = $f.method; methods = $f.methods; name = $f.name; params = $f.params; pkgPath = $f.pkgPath; pkgPath$1 = $f.pkgPath$1; results = $f.results; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; t$8 = $f.t$8; ty = $f.ty; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _ref = ty;
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$39, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$22, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$17, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$24, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$23, true)[1]) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($assertType(_ref, ptrType$20, true)[1]) { */ case 1:
- t = _ref.$val;
- _r = c.typeName(t.Elem()); /* */ $s = 11; case 11: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg = new $String(_r);
- _arg$1 = t.Len();
- _r$1 = fmt.Sprintf("%s, %d", new sliceType$5([_arg, _arg$1])); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 10; continue;
- /* } else if ($assertType(_ref, ptrType$39, true)[1]) { */ case 2:
- t$1 = _ref.$val;
- _r$2 = c.typeName(t$1.Elem()); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$2);
- _arg$3 = new $Bool(!(((t$1.Dir() & 1) === 0)));
- _arg$4 = new $Bool(!(((t$1.Dir() & 2) === 0)));
- _r$3 = fmt.Sprintf("%s, %t, %t", new sliceType$5([_arg$2, _arg$3, _arg$4])); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- $s = 10; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 3:
- t$2 = _ref.$val;
- methods = $makeSlice(sliceType, t$2.NumMethods());
- _ref$1 = methods;
- _i = 0;
- /* while (true) { */ case 15:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 16; continue; }
- i = _i;
- method = t$2.Method(i);
- pkgPath = "";
- if (!method.object.Exported()) {
- pkgPath = method.object.Pkg().Path();
- }
- _arg$5 = new $String(method.object.Name());
- _arg$6 = new $String(method.object.Name());
- _arg$7 = new $String(pkgPath);
- _r$4 = c.initArgs(method.object.Type()); /* */ $s = 17; case 17: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$8 = new $String(_r$4);
- _r$5 = fmt.Sprintf("{prop: \"%s\", name: \"%s\", pkg: \"%s\", typ: $funcType(%s)}", new sliceType$5([_arg$5, _arg$6, _arg$7, _arg$8])); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- ((i < 0 || i >= methods.$length) ? $throwRuntimeError("index out of range") : methods.$array[methods.$offset + i] = _r$5);
- _i++;
- /* } */ $s = 15; continue; case 16:
- _r$6 = fmt.Sprintf("[%s]", new sliceType$5([new $String(strings.Join(methods, ", "))])); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- $s = 10; continue;
- /* } else if ($assertType(_ref, ptrType$22, true)[1]) { */ case 4:
- t$3 = _ref.$val;
- _r$7 = c.typeName(t$3.Key()); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$9 = new $String(_r$7);
- _r$8 = c.typeName(t$3.Elem()); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$10 = new $String(_r$8);
- _r$9 = fmt.Sprintf("%s, %s", new sliceType$5([_arg$9, _arg$10])); /* */ $s = 22; case 22: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- return _r$9;
- $s = 10; continue;
- /* } else if ($assertType(_ref, ptrType$17, true)[1]) { */ case 5:
- t$4 = _ref.$val;
- _r$10 = c.typeName(t$4.Elem()); /* */ $s = 23; case 23: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _arg$11 = new $String(_r$10);
- _r$11 = fmt.Sprintf("%s", new sliceType$5([_arg$11])); /* */ $s = 24; case 24: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- $s = 10; continue;
- /* } else if ($assertType(_ref, ptrType$21, true)[1]) { */ case 6:
- t$5 = _ref.$val;
- _r$12 = c.typeName(t$5.Elem()); /* */ $s = 25; case 25: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _arg$12 = new $String(_r$12);
- _r$13 = fmt.Sprintf("%s", new sliceType$5([_arg$12])); /* */ $s = 26; case 26: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- return _r$13;
- $s = 10; continue;
- /* } else if ($assertType(_ref, ptrType$24, true)[1]) { */ case 7:
- t$6 = _ref.$val;
- params = $makeSlice(sliceType, t$6.Params().Len());
- _ref$2 = params;
- _i$1 = 0;
- /* while (true) { */ case 27:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 28; continue; }
- i$1 = _i$1;
- _r$14 = c.typeName(t$6.Params().At(i$1).object.Type()); /* */ $s = 29; case 29: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- ((i$1 < 0 || i$1 >= params.$length) ? $throwRuntimeError("index out of range") : params.$array[params.$offset + i$1] = _r$14);
- _i$1++;
- /* } */ $s = 27; continue; case 28:
- results = $makeSlice(sliceType, t$6.Results().Len());
- _ref$3 = results;
- _i$2 = 0;
- /* while (true) { */ case 30:
- /* if (!(_i$2 < _ref$3.$length)) { break; } */ if(!(_i$2 < _ref$3.$length)) { $s = 31; continue; }
- i$2 = _i$2;
- _r$15 = c.typeName(t$6.Results().At(i$2).object.Type()); /* */ $s = 32; case 32: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- ((i$2 < 0 || i$2 >= results.$length) ? $throwRuntimeError("index out of range") : results.$array[results.$offset + i$2] = _r$15);
- _i$2++;
- /* } */ $s = 30; continue; case 31:
- _r$16 = fmt.Sprintf("[%s], [%s], %t", new sliceType$5([new $String(strings.Join(params, ", ")), new $String(strings.Join(results, ", ")), new $Bool(t$6.Variadic())])); /* */ $s = 33; case 33: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- return _r$16;
- $s = 10; continue;
- /* } else if ($assertType(_ref, ptrType$23, true)[1]) { */ case 8:
- t$7 = _ref.$val;
- fields = $makeSlice(sliceType, t$7.NumFields());
- _ref$4 = fields;
- _i$3 = 0;
- /* while (true) { */ case 34:
- /* if (!(_i$3 < _ref$4.$length)) { break; } */ if(!(_i$3 < _ref$4.$length)) { $s = 35; continue; }
- i$3 = _i$3;
- field = t$7.Field(i$3);
- name = "";
- if (!field.Anonymous()) {
- name = field.object.Name();
- }
- pkgPath$1 = "";
- if (!field.object.Exported()) {
- pkgPath$1 = field.object.Pkg().Path();
- }
- _r$17 = fieldName(t$7, i$3); /* */ $s = 36; case 36: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _arg$13 = new $String(_r$17);
- _arg$14 = new $String(name);
- _arg$15 = new $String(pkgPath$1);
- _r$18 = c.typeName(field.object.Type()); /* */ $s = 37; case 37: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _arg$16 = new $String(_r$18);
- _r$19 = encodeString(t$7.Tag(i$3)); /* */ $s = 38; case 38: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- _arg$17 = new $String(_r$19);
- _r$20 = fmt.Sprintf("{prop: \"%s\", name: \"%s\", pkg: \"%s\", typ: %s, tag: %s}", new sliceType$5([_arg$13, _arg$14, _arg$15, _arg$16, _arg$17])); /* */ $s = 39; case 39: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- ((i$3 < 0 || i$3 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + i$3] = _r$20);
- _i$3++;
- /* } */ $s = 34; continue; case 35:
- _r$21 = fmt.Sprintf("[%s]", new sliceType$5([new $String(strings.Join(fields, ", "))])); /* */ $s = 40; case 40: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- return _r$21;
- $s = 10; continue;
- /* } else { */ case 9:
- t$8 = _ref;
- $panic(new $String("invalid type"));
- /* } */ case 10:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.initArgs }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$16 = _arg$16; $f._arg$17 = _arg$17; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f.c = c; $f.field = field; $f.fields = fields; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.method = method; $f.methods = methods; $f.name = name; $f.params = params; $f.pkgPath = pkgPath; $f.pkgPath$1 = pkgPath$1; $f.results = results; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.t$8 = t$8; $f.ty = ty; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.initArgs = function(ty) { return this.$val.initArgs(ty); };
- funcContext.ptr.prototype.translateToplevelFunction = function(fun, info) {
- var $ptr, _entry, _entry$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, _tuple$2, _tuple$3, c, code, fun, funName, funcRef, info, isArray, isPointer, isStruct, joinedParams, namedRecvType, o, primaryFunction, ptr, recv, recvType, sig, typeName, value, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; c = $f.c; code = $f.code; fun = $f.fun; funName = $f.funName; funcRef = $f.funcRef; info = $f.info; isArray = $f.isArray; isPointer = $f.isPointer; isStruct = $f.isStruct; joinedParams = $f.joinedParams; namedRecvType = $f.namedRecvType; o = $f.o; primaryFunction = $f.primaryFunction; ptr = $f.ptr; recv = $f.recv; recvType = $f.recvType; sig = $f.sig; typeName = $f.typeName; value = $f.value; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = [c];
- fun = [fun];
- info = [info];
- joinedParams = [joinedParams];
- o = [o];
- recv = [recv];
- sig = [sig];
- c[0] = this;
- o[0] = $assertType((_entry = c[0].p.Info.Info.Defs[ptrType$5.keyFor(fun[0].Name)], _entry !== undefined ? _entry.v : $ifaceNil), ptrType$32);
- sig[0] = $assertType(o[0].object.Type(), ptrType$24);
- recv[0] = ptrType$5.nil;
- if (!(fun[0].Recv === ptrType$49.nil) && !((x = fun[0].Recv.List, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Names === sliceType$15.nil)) {
- recv[0] = (x$1 = (x$2 = fun[0].Recv.List, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])).Names, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0]));
- }
- joinedParams[0] = "";
- primaryFunction = (function(c, fun, info, joinedParams, o, recv, sig) { return function $b(funcRef) {
- var $ptr, _arg, _arg$1, _entry$1, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, _ref$1, _ref$2, _tuple, fun$1, funcRef, initStmts, n, p, params, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry$1 = $f._entry$1; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; fun$1 = $f.fun$1; funcRef = $f.funcRef; initStmts = $f.initStmts; n = $f.n; p = $f.p; params = $f.params; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (fun[0].Body === ptrType$50.nil) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (fun[0].Body === ptrType$50.nil) { */ case 1:
- _arg = new $String(funcRef);
- _r = o[0].FullName(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r);
- _r$1 = fmt.Sprintf("\t%s = function() {\n\t\t$panic(\"Native function not implemented: %s\");\n\t};\n", new sliceType$5([_arg, _arg$1])); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return new sliceType$4($stringToBytes(_r$1));
- /* } */ case 2:
- initStmts = sliceType$6.nil;
- _ref = fun[0].Type.Params.List;
- _i = 0;
- /* while (true) { */ case 5:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 6; continue; }
- p = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = p.Names;
- _i$1 = 0;
- /* while (true) { */ case 7:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 8; continue; }
- n = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _r$2 = (_entry$1 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(n)], _entry$1 !== undefined ? _entry$1.v : $ifaceNil).Type(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = _r$2.Underlying(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _ref$2 = _r$3;
- /* */ if ($assertType(_ref$2, ptrType$20, true)[1] || $assertType(_ref$2, ptrType$23, true)[1]) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if ($assertType(_ref$2, ptrType$20, true)[1] || $assertType(_ref$2, ptrType$23, true)[1]) { */ case 11:
- initStmts = $appendSlice(new sliceType$6([new ast.AssignStmt.ptr(new sliceType$7([n]), 0, 47, new sliceType$7([n]))]), initStmts);
- /* } */ case 12:
- _i$1++;
- /* } */ $s = 7; continue; case 8:
- _i++;
- /* } */ $s = 5; continue; case 6:
- if (!(recv[0] === ptrType$5.nil) && !isBlank(recv[0])) {
- initStmts = $appendSlice(new sliceType$6([new ast.AssignStmt.ptr(new sliceType$7([recv[0]]), 0, 47, new sliceType$7([c[0].setType(new this$1.ptr(new ast.Ident.ptr()), sig[0].Recv().object.Type())]))]), initStmts);
- }
- _r$4 = translateFunction(fun[0].Type, initStmts, fun[0].Body, c[0], sig[0], info[0], funcRef); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple = _r$4; params = _tuple[0]; fun$1 = _tuple[1];
- joinedParams[0] = strings.Join(params, ", ");
- _r$5 = fmt.Sprintf("\t%s = %s;\n", new sliceType$5([new $String(funcRef), new $String(fun$1)])); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return new sliceType$4($stringToBytes(_r$5));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry$1 = _entry$1; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f.fun$1 = fun$1; $f.funcRef = funcRef; $f.initStmts = initStmts; $f.n = n; $f.p = p; $f.params = params; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, fun, info, joinedParams, o, recv, sig);
- code = bytes.NewBuffer(sliceType$4.nil);
- /* */ if (fun[0].Recv === ptrType$49.nil) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (fun[0].Recv === ptrType$49.nil) { */ case 1:
- _r = c[0].objectName(o[0]); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- funcRef = _r;
- _r$1 = primaryFunction(funcRef); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = code.Write(_r$1); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* */ if (fun[0].Name.IsExported()) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (fun[0].Name.IsExported()) { */ case 6:
- _r$3 = fmt.Fprintf(code, "\t$pkg.%s = %s;\n", new sliceType$5([new $String(fun[0].Name.Name), new $String(funcRef)])); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* } */ case 7:
- return code.Bytes();
- /* } */ case 2:
- recvType = sig[0].Recv().object.Type();
- _tuple = $assertType(recvType, ptrType$17, true); ptr = _tuple[0]; isPointer = _tuple[1];
- _tuple$1 = $assertType(recvType, ptrType$34, true); namedRecvType = _tuple$1[0];
- if (isPointer) {
- namedRecvType = $assertType(ptr.Elem(), ptrType$34);
- }
- _r$4 = c[0].objectName(namedRecvType.Obj()); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- typeName = _r$4;
- funName = fun[0].Name.Name;
- if ((_entry$1 = reservedKeywords[$String.keyFor(funName)], _entry$1 !== undefined ? _entry$1.v : false)) {
- funName = funName + ("$");
- }
- _tuple$2 = $assertType(namedRecvType.Underlying(), ptrType$23, true); isStruct = _tuple$2[1];
- /* */ if (isStruct) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (isStruct) { */ case 10:
- _r$5 = primaryFunction(typeName + ".ptr.prototype." + funName); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = code.Write(_r$5); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- _r$7 = fmt.Fprintf(code, "\t%s.prototype.%s = function(%s) { return this.$val.%s(%s); };\n", new sliceType$5([new $String(typeName), new $String(funName), new $String(joinedParams[0]), new $String(funName), new $String(joinedParams[0])])); /* */ $s = 14; case 14: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$7;
- return code.Bytes();
- /* } */ case 11:
- /* */ if (isPointer) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (isPointer) { */ case 15:
- _r$8 = ptr.Elem().Underlying(); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _tuple$3 = $assertType(_r$8, ptrType$20, true); isArray = _tuple$3[1];
- /* */ if (isArray) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (isArray) { */ case 18:
- _r$9 = primaryFunction(typeName + ".prototype." + funName); /* */ $s = 20; case 20: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$10 = code.Write(_r$9); /* */ $s = 21; case 21: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$10;
- _r$11 = fmt.Fprintf(code, "\t$ptrType(%s).prototype.%s = function(%s) { return (new %s(this.$get())).%s(%s); };\n", new sliceType$5([new $String(typeName), new $String(funName), new $String(joinedParams[0]), new $String(typeName), new $String(funName), new $String(joinedParams[0])])); /* */ $s = 22; case 22: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$11;
- return code.Bytes();
- /* } */ case 19:
- _r$12 = fmt.Sprintf("$ptrType(%s).prototype.%s", new sliceType$5([new $String(typeName), new $String(funName)])); /* */ $s = 23; case 23: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _r$13 = primaryFunction(_r$12); /* */ $s = 24; case 24: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- return _r$13;
- /* } */ case 16:
- value = "this.$get()";
- _r$14 = isWrapped(recvType); /* */ $s = 27; case 27: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- /* */ if (_r$14) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if (_r$14) { */ case 25:
- _r$15 = fmt.Sprintf("new %s(%s)", new sliceType$5([new $String(typeName), new $String(value)])); /* */ $s = 28; case 28: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- value = _r$15;
- /* } */ case 26:
- _r$16 = primaryFunction(typeName + ".prototype." + funName); /* */ $s = 29; case 29: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _r$17 = code.Write(_r$16); /* */ $s = 30; case 30: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _r$17;
- _r$18 = fmt.Fprintf(code, "\t$ptrType(%s).prototype.%s = function(%s) { return %s.%s(%s); };\n", new sliceType$5([new $String(typeName), new $String(funName), new $String(joinedParams[0]), new $String(value), new $String(funName), new $String(joinedParams[0])])); /* */ $s = 31; case 31: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- _r$18;
- return code.Bytes();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateToplevelFunction }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.c = c; $f.code = code; $f.fun = fun; $f.funName = funName; $f.funcRef = funcRef; $f.info = info; $f.isArray = isArray; $f.isPointer = isPointer; $f.isStruct = isStruct; $f.joinedParams = joinedParams; $f.namedRecvType = namedRecvType; $f.o = o; $f.primaryFunction = primaryFunction; $f.ptr = ptr; $f.recv = recv; $f.recvType = recvType; $f.sig = sig; $f.typeName = typeName; $f.value = value; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateToplevelFunction = function(fun, info) { return this.$val.translateToplevelFunction(fun, info); };
- translateFunction = function(typ, initStmts, body, outerContext, sig, info, funcRef) {
- var $ptr, _arg, _arg$1, _entry, _entry$1, _i, _i$1, _i$2, _i$3, _key, _key$1, _keys, _map, _r, _r$1, _r$10, _r$11, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, body, bodyOutput, c, deferSuffix, funcRef, functionName, ident, info, initStmts, k, loads, outerContext, param, params, prefix, prevEV, sig, stores, suffix, typ, v, v$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _key = $f._key; _key$1 = $f._key$1; _keys = $f._keys; _map = $f._map; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tmp$2 = $f._tmp$2; _tmp$3 = $f._tmp$3; _tmp$4 = $f._tmp$4; body = $f.body; bodyOutput = $f.bodyOutput; c = $f.c; deferSuffix = $f.deferSuffix; funcRef = $f.funcRef; functionName = $f.functionName; ident = $f.ident; info = $f.info; initStmts = $f.initStmts; k = $f.k; loads = $f.loads; outerContext = $f.outerContext; param = $f.param; params = $f.params; prefix = $f.prefix; prevEV = $f.prevEV; sig = $f.sig; stores = $f.stores; suffix = $f.suffix; typ = $f.typ; v = $f.v; v$1 = $f.v$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- body = [body];
- c = [c];
- initStmts = [initStmts];
- typ = [typ];
- if (info === ptrType$25.nil) {
- $panic(new $String("nil info"));
- }
- c[0] = new funcContext.ptr(info, outerContext.p, outerContext, sig, new $Map(), new sliceType(["$ptr"]), sliceType$7.nil, (_map = new $Map(), _key = ptrType$44.nil, _map[ptrType$44.keyFor(_key)] = { k: _key, v: new flowData.ptr($throwNilPointerError, 0, 0) }, _map), 1, new $Map(), sliceType$4.nil, sliceType$4.nil, false, 0);
- _ref = outerContext.allVars;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- k = _entry.k;
- v = _entry.v;
- _key$1 = k; (c[0].allVars || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$1)] = { k: _key$1, v: v };
- _i++;
- }
- prevEV = c[0].p.escapingVars;
- params = sliceType.nil;
- _ref$1 = typ[0].Params.List;
- _i$1 = 0;
- /* while (true) { */ case 1:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 2; continue; }
- param = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- /* */ if (param.Names.$length === 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (param.Names.$length === 0) { */ case 3:
- _r = c[0].newVariable("param"); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- params = $append(params, _r);
- _i$1++;
- /* continue; */ $s = 1; continue;
- /* } */ case 4:
- _ref$2 = param.Names;
- _i$2 = 0;
- /* while (true) { */ case 6:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 7; continue; }
- ident = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- /* */ if (isBlank(ident)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (isBlank(ident)) { */ case 8:
- _r$1 = c[0].newVariable("param"); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- params = $append(params, _r$1);
- _i$2++;
- /* continue; */ $s = 6; continue;
- /* } */ case 9:
- _r$2 = c[0].objectName((_entry$1 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(ident)], _entry$1 !== undefined ? _entry$1.v : $ifaceNil)); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- params = $append(params, _r$2);
- _i$2++;
- /* } */ $s = 6; continue; case 7:
- _i$1++;
- /* } */ $s = 1; continue; case 2:
- _r$3 = c[0].CatchOutput(1, (function(body, c, initStmts, typ) { return function $b() {
- var $ptr, _arg, _arg$1, _entry$2, _key$2, _key$3, _r$3, _r$4, i, id, result, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry$2 = $f._entry$2; _key$2 = $f._key$2; _key$3 = $f._key$3; _r$3 = $f._r$3; _r$4 = $f._r$4; i = $f.i; id = $f.id; result = $f.result; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!(($keys(c[0].FuncInfo.Blocking).length === 0))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(($keys(c[0].FuncInfo.Blocking).length === 0))) { */ case 1:
- _key$2 = body[0]; (c[0].p.Info.Info.Scopes || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$2)] = { k: _key$2, v: (_entry$2 = c[0].p.Info.Info.Scopes[ast.Node.keyFor(typ[0])], _entry$2 !== undefined ? _entry$2.v : ptrType$51.nil) };
- $r = c[0].handleEscapingVars(body[0]); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ if (!(c[0].sig === ptrType$24.nil) && !((c[0].sig.Results().Len() === 0)) && !(c[0].sig.Results().At(0).object.Name() === "")) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(c[0].sig === ptrType$24.nil) && !((c[0].sig.Results().Len() === 0)) && !(c[0].sig.Results().At(0).object.Name() === "")) { */ case 4:
- c[0].resultNames = $makeSlice(sliceType$7, c[0].sig.Results().Len());
- i = 0;
- /* while (true) { */ case 6:
- /* if (!(i < c[0].sig.Results().Len())) { break; } */ if(!(i < c[0].sig.Results().Len())) { $s = 7; continue; }
- result = c[0].sig.Results().At(i);
- _r$3 = c[0].objectName(result); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg = new $String(_r$3);
- _r$4 = c[0].zeroValue(result.object.Type()); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$4);
- $r = c[0].Printf("%s = %s;", new sliceType$5([_arg, _arg$1])); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- id = ast.NewIdent("");
- _key$3 = id; (c[0].p.Info.Info.Uses || $throwRuntimeError("assignment to entry in nil map"))[ptrType$5.keyFor(_key$3)] = { k: _key$3, v: result };
- (x = c[0].resultNames, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = c[0].setType(id, result.object.Type())));
- i = i + (1) >> 0;
- /* } */ $s = 6; continue; case 7:
- /* } */ case 5:
- $r = c[0].translateStmtList(initStmts[0]); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].translateStmtList(body[0].List); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry$2 = _entry$2; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.i = i; $f.id = id; $f.result = result; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- }; })(body, c, initStmts, typ)); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- bodyOutput = $bytesToString(_r$3);
- $r = sort.Strings(c[0].localVars); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tmp = ""; _tmp$1 = ""; _tmp$2 = ""; prefix = _tmp; suffix = _tmp$1; functionName = _tmp$2;
- if (!(($keys(c[0].FuncInfo.Flattened).length === 0))) {
- c[0].localVars = $append(c[0].localVars, "$s");
- prefix = prefix + " $s = 0;";
- }
- if (c[0].FuncInfo.HasDefer) {
- c[0].localVars = $append(c[0].localVars, "$deferred");
- suffix = " }" + suffix;
- if (!(($keys(c[0].FuncInfo.Blocking).length === 0))) {
- suffix = " }" + suffix;
- }
- }
- /* */ if (!(($keys(c[0].FuncInfo.Blocking).length === 0))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!(($keys(c[0].FuncInfo.Blocking).length === 0))) { */ case 14:
- c[0].localVars = $append(c[0].localVars, "$r");
- if (funcRef === "") {
- funcRef = "$b";
- functionName = " $b";
- }
- _tmp$3 = ""; _tmp$4 = ""; stores = _tmp$3; loads = _tmp$4;
- _ref$3 = c[0].localVars;
- _i$3 = 0;
- /* while (true) { */ case 16:
- /* if (!(_i$3 < _ref$3.$length)) { break; } */ if(!(_i$3 < _ref$3.$length)) { $s = 17; continue; }
- v$1 = ((_i$3 < 0 || _i$3 >= _ref$3.$length) ? $throwRuntimeError("index out of range") : _ref$3.$array[_ref$3.$offset + _i$3]);
- _r$4 = fmt.Sprintf("%s = $f.%s; ", new sliceType$5([new $String(v$1), new $String(v$1)])); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- loads = loads + (_r$4);
- _r$5 = fmt.Sprintf("$f.%s = %s; ", new sliceType$5([new $String(v$1), new $String(v$1)])); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- stores = stores + (_r$5);
- _i$3++;
- /* } */ $s = 16; continue; case 17:
- prefix = prefix + " var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; " + loads + "}";
- suffix = " if ($f === undefined) { $f = { $blk: " + funcRef + " }; } " + stores + "return $f;" + suffix;
- /* } */ case 15:
- /* */ if (c[0].FuncInfo.HasDefer) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (c[0].FuncInfo.HasDefer) { */ case 20:
- prefix = prefix + " var $err = null; try {";
- deferSuffix = " } catch(err) { $err = err;";
- if (!(($keys(c[0].FuncInfo.Blocking).length === 0))) {
- deferSuffix = deferSuffix + (" $s = -1;");
- }
- /* */ if (c[0].resultNames === sliceType$7.nil && c[0].sig.Results().Len() > 0) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (c[0].resultNames === sliceType$7.nil && c[0].sig.Results().Len() > 0) { */ case 22:
- _r$6 = c[0].translateResults(sliceType$7.nil); /* */ $s = 24; case 24: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _arg = new $String(_r$6);
- _r$7 = fmt.Sprintf(" return%s;", new sliceType$5([_arg])); /* */ $s = 25; case 25: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- deferSuffix = deferSuffix + (_r$7);
- /* } */ case 23:
- deferSuffix = deferSuffix + (" } finally { $callDeferred($deferred, $err);");
- /* */ if (!(c[0].resultNames === sliceType$7.nil)) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (!(c[0].resultNames === sliceType$7.nil)) { */ case 26:
- _r$8 = c[0].translateResults(c[0].resultNames); /* */ $s = 28; case 28: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$8);
- _r$9 = fmt.Sprintf(" if (!$curGoroutine.asleep) { return %s; }", new sliceType$5([_arg$1])); /* */ $s = 29; case 29: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- deferSuffix = deferSuffix + (_r$9);
- /* } */ case 27:
- if (!(($keys(c[0].FuncInfo.Blocking).length === 0))) {
- deferSuffix = deferSuffix + (" if($curGoroutine.asleep) {");
- }
- suffix = deferSuffix + suffix;
- /* } */ case 21:
- if (!(($keys(c[0].FuncInfo.Flattened).length === 0))) {
- prefix = prefix + " s: while (true) { switch ($s) { case 0:";
- suffix = " $s = -1; case -1: } return; }" + suffix;
- }
- if (c[0].FuncInfo.HasDefer) {
- prefix = prefix + " $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);";
- }
- if (!(prefix === "")) {
- bodyOutput = strings.Repeat("\t", c[0].p.indentation + 1 >> 0) + "/* */" + prefix + "\n" + bodyOutput;
- }
- if (!(suffix === "")) {
- bodyOutput = bodyOutput + strings.Repeat("\t", c[0].p.indentation + 1 >> 0) + "/* */" + suffix + "\n";
- }
- /* */ if (!((c[0].localVars.$length === 0))) { $s = 30; continue; }
- /* */ $s = 31; continue;
- /* if (!((c[0].localVars.$length === 0))) { */ case 30:
- _r$10 = fmt.Sprintf("%svar %s;\n", new sliceType$5([new $String(strings.Repeat("\t", c[0].p.indentation + 1 >> 0)), new $String(strings.Join(c[0].localVars, ", "))])); /* */ $s = 32; case 32: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- bodyOutput = _r$10 + bodyOutput;
- /* } */ case 31:
- c[0].p.escapingVars = prevEV;
- _r$11 = fmt.Sprintf("function%s(%s) {\n%s%s}", new sliceType$5([new $String(functionName), new $String(strings.Join(params, ", ")), new $String(bodyOutput), new $String(strings.Repeat("\t", c[0].p.indentation))])); /* */ $s = 33; case 33: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return [params, _r$11];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: translateFunction }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._key = _key; $f._key$1 = _key$1; $f._keys = _keys; $f._map = _map; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tmp$2 = _tmp$2; $f._tmp$3 = _tmp$3; $f._tmp$4 = _tmp$4; $f.body = body; $f.bodyOutput = bodyOutput; $f.c = c; $f.deferSuffix = deferSuffix; $f.funcRef = funcRef; $f.functionName = functionName; $f.ident = ident; $f.info = info; $f.initStmts = initStmts; $f.k = k; $f.loads = loads; $f.outerContext = outerContext; $f.param = param; $f.params = params; $f.prefix = prefix; $f.prevEV = prevEV; $f.sig = sig; $f.stores = stores; $f.suffix = suffix; $f.typ = typ; $f.v = v; $f.v$1 = v$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.ptr.prototype.translateStmtList = function(stmts) {
- var $ptr, _i, _ref, c, stmt, stmts, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; c = $f.c; stmt = $f.stmt; stmts = $f.stmts; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _ref = stmts;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- stmt = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- $r = c.translateStmt(stmt, ptrType$44.nil); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- c.SetPos(0);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateStmtList }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.c = c; $f.stmt = stmt; $f.stmts = stmts; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateStmtList = function(stmts) { return this.$val.translateStmtList(stmts); };
- funcContext.ptr.prototype.translateStmt = function(stmt, label) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$16, _arg$17, _arg$18, _arg$19, _arg$2, _arg$20, _arg$21, _arg$22, _arg$23, _arg$24, _arg$25, _arg$26, _arg$27, _arg$28, _arg$29, _arg$3, _arg$30, _arg$31, _arg$32, _arg$33, _arg$34, _arg$35, _arg$36, _arg$37, _arg$38, _arg$39, _arg$4, _arg$40, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _entry, _entry$1, _entry$10, _entry$11, _entry$12, _entry$13, _entry$14, _entry$15, _entry$16, _entry$17, _entry$18, _entry$19, _entry$2, _entry$20, _entry$21, _entry$22, _entry$23, _entry$24, _entry$25, _entry$26, _entry$27, _entry$28, _entry$29, _entry$3, _entry$30, _entry$31, _entry$32, _entry$4, _entry$5, _entry$6, _entry$7, _entry$8, _entry$9, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _i$7, _i$8, _key, _key$1, _key$2, _key$3, _key$4, _key$5, _key$6, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$36, _r$37, _r$38, _r$39, _r$4, _r$40, _r$41, _r$42, _r$43, _r$44, _r$45, _r$46, _r$47, _r$48, _r$49, _r$5, _r$50, _r$51, _r$52, _r$53, _r$54, _r$55, _r$56, _r$57, _r$58, _r$59, _r$6, _r$60, _r$61, _r$62, _r$63, _r$64, _r$65, _r$66, _r$67, _r$68, _r$69, _r$7, _r$70, _r$71, _r$72, _r$73, _r$74, _r$75, _r$76, _r$77, _r$78, _r$79, _r$8, _r$80, _r$81, _r$9, _ref, _ref$1, _ref$10, _ref$11, _ref$12, _ref$13, _ref$14, _ref$15, _ref$16, _ref$17, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _ref$8, _ref$9, _tuple, _tuple$1, a, a$1, arg, args, blockingLabel, builtin, c, call, call$1, callArgs, caseClauses, caseClauses$1, chanType, channels, clause, comm, comm$1, comm$2, comm$3, comm$4, cond, data, decl, elemType, elseStmt, elseStmt$1, elseStmt$2, elseStmt$3, expr, expr$1, flattened, forStmt, fun, fun$1, hasDefault, i, i$1, i$2, i$3, i$4, i$5, iVar, iVar$1, iVar$2, ifStmt, indexLit, isBuiltin, isJs, isTuple, key, keysVar, label, label$1, length, lhs, lhs$1, lhs$2, lhs$3, lhs$4, lhsType, lhsType$1, lhsType$2, name, normalLabel, o, obj, okVar, out, parts, printCaseBodyPrefix, printCaseBodyPrefix$1, refVar, refVar$1, refVar$2, results, rhs, rhs$1, runeVar, s, s$1, s$10, s$11, s$12, s$13, s$14, s$15, s$16, s$17, s$18, s$2, s$3, s$4, s$5, s$6, s$7, s$8, s$9, selectCall, selectionVar, sig, spec, spec$1, stmt, t, t$1, t$2, t$3, t$4, t$5, t2, t2$1, t2$2, tag, tmpVars, tok, translateCond, translateCond$1, translateCond$2, tuple, tupleVar, v, valueSpec, vars, x, x$1, x$10, x$11, x$12, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$16 = $f._arg$16; _arg$17 = $f._arg$17; _arg$18 = $f._arg$18; _arg$19 = $f._arg$19; _arg$2 = $f._arg$2; _arg$20 = $f._arg$20; _arg$21 = $f._arg$21; _arg$22 = $f._arg$22; _arg$23 = $f._arg$23; _arg$24 = $f._arg$24; _arg$25 = $f._arg$25; _arg$26 = $f._arg$26; _arg$27 = $f._arg$27; _arg$28 = $f._arg$28; _arg$29 = $f._arg$29; _arg$3 = $f._arg$3; _arg$30 = $f._arg$30; _arg$31 = $f._arg$31; _arg$32 = $f._arg$32; _arg$33 = $f._arg$33; _arg$34 = $f._arg$34; _arg$35 = $f._arg$35; _arg$36 = $f._arg$36; _arg$37 = $f._arg$37; _arg$38 = $f._arg$38; _arg$39 = $f._arg$39; _arg$4 = $f._arg$4; _arg$40 = $f._arg$40; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$10 = $f._entry$10; _entry$11 = $f._entry$11; _entry$12 = $f._entry$12; _entry$13 = $f._entry$13; _entry$14 = $f._entry$14; _entry$15 = $f._entry$15; _entry$16 = $f._entry$16; _entry$17 = $f._entry$17; _entry$18 = $f._entry$18; _entry$19 = $f._entry$19; _entry$2 = $f._entry$2; _entry$20 = $f._entry$20; _entry$21 = $f._entry$21; _entry$22 = $f._entry$22; _entry$23 = $f._entry$23; _entry$24 = $f._entry$24; _entry$25 = $f._entry$25; _entry$26 = $f._entry$26; _entry$27 = $f._entry$27; _entry$28 = $f._entry$28; _entry$29 = $f._entry$29; _entry$3 = $f._entry$3; _entry$30 = $f._entry$30; _entry$31 = $f._entry$31; _entry$32 = $f._entry$32; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _entry$7 = $f._entry$7; _entry$8 = $f._entry$8; _entry$9 = $f._entry$9; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _i$7 = $f._i$7; _i$8 = $f._i$8; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _key$4 = $f._key$4; _key$5 = $f._key$5; _key$6 = $f._key$6; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _r$36 = $f._r$36; _r$37 = $f._r$37; _r$38 = $f._r$38; _r$39 = $f._r$39; _r$4 = $f._r$4; _r$40 = $f._r$40; _r$41 = $f._r$41; _r$42 = $f._r$42; _r$43 = $f._r$43; _r$44 = $f._r$44; _r$45 = $f._r$45; _r$46 = $f._r$46; _r$47 = $f._r$47; _r$48 = $f._r$48; _r$49 = $f._r$49; _r$5 = $f._r$5; _r$50 = $f._r$50; _r$51 = $f._r$51; _r$52 = $f._r$52; _r$53 = $f._r$53; _r$54 = $f._r$54; _r$55 = $f._r$55; _r$56 = $f._r$56; _r$57 = $f._r$57; _r$58 = $f._r$58; _r$59 = $f._r$59; _r$6 = $f._r$6; _r$60 = $f._r$60; _r$61 = $f._r$61; _r$62 = $f._r$62; _r$63 = $f._r$63; _r$64 = $f._r$64; _r$65 = $f._r$65; _r$66 = $f._r$66; _r$67 = $f._r$67; _r$68 = $f._r$68; _r$69 = $f._r$69; _r$7 = $f._r$7; _r$70 = $f._r$70; _r$71 = $f._r$71; _r$72 = $f._r$72; _r$73 = $f._r$73; _r$74 = $f._r$74; _r$75 = $f._r$75; _r$76 = $f._r$76; _r$77 = $f._r$77; _r$78 = $f._r$78; _r$79 = $f._r$79; _r$8 = $f._r$8; _r$80 = $f._r$80; _r$81 = $f._r$81; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$10 = $f._ref$10; _ref$11 = $f._ref$11; _ref$12 = $f._ref$12; _ref$13 = $f._ref$13; _ref$14 = $f._ref$14; _ref$15 = $f._ref$15; _ref$16 = $f._ref$16; _ref$17 = $f._ref$17; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _ref$8 = $f._ref$8; _ref$9 = $f._ref$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; a = $f.a; a$1 = $f.a$1; arg = $f.arg; args = $f.args; blockingLabel = $f.blockingLabel; builtin = $f.builtin; c = $f.c; call = $f.call; call$1 = $f.call$1; callArgs = $f.callArgs; caseClauses = $f.caseClauses; caseClauses$1 = $f.caseClauses$1; chanType = $f.chanType; channels = $f.channels; clause = $f.clause; comm = $f.comm; comm$1 = $f.comm$1; comm$2 = $f.comm$2; comm$3 = $f.comm$3; comm$4 = $f.comm$4; cond = $f.cond; data = $f.data; decl = $f.decl; elemType = $f.elemType; elseStmt = $f.elseStmt; elseStmt$1 = $f.elseStmt$1; elseStmt$2 = $f.elseStmt$2; elseStmt$3 = $f.elseStmt$3; expr = $f.expr; expr$1 = $f.expr$1; flattened = $f.flattened; forStmt = $f.forStmt; fun = $f.fun; fun$1 = $f.fun$1; hasDefault = $f.hasDefault; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; i$4 = $f.i$4; i$5 = $f.i$5; iVar = $f.iVar; iVar$1 = $f.iVar$1; iVar$2 = $f.iVar$2; ifStmt = $f.ifStmt; indexLit = $f.indexLit; isBuiltin = $f.isBuiltin; isJs = $f.isJs; isTuple = $f.isTuple; key = $f.key; keysVar = $f.keysVar; label = $f.label; label$1 = $f.label$1; length = $f.length; lhs = $f.lhs; lhs$1 = $f.lhs$1; lhs$2 = $f.lhs$2; lhs$3 = $f.lhs$3; lhs$4 = $f.lhs$4; lhsType = $f.lhsType; lhsType$1 = $f.lhsType$1; lhsType$2 = $f.lhsType$2; name = $f.name; normalLabel = $f.normalLabel; o = $f.o; obj = $f.obj; okVar = $f.okVar; out = $f.out; parts = $f.parts; printCaseBodyPrefix = $f.printCaseBodyPrefix; printCaseBodyPrefix$1 = $f.printCaseBodyPrefix$1; refVar = $f.refVar; refVar$1 = $f.refVar$1; refVar$2 = $f.refVar$2; results = $f.results; rhs = $f.rhs; rhs$1 = $f.rhs$1; runeVar = $f.runeVar; s = $f.s; s$1 = $f.s$1; s$10 = $f.s$10; s$11 = $f.s$11; s$12 = $f.s$12; s$13 = $f.s$13; s$14 = $f.s$14; s$15 = $f.s$15; s$16 = $f.s$16; s$17 = $f.s$17; s$18 = $f.s$18; s$2 = $f.s$2; s$3 = $f.s$3; s$4 = $f.s$4; s$5 = $f.s$5; s$6 = $f.s$6; s$7 = $f.s$7; s$8 = $f.s$8; s$9 = $f.s$9; selectCall = $f.selectCall; selectionVar = $f.selectionVar; sig = $f.sig; spec = $f.spec; spec$1 = $f.spec$1; stmt = $f.stmt; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t2 = $f.t2; t2$1 = $f.t2$1; t2$2 = $f.t2$2; tag = $f.tag; tmpVars = $f.tmpVars; tok = $f.tok; translateCond = $f.translateCond; translateCond$1 = $f.translateCond$1; translateCond$2 = $f.translateCond$2; tuple = $f.tuple; tupleVar = $f.tupleVar; v = $f.v; valueSpec = $f.valueSpec; vars = $f.vars; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = [c];
- elemType = [elemType];
- iVar = [iVar];
- iVar$1 = [iVar$1];
- iVar$2 = [iVar$2];
- keysVar = [keysVar];
- length = [length];
- refVar = [refVar];
- refVar$1 = [refVar$1];
- runeVar = [runeVar];
- s = [s];
- s$1 = [s$1];
- s$2 = [s$2];
- s$3 = [s$3];
- selectionVar = [selectionVar];
- t = [t];
- t$1 = [t$1];
- tag = [tag];
- c[0] = this;
- _r = stmt.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = c[0].SetPos(_r); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = filter.IncDecStmt(stmt, c[0].p.Info); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- stmt = _r$1;
- _r$2 = filter.Assign(stmt, c[0].p.Info); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- stmt = _r$2;
- _ref = stmt;
- /* */ if ($assertType(_ref, ptrType$50, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$52, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$53, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$54, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$55, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$56, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$57, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$58, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$59, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, ptrType$60, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$61, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$62, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, ptrType$63, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref, ptrType$64, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref, ptrType$65, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref, ptrType$66, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref, ptrType$67, true)[1]) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if ($assertType(_ref, ptrType$50, true)[1]) { */ case 5:
- s$4 = _ref.$val;
- $r = c[0].translateStmtList(s$4.List); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$52, true)[1]) { */ case 6:
- s$5 = _ref.$val;
- /* */ if (!($interfaceIsEqual(s$5.Init, $ifaceNil))) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if (!($interfaceIsEqual(s$5.Init, $ifaceNil))) { */ case 25:
- $r = c[0].translateStmt(s$5.Init, ptrType$44.nil); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 26:
- caseClauses = sliceType$6.nil;
- ifStmt = s$5;
- /* while (true) { */ case 28:
- caseClauses = $append(caseClauses, new ast.CaseClause.ptr(0, new sliceType$7([ifStmt.Cond]), 0, ifStmt.Body.List));
- _ref$1 = ifStmt.Else;
- /* */ if ($assertType(_ref$1, ptrType$52, true)[1]) { $s = 30; continue; }
- /* */ if ($assertType(_ref$1, ptrType$50, true)[1]) { $s = 31; continue; }
- /* */ if ($assertType(_ref$1, ptrType$67, true)[1] || _ref$1 === $ifaceNil) { $s = 32; continue; }
- /* */ $s = 33; continue;
- /* switch (0) { default: if ($assertType(_ref$1, ptrType$52, true)[1]) { */ case 30:
- elseStmt = _ref$1.$val;
- if (!($interfaceIsEqual(elseStmt.Init, $ifaceNil))) {
- caseClauses = $append(caseClauses, new ast.CaseClause.ptr(0, sliceType$7.nil, 0, new sliceType$6([elseStmt])));
- /* break; */ $s = 34; continue;
- }
- ifStmt = elseStmt;
- /* continue; */ $s = 28; continue;
- $s = 34; continue;
- /* } else if ($assertType(_ref$1, ptrType$50, true)[1]) { */ case 31:
- elseStmt$1 = _ref$1.$val;
- caseClauses = $append(caseClauses, new ast.CaseClause.ptr(0, sliceType$7.nil, 0, elseStmt$1.List));
- $s = 34; continue;
- /* } else if ($assertType(_ref$1, ptrType$67, true)[1] || _ref$1 === $ifaceNil) { */ case 32:
- elseStmt$2 = _ref$1;
- $s = 34; continue;
- /* } else { */ case 33:
- elseStmt$3 = _ref$1;
- _r$3 = fmt.Sprintf("Unhandled else: %T\n", new sliceType$5([elseStmt$3])); /* */ $s = 35; case 35: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- $panic(new $String(_r$3));
- /* } } */ case 34:
- /* break; */ $s = 29; continue;
- /* } */ $s = 28; continue; case 29:
- $r = c[0].translateBranchingStmt(caseClauses, false, $throwNilPointerError, $throwNilPointerError, ptrType$44.nil, (_entry = c[0].FuncInfo.Flattened[ast.Node.keyFor(s$5)], _entry !== undefined ? _entry.v : false)); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$53, true)[1]) { */ case 7:
- s$6 = _ref.$val;
- /* */ if (!($interfaceIsEqual(s$6.Init, $ifaceNil))) { $s = 37; continue; }
- /* */ $s = 38; continue;
- /* if (!($interfaceIsEqual(s$6.Init, $ifaceNil))) { */ case 37:
- $r = c[0].translateStmt(s$6.Init, ptrType$44.nil); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 38:
- tag[0] = s$6.Tag;
- if ($interfaceIsEqual(tag[0], $ifaceNil)) {
- tag[0] = ast.NewIdent("true");
- _key = tag[0]; (c[0].p.Info.Info.Types || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key)] = { k: _key, v: new types.TypeAndValue.ptr(0, types.Typ[1], exact.MakeBool(true)) };
- }
- /* */ if ($interfaceIsEqual((_entry$1 = c[0].p.Info.Info.Types[ast.Expr.keyFor(tag[0])], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if ($interfaceIsEqual((_entry$1 = c[0].p.Info.Info.Types[ast.Expr.keyFor(tag[0])], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)) { */ case 40:
- _r$4 = c[0].newVariable("_ref"); /* */ $s = 42; case 42: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- refVar$2 = _r$4;
- _arg = new $String(refVar$2);
- _r$5 = c[0].translateExpr(tag[0]); /* */ $s = 43; case 43: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$1 = _r$5;
- $r = c[0].Printf("%s = %s;", new sliceType$5([_arg, _arg$1])); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- tag[0] = c[0].newIdent(refVar$2, (_entry$2 = c[0].p.Info.Info.Types[ast.Expr.keyFor(tag[0])], _entry$2 !== undefined ? _entry$2.v : new types.TypeAndValue.ptr()).Type);
- /* } */ case 41:
- translateCond = (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b(cond) {
- var $ptr, _r$6, cond, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$6 = $f._r$6; cond = $f.cond; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$6 = c[0].translateExpr(new ast.BinaryExpr.ptr(tag[0], 0, 39, cond)); /* */ $s = 1; case 1: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$6 = _r$6; $f.cond = cond; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag);
- $r = c[0].translateBranchingStmt(s$6.Body.List, true, translateCond, $throwNilPointerError, label, (_entry$3 = c[0].FuncInfo.Flattened[ast.Node.keyFor(s$6)], _entry$3 !== undefined ? _entry$3.v : false)); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$54, true)[1]) { */ case 8:
- s$2[0] = _ref.$val;
- /* */ if (!($interfaceIsEqual(s$2[0].Init, $ifaceNil))) { $s = 46; continue; }
- /* */ $s = 47; continue;
- /* if (!($interfaceIsEqual(s$2[0].Init, $ifaceNil))) { */ case 46:
- $r = c[0].translateStmt(s$2[0].Init, ptrType$44.nil); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 47:
- _r$6 = c[0].newVariable("_ref"); /* */ $s = 49; case 49: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- refVar[0] = _r$6;
- expr = $ifaceNil;
- printCaseBodyPrefix = $throwNilPointerError;
- _ref$2 = s$2[0].Assign;
- /* */ if ($assertType(_ref$2, ptrType$60, true)[1]) { $s = 50; continue; }
- /* */ if ($assertType(_ref$2, ptrType$62, true)[1]) { $s = 51; continue; }
- /* */ $s = 52; continue;
- /* if ($assertType(_ref$2, ptrType$60, true)[1]) { */ case 50:
- a = _ref$2.$val;
- expr = $assertType((x = a.Rhs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])), ptrType$15).X;
- printCaseBodyPrefix = (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b(index) {
- var $ptr, _arg$2, _arg$3, _entry$4, _entry$5, _r$7, _r$8, _r$9, _tuple, _v, caseClause, index, isInterface, t$2, value, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _v = $f._v; caseClause = $f.caseClause; index = $f.index; isInterface = $f.isInterface; t$2 = $f.t$2; value = $f.value; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- value = refVar[0];
- caseClause = $assertType((x$1 = s$2[0].Body.List, ((index < 0 || index >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + index])), ptrType$68);
- /* */ if (caseClause.List.$length === 1) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (caseClause.List.$length === 1) { */ case 1:
- t$2 = (_entry$4 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$2 = caseClause.List, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])))], _entry$4 !== undefined ? _entry$4.v : new types.TypeAndValue.ptr()).Type;
- _r$7 = t$2.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$7, ptrType$30, true); isInterface = _tuple[1];
- if (!(!isInterface)) { _v = false; $s = 6; continue s; }
- _r$8 = types.Identical(t$2, types.Typ[25]); /* */ $s = 7; case 7: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _v = !_r$8; case 6:
- /* */ if (_v) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_v) { */ case 4:
- value = value + (".$val");
- /* } */ case 5:
- /* } */ case 2:
- _r$9 = c[0].objectName((_entry$5 = c[0].p.Info.Info.Implicits[ast.Node.keyFor(caseClause)], _entry$5 !== undefined ? _entry$5.v : $ifaceNil)); /* */ $s = 8; case 8: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$9);
- _arg$3 = new $String(value);
- $r = c[0].Printf("%s = %s;", new sliceType$5([_arg$2, _arg$3])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._v = _v; $f.caseClause = caseClause; $f.index = index; $f.isInterface = isInterface; $f.t$2 = t$2; $f.value = value; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag);
- $s = 52; continue;
- /* } else if ($assertType(_ref$2, ptrType$62, true)[1]) { */ case 51:
- a$1 = _ref$2.$val;
- expr = $assertType(a$1.X, ptrType$15).X;
- /* } */ case 52:
- _arg$2 = new $String(refVar[0]);
- _r$7 = c[0].translateExpr(expr); /* */ $s = 53; case 53: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$3 = _r$7;
- $r = c[0].Printf("%s = %s;", new sliceType$5([_arg$2, _arg$3])); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- translateCond$1 = (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b(cond) {
- var $ptr, _arg$4, _arg$5, _entry$4, _entry$5, _r$10, _r$11, _r$8, _r$9, cond, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$8 = $f._r$8; _r$9 = $f._r$9; cond = $f.cond; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$8 = types.Identical((_entry$4 = c[0].p.Info.Info.Types[ast.Expr.keyFor(cond)], _entry$4 !== undefined ? _entry$4.v : new types.TypeAndValue.ptr()).Type, types.Typ[25]); /* */ $s = 3; case 3: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- /* */ if (_r$8) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r$8) { */ case 1:
- _r$9 = c[0].formatExpr("%s === $ifaceNil", new sliceType$5([new $String(refVar[0])])); /* */ $s = 4; case 4: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- return _r$9;
- /* } */ case 2:
- _arg$4 = new $String(refVar[0]);
- _r$10 = c[0].typeName((_entry$5 = c[0].p.Info.Info.Types[ast.Expr.keyFor(cond)], _entry$5 !== undefined ? _entry$5.v : new types.TypeAndValue.ptr()).Type); /* */ $s = 5; case 5: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _arg$5 = new $String(_r$10);
- _r$11 = c[0].formatExpr("$assertType(%s, %s, true)[1]", new sliceType$5([_arg$4, _arg$5])); /* */ $s = 6; case 6: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return _r$11;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$8 = _r$8; $f._r$9 = _r$9; $f.cond = cond; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag);
- $r = c[0].translateBranchingStmt(s$2[0].Body.List, true, translateCond$1, printCaseBodyPrefix, label, (_entry$4 = c[0].FuncInfo.Flattened[ast.Node.keyFor(s$2[0])], _entry$4 !== undefined ? _entry$4.v : false)); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$55, true)[1]) { */ case 9:
- s[0] = _ref.$val;
- /* */ if (!($interfaceIsEqual(s[0].Init, $ifaceNil))) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if (!($interfaceIsEqual(s[0].Init, $ifaceNil))) { */ case 56:
- $r = c[0].translateStmt(s[0].Init, ptrType$44.nil); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 57:
- cond = (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, _r$8, _r$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$8 = $f._r$8; _r$9 = $f._r$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if ($interfaceIsEqual(s[0].Cond, $ifaceNil)) {
- return "true";
- }
- _r$8 = c[0].translateExpr(s[0].Cond); /* */ $s = 1; case 1: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = _r$8.String(); /* */ $s = 2; case 2: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- return _r$9;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$8 = _r$8; $f._r$9 = _r$9; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag);
- $r = c[0].translateLoopingStmt(cond, s[0].Body, $throwNilPointerError, (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!($interfaceIsEqual(s[0].Post, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(s[0].Post, $ifaceNil))) { */ case 1:
- $r = c[0].translateStmt(s[0].Post, ptrType$44.nil); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), label, (_entry$5 = c[0].FuncInfo.Flattened[ast.Node.keyFor(s[0])], _entry$5 !== undefined ? _entry$5.v : false)); /* */ $s = 59; case 59: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$56, true)[1]) { */ case 10:
- s$3[0] = _ref.$val;
- _r$8 = c[0].newVariable("_ref"); /* */ $s = 60; case 60: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- refVar$1[0] = _r$8;
- _arg$4 = new $String(refVar$1[0]);
- _r$9 = c[0].translateExpr(s$3[0].X); /* */ $s = 61; case 61: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$5 = _r$9;
- $r = c[0].Printf("%s = %s;", new sliceType$5([_arg$4, _arg$5])); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$10 = (_entry$6 = c[0].p.Info.Info.Types[ast.Expr.keyFor(s$3[0].X)], _entry$6 !== undefined ? _entry$6.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 63; case 63: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _ref$3 = _r$10;
- /* */ if ($assertType(_ref$3, ptrType$3, true)[1]) { $s = 64; continue; }
- /* */ if ($assertType(_ref$3, ptrType$22, true)[1]) { $s = 65; continue; }
- /* */ if ($assertType(_ref$3, ptrType$20, true)[1] || $assertType(_ref$3, ptrType$17, true)[1] || $assertType(_ref$3, ptrType$21, true)[1]) { $s = 66; continue; }
- /* */ if ($assertType(_ref$3, ptrType$39, true)[1]) { $s = 67; continue; }
- /* */ $s = 68; continue;
- /* if ($assertType(_ref$3, ptrType$3, true)[1]) { */ case 64:
- t$2 = _ref$3.$val;
- _r$11 = c[0].newVariable("_i"); /* */ $s = 70; case 70: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- iVar$2[0] = _r$11;
- $r = c[0].Printf("%s = 0;", new sliceType$5([new $String(iVar$2[0])])); /* */ $s = 71; case 71: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$12 = c[0].newVariable("_rune"); /* */ $s = 72; case 72: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- runeVar[0] = _r$12;
- $r = c[0].translateLoopingStmt((function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function() {
- var $ptr;
- return iVar$2[0] + " < " + refVar$1[0] + ".length";
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), s$3[0].Body, (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, _arg$6, _arg$7, _r$13, _r$14, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _r$13 = $f._r$13; _r$14 = $f._r$14; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = c[0].Printf("%s = $decodeRune(%s, %s);", new sliceType$5([new $String(runeVar[0]), new $String(refVar$1[0]), new $String(iVar$2[0])])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!isBlank(s$3[0].Key)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!isBlank(s$3[0].Key)) { */ case 2:
- _r$13 = c[0].translateAssign(s$3[0].Key, iVar$2[0], types.Typ[2], s$3[0].Tok === 47); /* */ $s = 4; case 4: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _arg$6 = new $String(_r$13);
- $r = c[0].Printf("%s", new sliceType$5([_arg$6])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- /* */ if (!isBlank(s$3[0].Value)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!isBlank(s$3[0].Value)) { */ case 6:
- _r$14 = c[0].translateAssign(s$3[0].Value, runeVar[0] + "[0]", types.Typ[5], s$3[0].Tok === 47); /* */ $s = 8; case 8: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _arg$7 = new $String(_r$14);
- $r = c[0].Printf("%s", new sliceType$5([_arg$7])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._r$13 = _r$13; $f._r$14 = _r$14; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = c[0].Printf("%s += %s[1];", new sliceType$5([new $String(iVar$2[0]), new $String(runeVar[0])])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), label, (_entry$7 = c[0].FuncInfo.Flattened[ast.Node.keyFor(s$3[0])], _entry$7 !== undefined ? _entry$7.v : false)); /* */ $s = 73; case 73: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 69; continue;
- /* } else if ($assertType(_ref$3, ptrType$22, true)[1]) { */ case 65:
- t[0] = _ref$3.$val;
- _r$13 = c[0].newVariable("_i"); /* */ $s = 74; case 74: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- iVar[0] = _r$13;
- $r = c[0].Printf("%s = 0;", new sliceType$5([new $String(iVar[0])])); /* */ $s = 75; case 75: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$14 = c[0].newVariable("_keys"); /* */ $s = 76; case 76: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- keysVar[0] = _r$14;
- $r = c[0].Printf("%s = $keys(%s);", new sliceType$5([new $String(keysVar[0]), new $String(refVar$1[0])])); /* */ $s = 77; case 77: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].translateLoopingStmt((function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function() {
- var $ptr;
- return iVar[0] + " < " + keysVar[0] + ".length";
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), s$3[0].Body, (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, _arg$6, _arg$7, _r$15, _r$16, _r$17, entryVar, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; entryVar = $f.entryVar; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$15 = c[0].newVariable("_entry"); /* */ $s = 1; case 1: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- entryVar = _r$15;
- $r = c[0].Printf("%s = %s[%s[%s]];", new sliceType$5([new $String(entryVar), new $String(refVar$1[0]), new $String(keysVar[0]), new $String(iVar[0])])); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].translateStmt(new ast.IfStmt.ptr(0, $ifaceNil, c[0].newIdent(entryVar + " === undefined", types.Typ[1]), new ast.BlockStmt.ptr(0, new sliceType$6([new ast.BranchStmt.ptr(0, 65, ptrType$5.nil)]), 0), $ifaceNil), ptrType$44.nil); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!isBlank(s$3[0].Key)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!isBlank(s$3[0].Key)) { */ case 4:
- _r$16 = c[0].translateAssign(s$3[0].Key, entryVar + ".k", t[0].Key(), s$3[0].Tok === 47); /* */ $s = 6; case 6: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _arg$6 = new $String(_r$16);
- $r = c[0].Printf("%s", new sliceType$5([_arg$6])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- /* */ if (!isBlank(s$3[0].Value)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!isBlank(s$3[0].Value)) { */ case 8:
- _r$17 = c[0].translateAssign(s$3[0].Value, entryVar + ".v", t[0].Elem(), s$3[0].Tok === 47); /* */ $s = 10; case 10: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _arg$7 = new $String(_r$17);
- $r = c[0].Printf("%s", new sliceType$5([_arg$7])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f.entryVar = entryVar; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = c[0].Printf("%s++;", new sliceType$5([new $String(iVar[0])])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), label, (_entry$8 = c[0].FuncInfo.Flattened[ast.Node.keyFor(s$3[0])], _entry$8 !== undefined ? _entry$8.v : false)); /* */ $s = 78; case 78: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 69; continue;
- /* } else if ($assertType(_ref$3, ptrType$20, true)[1] || $assertType(_ref$3, ptrType$17, true)[1] || $assertType(_ref$3, ptrType$21, true)[1]) { */ case 66:
- t$1[0] = _ref$3;
- length[0] = "";
- elemType[0] = $ifaceNil;
- _ref$4 = t$1[0];
- /* */ if ($assertType(_ref$4, ptrType$20, true)[1]) { $s = 79; continue; }
- /* */ if ($assertType(_ref$4, ptrType$17, true)[1]) { $s = 80; continue; }
- /* */ if ($assertType(_ref$4, ptrType$21, true)[1]) { $s = 81; continue; }
- /* */ $s = 82; continue;
- /* if ($assertType(_ref$4, ptrType$20, true)[1]) { */ case 79:
- t2 = _ref$4.$val;
- _r$15 = fmt.Sprintf("%d", new sliceType$5([t2.Len()])); /* */ $s = 83; case 83: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- length[0] = _r$15;
- elemType[0] = t2.Elem();
- $s = 82; continue;
- /* } else if ($assertType(_ref$4, ptrType$17, true)[1]) { */ case 80:
- t2$1 = _ref$4.$val;
- _r$16 = t2$1.Elem().Underlying(); /* */ $s = 84; case 84: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- _r$17 = $assertType(_r$16, ptrType$20).Len(); /* */ $s = 85; case 85: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _arg$6 = _r$17;
- _r$18 = fmt.Sprintf("%d", new sliceType$5([_arg$6])); /* */ $s = 86; case 86: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- length[0] = _r$18;
- _r$19 = t2$1.Elem().Underlying(); /* */ $s = 87; case 87: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- _r$20 = $assertType(_r$19, ptrType$20).Elem(); /* */ $s = 88; case 88: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- elemType[0] = _r$20;
- $s = 82; continue;
- /* } else if ($assertType(_ref$4, ptrType$21, true)[1]) { */ case 81:
- t2$2 = _ref$4.$val;
- length[0] = refVar$1[0] + ".$length";
- elemType[0] = t2$2.Elem();
- /* } */ case 82:
- _r$21 = c[0].newVariable("_i"); /* */ $s = 89; case 89: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- iVar$1[0] = _r$21;
- $r = c[0].Printf("%s = 0;", new sliceType$5([new $String(iVar$1[0])])); /* */ $s = 90; case 90: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].translateLoopingStmt((function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function() {
- var $ptr;
- return iVar$1[0] + " < " + length[0];
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), s$3[0].Body, (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, _arg$10, _arg$11, _arg$12, _arg$7, _arg$8, _arg$9, _r$22, _r$23, _r$24, _r$25, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!isBlank(s$3[0].Key)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!isBlank(s$3[0].Key)) { */ case 1:
- _r$22 = c[0].translateAssign(s$3[0].Key, iVar$1[0], types.Typ[2], s$3[0].Tok === 47); /* */ $s = 3; case 3: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _arg$7 = new $String(_r$22);
- $r = c[0].Printf("%s", new sliceType$5([_arg$7])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- /* */ if (!isBlank(s$3[0].Value)) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!isBlank(s$3[0].Value)) { */ case 5:
- _arg$8 = s$3[0].Value;
- _r$23 = c[0].translateImplicitConversion(c[0].setType(new ast.IndexExpr.ptr(c[0].newIdent(refVar$1[0], t$1[0]), 0, c[0].newIdent(iVar$1[0], types.Typ[2]), 0), elemType[0]), elemType[0]); /* */ $s = 7; case 7: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- _r$24 = _r$23.String(); /* */ $s = 8; case 8: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _arg$9 = _r$24;
- _arg$10 = elemType[0];
- _arg$11 = s$3[0].Tok === 47;
- _r$25 = c[0].translateAssign(_arg$8, _arg$9, _arg$10, _arg$11); /* */ $s = 9; case 9: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _arg$12 = new $String(_r$25);
- $r = c[0].Printf("%s", new sliceType$5([_arg$12])); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = c[0].Printf("%s++;", new sliceType$5([new $String(iVar$1[0])])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag), label, (_entry$9 = c[0].FuncInfo.Flattened[ast.Node.keyFor(s$3[0])], _entry$9 !== undefined ? _entry$9.v : false)); /* */ $s = 91; case 91: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 69; continue;
- /* } else if ($assertType(_ref$3, ptrType$39, true)[1]) { */ case 67:
- t$3 = _ref$3.$val;
- _r$22 = c[0].newVariable("_ok"); /* */ $s = 92; case 92: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = c[0].newIdent(_r$22, types.Typ[1]); /* */ $s = 93; case 93: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- okVar = _r$23;
- key = s$3[0].Key;
- tok = s$3[0].Tok;
- if ($interfaceIsEqual(key, $ifaceNil)) {
- key = ast.NewIdent("_");
- tok = 42;
- }
- forStmt = new ast.ForStmt.ptr(0, $ifaceNil, $ifaceNil, $ifaceNil, new ast.BlockStmt.ptr(0, new sliceType$6([new ast.AssignStmt.ptr(new sliceType$7([key, okVar]), 0, tok, new sliceType$7([c[0].setType(new ast.UnaryExpr.ptr(0, 36, c[0].newIdent(refVar$1[0], t$3)), types.NewTuple(new sliceType$8([types.NewVar(0, ptrType$28.nil, "", t$3.Elem()), types.NewVar(0, ptrType$28.nil, "", types.Typ[1])])))])), new ast.IfStmt.ptr(0, $ifaceNil, new ast.UnaryExpr.ptr(0, 43, okVar), new ast.BlockStmt.ptr(0, new sliceType$6([new ast.BranchStmt.ptr(0, 61, ptrType$5.nil)]), 0), $ifaceNil), s$3[0].Body]), 0));
- _key$1 = forStmt; (c[0].FuncInfo.Flattened || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$1)] = { k: _key$1, v: true };
- $r = c[0].translateStmt(forStmt, label); /* */ $s = 94; case 94: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 69; continue;
- /* } else { */ case 68:
- t$4 = _ref$3;
- $panic(new $String(""));
- /* } */ case 69:
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$57, true)[1]) { */ case 11:
- s$7 = _ref.$val;
- normalLabel = "";
- blockingLabel = "";
- data = (_entry$10 = c[0].flowDatas[ptrType$44.keyFor(ptrType$44.nil)], _entry$10 !== undefined ? _entry$10.v : ptrType$69.nil);
- if (!(s$7.Label === ptrType$5.nil)) {
- normalLabel = " " + s$7.Label.Name;
- blockingLabel = " s";
- data = (_entry$12 = c[0].flowDatas[ptrType$44.keyFor($assertType((_entry$11 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(s$7.Label)], _entry$11 !== undefined ? _entry$11.v : $ifaceNil), ptrType$44))], _entry$12 !== undefined ? _entry$12.v : ptrType$69.nil);
- }
- _ref$5 = s$7.Tok;
- /* */ if (_ref$5 === 61) { $s = 95; continue; }
- /* */ if (_ref$5 === 65) { $s = 96; continue; }
- /* */ if (_ref$5 === 73) { $s = 97; continue; }
- /* */ if (_ref$5 === 69) { $s = 98; continue; }
- /* */ $s = 99; continue;
- /* if (_ref$5 === 61) { */ case 95:
- _arg$7 = data.endCase === 0;
- _r$24 = fmt.Sprintf("break%s;", new sliceType$5([new $String(normalLabel)])); /* */ $s = 101; case 101: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _arg$8 = _r$24;
- _r$25 = fmt.Sprintf("$s = %d; continue%s;", new sliceType$5([new $Int(data.endCase), new $String(blockingLabel)])); /* */ $s = 102; case 102: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- _arg$9 = _r$25;
- $r = c[0].PrintCond(_arg$7, _arg$8, _arg$9); /* */ $s = 103; case 103: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 100; continue;
- /* } else if (_ref$5 === 65) { */ case 96:
- $r = data.postStmt(); /* */ $s = 104; case 104: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _arg$10 = data.beginCase === 0;
- _r$26 = fmt.Sprintf("continue%s;", new sliceType$5([new $String(normalLabel)])); /* */ $s = 105; case 105: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- _arg$11 = _r$26;
- _r$27 = fmt.Sprintf("$s = %d; continue%s;", new sliceType$5([new $Int(data.beginCase), new $String(blockingLabel)])); /* */ $s = 106; case 106: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- _arg$12 = _r$27;
- $r = c[0].PrintCond(_arg$10, _arg$11, _arg$12); /* */ $s = 107; case 107: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 100; continue;
- /* } else if (_ref$5 === 73) { */ case 97:
- _arg$13 = "goto " + s$7.Label.Name;
- _r$28 = fmt.Sprintf("$s = %d; continue;", new sliceType$5([new $Int(c[0].labelCase($assertType((_entry$13 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(s$7.Label)], _entry$13 !== undefined ? _entry$13.v : $ifaceNil), ptrType$44)))])); /* */ $s = 108; case 108: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; }
- _arg$14 = _r$28;
- $r = c[0].PrintCond(false, _arg$13, _arg$14); /* */ $s = 109; case 109: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 100; continue;
- /* } else if (_ref$5 === 69) { */ case 98:
- $s = 100; continue;
- /* } else { */ case 99:
- $panic(new $String("Unhandled branch statment: " + new token.Token(s$7.Tok).String()));
- /* } */ case 100:
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$58, true)[1]) { */ case 12:
- s$8 = _ref.$val;
- results = s$8.Results;
- /* */ if (!(c[0].resultNames === sliceType$7.nil)) { $s = 110; continue; }
- /* */ $s = 111; continue;
- /* if (!(c[0].resultNames === sliceType$7.nil)) { */ case 110:
- /* */ if (!((s$8.Results.$length === 0))) { $s = 112; continue; }
- /* */ $s = 113; continue;
- /* if (!((s$8.Results.$length === 0))) { */ case 112:
- $r = c[0].translateStmt(new ast.AssignStmt.ptr(c[0].resultNames, 0, 42, s$8.Results), ptrType$44.nil); /* */ $s = 114; case 114: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 113:
- results = c[0].resultNames;
- /* } */ case 111:
- _r$29 = c[0].translateResults(results); /* */ $s = 115; case 115: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; }
- _arg$15 = new $String(_r$29);
- $r = c[0].Printf("return%s;", new sliceType$5([_arg$15])); /* */ $s = 116; case 116: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$59, true)[1]) { */ case 13:
- s$9 = _ref.$val;
- isBuiltin = false;
- isJs = false;
- _ref$6 = s$9.Call.Fun;
- /* */ if ($assertType(_ref$6, ptrType$5, true)[1]) { $s = 117; continue; }
- /* */ if ($assertType(_ref$6, ptrType$4, true)[1]) { $s = 118; continue; }
- /* */ $s = 119; continue;
- /* if ($assertType(_ref$6, ptrType$5, true)[1]) { */ case 117:
- fun = _ref$6.$val;
- builtin = ptrType$33.nil;
- _tuple = $assertType((_entry$14 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(fun)], _entry$14 !== undefined ? _entry$14.v : $ifaceNil), ptrType$33, true); builtin = _tuple[0]; isBuiltin = _tuple[1];
- /* */ if (isBuiltin && builtin.object.Name() === "recover") { $s = 120; continue; }
- /* */ $s = 121; continue;
- /* if (isBuiltin && builtin.object.Name() === "recover") { */ case 120:
- $r = c[0].Printf("$deferred.push([$recover, []]);", new sliceType$5([])); /* */ $s = 122; case 122: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 121:
- $s = 119; continue;
- /* } else if ($assertType(_ref$6, ptrType$4, true)[1]) { */ case 118:
- fun$1 = _ref$6.$val;
- _r$30 = (_entry$15 = c[0].p.Info.Info.Uses[ptrType$5.keyFor(fun$1.Sel)], _entry$15 !== undefined ? _entry$15.v : $ifaceNil).Pkg(); /* */ $s = 123; case 123: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; }
- _r$31 = typesutil.IsJsPackage(_r$30); /* */ $s = 124; case 124: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; }
- isJs = _r$31;
- /* } */ case 119:
- _r$32 = (_entry$16 = c[0].p.Info.Info.Types[ast.Expr.keyFor(s$9.Call.Fun)], _entry$16 !== undefined ? _entry$16.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 125; case 125: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; }
- sig = $assertType(_r$32, ptrType$24);
- _r$33 = c[0].translateArgs(sig, s$9.Call.Args, new token.Pos(s$9.Call.Ellipsis).IsValid(), true); /* */ $s = 126; case 126: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; }
- args = _r$33;
- /* */ if (isBuiltin || isJs) { $s = 127; continue; }
- /* */ $s = 128; continue;
- /* if (isBuiltin || isJs) { */ case 127:
- vars = $makeSlice(sliceType, s$9.Call.Args.$length);
- callArgs = $makeSlice(sliceType$7, s$9.Call.Args.$length);
- _ref$7 = s$9.Call.Args;
- _i = 0;
- /* while (true) { */ case 129:
- /* if (!(_i < _ref$7.$length)) { break; } */ if(!(_i < _ref$7.$length)) { $s = 130; continue; }
- i = _i;
- arg = ((_i < 0 || _i >= _ref$7.$length) ? $throwRuntimeError("index out of range") : _ref$7.$array[_ref$7.$offset + _i]);
- _r$34 = c[0].newVariable("_arg"); /* */ $s = 131; case 131: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; }
- v = _r$34;
- ((i < 0 || i >= vars.$length) ? $throwRuntimeError("index out of range") : vars.$array[vars.$offset + i] = v);
- ((i < 0 || i >= callArgs.$length) ? $throwRuntimeError("index out of range") : callArgs.$array[callArgs.$offset + i] = c[0].newIdent(v, (_entry$17 = c[0].p.Info.Info.Types[ast.Expr.keyFor(arg)], _entry$17 !== undefined ? _entry$17.v : new types.TypeAndValue.ptr()).Type));
- _i++;
- /* } */ $s = 129; continue; case 130:
- _r$35 = c[0].translateExpr(new ast.CallExpr.ptr(s$9.Call.Fun, 0, callArgs, s$9.Call.Ellipsis, 0)); /* */ $s = 132; case 132: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; }
- call = _r$35;
- $r = c[0].Printf("$deferred.push([function(%s) { %s; }, [%s]]);", new sliceType$5([new $String(strings.Join(vars, ", ")), call, new $String(strings.Join(args, ", "))])); /* */ $s = 133; case 133: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 128:
- _r$36 = c[0].translateExpr(s$9.Call.Fun); /* */ $s = 134; case 134: if($c) { $c = false; _r$36 = _r$36.$blk(); } if (_r$36 && _r$36.$blk !== undefined) { break s; }
- _arg$16 = _r$36;
- _arg$17 = new $String(strings.Join(args, ", "));
- $r = c[0].Printf("$deferred.push([%s, [%s]]);", new sliceType$5([_arg$16, _arg$17])); /* */ $s = 135; case 135: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$60, true)[1]) { */ case 14:
- s$10 = _ref.$val;
- if (!((s$10.Tok === 42)) && !((s$10.Tok === 47))) {
- $panic(new token.Token(s$10.Tok));
- }
- /* */ if (s$10.Tok === 47) { $s = 136; continue; }
- /* */ $s = 137; continue;
- /* if (s$10.Tok === 47) { */ case 136:
- _ref$8 = s$10.Lhs;
- _i$1 = 0;
- /* while (true) { */ case 138:
- /* if (!(_i$1 < _ref$8.$length)) { break; } */ if(!(_i$1 < _ref$8.$length)) { $s = 139; continue; }
- lhs = ((_i$1 < 0 || _i$1 >= _ref$8.$length) ? $throwRuntimeError("index out of range") : _ref$8.$array[_ref$8.$offset + _i$1]);
- /* */ if (!isBlank(lhs)) { $s = 140; continue; }
- /* */ $s = 141; continue;
- /* if (!isBlank(lhs)) { */ case 140:
- obj = (_entry$18 = c[0].p.Info.Info.Defs[ptrType$5.keyFor($assertType(lhs, ptrType$5))], _entry$18 !== undefined ? _entry$18.v : $ifaceNil);
- if ($interfaceIsEqual(obj, $ifaceNil)) {
- obj = (_entry$19 = c[0].p.Info.Info.Uses[ptrType$5.keyFor($assertType(lhs, ptrType$5))], _entry$19 !== undefined ? _entry$19.v : $ifaceNil);
- }
- _arg$18 = lhs;
- _r$37 = obj.Type(); /* */ $s = 142; case 142: if($c) { $c = false; _r$37 = _r$37.$blk(); } if (_r$37 && _r$37.$blk !== undefined) { break s; }
- _arg$19 = _r$37;
- _r$38 = c[0].setType(_arg$18, _arg$19); /* */ $s = 143; case 143: if($c) { $c = false; _r$38 = _r$38.$blk(); } if (_r$38 && _r$38.$blk !== undefined) { break s; }
- _r$38;
- /* } */ case 141:
- _i$1++;
- /* } */ $s = 138; continue; case 139:
- /* } */ case 137:
- /* */ if ((s$10.Lhs.$length === 1) && (s$10.Rhs.$length === 1)) { $s = 144; continue; }
- /* */ if (s$10.Lhs.$length > 1 && (s$10.Rhs.$length === 1)) { $s = 145; continue; }
- /* */ if (s$10.Lhs.$length === s$10.Rhs.$length) { $s = 146; continue; }
- /* */ $s = 147; continue;
- /* if ((s$10.Lhs.$length === 1) && (s$10.Rhs.$length === 1)) { */ case 144:
- lhs$1 = astutil.RemoveParens((x$1 = s$10.Lhs, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])));
- /* */ if (isBlank(lhs$1)) { $s = 149; continue; }
- /* */ $s = 150; continue;
- /* if (isBlank(lhs$1)) { */ case 149:
- _r$39 = analysis.HasSideEffect((x$2 = s$10.Rhs, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])), c[0].p.Info.Info); /* */ $s = 153; case 153: if($c) { $c = false; _r$39 = _r$39.$blk(); } if (_r$39 && _r$39.$blk !== undefined) { break s; }
- /* */ if (_r$39) { $s = 151; continue; }
- /* */ $s = 152; continue;
- /* if (_r$39) { */ case 151:
- _r$40 = c[0].translateExpr((x$3 = s$10.Rhs, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0]))); /* */ $s = 154; case 154: if($c) { $c = false; _r$40 = _r$40.$blk(); } if (_r$40 && _r$40.$blk !== undefined) { break s; }
- _r$41 = _r$40.String(); /* */ $s = 155; case 155: if($c) { $c = false; _r$41 = _r$41.$blk(); } if (_r$41 && _r$41.$blk !== undefined) { break s; }
- _arg$20 = new $String(_r$41);
- $r = c[0].Printf("%s;", new sliceType$5([_arg$20])); /* */ $s = 156; case 156: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 152:
- return;
- /* } */ case 150:
- lhsType = (_entry$20 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$4 = s$10.Lhs, (0 >= x$4.$length ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + 0])))], _entry$20 !== undefined ? _entry$20.v : new types.TypeAndValue.ptr()).Type;
- _r$42 = c[0].translateAssignOfExpr(lhs$1, (x$5 = s$10.Rhs, (0 >= x$5.$length ? $throwRuntimeError("index out of range") : x$5.$array[x$5.$offset + 0])), lhsType, s$10.Tok === 47); /* */ $s = 157; case 157: if($c) { $c = false; _r$42 = _r$42.$blk(); } if (_r$42 && _r$42.$blk !== undefined) { break s; }
- _arg$21 = new $String(_r$42);
- $r = c[0].Printf("%s", new sliceType$5([_arg$21])); /* */ $s = 158; case 158: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 148; continue;
- /* } else if (s$10.Lhs.$length > 1 && (s$10.Rhs.$length === 1)) { */ case 145:
- _r$43 = c[0].newVariable("_tuple"); /* */ $s = 159; case 159: if($c) { $c = false; _r$43 = _r$43.$blk(); } if (_r$43 && _r$43.$blk !== undefined) { break s; }
- tupleVar = _r$43;
- _r$44 = c[0].translateExpr((x$6 = s$10.Rhs, (0 >= x$6.$length ? $throwRuntimeError("index out of range") : x$6.$array[x$6.$offset + 0]))); /* */ $s = 160; case 160: if($c) { $c = false; _r$44 = _r$44.$blk(); } if (_r$44 && _r$44.$blk !== undefined) { break s; }
- _r$45 = _r$44.String(); /* */ $s = 161; case 161: if($c) { $c = false; _r$45 = _r$45.$blk(); } if (_r$45 && _r$45.$blk !== undefined) { break s; }
- out = tupleVar + " = " + _r$45 + ";";
- tuple = $assertType((_entry$21 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$7 = s$10.Rhs, (0 >= x$7.$length ? $throwRuntimeError("index out of range") : x$7.$array[x$7.$offset + 0])))], _entry$21 !== undefined ? _entry$21.v : new types.TypeAndValue.ptr()).Type, ptrType$29);
- _ref$9 = s$10.Lhs;
- _i$2 = 0;
- /* while (true) { */ case 162:
- /* if (!(_i$2 < _ref$9.$length)) { break; } */ if(!(_i$2 < _ref$9.$length)) { $s = 163; continue; }
- i$1 = _i$2;
- lhs$2 = ((_i$2 < 0 || _i$2 >= _ref$9.$length) ? $throwRuntimeError("index out of range") : _ref$9.$array[_ref$9.$offset + _i$2]);
- lhs$2 = astutil.RemoveParens(lhs$2);
- /* */ if (!isBlank(lhs$2)) { $s = 164; continue; }
- /* */ $s = 165; continue;
- /* if (!isBlank(lhs$2)) { */ case 164:
- lhsType$1 = (_entry$22 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$8 = s$10.Lhs, ((i$1 < 0 || i$1 >= x$8.$length) ? $throwRuntimeError("index out of range") : x$8.$array[x$8.$offset + i$1])))], _entry$22 !== undefined ? _entry$22.v : new types.TypeAndValue.ptr()).Type;
- _arg$22 = lhs$2;
- _r$46 = fmt.Sprintf("%s[%d]", new sliceType$5([new $String(tupleVar), new $Int(i$1)])); /* */ $s = 166; case 166: if($c) { $c = false; _r$46 = _r$46.$blk(); } if (_r$46 && _r$46.$blk !== undefined) { break s; }
- _r$47 = c[0].newIdent(_r$46, tuple.At(i$1).object.Type()); /* */ $s = 167; case 167: if($c) { $c = false; _r$47 = _r$47.$blk(); } if (_r$47 && _r$47.$blk !== undefined) { break s; }
- _arg$23 = _r$47;
- _arg$24 = lhsType$1;
- _arg$25 = s$10.Tok === 47;
- _r$48 = c[0].translateAssignOfExpr(_arg$22, _arg$23, _arg$24, _arg$25); /* */ $s = 168; case 168: if($c) { $c = false; _r$48 = _r$48.$blk(); } if (_r$48 && _r$48.$blk !== undefined) { break s; }
- out = out + (" " + _r$48);
- /* } */ case 165:
- _i$2++;
- /* } */ $s = 162; continue; case 163:
- $r = c[0].Printf("%s", new sliceType$5([new $String(out)])); /* */ $s = 169; case 169: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 148; continue;
- /* } else if (s$10.Lhs.$length === s$10.Rhs.$length) { */ case 146:
- tmpVars = $makeSlice(sliceType, s$10.Rhs.$length);
- parts = sliceType.nil;
- _ref$10 = s$10.Rhs;
- _i$3 = 0;
- /* while (true) { */ case 170:
- /* if (!(_i$3 < _ref$10.$length)) { break; } */ if(!(_i$3 < _ref$10.$length)) { $s = 171; continue; }
- i$2 = _i$3;
- rhs = ((_i$3 < 0 || _i$3 >= _ref$10.$length) ? $throwRuntimeError("index out of range") : _ref$10.$array[_ref$10.$offset + _i$3]);
- _r$49 = c[0].newVariable("_tmp"); /* */ $s = 172; case 172: if($c) { $c = false; _r$49 = _r$49.$blk(); } if (_r$49 && _r$49.$blk !== undefined) { break s; }
- ((i$2 < 0 || i$2 >= tmpVars.$length) ? $throwRuntimeError("index out of range") : tmpVars.$array[tmpVars.$offset + i$2] = _r$49);
- /* */ if (isBlank(astutil.RemoveParens((x$9 = s$10.Lhs, ((i$2 < 0 || i$2 >= x$9.$length) ? $throwRuntimeError("index out of range") : x$9.$array[x$9.$offset + i$2]))))) { $s = 173; continue; }
- /* */ $s = 174; continue;
- /* if (isBlank(astutil.RemoveParens((x$9 = s$10.Lhs, ((i$2 < 0 || i$2 >= x$9.$length) ? $throwRuntimeError("index out of range") : x$9.$array[x$9.$offset + i$2]))))) { */ case 173:
- _r$50 = analysis.HasSideEffect(rhs, c[0].p.Info.Info); /* */ $s = 177; case 177: if($c) { $c = false; _r$50 = _r$50.$blk(); } if (_r$50 && _r$50.$blk !== undefined) { break s; }
- /* */ if (_r$50) { $s = 175; continue; }
- /* */ $s = 176; continue;
- /* if (_r$50) { */ case 175:
- _r$51 = c[0].translateExpr(rhs); /* */ $s = 178; case 178: if($c) { $c = false; _r$51 = _r$51.$blk(); } if (_r$51 && _r$51.$blk !== undefined) { break s; }
- _r$52 = _r$51.String(); /* */ $s = 179; case 179: if($c) { $c = false; _r$52 = _r$52.$blk(); } if (_r$52 && _r$52.$blk !== undefined) { break s; }
- _arg$26 = new $String(_r$52);
- $r = c[0].Printf("%s;", new sliceType$5([_arg$26])); /* */ $s = 180; case 180: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 176:
- _i$3++;
- /* continue; */ $s = 170; continue;
- /* } */ case 174:
- lhsType$2 = (_entry$23 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$10 = s$10.Lhs, ((i$2 < 0 || i$2 >= x$10.$length) ? $throwRuntimeError("index out of range") : x$10.$array[x$10.$offset + i$2])))], _entry$23 !== undefined ? _entry$23.v : new types.TypeAndValue.ptr()).Type;
- _r$53 = c[0].translateAssignOfExpr(c[0].newIdent(((i$2 < 0 || i$2 >= tmpVars.$length) ? $throwRuntimeError("index out of range") : tmpVars.$array[tmpVars.$offset + i$2]), (_entry$24 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$11 = s$10.Lhs, ((i$2 < 0 || i$2 >= x$11.$length) ? $throwRuntimeError("index out of range") : x$11.$array[x$11.$offset + i$2])))], _entry$24 !== undefined ? _entry$24.v : new types.TypeAndValue.ptr()).Type), rhs, lhsType$2, true); /* */ $s = 181; case 181: if($c) { $c = false; _r$53 = _r$53.$blk(); } if (_r$53 && _r$53.$blk !== undefined) { break s; }
- parts = $append(parts, _r$53);
- _i$3++;
- /* } */ $s = 170; continue; case 171:
- _ref$11 = s$10.Lhs;
- _i$4 = 0;
- /* while (true) { */ case 182:
- /* if (!(_i$4 < _ref$11.$length)) { break; } */ if(!(_i$4 < _ref$11.$length)) { $s = 183; continue; }
- i$3 = _i$4;
- lhs$3 = ((_i$4 < 0 || _i$4 >= _ref$11.$length) ? $throwRuntimeError("index out of range") : _ref$11.$array[_ref$11.$offset + _i$4]);
- lhs$3 = astutil.RemoveParens(lhs$3);
- /* */ if (!isBlank(lhs$3)) { $s = 184; continue; }
- /* */ $s = 185; continue;
- /* if (!isBlank(lhs$3)) { */ case 184:
- t$5 = (_entry$25 = c[0].p.Info.Info.Types[ast.Expr.keyFor(lhs$3)], _entry$25 !== undefined ? _entry$25.v : new types.TypeAndValue.ptr()).Type;
- _r$54 = c[0].translateAssignOfExpr(lhs$3, c[0].newIdent(((i$3 < 0 || i$3 >= tmpVars.$length) ? $throwRuntimeError("index out of range") : tmpVars.$array[tmpVars.$offset + i$3]), t$5), t$5, s$10.Tok === 47); /* */ $s = 186; case 186: if($c) { $c = false; _r$54 = _r$54.$blk(); } if (_r$54 && _r$54.$blk !== undefined) { break s; }
- parts = $append(parts, _r$54);
- /* } */ case 185:
- _i$4++;
- /* } */ $s = 182; continue; case 183:
- $r = c[0].Printf("%s", new sliceType$5([new $String(strings.Join(parts, " "))])); /* */ $s = 187; case 187: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 148; continue;
- /* } else { */ case 147:
- $panic(new $String("Invalid arity of AssignStmt."));
- /* } */ case 148:
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$61, true)[1]) { */ case 15:
- s$11 = _ref.$val;
- decl = $assertType(s$11.Decl, ptrType$46);
- _ref$12 = decl.Tok;
- /* */ if (_ref$12 === 85) { $s = 188; continue; }
- /* */ if (_ref$12 === 84) { $s = 189; continue; }
- /* */ $s = 190; continue;
- /* if (_ref$12 === 85) { */ case 188:
- _ref$13 = $assertType(s$11.Decl, ptrType$46).Specs;
- _i$5 = 0;
- /* while (true) { */ case 191:
- /* if (!(_i$5 < _ref$13.$length)) { break; } */ if(!(_i$5 < _ref$13.$length)) { $s = 192; continue; }
- spec = ((_i$5 < 0 || _i$5 >= _ref$13.$length) ? $throwRuntimeError("index out of range") : _ref$13.$array[_ref$13.$offset + _i$5]);
- valueSpec = $assertType(spec, ptrType$48);
- lhs$4 = $makeSlice(sliceType$7, valueSpec.Names.$length);
- _ref$14 = valueSpec.Names;
- _i$6 = 0;
- while (true) {
- if (!(_i$6 < _ref$14.$length)) { break; }
- i$4 = _i$6;
- name = ((_i$6 < 0 || _i$6 >= _ref$14.$length) ? $throwRuntimeError("index out of range") : _ref$14.$array[_ref$14.$offset + _i$6]);
- ((i$4 < 0 || i$4 >= lhs$4.$length) ? $throwRuntimeError("index out of range") : lhs$4.$array[lhs$4.$offset + i$4] = name);
- _i$6++;
- }
- rhs$1 = valueSpec.Values;
- isTuple = false;
- if (rhs$1.$length === 1) {
- _tuple$1 = $assertType((_entry$26 = c[0].p.Info.Info.Types[ast.Expr.keyFor((0 >= rhs$1.$length ? $throwRuntimeError("index out of range") : rhs$1.$array[rhs$1.$offset + 0]))], _entry$26 !== undefined ? _entry$26.v : new types.TypeAndValue.ptr()).Type, ptrType$29, true); isTuple = _tuple$1[1];
- }
- while (true) {
- if (!(rhs$1.$length < lhs$4.$length && !isTuple)) { break; }
- rhs$1 = $append(rhs$1, $ifaceNil);
- }
- $r = c[0].translateStmt(new ast.AssignStmt.ptr(lhs$4, 0, 47, rhs$1), ptrType$44.nil); /* */ $s = 193; case 193: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$5++;
- /* } */ $s = 191; continue; case 192:
- $s = 190; continue;
- /* } else if (_ref$12 === 84) { */ case 189:
- _ref$15 = decl.Specs;
- _i$7 = 0;
- /* while (true) { */ case 194:
- /* if (!(_i$7 < _ref$15.$length)) { break; } */ if(!(_i$7 < _ref$15.$length)) { $s = 195; continue; }
- spec$1 = ((_i$7 < 0 || _i$7 >= _ref$15.$length) ? $throwRuntimeError("index out of range") : _ref$15.$array[_ref$15.$offset + _i$7]);
- o = $assertType((_entry$27 = c[0].p.Info.Info.Defs[ptrType$5.keyFor($assertType(spec$1, ptrType$47).Name)], _entry$27 !== undefined ? _entry$27.v : $ifaceNil), ptrType$36);
- c[0].p.typeNames = $append(c[0].p.typeNames, o);
- _r$55 = c[0].newVariableWithLevel(o.object.Name(), true); /* */ $s = 196; case 196: if($c) { $c = false; _r$55 = _r$55.$blk(); } if (_r$55 && _r$55.$blk !== undefined) { break s; }
- _key$2 = o; (c[0].p.objectNames || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key$2)] = { k: _key$2, v: _r$55 };
- _key$3 = o; (c[0].p.dependencies || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key$3)] = { k: _key$3, v: true };
- _i$7++;
- /* } */ $s = 194; continue; case 195:
- /* } */ case 190:
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$62, true)[1]) { */ case 16:
- s$12 = _ref.$val;
- _r$56 = c[0].translateExpr(s$12.X); /* */ $s = 197; case 197: if($c) { $c = false; _r$56 = _r$56.$blk(); } if (_r$56 && _r$56.$blk !== undefined) { break s; }
- expr$1 = _r$56;
- /* */ if (!(expr$1 === ptrType$38.nil) && !(expr$1.String() === "")) { $s = 198; continue; }
- /* */ $s = 199; continue;
- /* if (!(expr$1 === ptrType$38.nil) && !(expr$1.String() === "")) { */ case 198:
- $r = c[0].Printf("%s;", new sliceType$5([expr$1])); /* */ $s = 200; case 200: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 199:
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$63, true)[1]) { */ case 17:
- s$13 = _ref.$val;
- label$1 = $assertType((_entry$28 = c[0].p.Info.Info.Defs[ptrType$5.keyFor(s$13.Label)], _entry$28 !== undefined ? _entry$28.v : $ifaceNil), ptrType$44);
- /* */ if ((_entry$29 = c[0].FuncInfo.GotoLabel[ptrType$44.keyFor(label$1)], _entry$29 !== undefined ? _entry$29.v : false)) { $s = 201; continue; }
- /* */ $s = 202; continue;
- /* if ((_entry$29 = c[0].FuncInfo.GotoLabel[ptrType$44.keyFor(label$1)], _entry$29 !== undefined ? _entry$29.v : false)) { */ case 201:
- _arg$27 = s$13.Label.Name + ":";
- _r$57 = fmt.Sprintf("case %d:", new sliceType$5([new $Int(c[0].labelCase(label$1))])); /* */ $s = 203; case 203: if($c) { $c = false; _r$57 = _r$57.$blk(); } if (_r$57 && _r$57.$blk !== undefined) { break s; }
- _arg$28 = _r$57;
- $r = c[0].PrintCond(false, _arg$27, _arg$28); /* */ $s = 204; case 204: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 202:
- $r = c[0].translateStmt(s$13.Stmt, label$1); /* */ $s = 205; case 205: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$64, true)[1]) { */ case 18:
- s$14 = _ref.$val;
- _r$58 = c[0].translateExpr(s$14.Call.Fun); /* */ $s = 206; case 206: if($c) { $c = false; _r$58 = _r$58.$blk(); } if (_r$58 && _r$58.$blk !== undefined) { break s; }
- _arg$29 = _r$58;
- _r$59 = (_entry$30 = c[0].p.Info.Info.Types[ast.Expr.keyFor(s$14.Call.Fun)], _entry$30 !== undefined ? _entry$30.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 207; case 207: if($c) { $c = false; _r$59 = _r$59.$blk(); } if (_r$59 && _r$59.$blk !== undefined) { break s; }
- _r$60 = c[0].translateArgs($assertType(_r$59, ptrType$24), s$14.Call.Args, new token.Pos(s$14.Call.Ellipsis).IsValid(), false); /* */ $s = 208; case 208: if($c) { $c = false; _r$60 = _r$60.$blk(); } if (_r$60 && _r$60.$blk !== undefined) { break s; }
- _r$61 = strings.Join(_r$60, ", "); /* */ $s = 209; case 209: if($c) { $c = false; _r$61 = _r$61.$blk(); } if (_r$61 && _r$61.$blk !== undefined) { break s; }
- _arg$30 = new $String(_r$61);
- $r = c[0].Printf("$go(%s, [%s]);", new sliceType$5([_arg$29, _arg$30])); /* */ $s = 210; case 210: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$65, true)[1]) { */ case 19:
- s$15 = _ref.$val;
- _r$62 = (_entry$31 = c[0].p.Info.Info.Types[ast.Expr.keyFor(s$15.Chan)], _entry$31 !== undefined ? _entry$31.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 211; case 211: if($c) { $c = false; _r$62 = _r$62.$blk(); } if (_r$62 && _r$62.$blk !== undefined) { break s; }
- chanType = $assertType(_r$62, ptrType$39);
- call$1 = new ast.CallExpr.ptr(c[0].newIdent("$send", types.NewSignature(ptrType$26.nil, types.NewTuple(new sliceType$8([types.NewVar(0, ptrType$28.nil, "", chanType), types.NewVar(0, ptrType$28.nil, "", chanType.Elem())])), ptrType$29.nil, false)), 0, new sliceType$7([s$15.Chan, s$15.Value]), 0, 0);
- _key$4 = call$1; (c[0].FuncInfo.Blocking || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$4)] = { k: _key$4, v: true };
- $r = c[0].translateStmt(new ast.ExprStmt.ptr(call$1), label); /* */ $s = 212; case 212: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$66, true)[1]) { */ case 20:
- s$1[0] = _ref.$val;
- channels = sliceType.nil;
- caseClauses$1 = sliceType$6.nil;
- flattened = false;
- hasDefault = false;
- _ref$16 = s$1[0].Body.List;
- _i$8 = 0;
- /* while (true) { */ case 213:
- /* if (!(_i$8 < _ref$16.$length)) { break; } */ if(!(_i$8 < _ref$16.$length)) { $s = 214; continue; }
- i$5 = _i$8;
- s$16 = ((_i$8 < 0 || _i$8 >= _ref$16.$length) ? $throwRuntimeError("index out of range") : _ref$16.$array[_ref$16.$offset + _i$8]);
- clause = $assertType(s$16, ptrType$70);
- _ref$17 = clause.Comm;
- /* */ if (_ref$17 === $ifaceNil) { $s = 215; continue; }
- /* */ if ($assertType(_ref$17, ptrType$62, true)[1]) { $s = 216; continue; }
- /* */ if ($assertType(_ref$17, ptrType$60, true)[1]) { $s = 217; continue; }
- /* */ if ($assertType(_ref$17, ptrType$65, true)[1]) { $s = 218; continue; }
- /* */ $s = 219; continue;
- /* if (_ref$17 === $ifaceNil) { */ case 215:
- comm = _ref$17;
- channels = $append(channels, "[]");
- hasDefault = true;
- $s = 220; continue;
- /* } else if ($assertType(_ref$17, ptrType$62, true)[1]) { */ case 216:
- comm$1 = _ref$17.$val;
- _r$63 = c[0].formatExpr("[%e]", new sliceType$5([$assertType(astutil.RemoveParens(comm$1.X), ptrType$8).X])); /* */ $s = 221; case 221: if($c) { $c = false; _r$63 = _r$63.$blk(); } if (_r$63 && _r$63.$blk !== undefined) { break s; }
- _r$64 = _r$63.String(); /* */ $s = 222; case 222: if($c) { $c = false; _r$64 = _r$64.$blk(); } if (_r$64 && _r$64.$blk !== undefined) { break s; }
- channels = $append(channels, _r$64);
- $s = 220; continue;
- /* } else if ($assertType(_ref$17, ptrType$60, true)[1]) { */ case 217:
- comm$2 = _ref$17.$val;
- _r$65 = c[0].formatExpr("[%e]", new sliceType$5([$assertType(astutil.RemoveParens((x$12 = comm$2.Rhs, (0 >= x$12.$length ? $throwRuntimeError("index out of range") : x$12.$array[x$12.$offset + 0]))), ptrType$8).X])); /* */ $s = 223; case 223: if($c) { $c = false; _r$65 = _r$65.$blk(); } if (_r$65 && _r$65.$blk !== undefined) { break s; }
- _r$66 = _r$65.String(); /* */ $s = 224; case 224: if($c) { $c = false; _r$66 = _r$66.$blk(); } if (_r$66 && _r$66.$blk !== undefined) { break s; }
- channels = $append(channels, _r$66);
- $s = 220; continue;
- /* } else if ($assertType(_ref$17, ptrType$65, true)[1]) { */ case 218:
- comm$3 = _ref$17.$val;
- _r$67 = c[0].formatExpr("[%e, %e]", new sliceType$5([comm$3.Chan, comm$3.Value])); /* */ $s = 225; case 225: if($c) { $c = false; _r$67 = _r$67.$blk(); } if (_r$67 && _r$67.$blk !== undefined) { break s; }
- _r$68 = _r$67.String(); /* */ $s = 226; case 226: if($c) { $c = false; _r$68 = _r$68.$blk(); } if (_r$68 && _r$68.$blk !== undefined) { break s; }
- channels = $append(channels, _r$68);
- $s = 220; continue;
- /* } else { */ case 219:
- comm$4 = _ref$17;
- _r$69 = fmt.Sprintf("unhandled: %T", new sliceType$5([comm$4])); /* */ $s = 227; case 227: if($c) { $c = false; _r$69 = _r$69.$blk(); } if (_r$69 && _r$69.$blk !== undefined) { break s; }
- $panic(new $String(_r$69));
- /* } */ case 220:
- indexLit = new ast.BasicLit.ptr(0, 5, "");
- _key$5 = indexLit; (c[0].p.Info.Info.Types || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key$5)] = { k: _key$5, v: new types.TypeAndValue.ptr(0, types.Typ[2], exact.MakeInt64(new $Int64(0, i$5))) };
- caseClauses$1 = $append(caseClauses$1, new ast.CaseClause.ptr(0, new sliceType$7([indexLit]), 0, clause.Body));
- flattened = flattened || (_entry$32 = c[0].FuncInfo.Flattened[ast.Node.keyFor(clause)], _entry$32 !== undefined ? _entry$32.v : false);
- _i$8++;
- /* } */ $s = 213; continue; case 214:
- _arg$31 = ptrType$26.nil;
- _arg$32 = ptrType$28.nil;
- _r$70 = types.NewInterface(sliceType$9.nil, sliceType$10.nil); /* */ $s = 228; case 228: if($c) { $c = false; _r$70 = _r$70.$blk(); } if (_r$70 && _r$70.$blk !== undefined) { break s; }
- _arg$33 = _r$70;
- _r$71 = types.NewVar(0, _arg$32, "", _arg$33); /* */ $s = 229; case 229: if($c) { $c = false; _r$71 = _r$71.$blk(); } if (_r$71 && _r$71.$blk !== undefined) { break s; }
- _r$72 = types.NewTuple(new sliceType$8([_r$71])); /* */ $s = 230; case 230: if($c) { $c = false; _r$72 = _r$72.$blk(); } if (_r$72 && _r$72.$blk !== undefined) { break s; }
- _arg$34 = _r$72;
- _arg$35 = types.NewTuple(new sliceType$8([types.NewVar(0, ptrType$28.nil, "", types.Typ[2])]));
- _r$73 = types.NewSignature(_arg$31, _arg$34, _arg$35, false); /* */ $s = 231; case 231: if($c) { $c = false; _r$73 = _r$73.$blk(); } if (_r$73 && _r$73.$blk !== undefined) { break s; }
- _arg$36 = _r$73;
- _r$74 = c[0].newIdent("$select", _arg$36); /* */ $s = 232; case 232: if($c) { $c = false; _r$74 = _r$74.$blk(); } if (_r$74 && _r$74.$blk !== undefined) { break s; }
- _r$75 = fmt.Sprintf("[%s]", new sliceType$5([new $String(strings.Join(channels, ", "))])); /* */ $s = 233; case 233: if($c) { $c = false; _r$75 = _r$75.$blk(); } if (_r$75 && _r$75.$blk !== undefined) { break s; }
- _arg$37 = _r$75;
- _r$76 = types.NewInterface(sliceType$9.nil, sliceType$10.nil); /* */ $s = 234; case 234: if($c) { $c = false; _r$76 = _r$76.$blk(); } if (_r$76 && _r$76.$blk !== undefined) { break s; }
- _arg$38 = _r$76;
- _r$77 = c[0].newIdent(_arg$37, _arg$38); /* */ $s = 235; case 235: if($c) { $c = false; _r$77 = _r$77.$blk(); } if (_r$77 && _r$77.$blk !== undefined) { break s; }
- _r$78 = c[0].setType(new ast.CallExpr.ptr(_r$74, 0, new sliceType$7([_r$77]), 0, 0), types.Typ[2]); /* */ $s = 236; case 236: if($c) { $c = false; _r$78 = _r$78.$blk(); } if (_r$78 && _r$78.$blk !== undefined) { break s; }
- selectCall = _r$78;
- _key$6 = selectCall; (c[0].FuncInfo.Blocking || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$6)] = { k: _key$6, v: !hasDefault };
- _r$79 = c[0].newVariable("_selection"); /* */ $s = 237; case 237: if($c) { $c = false; _r$79 = _r$79.$blk(); } if (_r$79 && _r$79.$blk !== undefined) { break s; }
- selectionVar[0] = _r$79;
- _arg$39 = new $String(selectionVar[0]);
- _r$80 = c[0].translateExpr(selectCall); /* */ $s = 238; case 238: if($c) { $c = false; _r$80 = _r$80.$blk(); } if (_r$80 && _r$80.$blk !== undefined) { break s; }
- _arg$40 = _r$80;
- $r = c[0].Printf("%s = %s;", new sliceType$5([_arg$39, _arg$40])); /* */ $s = 239; case 239: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- translateCond$2 = (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b(cond$1) {
- var $ptr, _r$81, cond$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$81 = $f._r$81; cond$1 = $f.cond$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$81 = c[0].formatExpr("%s[0] === %e", new sliceType$5([new $String(selectionVar[0]), cond$1])); /* */ $s = 1; case 1: if($c) { $c = false; _r$81 = _r$81.$blk(); } if (_r$81 && _r$81.$blk !== undefined) { break s; }
- return _r$81;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$81 = _r$81; $f.cond$1 = cond$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag);
- printCaseBodyPrefix$1 = (function(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag) { return function $b(index) {
- var $ptr, _entry$33, _ref$18, _tuple$2, assign, index, ok, rhsType, rhsType$1, x$13, x$14, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry$33 = $f._entry$33; _ref$18 = $f._ref$18; _tuple$2 = $f._tuple$2; assign = $f.assign; index = $f.index; ok = $f.ok; rhsType = $f.rhsType; rhsType$1 = $f.rhsType$1; x$13 = $f.x$13; x$14 = $f.x$14; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _tuple$2 = $assertType($assertType((x$13 = s$1[0].Body.List, ((index < 0 || index >= x$13.$length) ? $throwRuntimeError("index out of range") : x$13.$array[x$13.$offset + index])), ptrType$70).Comm, ptrType$60, true); assign = _tuple$2[0]; ok = _tuple$2[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _ref$18 = (_entry$33 = c[0].p.Info.Info.Types[ast.Expr.keyFor((x$14 = assign.Rhs, (0 >= x$14.$length ? $throwRuntimeError("index out of range") : x$14.$array[x$14.$offset + 0])))], _entry$33 !== undefined ? _entry$33.v : new types.TypeAndValue.ptr()).Type;
- /* */ if ($assertType(_ref$18, ptrType$29, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref$18, ptrType$29, true)[1]) { */ case 3:
- rhsType = _ref$18.$val;
- $r = c[0].translateStmt(new ast.AssignStmt.ptr(assign.Lhs, 0, assign.Tok, new sliceType$7([c[0].newIdent(selectionVar[0] + "[1]", rhsType)])), ptrType$44.nil); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else { */ case 4:
- rhsType$1 = _ref$18;
- $r = c[0].translateStmt(new ast.AssignStmt.ptr(assign.Lhs, 0, assign.Tok, new sliceType$7([c[0].newIdent(selectionVar[0] + "[1][0]", rhsType$1)])), ptrType$44.nil); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry$33 = _entry$33; $f._ref$18 = _ref$18; $f._tuple$2 = _tuple$2; $f.assign = assign; $f.index = index; $f.ok = ok; $f.rhsType = rhsType; $f.rhsType$1 = rhsType$1; $f.x$13 = x$13; $f.x$14 = x$14; $f.$s = $s; $f.$r = $r; return $f;
- }; })(c, elemType, iVar, iVar$1, iVar$2, keysVar, length, refVar, refVar$1, runeVar, s, s$1, s$2, s$3, selectionVar, t, t$1, tag);
- $r = c[0].translateBranchingStmt(caseClauses$1, true, translateCond$2, printCaseBodyPrefix$1, label, flattened); /* */ $s = 240; case 240: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 23; continue;
- /* } else if ($assertType(_ref, ptrType$67, true)[1]) { */ case 21:
- s$17 = _ref.$val;
- $s = 23; continue;
- /* } else { */ case 22:
- s$18 = _ref;
- _r$81 = fmt.Sprintf("Unhandled statement: %T\n", new sliceType$5([s$18])); /* */ $s = 241; case 241: if($c) { $c = false; _r$81 = _r$81.$blk(); } if (_r$81 && _r$81.$blk !== undefined) { break s; }
- $panic(new $String(_r$81));
- /* } */ case 23:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateStmt }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$16 = _arg$16; $f._arg$17 = _arg$17; $f._arg$18 = _arg$18; $f._arg$19 = _arg$19; $f._arg$2 = _arg$2; $f._arg$20 = _arg$20; $f._arg$21 = _arg$21; $f._arg$22 = _arg$22; $f._arg$23 = _arg$23; $f._arg$24 = _arg$24; $f._arg$25 = _arg$25; $f._arg$26 = _arg$26; $f._arg$27 = _arg$27; $f._arg$28 = _arg$28; $f._arg$29 = _arg$29; $f._arg$3 = _arg$3; $f._arg$30 = _arg$30; $f._arg$31 = _arg$31; $f._arg$32 = _arg$32; $f._arg$33 = _arg$33; $f._arg$34 = _arg$34; $f._arg$35 = _arg$35; $f._arg$36 = _arg$36; $f._arg$37 = _arg$37; $f._arg$38 = _arg$38; $f._arg$39 = _arg$39; $f._arg$4 = _arg$4; $f._arg$40 = _arg$40; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$10 = _entry$10; $f._entry$11 = _entry$11; $f._entry$12 = _entry$12; $f._entry$13 = _entry$13; $f._entry$14 = _entry$14; $f._entry$15 = _entry$15; $f._entry$16 = _entry$16; $f._entry$17 = _entry$17; $f._entry$18 = _entry$18; $f._entry$19 = _entry$19; $f._entry$2 = _entry$2; $f._entry$20 = _entry$20; $f._entry$21 = _entry$21; $f._entry$22 = _entry$22; $f._entry$23 = _entry$23; $f._entry$24 = _entry$24; $f._entry$25 = _entry$25; $f._entry$26 = _entry$26; $f._entry$27 = _entry$27; $f._entry$28 = _entry$28; $f._entry$29 = _entry$29; $f._entry$3 = _entry$3; $f._entry$30 = _entry$30; $f._entry$31 = _entry$31; $f._entry$32 = _entry$32; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._entry$7 = _entry$7; $f._entry$8 = _entry$8; $f._entry$9 = _entry$9; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._i$7 = _i$7; $f._i$8 = _i$8; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._key$4 = _key$4; $f._key$5 = _key$5; $f._key$6 = _key$6; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $f._r$36 = _r$36; $f._r$37 = _r$37; $f._r$38 = _r$38; $f._r$39 = _r$39; $f._r$4 = _r$4; $f._r$40 = _r$40; $f._r$41 = _r$41; $f._r$42 = _r$42; $f._r$43 = _r$43; $f._r$44 = _r$44; $f._r$45 = _r$45; $f._r$46 = _r$46; $f._r$47 = _r$47; $f._r$48 = _r$48; $f._r$49 = _r$49; $f._r$5 = _r$5; $f._r$50 = _r$50; $f._r$51 = _r$51; $f._r$52 = _r$52; $f._r$53 = _r$53; $f._r$54 = _r$54; $f._r$55 = _r$55; $f._r$56 = _r$56; $f._r$57 = _r$57; $f._r$58 = _r$58; $f._r$59 = _r$59; $f._r$6 = _r$6; $f._r$60 = _r$60; $f._r$61 = _r$61; $f._r$62 = _r$62; $f._r$63 = _r$63; $f._r$64 = _r$64; $f._r$65 = _r$65; $f._r$66 = _r$66; $f._r$67 = _r$67; $f._r$68 = _r$68; $f._r$69 = _r$69; $f._r$7 = _r$7; $f._r$70 = _r$70; $f._r$71 = _r$71; $f._r$72 = _r$72; $f._r$73 = _r$73; $f._r$74 = _r$74; $f._r$75 = _r$75; $f._r$76 = _r$76; $f._r$77 = _r$77; $f._r$78 = _r$78; $f._r$79 = _r$79; $f._r$8 = _r$8; $f._r$80 = _r$80; $f._r$81 = _r$81; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$10 = _ref$10; $f._ref$11 = _ref$11; $f._ref$12 = _ref$12; $f._ref$13 = _ref$13; $f._ref$14 = _ref$14; $f._ref$15 = _ref$15; $f._ref$16 = _ref$16; $f._ref$17 = _ref$17; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._ref$8 = _ref$8; $f._ref$9 = _ref$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.a = a; $f.a$1 = a$1; $f.arg = arg; $f.args = args; $f.blockingLabel = blockingLabel; $f.builtin = builtin; $f.c = c; $f.call = call; $f.call$1 = call$1; $f.callArgs = callArgs; $f.caseClauses = caseClauses; $f.caseClauses$1 = caseClauses$1; $f.chanType = chanType; $f.channels = channels; $f.clause = clause; $f.comm = comm; $f.comm$1 = comm$1; $f.comm$2 = comm$2; $f.comm$3 = comm$3; $f.comm$4 = comm$4; $f.cond = cond; $f.data = data; $f.decl = decl; $f.elemType = elemType; $f.elseStmt = elseStmt; $f.elseStmt$1 = elseStmt$1; $f.elseStmt$2 = elseStmt$2; $f.elseStmt$3 = elseStmt$3; $f.expr = expr; $f.expr$1 = expr$1; $f.flattened = flattened; $f.forStmt = forStmt; $f.fun = fun; $f.fun$1 = fun$1; $f.hasDefault = hasDefault; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.i$4 = i$4; $f.i$5 = i$5; $f.iVar = iVar; $f.iVar$1 = iVar$1; $f.iVar$2 = iVar$2; $f.ifStmt = ifStmt; $f.indexLit = indexLit; $f.isBuiltin = isBuiltin; $f.isJs = isJs; $f.isTuple = isTuple; $f.key = key; $f.keysVar = keysVar; $f.label = label; $f.label$1 = label$1; $f.length = length; $f.lhs = lhs; $f.lhs$1 = lhs$1; $f.lhs$2 = lhs$2; $f.lhs$3 = lhs$3; $f.lhs$4 = lhs$4; $f.lhsType = lhsType; $f.lhsType$1 = lhsType$1; $f.lhsType$2 = lhsType$2; $f.name = name; $f.normalLabel = normalLabel; $f.o = o; $f.obj = obj; $f.okVar = okVar; $f.out = out; $f.parts = parts; $f.printCaseBodyPrefix = printCaseBodyPrefix; $f.printCaseBodyPrefix$1 = printCaseBodyPrefix$1; $f.refVar = refVar; $f.refVar$1 = refVar$1; $f.refVar$2 = refVar$2; $f.results = results; $f.rhs = rhs; $f.rhs$1 = rhs$1; $f.runeVar = runeVar; $f.s = s; $f.s$1 = s$1; $f.s$10 = s$10; $f.s$11 = s$11; $f.s$12 = s$12; $f.s$13 = s$13; $f.s$14 = s$14; $f.s$15 = s$15; $f.s$16 = s$16; $f.s$17 = s$17; $f.s$18 = s$18; $f.s$2 = s$2; $f.s$3 = s$3; $f.s$4 = s$4; $f.s$5 = s$5; $f.s$6 = s$6; $f.s$7 = s$7; $f.s$8 = s$8; $f.s$9 = s$9; $f.selectCall = selectCall; $f.selectionVar = selectionVar; $f.sig = sig; $f.spec = spec; $f.spec$1 = spec$1; $f.stmt = stmt; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t2 = t2; $f.t2$1 = t2$1; $f.t2$2 = t2$2; $f.tag = tag; $f.tmpVars = tmpVars; $f.tok = tok; $f.translateCond = translateCond; $f.translateCond$1 = translateCond$1; $f.translateCond$2 = translateCond$2; $f.tuple = tuple; $f.tupleVar = tupleVar; $f.v = v; $f.valueSpec = valueSpec; $f.vars = vars; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateStmt = function(stmt, label) { return this.$val.translateStmt(stmt, label); };
- funcContext.ptr.prototype.translateBranchingStmt = function(caseClauses, isSwitch, translateCond, printCaseBodyPrefix, label, flatten) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _entry, _i, _i$1, _i$2, _i$3, _i$4, _i$5, _i$6, _key, _key$1, _r, _r$1, _r$10, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _ref$5, _ref$6, _ref$7, _tmp, _tmp$1, _tuple, b, b$1, b$2, branch$1, branches, c, caseClauses, caseOffset, cc, child, clause, cond, cond$1, conds, data, defaultBranch, endCase, flatten, hasBreak, i, i$1, i$2, i$3, isSwitch, label, ok, openBranch, openBranches, prefix, prevFlowData, printCaseBodyPrefix, translateCond, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _i$3 = $f._i$3; _i$4 = $f._i$4; _i$5 = $f._i$5; _i$6 = $f._i$6; _key = $f._key; _key$1 = $f._key$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _ref$5 = $f._ref$5; _ref$6 = $f._ref$6; _ref$7 = $f._ref$7; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; b = $f.b; b$1 = $f.b$1; b$2 = $f.b$2; branch$1 = $f.branch$1; branches = $f.branches; c = $f.c; caseClauses = $f.caseClauses; caseOffset = $f.caseOffset; cc = $f.cc; child = $f.child; clause = $f.clause; cond = $f.cond; cond$1 = $f.cond$1; conds = $f.conds; data = $f.data; defaultBranch = $f.defaultBranch; endCase = $f.endCase; flatten = $f.flatten; hasBreak = $f.hasBreak; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; isSwitch = $f.isSwitch; label = $f.label; ok = $f.ok; openBranch = $f.openBranch; openBranches = $f.openBranches; prefix = $f.prefix; prevFlowData = $f.prevFlowData; printCaseBodyPrefix = $f.printCaseBodyPrefix; translateCond = $f.translateCond; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- branches = [branches];
- c = [c];
- defaultBranch = [defaultBranch];
- endCase = [endCase];
- flatten = [flatten];
- label = [label];
- prevFlowData = [prevFlowData];
- printCaseBodyPrefix = [printCaseBodyPrefix];
- c[0] = this;
- branches[0] = sliceType$16.nil;
- defaultBranch[0] = ptrType$71.nil;
- openBranches = sliceType$16.nil;
- _ref = caseClauses;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- cc = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- clause = $assertType(cc, ptrType$68);
- branch$1 = new branch.ptr(i, clause, sliceType$7.nil, "", sliceType$6.nil);
- openBranches = $append(openBranches, branch$1);
- _ref$1 = openBranches;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- openBranch = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- openBranch.body = $appendSlice(openBranch.body, clause.Body);
- _i$1++;
- }
- if (!hasFallthrough(clause)) {
- openBranches = sliceType$16.nil;
- }
- /* */ if (clause.List.$length === 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (clause.List.$length === 0) { */ case 3:
- defaultBranch[0] = branch$1;
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 4:
- _ref$2 = clause.List;
- _i$2 = 0;
- /* while (true) { */ case 5:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 6; continue; }
- cond = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- /* */ if (translateCond === $throwNilPointerError) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (translateCond === $throwNilPointerError) { */ case 7:
- _r = analysis.BoolValue(cond, c[0].p.Info.Info); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; b = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (ok) { */ case 10:
- if (b) {
- defaultBranch[0] = branch$1;
- /* break clauseLoop; */ $s = 2; continue s;
- }
- _i$2++;
- /* continue; */ $s = 5; continue;
- /* } */ case 11:
- /* } */ case 8:
- branch$1.conds = $append(branch$1.conds, cond);
- _i$2++;
- /* } */ $s = 5; continue; case 6:
- if (branch$1.conds.$length === 0) {
- _i++;
- /* continue; */ $s = 1; continue;
- }
- branches[0] = $append(branches[0], branch$1);
- _i++;
- /* } */ $s = 1; continue; case 2:
- while (true) {
- if (!(defaultBranch[0] === ptrType$71.nil && !((branches[0].$length === 0)) && ((x = branches[0].$length - 1 >> 0, ((x < 0 || x >= branches[0].$length) ? $throwRuntimeError("index out of range") : branches[0].$array[branches[0].$offset + x])).body.$length === 0))) { break; }
- branches[0] = $subslice(branches[0], 0, (branches[0].$length - 1 >> 0));
- }
- /* */ if (branches[0].$length === 0) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (branches[0].$length === 0) { */ case 12:
- /* */ if (!(defaultBranch[0] === ptrType$71.nil)) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!(defaultBranch[0] === ptrType$71.nil)) { */ case 14:
- $r = c[0].translateStmtList(defaultBranch[0].body); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 15:
- return;
- /* } */ case 13:
- hasBreak = false;
- /* */ if (isSwitch) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (isSwitch) { */ case 17:
- _ref$3 = label[0];
- /* */ if (_ref$3 === ptrType$44.nil) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (_ref$3 === ptrType$44.nil) { */ case 19:
- _ref$4 = caseClauses;
- _i$3 = 0;
- /* while (true) { */ case 22:
- /* if (!(_i$3 < _ref$4.$length)) { break; } */ if(!(_i$3 < _ref$4.$length)) { $s = 23; continue; }
- child = ((_i$3 < 0 || _i$3 >= _ref$4.$length) ? $throwRuntimeError("index out of range") : _ref$4.$array[_ref$4.$offset + _i$3]);
- _r$1 = analysis.HasBreak(child); /* */ $s = 26; case 26: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- /* */ if (_r$1) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (_r$1) { */ case 24:
- hasBreak = true;
- /* break; */ $s = 23; continue;
- /* } */ case 25:
- _i$3++;
- /* } */ $s = 22; continue; case 23:
- $s = 21; continue;
- /* } else { */ case 20:
- hasBreak = true;
- /* } */ case 21:
- /* } */ case 18:
- _tmp = 0; _tmp$1 = 0; caseOffset = _tmp; endCase[0] = _tmp$1;
- if (flatten[0]) {
- caseOffset = c[0].caseCounter;
- endCase[0] = caseOffset + branches[0].$length >> 0;
- if (!(defaultBranch[0] === ptrType$71.nil)) {
- endCase[0] = endCase[0] + (1) >> 0;
- }
- c[0].caseCounter = endCase[0] + 1 >> 0;
- }
- /* */ if (isSwitch) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (isSwitch) { */ case 27:
- prevFlowData[0] = (_entry = c[0].flowDatas[ptrType$44.keyFor(ptrType$44.nil)], _entry !== undefined ? _entry.v : ptrType$69.nil);
- data = new flowData.ptr(prevFlowData[0].postStmt, prevFlowData[0].beginCase, endCase[0]);
- _key = ptrType$44.nil; (c[0].flowDatas || $throwRuntimeError("assignment to entry in nil map"))[ptrType$44.keyFor(_key)] = { k: _key, v: data };
- _key$1 = label[0]; (c[0].flowDatas || $throwRuntimeError("assignment to entry in nil map"))[ptrType$44.keyFor(_key$1)] = { k: _key$1, v: data };
- $deferred.push([(function(branches, c, defaultBranch, endCase, flatten, label, prevFlowData, printCaseBodyPrefix) { return function() {
- var $ptr, _key$2;
- delete c[0].flowDatas[ptrType$44.keyFor(label[0])];
- _key$2 = ptrType$44.nil; (c[0].flowDatas || $throwRuntimeError("assignment to entry in nil map"))[ptrType$44.keyFor(_key$2)] = { k: _key$2, v: prevFlowData[0] };
- }; })(branches, c, defaultBranch, endCase, flatten, label, prevFlowData, printCaseBodyPrefix), []]);
- /* } */ case 28:
- /* */ if (isSwitch && !flatten[0] && !(label[0] === ptrType$44.nil)) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (isSwitch && !flatten[0] && !(label[0] === ptrType$44.nil)) { */ case 29:
- $r = c[0].Printf("%s:", new sliceType$5([new $String(label[0].object.Name())])); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 30:
- prefix = "";
- if (hasBreak) {
- prefix = "switch (0) { default: ";
- }
- _ref$5 = branches[0];
- _i$4 = 0;
- /* while (true) { */ case 32:
- /* if (!(_i$4 < _ref$5.$length)) { break; } */ if(!(_i$4 < _ref$5.$length)) { $s = 33; continue; }
- i$1 = _i$4;
- b$1 = ((_i$4 < 0 || _i$4 >= _ref$5.$length) ? $throwRuntimeError("index out of range") : _ref$5.$array[_ref$5.$offset + _i$4]);
- conds = $makeSlice(sliceType, b$1.conds.$length);
- _ref$6 = b$1.conds;
- _i$5 = 0;
- /* while (true) { */ case 34:
- /* if (!(_i$5 < _ref$6.$length)) { break; } */ if(!(_i$5 < _ref$6.$length)) { $s = 35; continue; }
- i$2 = _i$5;
- cond$1 = ((_i$5 < 0 || _i$5 >= _ref$6.$length) ? $throwRuntimeError("index out of range") : _ref$6.$array[_ref$6.$offset + _i$5]);
- /* */ if (translateCond === $throwNilPointerError) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (translateCond === $throwNilPointerError) { */ case 36:
- _r$2 = c[0].translateExpr(cond$1); /* */ $s = 38; case 38: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = _r$2.String(); /* */ $s = 39; case 39: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- ((i$2 < 0 || i$2 >= conds.$length) ? $throwRuntimeError("index out of range") : conds.$array[conds.$offset + i$2] = _r$3);
- _i$5++;
- /* continue; */ $s = 34; continue;
- /* } */ case 37:
- _r$4 = translateCond(cond$1); /* */ $s = 40; case 40: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = _r$4.String(); /* */ $s = 41; case 41: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- ((i$2 < 0 || i$2 >= conds.$length) ? $throwRuntimeError("index out of range") : conds.$array[conds.$offset + i$2] = _r$5);
- _i$5++;
- /* } */ $s = 34; continue; case 35:
- b$1.condStr = strings.Join(conds, " || ");
- /* */ if (flatten[0]) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (flatten[0]) { */ case 42:
- $r = c[0].Printf("/* */ if (%s) { $s = %d; continue; }", new sliceType$5([new $String(b$1.condStr), new $Int((caseOffset + i$1 >> 0))])); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 43:
- _i$4++;
- /* } */ $s = 32; continue; case 33:
- /* */ if (flatten[0]) { $s = 45; continue; }
- /* */ $s = 46; continue;
- /* if (flatten[0]) { */ case 45:
- $r = c[0].Printf("/* */ $s = %d; continue;", new sliceType$5([new $Int((caseOffset + branches[0].$length >> 0))])); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 46:
- _ref$7 = branches[0];
- _i$6 = 0;
- /* while (true) { */ case 48:
- /* if (!(_i$6 < _ref$7.$length)) { break; } */ if(!(_i$6 < _ref$7.$length)) { $s = 49; continue; }
- i$3 = _i$6;
- b$2 = ((_i$6 < 0 || _i$6 >= _ref$7.$length) ? $throwRuntimeError("index out of range") : _ref$7.$array[_ref$7.$offset + _i$6]);
- c[0].SetPos(b$2.clause.Pos());
- _arg = !flatten[0];
- _r$6 = fmt.Sprintf("%sif (%s) {", new sliceType$5([new $String(prefix), new $String(b$2.condStr)])); /* */ $s = 50; case 50: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _arg$1 = _r$6;
- _r$7 = fmt.Sprintf("case %d:", new sliceType$5([new $Int((caseOffset + i$3 >> 0))])); /* */ $s = 51; case 51: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$2 = _r$7;
- $r = c[0].PrintCond(_arg, _arg$1, _arg$2); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].Indent((function(branches, c, defaultBranch, endCase, flatten, label, prevFlowData, printCaseBodyPrefix) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!(printCaseBodyPrefix[0] === $throwNilPointerError)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(printCaseBodyPrefix[0] === $throwNilPointerError)) { */ case 1:
- $r = printCaseBodyPrefix[0](b$2.index); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- $r = c[0].translateStmtList(b$2.body); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (flatten[0] && (!(defaultBranch[0] === ptrType$71.nil) || !((i$3 === (branches[0].$length - 1 >> 0))))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (flatten[0] && (!(defaultBranch[0] === ptrType$71.nil) || !((i$3 === (branches[0].$length - 1 >> 0))))) { */ case 5:
- $r = c[0].Printf("$s = %d; continue;", new sliceType$5([new $Int(endCase[0])])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(branches, c, defaultBranch, endCase, flatten, label, prevFlowData, printCaseBodyPrefix)); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- prefix = "} else ";
- _i$6++;
- /* } */ $s = 48; continue; case 49:
- /* */ if (!(defaultBranch[0] === ptrType$71.nil)) { $s = 54; continue; }
- /* */ $s = 55; continue;
- /* if (!(defaultBranch[0] === ptrType$71.nil)) { */ case 54:
- _arg$3 = !flatten[0];
- _r$8 = fmt.Sprintf("case %d:", new sliceType$5([new $Int((caseOffset + branches[0].$length >> 0))])); /* */ $s = 56; case 56: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$4 = _r$8;
- $r = c[0].PrintCond(_arg$3, "} else {", _arg$4); /* */ $s = 57; case 57: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].Indent((function(branches, c, defaultBranch, endCase, flatten, label, prevFlowData, printCaseBodyPrefix) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- /* */ if (!(printCaseBodyPrefix[0] === $throwNilPointerError)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(printCaseBodyPrefix[0] === $throwNilPointerError)) { */ case 1:
- $r = printCaseBodyPrefix[0](defaultBranch[0].index); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- $r = c[0].translateStmtList(defaultBranch[0].body); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(branches, c, defaultBranch, endCase, flatten, label, prevFlowData, printCaseBodyPrefix)); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 55:
- /* */ if (hasBreak) { $s = 59; continue; }
- /* */ $s = 60; continue;
- /* if (hasBreak) { */ case 59:
- _arg$5 = !flatten[0];
- _r$9 = fmt.Sprintf("case %d:", new sliceType$5([new $Int(endCase[0])])); /* */ $s = 61; case 61: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$6 = _r$9;
- $r = c[0].PrintCond(_arg$5, "} }", _arg$6); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 60:
- _arg$7 = !flatten[0];
- _r$10 = fmt.Sprintf("case %d:", new sliceType$5([new $Int(endCase[0])])); /* */ $s = 63; case 63: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _arg$8 = _r$10;
- $r = c[0].PrintCond(_arg$7, "}", _arg$8); /* */ $s = 64; case 64: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateBranchingStmt }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._i$3 = _i$3; $f._i$4 = _i$4; $f._i$5 = _i$5; $f._i$6 = _i$6; $f._key = _key; $f._key$1 = _key$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._ref$5 = _ref$5; $f._ref$6 = _ref$6; $f._ref$7 = _ref$7; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.b = b; $f.b$1 = b$1; $f.b$2 = b$2; $f.branch$1 = branch$1; $f.branches = branches; $f.c = c; $f.caseClauses = caseClauses; $f.caseOffset = caseOffset; $f.cc = cc; $f.child = child; $f.clause = clause; $f.cond = cond; $f.cond$1 = cond$1; $f.conds = conds; $f.data = data; $f.defaultBranch = defaultBranch; $f.endCase = endCase; $f.flatten = flatten; $f.hasBreak = hasBreak; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.isSwitch = isSwitch; $f.label = label; $f.ok = ok; $f.openBranch = openBranch; $f.openBranches = openBranches; $f.prefix = prefix; $f.prevFlowData = prevFlowData; $f.printCaseBodyPrefix = printCaseBodyPrefix; $f.translateCond = translateCond; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- funcContext.prototype.translateBranchingStmt = function(caseClauses, isSwitch, translateCond, printCaseBodyPrefix, label, flatten) { return this.$val.translateBranchingStmt(caseClauses, isSwitch, translateCond, printCaseBodyPrefix, label, flatten); };
- funcContext.ptr.prototype.translateLoopingStmt = function(cond, body, bodyPrefix, post, label, flatten) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _entry, _key, _key$1, _r, _r$1, body, bodyPrefix, c, cond, data, flatten, label, post, prevFlowData, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _entry = $f._entry; _key = $f._key; _key$1 = $f._key$1; _r = $f._r; _r$1 = $f._r$1; body = $f.body; bodyPrefix = $f.bodyPrefix; c = $f.c; cond = $f.cond; data = $f.data; flatten = $f.flatten; label = $f.label; post = $f.post; prevFlowData = $f.prevFlowData; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- body = [body];
- bodyPrefix = [bodyPrefix];
- c = [c];
- cond = [cond];
- data = [data];
- flatten = [flatten];
- label = [label];
- post = [post];
- prevFlowData = [prevFlowData];
- c[0] = this;
- prevFlowData[0] = (_entry = c[0].flowDatas[ptrType$44.keyFor(ptrType$44.nil)], _entry !== undefined ? _entry.v : ptrType$69.nil);
- data[0] = new flowData.ptr(post[0], 0, 0);
- if (flatten[0]) {
- data[0].beginCase = c[0].caseCounter;
- data[0].endCase = c[0].caseCounter + 1 >> 0;
- c[0].caseCounter = c[0].caseCounter + (2) >> 0;
- }
- _key = ptrType$44.nil; (c[0].flowDatas || $throwRuntimeError("assignment to entry in nil map"))[ptrType$44.keyFor(_key)] = { k: _key, v: data[0] };
- _key$1 = label[0]; (c[0].flowDatas || $throwRuntimeError("assignment to entry in nil map"))[ptrType$44.keyFor(_key$1)] = { k: _key$1, v: data[0] };
- $deferred.push([(function(body, bodyPrefix, c, cond, data, flatten, label, post, prevFlowData) { return function() {
- var $ptr, _key$2;
- delete c[0].flowDatas[ptrType$44.keyFor(label[0])];
- _key$2 = ptrType$44.nil; (c[0].flowDatas || $throwRuntimeError("assignment to entry in nil map"))[ptrType$44.keyFor(_key$2)] = { k: _key$2, v: prevFlowData[0] };
- }; })(body, bodyPrefix, c, cond, data, flatten, label, post, prevFlowData), []]);
- /* */ if (!flatten[0] && !(label[0] === ptrType$44.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!flatten[0] && !(label[0] === ptrType$44.nil)) { */ case 1:
- $r = c[0].Printf("%s:", new sliceType$5([new $String(label[0].object.Name())])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- _arg = !flatten[0];
- _r = fmt.Sprintf("case %d:", new sliceType$5([new $Int(data[0].beginCase)])); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _arg$1 = _r;
- $r = c[0].PrintCond(_arg, "while (true) {", _arg$1); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c[0].Indent((function(body, bodyPrefix, c, cond, data, flatten, label, post, prevFlowData) { return function $b() {
- var $ptr, _arg$2, _arg$3, _arg$4, _r$1, _r$2, _r$3, _ref, condStr, isTerminated, prevEV, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; condStr = $f.condStr; isTerminated = $f.isTerminated; prevEV = $f.prevEV; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$1 = cond[0](); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- condStr = _r$1;
- /* */ if (!(condStr === "true")) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!(condStr === "true")) { */ case 2:
- _arg$2 = !flatten[0];
- _r$2 = fmt.Sprintf("if (!(%s)) { break; }", new sliceType$5([new $String(condStr)])); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$3 = _r$2;
- _r$3 = fmt.Sprintf("if(!(%s)) { $s = %d; continue; }", new sliceType$5([new $String(condStr), new $Int(data[0].endCase)])); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$4 = _r$3;
- $r = c[0].PrintCond(_arg$2, _arg$3, _arg$4); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- prevEV = c[0].p.escapingVars;
- $r = c[0].handleEscapingVars(body[0]); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(bodyPrefix[0] === $throwNilPointerError)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!(bodyPrefix[0] === $throwNilPointerError)) { */ case 8:
- $r = bodyPrefix[0](); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 9:
- $r = c[0].translateStmtList(body[0].List); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- isTerminated = false;
- if (!((body[0].List.$length === 0))) {
- _ref = (x = body[0].List, x$1 = body[0].List.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- if ($assertType(_ref, ptrType$58, true)[1] || $assertType(_ref, ptrType$57, true)[1]) {
- isTerminated = true;
- }
- }
- /* */ if (!isTerminated) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (!isTerminated) { */ case 12:
- $r = post[0](); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 13:
- c[0].p.escapingVars = prevEV;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f.condStr = condStr; $f.isTerminated = isTerminated; $f.prevEV = prevEV; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(body, bodyPrefix, c, cond, data, flatten, label, post, prevFlowData)); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _arg$2 = !flatten[0];
- _r$1 = fmt.Sprintf("$s = %d; continue; case %d:", new sliceType$5([new $Int(data[0].beginCase), new $Int(data[0].endCase)])); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$3 = _r$1;
- $r = c[0].PrintCond(_arg$2, "}", _arg$3); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateLoopingStmt }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._entry = _entry; $f._key = _key; $f._key$1 = _key$1; $f._r = _r; $f._r$1 = _r$1; $f.body = body; $f.bodyPrefix = bodyPrefix; $f.c = c; $f.cond = cond; $f.data = data; $f.flatten = flatten; $f.label = label; $f.post = post; $f.prevFlowData = prevFlowData; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- funcContext.prototype.translateLoopingStmt = function(cond, body, bodyPrefix, post, label, flatten) { return this.$val.translateLoopingStmt(cond, body, bodyPrefix, post, label, flatten); };
- funcContext.ptr.prototype.translateAssignOfExpr = function(lhs, rhs, typ, define) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _entry, _entry$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tuple, _tuple$1, _tuple$2, c, define, keyVar, l, lhs, ok, ok$1, ok$2, rhs, t, typ, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _entry = $f._entry; _entry$1 = $f._entry$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; c = $f.c; define = $f.define; keyVar = $f.keyVar; l = $f.l; lhs = $f.lhs; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; rhs = $f.rhs; t = $f.t; typ = $f.typ; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _tuple = $assertType(lhs, ptrType$11, true); l = _tuple[0]; ok = _tuple[1];
- /* */ if (ok) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (ok) { */ case 1:
- _r = (_entry = c.p.Info.Info.Types[ast.Expr.keyFor(l.X)], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple$1 = $assertType(_r, ptrType$22, true); t = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (ok$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (ok$1) { */ case 4:
- /* */ if (typesutil.IsJsObject((_entry$1 = c.p.Info.Info.Types[ast.Expr.keyFor(l.Index)], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Type)) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (typesutil.IsJsObject((_entry$1 = c.p.Info.Info.Types[ast.Expr.keyFor(l.Index)], _entry$1 !== undefined ? _entry$1.v : new types.TypeAndValue.ptr()).Type)) { */ case 6:
- _r$1 = l.Index.Pos(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- c.p.errList = $append(c.p.errList, (x = new types.Error.ptr(c.p.fileSet, _r$1, "cannot use js.Object as map key", false), new x.constructor.elem(x)));
- /* } */ case 7:
- _r$2 = c.newVariable("_key"); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- keyVar = _r$2;
- _arg = new $String(keyVar);
- _r$3 = c.translateImplicitConversionWithCloning(l.Index, t.Key()); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$1 = _r$3;
- _r$4 = c.translateExpr(l.X); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$2 = _r$4;
- _r$5 = c.typeName(t.Key()); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$3 = new $String(_r$5);
- _arg$4 = new $String(keyVar);
- _arg$5 = new $String(keyVar);
- _r$6 = c.translateImplicitConversionWithCloning(rhs, t.Elem()); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _arg$6 = _r$6;
- _r$7 = fmt.Sprintf("%s = %s; (%s || $throwRuntimeError(\"assignment to entry in nil map\"))[%s.keyFor(%s)] = { k: %s, v: %s };", new sliceType$5([_arg, _arg$1, _arg$2, _arg$3, _arg$4, _arg$5, _arg$6])); /* */ $s = 14; case 14: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7;
- /* } */ case 5:
- /* } */ case 2:
- _tuple$2 = $assertType(rhs, ptrType$6, true); ok$2 = _tuple$2[1];
- /* */ if (ok$2 && define) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (ok$2 && define) { */ case 15:
- _r$8 = c.translateExpr(lhs); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _arg$7 = _r$8;
- _r$9 = c.translateImplicitConversion(rhs, typ); /* */ $s = 18; case 18: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$8 = _r$9;
- _r$10 = fmt.Sprintf("%s = %s;", new sliceType$5([_arg$7, _arg$8])); /* */ $s = 19; case 19: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- return _r$10;
- /* } */ case 16:
- _arg$9 = lhs;
- _r$11 = c.translateImplicitConversion(rhs, typ); /* */ $s = 20; case 20: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$12 = _r$11.String(); /* */ $s = 21; case 21: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _arg$10 = _r$12;
- _arg$11 = typ;
- _arg$12 = define;
- _r$13 = c.translateAssign(_arg$9, _arg$10, _arg$11, _arg$12); /* */ $s = 22; case 22: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- return _r$13;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateAssignOfExpr }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._entry = _entry; $f._entry$1 = _entry$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.c = c; $f.define = define; $f.keyVar = keyVar; $f.l = l; $f.lhs = lhs; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.rhs = rhs; $f.t = t; $f.typ = typ; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateAssignOfExpr = function(lhs, rhs, typ, define) { return this.$val.translateAssignOfExpr(lhs, rhs, typ, define); };
- funcContext.ptr.prototype.translateAssign = function(lhs, rhs, typ, define) {
- var $ptr, _arg, _arg$1, _arg$10, _arg$11, _arg$12, _arg$13, _arg$14, _arg$15, _arg$16, _arg$17, _arg$18, _arg$19, _arg$2, _arg$20, _arg$21, _arg$22, _arg$3, _arg$4, _arg$5, _arg$6, _arg$7, _arg$8, _arg$9, _entry, _entry$1, _entry$2, _entry$3, _entry$4, _entry$5, _entry$6, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$18, _r$19, _r$2, _r$20, _r$21, _r$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _tuple, _tuple$1, _tuple$2, _tuple$3, c, define, fields, isReflectValue, jsTag, l, l$1, l$2, l$3, l$4, lhs, named, o, ok, ok$1, ok$2, pattern, rhs, sel, t, t$1, t$2, typ, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$10 = $f._arg$10; _arg$11 = $f._arg$11; _arg$12 = $f._arg$12; _arg$13 = $f._arg$13; _arg$14 = $f._arg$14; _arg$15 = $f._arg$15; _arg$16 = $f._arg$16; _arg$17 = $f._arg$17; _arg$18 = $f._arg$18; _arg$19 = $f._arg$19; _arg$2 = $f._arg$2; _arg$20 = $f._arg$20; _arg$21 = $f._arg$21; _arg$22 = $f._arg$22; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _arg$5 = $f._arg$5; _arg$6 = $f._arg$6; _arg$7 = $f._arg$7; _arg$8 = $f._arg$8; _arg$9 = $f._arg$9; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _entry$4 = $f._entry$4; _entry$5 = $f._entry$5; _entry$6 = $f._entry$6; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$15 = $f._r$15; _r$16 = $f._r$16; _r$17 = $f._r$17; _r$18 = $f._r$18; _r$19 = $f._r$19; _r$2 = $f._r$2; _r$20 = $f._r$20; _r$21 = $f._r$21; _r$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; c = $f.c; define = $f.define; fields = $f.fields; isReflectValue = $f.isReflectValue; jsTag = $f.jsTag; l = $f.l; l$1 = $f.l$1; l$2 = $f.l$2; l$3 = $f.l$3; l$4 = $f.l$4; lhs = $f.lhs; named = $f.named; o = $f.o; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; pattern = $f.pattern; rhs = $f.rhs; sel = $f.sel; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- lhs = astutil.RemoveParens(lhs);
- if (isBlank(lhs)) {
- $panic(new $String("translateAssign with blank lhs"));
- }
- isReflectValue = false;
- _tuple = $assertType(typ, ptrType$34, true); named = _tuple[0]; ok = _tuple[1];
- if (ok && !(named.Obj().object.Pkg() === ptrType$28.nil) && named.Obj().object.Pkg().Path() === "reflect" && named.Obj().object.Name() === "Value") {
- isReflectValue = true;
- }
- /* */ if (!isReflectValue) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!isReflectValue) { */ case 1:
- _r = typ.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$20, true)[1] || $assertType(_ref, ptrType$23, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref, ptrType$20, true)[1] || $assertType(_ref, ptrType$23, true)[1]) { */ case 4:
- /* */ if (define) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (define) { */ case 6:
- _r$1 = c.translateExpr(lhs); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg = _r$1;
- _arg$1 = new $String(rhs);
- _r$2 = c.typeName(typ); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$2);
- _r$3 = fmt.Sprintf("%s = $clone(%s, %s);", new sliceType$5([_arg, _arg$1, _arg$2])); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- return _r$3;
- /* } */ case 7:
- _r$4 = c.translateExpr(lhs); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _arg$3 = _r$4;
- _arg$4 = new $String(rhs);
- _r$5 = c.typeName(typ); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$5 = new $String(_r$5);
- _r$6 = fmt.Sprintf("$copy(%s, %s, %s);", new sliceType$5([_arg$3, _arg$4, _arg$5])); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- /* } */ case 5:
- /* } */ case 2:
- _ref$1 = lhs;
- /* */ if ($assertType(_ref$1, ptrType$5, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref$1, ptrType$4, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref$1, ptrType$14, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref$1, ptrType$11, true)[1]) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if ($assertType(_ref$1, ptrType$5, true)[1]) { */ case 14:
- l = _ref$1.$val;
- o = (_entry = c.p.Info.Info.Defs[ptrType$5.keyFor(l)], _entry !== undefined ? _entry.v : $ifaceNil);
- if ($interfaceIsEqual(o, $ifaceNil)) {
- o = (_entry$1 = c.p.Info.Info.Uses[ptrType$5.keyFor(l)], _entry$1 !== undefined ? _entry$1.v : $ifaceNil);
- }
- _r$7 = c.objectName(o); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$6 = new $String(_r$7);
- _arg$7 = new $String(rhs);
- _r$8 = fmt.Sprintf("%s = %s;", new sliceType$5([_arg$6, _arg$7])); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- return _r$8;
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$4, true)[1]) { */ case 15:
- l$1 = _ref$1.$val;
- _tuple$1 = (_entry$2 = c.p.Info.Info.Selections[ptrType$4.keyFor(l$1)], _entry$2 !== undefined ? [_entry$2.v, true] : [ptrType$27.nil, false]); sel = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (!ok$1) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (!ok$1) { */ case 22:
- _r$9 = c.objectName((_entry$3 = c.p.Info.Info.Uses[ptrType$5.keyFor(l$1.Sel)], _entry$3 !== undefined ? _entry$3.v : $ifaceNil)); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$8 = new $String(_r$9);
- _arg$9 = new $String(rhs);
- _r$10 = fmt.Sprintf("%s = %s;", new sliceType$5([_arg$8, _arg$9])); /* */ $s = 25; case 25: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- return _r$10;
- /* } */ case 23:
- _arg$10 = sel;
- _r$11 = l$1.Pos(); /* */ $s = 26; case 26: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _arg$11 = _r$11;
- _r$12 = c.translateSelection(_arg$10, _arg$11); /* */ $s = 27; case 27: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _tuple$2 = _r$12; fields = _tuple$2[0]; jsTag = _tuple$2[1];
- /* */ if (!(jsTag === "")) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (!(jsTag === "")) { */ case 28:
- _r$13 = c.translateExpr(l$1.X); /* */ $s = 30; case 30: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _arg$12 = _r$13;
- _arg$13 = new $String(strings.Join(fields, "."));
- _arg$14 = new $String(jsTag);
- _arg$15 = rhs;
- _r$14 = sel.Type(); /* */ $s = 31; case 31: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _arg$16 = _r$14;
- _r$15 = c.externalize(_arg$15, _arg$16); /* */ $s = 32; case 32: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; }
- _arg$17 = new $String(_r$15);
- _r$16 = fmt.Sprintf("%s.%s.%s = %s;", new sliceType$5([_arg$12, _arg$13, _arg$14, _arg$17])); /* */ $s = 33; case 33: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; }
- return _r$16;
- /* } */ case 29:
- _r$17 = c.translateExpr(l$1.X); /* */ $s = 34; case 34: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; }
- _arg$18 = _r$17;
- _arg$19 = new $String(strings.Join(fields, "."));
- _arg$20 = new $String(rhs);
- _r$18 = fmt.Sprintf("%s.%s = %s;", new sliceType$5([_arg$18, _arg$19, _arg$20])); /* */ $s = 35; case 35: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; }
- return _r$18;
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$14, true)[1]) { */ case 16:
- l$2 = _ref$1.$val;
- _r$19 = c.translateExpr(l$2.X); /* */ $s = 36; case 36: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; }
- _arg$21 = _r$19;
- _arg$22 = new $String(rhs);
- _r$20 = fmt.Sprintf("%s.$set(%s);", new sliceType$5([_arg$21, _arg$22])); /* */ $s = 37; case 37: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; }
- return _r$20;
- $s = 19; continue;
- /* } else if ($assertType(_ref$1, ptrType$11, true)[1]) { */ case 17:
- l$3 = _ref$1.$val;
- _r$21 = (_entry$4 = c.p.Info.Info.Types[ast.Expr.keyFor(l$3.X)], _entry$4 !== undefined ? _entry$4.v : new types.TypeAndValue.ptr()).Type.Underlying(); /* */ $s = 38; case 38: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; }
- _ref$2 = _r$21;
- /* */ if ($assertType(_ref$2, ptrType$20, true)[1] || $assertType(_ref$2, ptrType$17, true)[1]) { $s = 39; continue; }
- /* */ if ($assertType(_ref$2, ptrType$21, true)[1]) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if ($assertType(_ref$2, ptrType$20, true)[1] || $assertType(_ref$2, ptrType$17, true)[1]) { */ case 39:
- t = _ref$2;
- pattern = rangeCheck("%1e[%2f] = %3s", !($interfaceIsEqual((_entry$5 = c.p.Info.Info.Types[ast.Expr.keyFor(l$3.Index)], _entry$5 !== undefined ? _entry$5.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)), true);
- _tuple$3 = $assertType(t, ptrType$17, true); ok$2 = _tuple$3[1];
- if (ok$2) {
- pattern = "%1e.nilCheck, " + pattern;
- }
- _r$22 = c.formatExpr(pattern, new sliceType$5([l$3.X, l$3.Index, new $String(rhs)])); /* */ $s = 43; case 43: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; }
- _r$23 = _r$22.String(); /* */ $s = 44; case 44: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; }
- return _r$23 + ";";
- $s = 42; continue;
- /* } else if ($assertType(_ref$2, ptrType$21, true)[1]) { */ case 40:
- t$1 = _ref$2.$val;
- _r$24 = c.formatExpr(rangeCheck("%1e.$array[%1e.$offset + %2f] = %3s", !($interfaceIsEqual((_entry$6 = c.p.Info.Info.Types[ast.Expr.keyFor(l$3.Index)], _entry$6 !== undefined ? _entry$6.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)), false), new sliceType$5([l$3.X, l$3.Index, new $String(rhs)])); /* */ $s = 45; case 45: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; }
- _r$25 = _r$24.String(); /* */ $s = 46; case 46: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; }
- return _r$25 + ";";
- $s = 42; continue;
- /* } else { */ case 41:
- t$2 = _ref$2;
- _r$26 = fmt.Sprintf("Unhandled lhs type: %T\n", new sliceType$5([t$2])); /* */ $s = 47; case 47: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; }
- $panic(new $String(_r$26));
- /* } */ case 42:
- $s = 19; continue;
- /* } else { */ case 18:
- l$4 = _ref$1;
- _r$27 = fmt.Sprintf("Unhandled lhs type: %T\n", new sliceType$5([l$4])); /* */ $s = 48; case 48: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; }
- $panic(new $String(_r$27));
- /* } */ case 19:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateAssign }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$10 = _arg$10; $f._arg$11 = _arg$11; $f._arg$12 = _arg$12; $f._arg$13 = _arg$13; $f._arg$14 = _arg$14; $f._arg$15 = _arg$15; $f._arg$16 = _arg$16; $f._arg$17 = _arg$17; $f._arg$18 = _arg$18; $f._arg$19 = _arg$19; $f._arg$2 = _arg$2; $f._arg$20 = _arg$20; $f._arg$21 = _arg$21; $f._arg$22 = _arg$22; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._arg$5 = _arg$5; $f._arg$6 = _arg$6; $f._arg$7 = _arg$7; $f._arg$8 = _arg$8; $f._arg$9 = _arg$9; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._entry$4 = _entry$4; $f._entry$5 = _entry$5; $f._entry$6 = _entry$6; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$15 = _r$15; $f._r$16 = _r$16; $f._r$17 = _r$17; $f._r$18 = _r$18; $f._r$19 = _r$19; $f._r$2 = _r$2; $f._r$20 = _r$20; $f._r$21 = _r$21; $f._r$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f.c = c; $f.define = define; $f.fields = fields; $f.isReflectValue = isReflectValue; $f.jsTag = jsTag; $f.l = l; $f.l$1 = l$1; $f.l$2 = l$2; $f.l$3 = l$3; $f.l$4 = l$4; $f.lhs = lhs; $f.named = named; $f.o = o; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.pattern = pattern; $f.rhs = rhs; $f.sel = sel; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateAssign = function(lhs, rhs, typ, define) { return this.$val.translateAssign(lhs, rhs, typ, define); };
- funcContext.ptr.prototype.translateResults = function(results) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _ref, _ref$1, c, i, result, result$1, results, v, values, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _ref$1 = $f._ref$1; c = $f.c; i = $f.i; result = $f.result; result$1 = $f.result$1; results = $f.results; v = $f.v; values = $f.values; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _ref = c.sig.Results().Len();
- /* */ if (_ref === 0) { $s = 1; continue; }
- /* */ if (_ref === 1) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_ref === 0) { */ case 1:
- return "";
- $s = 4; continue;
- /* } else if (_ref === 1) { */ case 2:
- result = $ifaceNil;
- if (!(results === sliceType$7.nil)) {
- result = (0 >= results.$length ? $throwRuntimeError("index out of range") : results.$array[results.$offset + 0]);
- }
- _r = c.translateImplicitConversion(result, c.sig.Results().At(0).object.Type()); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- v = _r;
- c.delayedOutput = sliceType$4.nil;
- return " " + v.String();
- $s = 4; continue;
- /* } else { */ case 3:
- /* */ if (results.$length === 1) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (results.$length === 1) { */ case 6:
- _r$1 = c.translateExpr((0 >= results.$length ? $throwRuntimeError("index out of range") : results.$array[results.$offset + 0])); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = _r$1.String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return " " + _r$2;
- /* } */ case 7:
- values = $makeSlice(sliceType, c.sig.Results().Len());
- _ref$1 = values;
- _i = 0;
- /* while (true) { */ case 10:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 11; continue; }
- i = _i;
- result$1 = $ifaceNil;
- if (!(results === sliceType$7.nil)) {
- result$1 = ((i < 0 || i >= results.$length) ? $throwRuntimeError("index out of range") : results.$array[results.$offset + i]);
- }
- _r$3 = c.translateImplicitConversion(result$1, c.sig.Results().At(i).object.Type()); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = _r$3.String(); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- ((i < 0 || i >= values.$length) ? $throwRuntimeError("index out of range") : values.$array[values.$offset + i] = _r$4);
- _i++;
- /* } */ $s = 10; continue; case 11:
- c.delayedOutput = sliceType$4.nil;
- return " [" + strings.Join(values, ", ") + "]";
- /* } */ case 4:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateResults }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._ref$1 = _ref$1; $f.c = c; $f.i = i; $f.result = result; $f.result$1 = result$1; $f.results = results; $f.v = v; $f.values = values; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateResults = function(results) { return this.$val.translateResults(results); };
- hasFallthrough = function(caseClause) {
- var $ptr, _tuple, b, caseClause, isBranchStmt, x, x$1;
- if (caseClause.Body.$length === 0) {
- return false;
- }
- _tuple = $assertType((x = caseClause.Body, x$1 = caseClause.Body.$length - 1 >> 0, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])), ptrType$57, true); b = _tuple[0]; isBranchStmt = _tuple[1];
- return isBranchStmt && (b.Tok === 69);
- };
- funcContext.ptr.prototype.labelCase = function(label) {
- var $ptr, _entry, _key, _tuple, c, label, labelCase, ok;
- c = this;
- _tuple = (_entry = c.labelCases[ptrType$44.keyFor(label)], _entry !== undefined ? [_entry.v, true] : [0, false]); labelCase = _tuple[0]; ok = _tuple[1];
- if (!ok) {
- labelCase = c.caseCounter;
- c.caseCounter = c.caseCounter + (1) >> 0;
- _key = label; (c.labelCases || $throwRuntimeError("assignment to entry in nil map"))[ptrType$44.keyFor(_key)] = { k: _key, v: labelCase };
- }
- return labelCase;
- };
- funcContext.prototype.labelCase = function(label) { return this.$val.labelCase(label); };
- funcContext.ptr.prototype.Write = function(b) {
- var $ptr, b, c, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; b = $f.b; c = $f.c; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- $r = c.writePos(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- c.output = $appendSlice(c.output, b);
- return [b.$length, $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.Write }; } $f.$ptr = $ptr; $f.b = b; $f.c = c; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.Write = function(b) { return this.$val.Write(b); };
- funcContext.ptr.prototype.Printf = function(format, values) {
- var $ptr, _r, _r$1, _r$2, _r$3, c, format, values, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; c = $f.c; format = $f.format; values = $f.values; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = c.Write(new sliceType$4($stringToBytes(strings.Repeat("\t", c.p.indentation)))); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- _r$1 = fmt.Fprintf(c, format, values); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- _r$2 = c.Write(new sliceType$4([10])); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- _r$3 = c.Write(c.delayedOutput); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- c.delayedOutput = sliceType$4.nil;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.Printf }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.c = c; $f.format = format; $f.values = values; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.Printf = function(format, values) { return this.$val.Printf(format, values); };
- funcContext.ptr.prototype.PrintCond = function(cond, onTrue, onFalse) {
- var $ptr, c, cond, onFalse, onTrue, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; c = $f.c; cond = $f.cond; onFalse = $f.onFalse; onTrue = $f.onTrue; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- /* */ if (!cond) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!cond) { */ case 1:
- $r = c.Printf("/* %s */ %s", new sliceType$5([new $String(strings.Replace(onTrue, "*/", "/", -1)), new $String(onFalse)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- $r = c.Printf("%s", new sliceType$5([new $String(onTrue)])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.PrintCond }; } $f.$ptr = $ptr; $f.c = c; $f.cond = cond; $f.onFalse = onFalse; $f.onTrue = onTrue; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.PrintCond = function(cond, onTrue, onFalse) { return this.$val.PrintCond(cond, onTrue, onFalse); };
- funcContext.ptr.prototype.SetPos = function(pos) {
- var $ptr, c, pos;
- c = this;
- c.posAvailable = true;
- c.pos = pos;
- };
- funcContext.prototype.SetPos = function(pos) { return this.$val.SetPos(pos); };
- funcContext.ptr.prototype.writePos = function() {
- var $ptr, _r, _r$1, c, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; c = $f.c; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- /* */ if (c.posAvailable) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (c.posAvailable) { */ case 1:
- c.posAvailable = false;
- _r = c.Write(new sliceType$4([8])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- _r$1 = binary.Write(c, (x = binary.BigEndian, new x.constructor.elem(x)), new $Uint32((c.pos >>> 0))); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- /* } */ case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.writePos }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.c = c; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.writePos = function() { return this.$val.writePos(); };
- funcContext.ptr.prototype.Indent = function(f) {
- var $ptr, c, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; c = $f.c; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- c.p.indentation = c.p.indentation + (1) >> 0;
- $r = f(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- c.p.indentation = c.p.indentation - (1) >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.Indent }; } $f.$ptr = $ptr; $f.c = c; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.Indent = function(f) { return this.$val.Indent(f); };
- funcContext.ptr.prototype.CatchOutput = function(indent, f) {
- var $ptr, c, catched, f, indent, origoutput, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; c = $f.c; catched = $f.catched; f = $f.f; indent = $f.indent; origoutput = $f.origoutput; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- origoutput = c.output;
- c.output = sliceType$4.nil;
- c.p.indentation = c.p.indentation + (indent) >> 0;
- $r = f(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = c.writePos(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- catched = c.output;
- c.output = origoutput;
- c.p.indentation = c.p.indentation - (indent) >> 0;
- return catched;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.CatchOutput }; } $f.$ptr = $ptr; $f.c = c; $f.catched = catched; $f.f = f; $f.indent = indent; $f.origoutput = origoutput; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.CatchOutput = function(indent, f) { return this.$val.CatchOutput(indent, f); };
- funcContext.ptr.prototype.Delayed = function(f) {
- var $ptr, _r, c, f, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; c = $f.c; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = c.CatchOutput(0, f); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- c.delayedOutput = _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.Delayed }; } $f.$ptr = $ptr; $f._r = _r; $f.c = c; $f.f = f; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.Delayed = function(f) { return this.$val.Delayed(f); };
- funcContext.ptr.prototype.translateArgs = function(sig, argExprs, ellipsis, clone) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _entry, _entry$1, _entry$2, _i, _i$1, _r, _r$1, _r$10, _r$11, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _tuple, arg, argExpr, argExprs, argType, argVar, args, c, clone, ellipsis, i, i$1, i$2, isTuple, paramsLen, preserveOrder, sig, tuple, tupleVar, varargType, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; arg = $f.arg; argExpr = $f.argExpr; argExprs = $f.argExprs; argType = $f.argType; argVar = $f.argVar; args = $f.args; c = $f.c; clone = $f.clone; ellipsis = $f.ellipsis; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; isTuple = $f.isTuple; paramsLen = $f.paramsLen; preserveOrder = $f.preserveOrder; sig = $f.sig; tuple = $f.tuple; tupleVar = $f.tupleVar; varargType = $f.varargType; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- /* */ if (argExprs.$length === 1) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (argExprs.$length === 1) { */ case 1:
- _tuple = $assertType((_entry = c.p.Info.Info.Types[ast.Expr.keyFor((0 >= argExprs.$length ? $throwRuntimeError("index out of range") : argExprs.$array[argExprs.$offset + 0]))], _entry !== undefined ? _entry.v : new types.TypeAndValue.ptr()).Type, ptrType$29, true); tuple = _tuple[0]; isTuple = _tuple[1];
- /* */ if (isTuple) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (isTuple) { */ case 3:
- _r = c.newVariable("_tuple"); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- tupleVar = _r;
- _arg = new $String(tupleVar);
- _r$1 = c.translateExpr((0 >= argExprs.$length ? $throwRuntimeError("index out of range") : argExprs.$array[argExprs.$offset + 0])); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = _r$1;
- $r = c.Printf("%s = %s;", new sliceType$5([_arg, _arg$1])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- argExprs = $makeSlice(sliceType$7, tuple.Len());
- _ref = argExprs;
- _i = 0;
- /* while (true) { */ case 8:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 9; continue; }
- i = _i;
- _r$2 = c.formatExpr("%s[%d]", new sliceType$5([new $String(tupleVar), new $Int(i)])); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = _r$2.String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = c.newIdent(_r$3, tuple.At(i).object.Type()); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- ((i < 0 || i >= argExprs.$length) ? $throwRuntimeError("index out of range") : argExprs.$array[argExprs.$offset + i] = _r$4);
- _i++;
- /* } */ $s = 8; continue; case 9:
- /* } */ case 4:
- /* } */ case 2:
- paramsLen = sig.Params().Len();
- varargType = ptrType$21.nil;
- if (sig.Variadic() && !ellipsis) {
- varargType = $assertType(sig.Params().At(paramsLen - 1 >> 0).object.Type(), ptrType$21);
- }
- preserveOrder = false;
- i$1 = 1;
- while (true) {
- if (!(i$1 < argExprs.$length)) { break; }
- preserveOrder = preserveOrder || (_entry$1 = c.FuncInfo.Blocking[ast.Node.keyFor(((i$1 < 0 || i$1 >= argExprs.$length) ? $throwRuntimeError("index out of range") : argExprs.$array[argExprs.$offset + i$1]))], _entry$1 !== undefined ? _entry$1.v : false);
- i$1 = i$1 + (1) >> 0;
- }
- args = $makeSlice(sliceType, argExprs.$length);
- _ref$1 = argExprs;
- _i$1 = 0;
- /* while (true) { */ case 13:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 14; continue; }
- i$2 = _i$1;
- argExpr = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- argType = $ifaceNil;
- if (!(varargType === ptrType$21.nil) && i$2 >= (paramsLen - 1 >> 0)) {
- argType = varargType.Elem();
- } else {
- argType = sig.Params().At(i$2).object.Type();
- }
- arg = "";
- /* */ if (clone) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (clone) { */ case 15:
- _r$5 = c.translateImplicitConversionWithCloning(argExpr, argType); /* */ $s = 18; case 18: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = _r$5.String(); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- arg = _r$6;
- $s = 17; continue;
- /* } else { */ case 16:
- _r$7 = c.translateImplicitConversion(argExpr, argType); /* */ $s = 20; case 20: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$8 = _r$7.String(); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- arg = _r$8;
- /* } */ case 17:
- /* */ if (preserveOrder && $interfaceIsEqual((_entry$2 = c.p.Info.Info.Types[ast.Expr.keyFor(argExpr)], _entry$2 !== undefined ? _entry$2.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (preserveOrder && $interfaceIsEqual((_entry$2 = c.p.Info.Info.Types[ast.Expr.keyFor(argExpr)], _entry$2 !== undefined ? _entry$2.v : new types.TypeAndValue.ptr()).Value, $ifaceNil)) { */ case 22:
- _r$9 = c.newVariable("_arg"); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- argVar = _r$9;
- $r = c.Printf("%s = %s;", new sliceType$5([new $String(argVar), new $String(arg)])); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- arg = argVar;
- /* } */ case 23:
- ((i$2 < 0 || i$2 >= args.$length) ? $throwRuntimeError("index out of range") : args.$array[args.$offset + i$2] = arg);
- _i$1++;
- /* } */ $s = 13; continue; case 14:
- /* */ if (!(varargType === ptrType$21.nil)) { $s = 26; continue; }
- /* */ $s = 27; continue;
- /* if (!(varargType === ptrType$21.nil)) { */ case 26:
- _r$10 = c.typeName(varargType); /* */ $s = 28; case 28: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$10);
- _arg$3 = new $String(strings.Join($subslice(args, (paramsLen - 1 >> 0)), ", "));
- _r$11 = fmt.Sprintf("new %s([%s])", new sliceType$5([_arg$2, _arg$3])); /* */ $s = 29; case 29: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- return $append($subslice(args, 0, (paramsLen - 1 >> 0)), _r$11);
- /* } */ case 27:
- return args;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateArgs }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f.arg = arg; $f.argExpr = argExpr; $f.argExprs = argExprs; $f.argType = argType; $f.argVar = argVar; $f.args = args; $f.c = c; $f.clone = clone; $f.ellipsis = ellipsis; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.isTuple = isTuple; $f.paramsLen = paramsLen; $f.preserveOrder = preserveOrder; $f.sig = sig; $f.tuple = tuple; $f.tupleVar = tupleVar; $f.varargType = varargType; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateArgs = function(sig, argExprs, ellipsis, clone) { return this.$val.translateArgs(sig, argExprs, ellipsis, clone); };
- funcContext.ptr.prototype.translateSelection = function(sel, pos) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, _tuple, _tuple$1, _tuple$2, c, fields, ft, index, isPtr, jsFieldName, jsTag, ok, ok$1, pos, ptr, ptr$1, s, sel, t, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; c = $f.c; fields = $f.fields; ft = $f.ft; index = $f.index; isPtr = $f.isPtr; jsFieldName = $f.jsFieldName; jsTag = $f.jsTag; ok = $f.ok; ok$1 = $f.ok$1; pos = $f.pos; ptr = $f.ptr; ptr$1 = $f.ptr$1; s = $f.s; sel = $f.sel; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- fields = sliceType.nil;
- t = sel.Recv();
- _ref = sel.Index();
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- index = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple = $assertType(t, ptrType$17, true); ptr = _tuple[0]; isPtr = _tuple[1];
- if (isPtr) {
- t = ptr.Elem();
- }
- _r = t.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- s = $assertType(_r, ptrType$23);
- jsTag = getJsTag(s.Tag(index));
- /* */ if (!(jsTag === "")) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(jsTag === "")) { */ case 4:
- jsFieldName = s.Field(index).object.Name();
- /* while (true) { */ case 6:
- _r$1 = fieldName(s, 0); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- fields = $append(fields, _r$1);
- ft = s.Field(0).object.Type();
- if (typesutil.IsJsObject(ft)) {
- return [fields, jsTag];
- }
- _r$2 = ft.Underlying(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- ft = _r$2;
- _tuple$1 = $assertType(ft, ptrType$17, true); ptr$1 = _tuple$1[0]; ok = _tuple$1[1];
- /* */ if (ok) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (ok) { */ case 10:
- _r$3 = ptr$1.Elem().Underlying(); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- ft = _r$3;
- /* } */ case 11:
- ok$1 = false;
- _tuple$2 = $assertType(ft, ptrType$23, true); s = _tuple$2[0]; ok$1 = _tuple$2[1];
- /* */ if (!ok$1 || (s.NumFields() === 0)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!ok$1 || (s.NumFields() === 0)) { */ case 13:
- _r$4 = fmt.Sprintf("could not find field with type *js.Object for 'js' tag of field '%s'", new sliceType$5([new $String(jsFieldName)])); /* */ $s = 15; case 15: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- c.p.errList = $append(c.p.errList, (x = new types.Error.ptr(c.p.fileSet, pos, _r$4, true), new x.constructor.elem(x)));
- return [sliceType.nil, ""];
- /* } */ case 14:
- /* } */ $s = 6; continue; case 7:
- /* } */ case 5:
- _r$5 = fieldName(s, index); /* */ $s = 16; case 16: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- fields = $append(fields, _r$5);
- t = s.Field(index).object.Type();
- _i++;
- /* } */ $s = 1; continue; case 2:
- return [fields, ""];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.translateSelection }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.c = c; $f.fields = fields; $f.ft = ft; $f.index = index; $f.isPtr = isPtr; $f.jsFieldName = jsFieldName; $f.jsTag = jsTag; $f.ok = ok; $f.ok$1 = ok$1; $f.pos = pos; $f.ptr = ptr; $f.ptr$1 = ptr$1; $f.s = s; $f.sel = sel; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.translateSelection = function(sel, pos) { return this.$val.translateSelection(sel, pos); };
- funcContext.ptr.prototype.zeroValue = function(ty) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _arg$4, _r, _r$1, _r$10, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, c, t, t$1, t$2, t$3, t$4, t$5, t$6, ty, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _arg$4 = $f._arg$4; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; c = $f.c; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; ty = $f.ty; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- if (typesutil.IsJsObject(ty)) {
- return "null";
- }
- _r = ty.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$24, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$23, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$22, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- t = _ref.$val;
- /* */ if (is64Bit(t) || isComplex(t)) { $s = 10; continue; }
- /* */ if (isBoolean(t)) { $s = 11; continue; }
- /* */ if (isNumeric(t) || t.Kind() === 18) { $s = 12; continue; }
- /* */ if (isString(t)) { $s = 13; continue; }
- /* */ if (t.Kind() === 25) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (is64Bit(t) || isComplex(t)) { */ case 10:
- _r$1 = c.typeName(ty); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg = new $String(_r$1);
- _r$2 = fmt.Sprintf("new %s(0, 0)", new sliceType$5([_arg])); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- $s = 16; continue;
- /* } else if (isBoolean(t)) { */ case 11:
- return "false";
- $s = 16; continue;
- /* } else if (isNumeric(t) || t.Kind() === 18) { */ case 12:
- return "0";
- $s = 16; continue;
- /* } else if (isString(t)) { */ case 13:
- return "\"\"";
- $s = 16; continue;
- /* } else if (t.Kind() === 25) { */ case 14:
- $panic(new $String("Zero value for untyped nil."));
- $s = 16; continue;
- /* } else { */ case 15:
- $panic(new $String("Unhandled type"));
- /* } */ case 16:
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1]) { */ case 3:
- t$1 = _ref.$val;
- _r$3 = c.typeName(ty); /* */ $s = 19; case 19: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$3);
- _r$4 = fmt.Sprintf("%s.zero()", new sliceType$5([_arg$1])); /* */ $s = 20; case 20: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$24, true)[1]) { */ case 4:
- t$2 = _ref.$val;
- return "$throwNilPointerError";
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$21, true)[1]) { */ case 5:
- t$3 = _ref.$val;
- _r$5 = c.typeName(ty); /* */ $s = 21; case 21: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _arg$2 = new $String(_r$5);
- _r$6 = fmt.Sprintf("%s.nil", new sliceType$5([_arg$2])); /* */ $s = 22; case 22: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- return _r$6;
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$23, true)[1]) { */ case 6:
- t$4 = _ref.$val;
- _r$7 = c.typeName(ty); /* */ $s = 23; case 23: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$3 = new $String(_r$7);
- _r$8 = fmt.Sprintf("new %s.ptr()", new sliceType$5([_arg$3])); /* */ $s = 24; case 24: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- return _r$8;
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$22, true)[1]) { */ case 7:
- t$5 = _ref.$val;
- return "false";
- $s = 9; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 8:
- t$6 = _ref.$val;
- return "$ifaceNil";
- /* } */ case 9:
- _r$9 = c.typeName(ty); /* */ $s = 25; case 25: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _arg$4 = new $String(_r$9);
- _r$10 = fmt.Sprintf("%s.nil", new sliceType$5([_arg$4])); /* */ $s = 26; case 26: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- return _r$10;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.zeroValue }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._arg$4 = _arg$4; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f.c = c; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.ty = ty; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.zeroValue = function(ty) { return this.$val.zeroValue(ty); };
- funcContext.ptr.prototype.newVariable = function(name) {
- var $ptr, _r, c, name, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; c = $f.c; name = $f.name; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = c.newVariableWithLevel(name, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.newVariable }; } $f.$ptr = $ptr; $f._r = _r; $f.c = c; $f.name = name; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.newVariable = function(name) { return this.$val.newVariable(name); };
- funcContext.ptr.prototype.newVariableWithLevel = function(name, pkgLevel) {
- var $ptr, _entry, _entry$1, _i, _key, _key$1, _q, _r, _r$1, _ref, b, c, c2, i, j, n, name, offset, pkgLevel, varName, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _key = $f._key; _key$1 = $f._key$1; _q = $f._q; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; b = $f.b; c = $f.c; c2 = $f.c2; i = $f.i; j = $f.j; n = $f.n; name = $f.name; offset = $f.offset; pkgLevel = $f.pkgLevel; varName = $f.varName; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- if (name === "") {
- $panic(new $String("newVariable: empty name"));
- }
- _ref = new sliceType$4($stringToBytes(name));
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (b < 48 || b > 122) {
- name = "nonAsciiName";
- break;
- }
- _i++;
- }
- if (c.p.minify) {
- i = 0;
- while (true) {
- offset = 97;
- if (pkgLevel) {
- offset = 65;
- }
- j = i;
- name = "";
- while (true) {
- name = $encodeRune((offset + ((_r = j % 26, _r === _r ? _r : $throwRuntimeError("integer divide by zero"))) >> 0)) + name;
- j = (_q = j / 26, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) - 1 >> 0;
- if (j === -1) {
- break;
- }
- }
- if ((_entry = c.allVars[$String.keyFor(name)], _entry !== undefined ? _entry.v : 0) === 0) {
- break;
- }
- i = i + (1) >> 0;
- }
- }
- n = (_entry$1 = c.allVars[$String.keyFor(name)], _entry$1 !== undefined ? _entry$1.v : 0);
- _key = name; (c.allVars || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: n + 1 >> 0 };
- varName = name;
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- _r$1 = fmt.Sprintf("%s$%d", new sliceType$5([new $String(name), new $Int(n)])); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- varName = _r$1;
- /* } */ case 2:
- if (pkgLevel) {
- c2 = c.parent;
- while (true) {
- if (!(!(c2 === ptrType$42.nil))) { break; }
- _key$1 = name; (c2.allVars || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$1)] = { k: _key$1, v: n + 1 >> 0 };
- c2 = c2.parent;
- }
- return varName;
- }
- c.localVars = $append(c.localVars, varName);
- return varName;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.newVariableWithLevel }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._key = _key; $f._key$1 = _key$1; $f._q = _q; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.b = b; $f.c = c; $f.c2 = c2; $f.i = i; $f.j = j; $f.n = n; $f.name = name; $f.offset = offset; $f.pkgLevel = pkgLevel; $f.varName = varName; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.newVariableWithLevel = function(name, pkgLevel) { return this.$val.newVariableWithLevel(name, pkgLevel); };
- funcContext.ptr.prototype.newIdent = function(name, t) {
- var $ptr, _key, _key$1, c, ident, name, obj, t;
- c = this;
- ident = ast.NewIdent(name);
- c.setType(ident, t);
- obj = types.NewVar(0, c.p.Info.Pkg, name, t);
- _key = ident; (c.p.Info.Info.Uses || $throwRuntimeError("assignment to entry in nil map"))[ptrType$5.keyFor(_key)] = { k: _key, v: obj };
- _key$1 = obj; (c.p.objectNames || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key$1)] = { k: _key$1, v: name };
- return ident;
- };
- funcContext.prototype.newIdent = function(name, t) { return this.$val.newIdent(name, t); };
- funcContext.ptr.prototype.setType = function(e, t) {
- var $ptr, _key, c, e, t;
- c = this;
- _key = e; (c.p.Info.Info.Types || $throwRuntimeError("assignment to entry in nil map"))[ast.Expr.keyFor(_key)] = { k: _key, v: new types.TypeAndValue.ptr(0, t, $ifaceNil) };
- return e;
- };
- funcContext.prototype.setType = function(e, t) { return this.$val.setType(e, t); };
- funcContext.ptr.prototype.pkgVar = function(pkg) {
- var $ptr, _entry, _r, _tuple, c, found, pkg, pkgVar, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; _tuple = $f._tuple; c = $f.c; found = $f.found; pkg = $f.pkg; pkgVar = $f.pkgVar; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- if (pkg === c.p.Info.Pkg) {
- return "$pkg";
- }
- _tuple = (_entry = c.p.pkgVars[$String.keyFor(pkg.Path())], _entry !== undefined ? [_entry.v, true] : ["", false]); pkgVar = _tuple[0]; found = _tuple[1];
- /* */ if (!found) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!found) { */ case 1:
- _r = fmt.Sprintf("$packages[\"%s\"]", new sliceType$5([new $String(pkg.Path())])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- pkgVar = _r;
- /* } */ case 2:
- return pkgVar;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.pkgVar }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f._tuple = _tuple; $f.c = c; $f.found = found; $f.pkg = pkg; $f.pkgVar = pkgVar; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.pkgVar = function(pkg) { return this.$val.pkgVar(pkg); };
- isVarOrConst = function(o) {
- var $ptr, _ref, o;
- _ref = o;
- if ($assertType(_ref, ptrType$26, true)[1] || $assertType(_ref, ptrType$35, true)[1]) {
- return true;
- }
- return false;
- };
- isPkgLevel = function(o) {
- var $ptr, _r, _r$1, _r$2, _v, o, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _v = $f._v; o = $f.o; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = o.Parent(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- if (!(!(_r === ptrType$51.nil))) { _v = false; $s = 1; continue s; }
- _r$1 = o.Parent(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = _r$1.Parent(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = _r$2 === types.Universe; case 1:
- return _v;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isPkgLevel }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._v = _v; $f.o = o; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.ptr.prototype.objectName = function(o) {
- var $ptr, _arg, _arg$1, _entry, _entry$1, _key, _key$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _tuple, _tuple$1, _v, _v$1, c, name, o, ok, ok$1, v, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _entry$1 = $f._entry$1; _key = $f._key; _key$1 = $f._key$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; _v$1 = $f._v$1; c = $f.c; name = $f.name; o = $f.o; ok = $f.ok; ok$1 = $f.ok$1; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = isPkgLevel(o); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r) { */ case 1:
- _key = o; (c.p.dependencies || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key)] = { k: _key, v: true };
- _r$1 = o.Pkg(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- if (!(_r$1 === c.p.Info.Pkg)) { _v = true; $s = 6; continue s; }
- if (!(isVarOrConst(o))) { _v$1 = false; $s = 8; continue s; }
- _r$2 = o.Exported(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v$1 = _r$2; case 8:
- _v = _v$1; case 6:
- /* */ if (_v) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_v) { */ case 4:
- _r$3 = o.Pkg(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = c.pkgVar(_r$3); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = o.Name(); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- return _r$4 + "." + _r$5;
- /* } */ case 5:
- /* } */ case 2:
- _tuple = (_entry = c.p.objectNames[types.Object.keyFor(o)], _entry !== undefined ? [_entry.v, true] : ["", false]); name = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!ok) { */ case 13:
- _r$6 = o.Name(); /* */ $s = 15; case 15: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _arg = _r$6;
- _r$7 = isPkgLevel(o); /* */ $s = 16; case 16: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _arg$1 = _r$7;
- _r$8 = c.newVariableWithLevel(_arg, _arg$1); /* */ $s = 17; case 17: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- name = _r$8;
- _key$1 = o; (c.p.objectNames || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key$1)] = { k: _key$1, v: name };
- /* } */ case 14:
- _tuple$1 = $assertType(o, ptrType$26, true); v = _tuple$1[0]; ok$1 = _tuple$1[1];
- if (ok$1 && (_entry$1 = c.p.escapingVars[ptrType$26.keyFor(v)], _entry$1 !== undefined ? _entry$1.v : false)) {
- return name + "[0]";
- }
- return name;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.objectName }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._entry$1 = _entry$1; $f._key = _key; $f._key$1 = _key$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f._v$1 = _v$1; $f.c = c; $f.name = name; $f.o = o; $f.ok = ok; $f.ok$1 = ok$1; $f.v = v; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.objectName = function(o) { return this.$val.objectName(o); };
- funcContext.ptr.prototype.varPtrName = function(o) {
- var $ptr, _arg, _arg$1, _entry, _key, _r, _r$1, _r$2, _r$3, _tuple, c, name, o, ok, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _entry = $f._entry; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; c = $f.c; name = $f.name; o = $f.o; ok = $f.ok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _r = isPkgLevel(o); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if (_r && o.object.Exported()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_r && o.object.Exported()) { */ case 1:
- _r$1 = c.pkgVar(o.object.Pkg()); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1 + "." + o.object.Name() + "$ptr";
- /* } */ case 2:
- _tuple = (_entry = c.p.varPtrNames[ptrType$26.keyFor(o)], _entry !== undefined ? [_entry.v, true] : ["", false]); name = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!ok) { */ case 5:
- _arg = o.object.Name() + "$ptr";
- _r$2 = isPkgLevel(o); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = _r$2;
- _r$3 = c.newVariableWithLevel(_arg, _arg$1); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- name = _r$3;
- _key = o; (c.p.varPtrNames || $throwRuntimeError("assignment to entry in nil map"))[ptrType$26.keyFor(_key)] = { k: _key, v: name };
- /* } */ case 6:
- return name;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.varPtrName }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._entry = _entry; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.c = c; $f.name = name; $f.o = o; $f.ok = ok; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.varPtrName = function(o) { return this.$val.varPtrName(o); };
- funcContext.ptr.prototype.typeName = function(ty) {
- var $ptr, _key, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, _tuple, anonType, c, ok, t, t$1, t$2, ty, varName, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; _tuple = $f._tuple; anonType = $f.anonType; c = $f.c; ok = $f.ok; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; ty = $f.ty; varName = $f.varName; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- _ref = ty;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$34, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 1:
- t = _ref.$val;
- _r = toJavaScriptType(t); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return "$" + _r;
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$34, true)[1]) { */ case 2:
- t$1 = _ref.$val;
- if (t$1.Obj().object.Name() === "error") {
- return "$error";
- }
- _r$1 = c.objectName(t$1.Obj()); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- $s = 4; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 3:
- t$2 = _ref.$val;
- if (t$2.Empty()) {
- return "$emptyInterface";
- }
- /* } */ case 4:
- _r$2 = c.p.anonTypeMap.At(ty); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$2, ptrType$36, true); anonType = _tuple[0]; ok = _tuple[1];
- /* */ if (!ok) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!ok) { */ case 8:
- _r$3 = c.initArgs(ty); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- _r$4 = typeKind(ty); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = strings.ToLower(_r$4.substring(5)); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = c.newVariableWithLevel(_r$5 + "Type", true); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- varName = _r$6;
- anonType = types.NewTypeName(0, c.p.Info.Pkg, varName, ty);
- c.p.anonTypes = $append(c.p.anonTypes, anonType);
- _r$7 = c.p.anonTypeMap.Set(ty, anonType); /* */ $s = 14; case 14: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$7;
- /* } */ case 9:
- _key = anonType; (c.p.dependencies || $throwRuntimeError("assignment to entry in nil map"))[types.Object.keyFor(_key)] = { k: _key, v: true };
- return anonType.object.Name();
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.typeName }; } $f.$ptr = $ptr; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f._tuple = _tuple; $f.anonType = anonType; $f.c = c; $f.ok = ok; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.ty = ty; $f.varName = varName; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.typeName = function(ty) { return this.$val.typeName(ty); };
- funcContext.ptr.prototype.externalize = function(s, t) {
- var $ptr, _arg, _arg$1, _r, _r$1, _r$2, _ref, c, s, t, u, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; c = $f.c; s = $f.s; t = $f.t; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- if (typesutil.IsJsObject(t)) {
- return s;
- }
- _r = t.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- u = _ref.$val;
- if (isNumeric(u) && !is64Bit(u) && !isComplex(u)) {
- return s;
- }
- if (u.Kind() === 25) {
- return "null";
- }
- /* } */ case 3:
- _arg = new $String(s);
- _r$1 = c.typeName(t); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _arg$1 = new $String(_r$1);
- _r$2 = fmt.Sprintf("$externalize(%s, %s)", new sliceType$5([_arg, _arg$1])); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.externalize }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.c = c; $f.s = s; $f.t = t; $f.u = u; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.externalize = function(s, t) { return this.$val.externalize(s, t); };
- funcContext.ptr.prototype.handleEscapingVars = function(n) {
- var $ptr, _entry, _entry$1, _i, _i$1, _i$2, _key, _key$1, _keys, _keys$1, _r, _r$1, _ref, _ref$1, _ref$2, c, escaping, n, name, names, newEscapingVars, obj, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _key = $f._key; _key$1 = $f._key$1; _keys = $f._keys; _keys$1 = $f._keys$1; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; c = $f.c; escaping = $f.escaping; n = $f.n; name = $f.name; names = $f.names; newEscapingVars = $f.newEscapingVars; obj = $f.obj; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- c = this;
- newEscapingVars = new $Map();
- _ref = c.p.escapingVars;
- _i = 0;
- _keys = $keys(_ref);
- while (true) {
- if (!(_i < _keys.length)) { break; }
- _entry = _ref[_keys[_i]];
- if (_entry === undefined) {
- _i++;
- continue;
- }
- escaping = _entry.k;
- _key = escaping; (newEscapingVars || $throwRuntimeError("assignment to entry in nil map"))[ptrType$26.keyFor(_key)] = { k: _key, v: true };
- _i++;
- }
- c.p.escapingVars = newEscapingVars;
- names = sliceType.nil;
- _r = analysis.EscapingObjects(n, c.p.Info.Info); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref$1 = _r;
- _i$1 = 0;
- _keys$1 = $keys(_ref$1);
- /* while (true) { */ case 2:
- /* if (!(_i$1 < _keys$1.length)) { break; } */ if(!(_i$1 < _keys$1.length)) { $s = 3; continue; }
- _entry$1 = _ref$1[_keys$1[_i$1]];
- if (_entry$1 === undefined) {
- _i$1++;
- /* continue; */ $s = 2; continue;
- }
- obj = _entry$1.k;
- _r$1 = c.objectName(obj); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- names = $append(names, _r$1);
- _key$1 = obj; (c.p.escapingVars || $throwRuntimeError("assignment to entry in nil map"))[ptrType$26.keyFor(_key$1)] = { k: _key$1, v: true };
- _i$1++;
- /* } */ $s = 2; continue; case 3:
- $r = sort.Strings(names); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$2 = names;
- _i$2 = 0;
- /* while (true) { */ case 6:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 7; continue; }
- name = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- $r = c.Printf("%s = [%s];", new sliceType$5([new $String(name), new $String(name)])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 6; continue; case 7:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: funcContext.ptr.prototype.handleEscapingVars }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._key = _key; $f._key$1 = _key$1; $f._keys = _keys; $f._keys$1 = _keys$1; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f.c = c; $f.escaping = escaping; $f.n = n; $f.name = name; $f.names = names; $f.newEscapingVars = newEscapingVars; $f.obj = obj; $f.$s = $s; $f.$r = $r; return $f;
- };
- funcContext.prototype.handleEscapingVars = function(n) { return this.$val.handleEscapingVars(n); };
- fieldName = function(t, i) {
- var $ptr, _entry, _r, i, name, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _r = $f._r; i = $f.i; name = $f.name; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- name = t.Field(i).object.Name();
- /* */ if (name === "_" || (_entry = reservedKeywords[$String.keyFor(name)], _entry !== undefined ? _entry.v : false)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (name === "_" || (_entry = reservedKeywords[$String.keyFor(name)], _entry !== undefined ? _entry.v : false)) { */ case 1:
- _r = fmt.Sprintf("%s$%d", new sliceType$5([new $String(name), new $Int(i)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 2:
- return name;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: fieldName }; } $f.$ptr = $ptr; $f._entry = _entry; $f._r = _r; $f.i = i; $f.name = name; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- typeKind = function(ty) {
- var $ptr, _r, _r$1, _r$2, _ref, t, t$1, t$2, t$3, t$4, t$5, t$6, t$7, t$8, t$9, ty, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; t$3 = $f.t$3; t$4 = $f.t$4; t$5 = $f.t$5; t$6 = $f.t$6; t$7 = $f.t$7; t$8 = $f.t$8; t$9 = $f.t$9; ty = $f.ty; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = ty.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$39, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$22, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$24, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$23, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$17, true)[1]) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- t = _ref.$val;
- _r$1 = toJavaScriptType(t); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return "$kind" + _r$1;
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1]) { */ case 3:
- t$1 = _ref.$val;
- return "$kindArray";
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$39, true)[1]) { */ case 4:
- t$2 = _ref.$val;
- return "$kindChan";
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 5:
- t$3 = _ref.$val;
- return "$kindInterface";
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$22, true)[1]) { */ case 6:
- t$4 = _ref.$val;
- return "$kindMap";
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$24, true)[1]) { */ case 7:
- t$5 = _ref.$val;
- return "$kindFunc";
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$21, true)[1]) { */ case 8:
- t$6 = _ref.$val;
- return "$kindSlice";
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$23, true)[1]) { */ case 9:
- t$7 = _ref.$val;
- return "$kindStruct";
- $s = 12; continue;
- /* } else if ($assertType(_ref, ptrType$17, true)[1]) { */ case 10:
- t$8 = _ref.$val;
- return "$kindPtr";
- $s = 12; continue;
- /* } else { */ case 11:
- t$9 = _ref;
- _r$2 = fmt.Sprintf("Unhandled type: %T\n", new sliceType$5([t$9])); /* */ $s = 14; case 14: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $panic(new $String(_r$2));
- /* } */ case 12:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: typeKind }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.t$3 = t$3; $f.t$4 = t$4; $f.t$5 = t$5; $f.t$6 = t$6; $f.t$7 = t$7; $f.t$8 = t$8; $f.t$9 = t$9; $f.ty = ty; $f.$s = $s; $f.$r = $r; return $f;
- };
- toJavaScriptType = function(t) {
- var $ptr, _r, _r$1, _ref, name, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; name = $f.name; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _ref = t.Kind();
- /* */ if (_ref === 20) { $s = 1; continue; }
- /* */ if (_ref === 8) { $s = 2; continue; }
- /* */ if (_ref === 5) { $s = 3; continue; }
- /* */ if (_ref === 18) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_ref === 20) { */ case 1:
- return "Int";
- $s = 6; continue;
- /* } else if (_ref === 8) { */ case 2:
- return "Uint8";
- $s = 6; continue;
- /* } else if (_ref === 5) { */ case 3:
- return "Int32";
- $s = 6; continue;
- /* } else if (_ref === 18) { */ case 4:
- return "UnsafePointer";
- $s = 6; continue;
- /* } else { */ case 5:
- _r = t.String(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- name = _r;
- _r$1 = strings.ToUpper(name.substring(0, 1)); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1 + name.substring(1);
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: toJavaScriptType }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f.name = name; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- is64Bit = function(t) {
- var $ptr, t;
- return (t.Kind() === 6) || (t.Kind() === 11);
- };
- isBoolean = function(t) {
- var $ptr, t;
- return !(((t.Info() & 1) === 0));
- };
- isComplex = function(t) {
- var $ptr, t;
- return !(((t.Info() & 16) === 0));
- };
- isFloat = function(t) {
- var $ptr, t;
- return !(((t.Info() & 8) === 0));
- };
- isInteger = function(t) {
- var $ptr, t;
- return !(((t.Info() & 2) === 0));
- };
- isNumeric = function(t) {
- var $ptr, t;
- return !(((t.Info() & 26) === 0));
- };
- isString = function(t) {
- var $ptr, t;
- return !(((t.Info() & 32) === 0));
- };
- isUnsigned = function(t) {
- var $ptr, t;
- return !(((t.Info() & 4) === 0));
- };
- isBlank = function(expr) {
- var $ptr, _tuple, expr, id, isIdent;
- if ($interfaceIsEqual(expr, $ifaceNil)) {
- return true;
- }
- _tuple = $assertType(expr, ptrType$5, true); id = _tuple[0]; isIdent = _tuple[1];
- if (isIdent) {
- return id.Name === "_";
- }
- return false;
- };
- isWrapped = function(ty) {
- var $ptr, _r, _r$1, _ref, _tuple, isArray, t, t$1, t$2, ty, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _tuple = $f._tuple; isArray = $f.isArray; t = $f.t; t$1 = $f.t$1; t$2 = $f.t$2; ty = $f.ty; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = ty.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _ref = _r;
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1] || $assertType(_ref, ptrType$22, true)[1] || $assertType(_ref, ptrType$24, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$17, true)[1]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ($assertType(_ref, ptrType$3, true)[1]) { */ case 2:
- t = _ref.$val;
- return !is64Bit(t) && !isComplex(t) && !((t.Kind() === 25));
- $s = 5; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1] || $assertType(_ref, ptrType$22, true)[1] || $assertType(_ref, ptrType$24, true)[1]) { */ case 3:
- t$1 = _ref;
- return true;
- $s = 5; continue;
- /* } else if ($assertType(_ref, ptrType$17, true)[1]) { */ case 4:
- t$2 = _ref.$val;
- _r$1 = t$2.Elem().Underlying(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple = $assertType(_r$1, ptrType$20, true); isArray = _tuple[1];
- return isArray;
- /* } */ case 5:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: isWrapped }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._tuple = _tuple; $f.isArray = isArray; $f.t = t; $f.t$1 = t$1; $f.t$2 = t$2; $f.ty = ty; $f.$s = $s; $f.$r = $r; return $f;
- };
- encodeString = function(s) {
- var $ptr, _i, _r, _ref, _ref$1, buffer, r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; buffer = $f.buffer; r = $f.r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buffer = bytes.NewBuffer(sliceType$4.nil);
- _ref = new sliceType$4($stringToBytes(s));
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- r = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = r;
- /* */ if (_ref$1 === 8) { $s = 3; continue; }
- /* */ if (_ref$1 === 12) { $s = 4; continue; }
- /* */ if (_ref$1 === 10) { $s = 5; continue; }
- /* */ if (_ref$1 === 13) { $s = 6; continue; }
- /* */ if (_ref$1 === 9) { $s = 7; continue; }
- /* */ if (_ref$1 === 11) { $s = 8; continue; }
- /* */ if (_ref$1 === 34) { $s = 9; continue; }
- /* */ if (_ref$1 === 92) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_ref$1 === 8) { */ case 3:
- buffer.WriteString("\\b");
- $s = 12; continue;
- /* } else if (_ref$1 === 12) { */ case 4:
- buffer.WriteString("\\f");
- $s = 12; continue;
- /* } else if (_ref$1 === 10) { */ case 5:
- buffer.WriteString("\\n");
- $s = 12; continue;
- /* } else if (_ref$1 === 13) { */ case 6:
- buffer.WriteString("\\r");
- $s = 12; continue;
- /* } else if (_ref$1 === 9) { */ case 7:
- buffer.WriteString("\\t");
- $s = 12; continue;
- /* } else if (_ref$1 === 11) { */ case 8:
- buffer.WriteString("\\v");
- $s = 12; continue;
- /* } else if (_ref$1 === 34) { */ case 9:
- buffer.WriteString("\\\"");
- $s = 12; continue;
- /* } else if (_ref$1 === 92) { */ case 10:
- buffer.WriteString("\\\\");
- $s = 12; continue;
- /* } else { */ case 11:
- /* */ if (r < 32 || r > 126) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (r < 32 || r > 126) { */ case 13:
- _r = fmt.Fprintf(buffer, "\\x%02X", new sliceType$5([new $Uint8(r)])); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 14:
- buffer.WriteByte(r);
- /* } */ case 12:
- _i++;
- /* } */ $s = 1; continue; case 2:
- return "\"" + buffer.String() + "\"";
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encodeString }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.buffer = buffer; $f.r = r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- getJsTag = function(tag) {
- var $ptr, _tuple, i, name, qvalue, tag, value;
- while (true) {
- if (!(!(tag === ""))) { break; }
- i = 0;
- while (true) {
- if (!(i < tag.length && (tag.charCodeAt(i) === 32))) { break; }
- i = i + (1) >> 0;
- }
- tag = tag.substring(i);
- if (tag === "") {
- break;
- }
- i = 0;
- while (true) {
- if (!(i < tag.length && !((tag.charCodeAt(i) === 32)) && !((tag.charCodeAt(i) === 58)) && !((tag.charCodeAt(i) === 34)))) { break; }
- i = i + (1) >> 0;
- }
- if ((i + 1 >> 0) >= tag.length || !((tag.charCodeAt(i) === 58)) || !((tag.charCodeAt((i + 1 >> 0)) === 34))) {
- break;
- }
- name = tag.substring(0, i);
- tag = tag.substring((i + 1 >> 0));
- i = 1;
- while (true) {
- if (!(i < tag.length && !((tag.charCodeAt(i) === 34)))) { break; }
- if (tag.charCodeAt(i) === 92) {
- i = i + (1) >> 0;
- }
- i = i + (1) >> 0;
- }
- if (i >= tag.length) {
- break;
- }
- qvalue = tag.substring(0, (i + 1 >> 0));
- tag = tag.substring((i + 1 >> 0));
- if (name === "js") {
- _tuple = strconv.Unquote(qvalue); value = _tuple[0];
- return value;
- }
- }
- return "";
- };
- needsSpace = function(c) {
- var $ptr, c;
- return (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || (c === 95) || (c === 36);
- };
- removeWhitespace = function(b, minify) {
- var $ptr, _ref, b, i, i$1, minify, out, previous;
- if (!minify) {
- return b;
- }
- out = sliceType$4.nil;
- previous = 0;
- while (true) {
- if (!(b.$length > 0)) { break; }
- _ref = (0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0]);
- if (_ref === 8) {
- out = $appendSlice(out, $subslice(b, 0, 5));
- b = $subslice(b, 5);
- continue;
- } else if (_ref === 32 || _ref === 9 || _ref === 10) {
- if ((!needsSpace(previous) || !needsSpace((1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1]))) && !((previous === 45) && ((1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1]) === 45))) {
- b = $subslice(b, 1);
- continue;
- }
- } else if (_ref === 34) {
- out = $append(out, 34);
- b = $subslice(b, 1);
- while (true) {
- i = bytes.IndexAny(b, "\"\\");
- out = $appendSlice(out, $subslice(b, 0, i));
- b = $subslice(b, i);
- if ((0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0]) === 34) {
- break;
- }
- out = $appendSlice(out, $subslice(b, 0, 2));
- b = $subslice(b, 2);
- }
- } else if (_ref === 47) {
- if ((1 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 1]) === 42) {
- i$1 = bytes.Index($subslice(b, 2), new sliceType$4($stringToBytes("*/")));
- b = $subslice(b, (i$1 + 4 >> 0));
- continue;
- }
- }
- out = $append(out, (0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0]));
- previous = (0 >= b.$length ? $throwRuntimeError("index out of range") : b.$array[b.$offset + 0]);
- b = $subslice(b, 1);
- }
- return out;
- };
- rangeCheck = function(pattern, constantIndex, array) {
- var $ptr, array, check, constantIndex, lengthProp, pattern;
- if (constantIndex && array) {
- return pattern;
- }
- lengthProp = "$length";
- if (array) {
- lengthProp = "length";
- }
- check = "%2f >= %1e." + lengthProp;
- if (!constantIndex) {
- check = "(%2f < 0 || " + check + ")";
- }
- return "(" + check + " ? $throwRuntimeError(\"index out of range\") : " + pattern + ")";
- };
- ErrorList.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$72.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$4], [$Int, $error], false)}];
- ptrType$38.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "StringWithParens", name: "StringWithParens", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$42.methods = [{prop: "translateExpr", name: "translateExpr", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr], [ptrType$38], false)}, {prop: "translateCall", name: "translateCall", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$13, ptrType$24, ptrType$38], [$String], false)}, {prop: "makeReceiver", name: "makeReceiver", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, ptrType$27], [ptrType$38], false)}, {prop: "translateBuiltin", name: "translateBuiltin", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, sliceType$7, $Bool, types.Type], [ptrType$38], false)}, {prop: "identifierConstant", name: "identifierConstant", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr], [$String, $Bool], false)}, {prop: "translateExprSlice", name: "translateExprSlice", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([sliceType$7, types.Type], [sliceType], false)}, {prop: "translateConversion", name: "translateConversion", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, types.Type], [ptrType$38], false)}, {prop: "translateImplicitConversionWithCloning", name: "translateImplicitConversionWithCloning", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, types.Type], [ptrType$38], false)}, {prop: "translateImplicitConversion", name: "translateImplicitConversion", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, types.Type], [ptrType$38], false)}, {prop: "translateConversionToSlice", name: "translateConversionToSlice", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, types.Type], [ptrType$38], false)}, {prop: "loadStruct", name: "loadStruct", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, $String, ptrType$23], [$String], false)}, {prop: "fixNumber", name: "fixNumber", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$38, ptrType$3], [ptrType$38], false)}, {prop: "internalize", name: "internalize", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$38, types.Type], [ptrType$38], false)}, {prop: "formatExpr", name: "formatExpr", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, sliceType$5], [ptrType$38], true)}, {prop: "formatParenExpr", name: "formatParenExpr", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, sliceType$5], [ptrType$38], true)}, {prop: "formatExprInternal", name: "formatExprInternal", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, sliceType$5, $Bool], [ptrType$38], false)}, {prop: "initArgs", name: "initArgs", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([types.Type], [$String], false)}, {prop: "translateToplevelFunction", name: "translateToplevelFunction", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$45, ptrType$25], [sliceType$4], false)}, {prop: "translateStmtList", name: "translateStmtList", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([sliceType$6], [], false)}, {prop: "translateStmt", name: "translateStmt", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Stmt, ptrType$44], [], false)}, {prop: "translateBranchingStmt", name: "translateBranchingStmt", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([sliceType$6, $Bool, funcType$1, funcType$2, ptrType$44, $Bool], [], false)}, {prop: "translateLoopingStmt", name: "translateLoopingStmt", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([funcType$3, ptrType$50, funcType$4, funcType$4, ptrType$44, $Bool], [], false)}, {prop: "translateAssignOfExpr", name: "translateAssignOfExpr", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, ast.Expr, types.Type, $Bool], [$String], false)}, {prop: "translateAssign", name: "translateAssign", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, $String, types.Type, $Bool], [$String], false)}, {prop: "translateResults", name: "translateResults", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([sliceType$7], [$String], false)}, {prop: "labelCase", name: "labelCase", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$44], [$Int], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$4], [$Int, $error], false)}, {prop: "Printf", name: "Printf", pkg: "", typ: $funcType([$String, sliceType$5], [], true)}, {prop: "PrintCond", name: "PrintCond", pkg: "", typ: $funcType([$Bool, $String, $String], [], false)}, {prop: "SetPos", name: "SetPos", pkg: "", typ: $funcType([token.Pos], [], false)}, {prop: "writePos", name: "writePos", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([], [], false)}, {prop: "Indent", name: "Indent", pkg: "", typ: $funcType([funcType$4], [], false)}, {prop: "CatchOutput", name: "CatchOutput", pkg: "", typ: $funcType([$Int, funcType$4], [sliceType$4], false)}, {prop: "Delayed", name: "Delayed", pkg: "", typ: $funcType([funcType$4], [], false)}, {prop: "translateArgs", name: "translateArgs", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$24, sliceType$7, $Bool, $Bool], [sliceType], false)}, {prop: "translateSelection", name: "translateSelection", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$27, token.Pos], [sliceType, $String], false)}, {prop: "zeroValue", name: "zeroValue", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([types.Type], [$String], false)}, {prop: "newVariable", name: "newVariable", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String], [$String], false)}, {prop: "newVariableWithLevel", name: "newVariableWithLevel", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, $Bool], [$String], false)}, {prop: "newIdent", name: "newIdent", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, types.Type], [ptrType$5], false)}, {prop: "setType", name: "setType", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Expr, types.Type], [ast.Expr], false)}, {prop: "pkgVar", name: "pkgVar", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$28], [$String], false)}, {prop: "objectName", name: "objectName", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([types.Object], [$String], false)}, {prop: "varPtrName", name: "varPtrName", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ptrType$26], [$String], false)}, {prop: "typeName", name: "typeName", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([types.Type], [$String], false)}, {prop: "externalize", name: "externalize", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([$String, types.Type], [$String], false)}, {prop: "handleEscapingVars", name: "handleEscapingVars", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $funcType([ast.Node], [], false)}];
- ErrorList.init($error);
- Archive.init([{prop: "ImportPath", name: "ImportPath", pkg: "", typ: $String, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Imports", name: "Imports", pkg: "", typ: sliceType, tag: ""}, {prop: "ExportData", name: "ExportData", pkg: "", typ: sliceType$4, tag: ""}, {prop: "Declarations", name: "Declarations", pkg: "", typ: sliceType$2, tag: ""}, {prop: "FileSet", name: "FileSet", pkg: "", typ: sliceType$4, tag: ""}, {prop: "Minified", name: "Minified", pkg: "", typ: $Bool, tag: ""}, {prop: "types", name: "types", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$28, tag: ""}]);
- Decl.init([{prop: "FullName", name: "FullName", pkg: "", typ: $String, tag: ""}, {prop: "Vars", name: "Vars", pkg: "", typ: sliceType, tag: ""}, {prop: "DeclCode", name: "DeclCode", pkg: "", typ: sliceType$4, tag: ""}, {prop: "MethodListCode", name: "MethodListCode", pkg: "", typ: sliceType$4, tag: ""}, {prop: "TypeInitCode", name: "TypeInitCode", pkg: "", typ: sliceType$4, tag: ""}, {prop: "InitCode", name: "InitCode", pkg: "", typ: sliceType$4, tag: ""}, {prop: "DceObjectFilter", name: "DceObjectFilter", pkg: "", typ: $String, tag: ""}, {prop: "DceMethodFilter", name: "DceMethodFilter", pkg: "", typ: $String, tag: ""}, {prop: "DceDeps", name: "DceDeps", pkg: "", typ: sliceType, tag: ""}, {prop: "Blocking", name: "Blocking", pkg: "", typ: $Bool, tag: ""}]);
- dceInfo.init([{prop: "decl", name: "decl", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$1, tag: ""}, {prop: "objectFilter", name: "objectFilter", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $String, tag: ""}, {prop: "methodFilter", name: "methodFilter", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $String, tag: ""}]);
- SourceMapFilter.init([{prop: "Writer", name: "Writer", pkg: "", typ: io.Writer, tag: ""}, {prop: "MappingCallback", name: "MappingCallback", pkg: "", typ: funcType, tag: ""}, {prop: "line", name: "line", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Int, tag: ""}, {prop: "column", name: "column", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Int, tag: ""}, {prop: "fileSet", name: "fileSet", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$31, tag: ""}]);
- expression.init([{prop: "str", name: "str", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $String, tag: ""}, {prop: "parens", name: "parens", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Bool, tag: ""}]);
- pkgContext.init([{prop: "Info", name: "", pkg: "", typ: ptrType$43, tag: ""}, {prop: "typeNames", name: "typeNames", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType$13, tag: ""}, {prop: "pkgVars", name: "pkgVars", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType, tag: ""}, {prop: "objectNames", name: "objectNames", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType$1, tag: ""}, {prop: "varPtrNames", name: "varPtrNames", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType$2, tag: ""}, {prop: "anonTypes", name: "anonTypes", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType$13, tag: ""}, {prop: "anonTypeMap", name: "anonTypeMap", pkg: "github.com/gopherjs/gopherjs/compiler", typ: typeutil.Map, tag: ""}, {prop: "escapingVars", name: "escapingVars", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType$3, tag: ""}, {prop: "indentation", name: "indentation", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Int, tag: ""}, {prop: "dependencies", name: "dependencies", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType$4, tag: ""}, {prop: "minify", name: "minify", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Bool, tag: ""}, {prop: "fileSet", name: "fileSet", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$31, tag: ""}, {prop: "errList", name: "errList", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ErrorList, tag: ""}]);
- funcContext.init([{prop: "FuncInfo", name: "", pkg: "", typ: ptrType$25, tag: ""}, {prop: "p", name: "p", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$41, tag: ""}, {prop: "parent", name: "parent", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$42, tag: ""}, {prop: "sig", name: "sig", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$24, tag: ""}, {prop: "allVars", name: "allVars", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType$5, tag: ""}, {prop: "localVars", name: "localVars", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType, tag: ""}, {prop: "resultNames", name: "resultNames", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType$7, tag: ""}, {prop: "flowDatas", name: "flowDatas", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType$6, tag: ""}, {prop: "caseCounter", name: "caseCounter", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Int, tag: ""}, {prop: "labelCases", name: "labelCases", pkg: "github.com/gopherjs/gopherjs/compiler", typ: mapType$7, tag: ""}, {prop: "output", name: "output", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType$4, tag: ""}, {prop: "delayedOutput", name: "delayedOutput", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType$4, tag: ""}, {prop: "posAvailable", name: "posAvailable", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Bool, tag: ""}, {prop: "pos", name: "pos", pkg: "github.com/gopherjs/gopherjs/compiler", typ: token.Pos, tag: ""}]);
- flowData.init([{prop: "postStmt", name: "postStmt", pkg: "github.com/gopherjs/gopherjs/compiler", typ: funcType$4, tag: ""}, {prop: "beginCase", name: "beginCase", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Int, tag: ""}, {prop: "endCase", name: "endCase", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Int, tag: ""}]);
- ImportContext.init([{prop: "Packages", name: "Packages", pkg: "", typ: mapType$8, tag: ""}, {prop: "Import", name: "Import", pkg: "", typ: funcType$5, tag: ""}]);
- this$1.init([{prop: "Ident", name: "", pkg: "", typ: ast.Ident, tag: ""}]);
- branch.init([{prop: "index", name: "index", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $Int, tag: ""}, {prop: "clause", name: "clause", pkg: "github.com/gopherjs/gopherjs/compiler", typ: ptrType$68, tag: ""}, {prop: "conds", name: "conds", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType$7, tag: ""}, {prop: "condStr", name: "condStr", pkg: "github.com/gopherjs/gopherjs/compiler", typ: $String, tag: ""}, {prop: "body", name: "body", pkg: "github.com/gopherjs/gopherjs/compiler", typ: sliceType$6, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = binary.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = gob.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = json.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = analysis.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = astutil.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = filter.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = prelude.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = typesutil.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = exact.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = importer.$init(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = types.$init(); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = typeutil.$init(); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = sort.$init(); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- sizes32 = new types.StdSizes.ptr(new $Int64(0, 4), new $Int64(0, 8));
- reservedKeywords = new $Map();
- init();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/neelance/go-angularjs"] = (function() {
- var $pkg = {}, $init, js, Module, Scope, JQueryElement, Event, HttpService, ptrType, funcType, funcType$1, sliceType, funcType$2, ptrType$1, funcType$3, ptrType$2, ptrType$3, funcType$4, ptrType$4, funcType$5, ptrType$5, NewModule, ElementById, Service;
- js = $packages["github.com/gopherjs/gopherjs/js"];
- Module = $pkg.Module = $newType(0, $kindStruct, "angularjs.Module", "Module", "github.com/neelance/go-angularjs", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- Scope = $pkg.Scope = $newType(0, $kindStruct, "angularjs.Scope", "Scope", "github.com/neelance/go-angularjs", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- JQueryElement = $pkg.JQueryElement = $newType(0, $kindStruct, "angularjs.JQueryElement", "JQueryElement", "github.com/neelance/go-angularjs", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- Event = $pkg.Event = $newType(0, $kindStruct, "angularjs.Event", "Event", "github.com/neelance/go-angularjs", function(Object_, KeyCode_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.KeyCode = 0;
- return;
- }
- this.Object = Object_;
- this.KeyCode = KeyCode_;
- });
- HttpService = $pkg.HttpService = $newType(0, $kindStruct, "angularjs.HttpService", "HttpService", "github.com/neelance/go-angularjs", function() {
- this.$val = this;
- if (arguments.length === 0) {
- return;
- }
- });
- ptrType = $ptrType(js.Object);
- funcType = $funcType([ptrType], [], false);
- funcType$1 = $funcType([], [], false);
- sliceType = $sliceType($String);
- funcType$2 = $funcType([$String, $Int, ptrType, ptrType], [], false);
- ptrType$1 = $ptrType(Scope);
- funcType$3 = $funcType([ptrType$1], [], false);
- ptrType$2 = $ptrType(Module);
- ptrType$3 = $ptrType(Event);
- funcType$4 = $funcType([ptrType$3], [], false);
- ptrType$4 = $ptrType(JQueryElement);
- funcType$5 = $funcType([$String, $Int], [], false);
- ptrType$5 = $ptrType(HttpService);
- Module.ptr.prototype.NewController = function(name, constructor) {
- var $ptr, constructor, m, name;
- m = this;
- m.Object.controller($externalize(name, $String), $externalize(new js.S([new $String("$scope"), new funcType((function $b(scope) {
- var $ptr, scope, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; scope = $f.scope; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = constructor(new Scope.ptr(scope)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.scope = scope; $f.$s = $s; $f.$r = $r; return $f;
- }))]), js.S));
- };
- Module.prototype.NewController = function(name, constructor) { return this.$val.NewController(name, constructor); };
- Scope.ptr.prototype.Apply = function(f) {
- var $ptr, f, s;
- s = this;
- s.Object.$apply($externalize(f, funcType$1));
- };
- Scope.prototype.Apply = function(f) { return this.$val.Apply(f); };
- Scope.ptr.prototype.EvalAsync = function(f) {
- var $ptr, f, s;
- s = this;
- s.Object.$evalAsync($externalize(f, funcType$1));
- };
- Scope.prototype.EvalAsync = function(f) { return this.$val.EvalAsync(f); };
- JQueryElement.ptr.prototype.Prop = function(name) {
- var $ptr, e, name;
- e = this;
- return e.Object.prop($externalize(name, $String));
- };
- JQueryElement.prototype.Prop = function(name) { return this.$val.Prop(name); };
- JQueryElement.ptr.prototype.SetProp = function(name, value) {
- var $ptr, e, name, value;
- e = this;
- e.Object.prop($externalize(name, $emptyInterface), $externalize(value, $emptyInterface));
- };
- JQueryElement.prototype.SetProp = function(name, value) { return this.$val.SetProp(name, value); };
- JQueryElement.ptr.prototype.On = function(events, handler) {
- var $ptr, e, events, handler;
- e = this;
- e.Object.on($externalize(events, $String), $externalize((function $b(e$1) {
- var $ptr, e$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e$1 = $f.e$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = handler(new Event.ptr(e$1, 0)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.e$1 = e$1; $f.$s = $s; $f.$r = $r; return $f;
- }), funcType));
- };
- JQueryElement.prototype.On = function(events, handler) { return this.$val.On(events, handler); };
- JQueryElement.ptr.prototype.Val = function() {
- var $ptr, e;
- e = this;
- return e.Object.val();
- };
- JQueryElement.prototype.Val = function() { return this.$val.Val(); };
- JQueryElement.ptr.prototype.SetVal = function(value) {
- var $ptr, e, value;
- e = this;
- e.Object.val($externalize(value, $emptyInterface));
- };
- JQueryElement.prototype.SetVal = function(value) { return this.$val.SetVal(value); };
- Event.ptr.prototype.PreventDefault = function() {
- var $ptr, e;
- e = this;
- e.Object.preventDefault();
- };
- Event.prototype.PreventDefault = function() { return this.$val.PreventDefault(); };
- NewModule = function(name, requires, configFn) {
- var $ptr, configFn, name, requires;
- return new Module.ptr($global.angular.module($externalize(name, $String), $externalize(requires, sliceType), $externalize(configFn, funcType$1)));
- };
- $pkg.NewModule = NewModule;
- ElementById = function(id) {
- var $ptr, id;
- return new JQueryElement.ptr($global.angular.element($global.document.getElementById($externalize(id, $String))));
- };
- $pkg.ElementById = ElementById;
- Service = function(name) {
- var $ptr, name;
- return $global.angular.element($global.document).injector().get($externalize(name, $String));
- };
- $pkg.Service = Service;
- HttpService.ptr.prototype.Get = function(url, callback) {
- var $ptr, callback, future, s, url;
- s = this;
- future = Service("$http").get($externalize(url, $String));
- future.success($externalize((function $b(data, status, headers, config) {
- var $ptr, config, data, headers, status, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; config = $f.config; data = $f.data; headers = $f.headers; status = $f.status; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = callback(data, status); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.config = config; $f.data = data; $f.headers = headers; $f.status = status; $f.$s = $s; $f.$r = $r; return $f;
- }), funcType$2));
- future.error($externalize((function $b(data, status, headers, config) {
- var $ptr, config, data, headers, status, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; config = $f.config; data = $f.data; headers = $f.headers; status = $f.status; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = callback(data, status); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.config = config; $f.data = data; $f.headers = headers; $f.status = status; $f.$s = $s; $f.$r = $r; return $f;
- }), funcType$2));
- };
- HttpService.prototype.Get = function(url, callback) { return this.$val.Get(url, callback); };
- ptrType$2.methods = [{prop: "NewController", name: "NewController", pkg: "", typ: $funcType([$String, funcType$3], [], false)}];
- ptrType$1.methods = [{prop: "Apply", name: "Apply", pkg: "", typ: $funcType([funcType$1], [], false)}, {prop: "EvalAsync", name: "EvalAsync", pkg: "", typ: $funcType([funcType$1], [], false)}];
- ptrType$4.methods = [{prop: "Prop", name: "Prop", pkg: "", typ: $funcType([$String], [ptrType], false)}, {prop: "SetProp", name: "SetProp", pkg: "", typ: $funcType([$emptyInterface, $emptyInterface], [], false)}, {prop: "On", name: "On", pkg: "", typ: $funcType([$String, funcType$4], [], false)}, {prop: "Val", name: "Val", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "SetVal", name: "SetVal", pkg: "", typ: $funcType([$emptyInterface], [], false)}];
- ptrType$3.methods = [{prop: "PreventDefault", name: "PreventDefault", pkg: "", typ: $funcType([], [], false)}];
- ptrType$5.methods = [{prop: "Get", name: "Get", pkg: "", typ: $funcType([$String, funcType$5], [], false)}];
- Module.init([{prop: "Object", name: "", pkg: "", typ: ptrType, tag: ""}]);
- Scope.init([{prop: "Object", name: "", pkg: "", typ: ptrType, tag: ""}]);
- JQueryElement.init([{prop: "Object", name: "", pkg: "", typ: ptrType, tag: ""}]);
- Event.init([{prop: "Object", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "KeyCode", name: "KeyCode", pkg: "", typ: $Int, tag: "js:\"keyCode\""}]);
- HttpService.init([]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.HTTP = new HttpService.ptr();
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["text/tabwriter"] = (function() {
- var $pkg = {}, $init, bytes, io, utf8, cell, Writer, osError, sliceType, sliceType$1, ptrType, ptrType$1, arrayType, sliceType$2, sliceType$3, ptrType$2, newline, tabs, vbar, hbar, handlePanic, NewWriter;
- bytes = $packages["bytes"];
- io = $packages["io"];
- utf8 = $packages["unicode/utf8"];
- cell = $pkg.cell = $newType(0, $kindStruct, "tabwriter.cell", "cell", "text/tabwriter", function(size_, width_, htab_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.size = 0;
- this.width = 0;
- this.htab = false;
- return;
- }
- this.size = size_;
- this.width = width_;
- this.htab = htab_;
- });
- Writer = $pkg.Writer = $newType(0, $kindStruct, "tabwriter.Writer", "Writer", "text/tabwriter", function(output_, minwidth_, tabwidth_, padding_, padbytes_, flags_, buf_, pos_, cell_, endChar_, lines_, widths_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.output = $ifaceNil;
- this.minwidth = 0;
- this.tabwidth = 0;
- this.padding = 0;
- this.padbytes = arrayType.zero();
- this.flags = 0;
- this.buf = new bytes.Buffer.ptr();
- this.pos = 0;
- this.cell = new cell.ptr();
- this.endChar = 0;
- this.lines = sliceType$2.nil;
- this.widths = sliceType$3.nil;
- return;
- }
- this.output = output_;
- this.minwidth = minwidth_;
- this.tabwidth = tabwidth_;
- this.padding = padding_;
- this.padbytes = padbytes_;
- this.flags = flags_;
- this.buf = buf_;
- this.pos = pos_;
- this.cell = cell_;
- this.endChar = endChar_;
- this.lines = lines_;
- this.widths = widths_;
- });
- osError = $pkg.osError = $newType(0, $kindStruct, "tabwriter.osError", "osError", "text/tabwriter", function(err_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.err = $ifaceNil;
- return;
- }
- this.err = err_;
- });
- sliceType = $sliceType($Uint8);
- sliceType$1 = $sliceType(cell);
- ptrType = $ptrType(sliceType$1);
- ptrType$1 = $ptrType($error);
- arrayType = $arrayType($Uint8, 8);
- sliceType$2 = $sliceType(sliceType$1);
- sliceType$3 = $sliceType($Int);
- ptrType$2 = $ptrType(Writer);
- Writer.ptr.prototype.addLine = function() {
- var $ptr, b;
- b = this;
- b.lines = $append(b.lines, new sliceType$1([]));
- };
- Writer.prototype.addLine = function() { return this.$val.addLine(); };
- Writer.ptr.prototype.reset = function() {
- var $ptr, b;
- b = this;
- b.buf.Reset();
- b.pos = 0;
- $copy(b.cell, new cell.ptr(0, 0, false), cell);
- b.endChar = 0;
- b.lines = $subslice(b.lines, 0, 0);
- b.widths = $subslice(b.widths, 0, 0);
- b.addLine();
- };
- Writer.prototype.reset = function() { return this.$val.reset(); };
- Writer.ptr.prototype.Init = function(output, minwidth, tabwidth, padding, padchar, flags) {
- var $ptr, _i, _ref, b, flags, i, minwidth, output, padchar, padding, tabwidth, x;
- b = this;
- if (minwidth < 0 || tabwidth < 0 || padding < 0) {
- $panic(new $String("negative minwidth, tabwidth, or padding"));
- }
- b.output = output;
- b.minwidth = minwidth;
- b.tabwidth = tabwidth;
- b.padding = padding;
- _ref = b.padbytes;
- _i = 0;
- while (true) {
- if (!(_i < 8)) { break; }
- i = _i;
- (x = b.padbytes, ((i < 0 || i >= x.length) ? $throwRuntimeError("index out of range") : x[i] = padchar));
- _i++;
- }
- if (padchar === 9) {
- flags = (flags & ~(4)) >>> 0;
- }
- b.flags = flags;
- b.reset();
- return b;
- };
- Writer.prototype.Init = function(output, minwidth, tabwidth, padding, padchar, flags) { return this.$val.Init(output, minwidth, tabwidth, padding, padchar, flags); };
- Writer.ptr.prototype.write0 = function(buf) {
- var $ptr, _r, _tuple, b, buf, err, n, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; b = $f.b; buf = $f.buf; err = $f.err; n = $f.n; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- b = this;
- _r = b.output.Write(buf); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; n = _tuple[0]; err = _tuple[1];
- if (!((n === buf.$length)) && $interfaceIsEqual(err, $ifaceNil)) {
- err = io.ErrShortWrite;
- }
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- $panic((x = new osError.ptr(err), new x.constructor.elem(x)));
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Writer.ptr.prototype.write0 }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.buf = buf; $f.err = err; $f.n = n; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- Writer.prototype.write0 = function(buf) { return this.$val.write0(buf); };
- Writer.ptr.prototype.writeN = function(src, n) {
- var $ptr, b, n, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; b = $f.b; n = $f.n; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- b = this;
- /* while (true) { */ case 1:
- /* if (!(n > src.$length)) { break; } */ if(!(n > src.$length)) { $s = 2; continue; }
- $r = b.write0(src); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = n - (src.$length) >> 0;
- /* } */ $s = 1; continue; case 2:
- $r = b.write0($subslice(src, 0, n)); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Writer.ptr.prototype.writeN }; } $f.$ptr = $ptr; $f.b = b; $f.n = n; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- Writer.prototype.writeN = function(src, n) { return this.$val.writeN(src, n); };
- Writer.ptr.prototype.writePadding = function(textw, cellw, useTabs) {
- var $ptr, _q, _q$1, b, cellw, n, textw, useTabs, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _q$1 = $f._q$1; b = $f.b; cellw = $f.cellw; n = $f.n; textw = $f.textw; useTabs = $f.useTabs; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- b = this;
- /* */ if ((b.padbytes[0] === 9) || useTabs) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((b.padbytes[0] === 9) || useTabs) { */ case 1:
- if (b.tabwidth === 0) {
- return;
- }
- cellw = (_q = (((cellw + b.tabwidth >> 0) - 1 >> 0)) / b.tabwidth, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) * b.tabwidth >> 0;
- n = cellw - textw >> 0;
- if (n < 0) {
- $panic(new $String("internal error"));
- }
- $r = b.writeN(tabs, (_q$1 = (((n + b.tabwidth >> 0) - 1 >> 0)) / b.tabwidth, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 0 : $throwRuntimeError("integer divide by zero"))); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- $r = b.writeN($subslice(new sliceType(b.padbytes), 0), cellw - textw >> 0); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Writer.ptr.prototype.writePadding }; } $f.$ptr = $ptr; $f._q = _q; $f._q$1 = _q$1; $f.b = b; $f.cellw = cellw; $f.n = n; $f.textw = textw; $f.useTabs = useTabs; $f.$s = $s; $f.$r = $r; return $f;
- };
- Writer.prototype.writePadding = function(textw, cellw, useTabs) { return this.$val.writePadding(textw, cellw, useTabs); };
- Writer.ptr.prototype.writeLines = function(pos0, line0, line1) {
- var $ptr, _i, _ref, b, c, i, j, line, line0, line1, pos, pos0, useTabs, x, x$1, x$2, x$3, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; b = $f.b; c = $f.c; i = $f.i; j = $f.j; line = $f.line; line0 = $f.line0; line1 = $f.line1; pos = $f.pos; pos0 = $f.pos0; useTabs = $f.useTabs; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = 0;
- b = this;
- pos = pos0;
- i = line0;
- /* while (true) { */ case 1:
- /* if (!(i < line1)) { break; } */ if(!(i < line1)) { $s = 2; continue; }
- line = (x = b.lines, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- useTabs = !((((b.flags & 16) >>> 0) === 0));
- _ref = line;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- j = _i;
- c = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), cell);
- /* */ if (j > 0 && !((((b.flags & 32) >>> 0) === 0))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (j > 0 && !((((b.flags & 32) >>> 0) === 0))) { */ case 5:
- $r = b.write0(vbar); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- /* */ if (c.size === 0) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (c.size === 0) { */ case 8:
- /* */ if (j < b.widths.$length) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (j < b.widths.$length) { */ case 11:
- $r = b.writePadding(c.width, (x$1 = b.widths, ((j < 0 || j >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + j])), useTabs); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 12:
- $s = 10; continue;
- /* } else { */ case 9:
- useTabs = false;
- /* */ if (((b.flags & 4) >>> 0) === 0) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (((b.flags & 4) >>> 0) === 0) { */ case 14:
- $r = b.write0($subslice(b.buf.Bytes(), pos, (pos + c.size >> 0))); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- pos = pos + (c.size) >> 0;
- /* */ if (j < b.widths.$length) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (j < b.widths.$length) { */ case 18:
- $r = b.writePadding(c.width, (x$2 = b.widths, ((j < 0 || j >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + j])), false); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 19:
- $s = 16; continue;
- /* } else { */ case 15:
- /* */ if (j < b.widths.$length) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (j < b.widths.$length) { */ case 21:
- $r = b.writePadding(c.width, (x$3 = b.widths, ((j < 0 || j >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + j])), false); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 22:
- $r = b.write0($subslice(b.buf.Bytes(), pos, (pos + c.size >> 0))); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- pos = pos + (c.size) >> 0;
- /* } */ case 16:
- /* } */ case 10:
- _i++;
- /* } */ $s = 3; continue; case 4:
- /* */ if ((i + 1 >> 0) === b.lines.$length) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if ((i + 1 >> 0) === b.lines.$length) { */ case 25:
- $r = b.write0($subslice(b.buf.Bytes(), pos, (pos + b.cell.size >> 0))); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- pos = pos + (b.cell.size) >> 0;
- $s = 27; continue;
- /* } else { */ case 26:
- $r = b.write0(newline); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 27:
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Writer.ptr.prototype.writeLines }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.b = b; $f.c = c; $f.i = i; $f.j = j; $f.line = line; $f.line0 = line0; $f.line1 = line1; $f.pos = pos; $f.pos0 = pos0; $f.useTabs = useTabs; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.$s = $s; $f.$r = $r; return $f;
- };
- Writer.prototype.writeLines = function(pos0, line0, line1) { return this.$val.writeLines(pos0, line0, line1); };
- Writer.ptr.prototype.format = function(pos0, line0, line1) {
- var $ptr, _r, _r$1, _r$2, b, c, column, discardable, line, line0, line1, pos, pos0, this$1, w, width, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; b = $f.b; c = $f.c; column = $f.column; discardable = $f.discardable; line = $f.line; line0 = $f.line0; line1 = $f.line1; pos = $f.pos; pos0 = $f.pos0; this$1 = $f.this$1; w = $f.w; width = $f.width; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- pos = 0;
- b = this;
- pos = pos0;
- column = b.widths.$length;
- this$1 = line0;
- /* while (true) { */ case 1:
- /* if (!(this$1 < line1)) { break; } */ if(!(this$1 < line1)) { $s = 2; continue; }
- line = (x = b.lines, ((this$1 < 0 || this$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + this$1]));
- /* */ if (column < (line.$length - 1 >> 0)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (column < (line.$length - 1 >> 0)) { */ case 3:
- _r = b.writeLines(pos, line0, this$1); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- pos = _r;
- line0 = this$1;
- width = b.minwidth;
- discardable = true;
- while (true) {
- if (!(this$1 < line1)) { break; }
- line = (x$1 = b.lines, ((this$1 < 0 || this$1 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + this$1]));
- if (column < (line.$length - 1 >> 0)) {
- c = $clone(((column < 0 || column >= line.$length) ? $throwRuntimeError("index out of range") : line.$array[line.$offset + column]), cell);
- w = c.width + b.padding >> 0;
- if (w > width) {
- width = w;
- }
- if (c.width > 0 || c.htab) {
- discardable = false;
- }
- } else {
- break;
- }
- this$1 = this$1 + (1) >> 0;
- }
- if (discardable && !((((b.flags & 8) >>> 0) === 0))) {
- width = 0;
- }
- b.widths = $append(b.widths, width);
- _r$1 = b.format(pos, line0, this$1); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- pos = _r$1;
- b.widths = $subslice(b.widths, 0, (b.widths.$length - 1 >> 0));
- line0 = this$1;
- /* } */ case 4:
- this$1 = this$1 + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- _r$2 = b.writeLines(pos, line0, line1); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- pos = _r$2;
- return pos;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Writer.ptr.prototype.format }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.b = b; $f.c = c; $f.column = column; $f.discardable = discardable; $f.line = line; $f.line0 = line0; $f.line1 = line1; $f.pos = pos; $f.pos0 = pos0; $f.this$1 = this$1; $f.w = w; $f.width = width; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- Writer.prototype.format = function(pos0, line0, line1) { return this.$val.format(pos0, line0, line1); };
- Writer.ptr.prototype.append = function(text) {
- var $ptr, b, text;
- b = this;
- b.buf.Write(text);
- b.cell.size = b.cell.size + (text.$length) >> 0;
- };
- Writer.prototype.append = function(text) { return this.$val.append(text); };
- Writer.ptr.prototype.updateWidth = function() {
- var $ptr, b;
- b = this;
- b.cell.width = b.cell.width + (utf8.RuneCount($subslice(b.buf.Bytes(), b.pos, b.buf.Len()))) >> 0;
- b.pos = b.buf.Len();
- };
- Writer.prototype.updateWidth = function() { return this.$val.updateWidth(); };
- Writer.ptr.prototype.startEscape = function(ch) {
- var $ptr, _ref, b, ch;
- b = this;
- _ref = ch;
- if (_ref === 255) {
- b.endChar = 255;
- } else if (_ref === 60) {
- b.endChar = 62;
- } else if (_ref === 38) {
- b.endChar = 59;
- }
- };
- Writer.prototype.startEscape = function(ch) { return this.$val.startEscape(ch); };
- Writer.ptr.prototype.endEscape = function() {
- var $ptr, _ref, b;
- b = this;
- _ref = b.endChar;
- if (_ref === 255) {
- b.updateWidth();
- if (((b.flags & 2) >>> 0) === 0) {
- b.cell.width = b.cell.width - (2) >> 0;
- }
- } else if (_ref === 62) {
- } else if (_ref === 59) {
- b.cell.width = b.cell.width + (1) >> 0;
- }
- b.pos = b.buf.Len();
- b.endChar = 0;
- };
- Writer.prototype.endEscape = function() { return this.$val.endEscape(); };
- Writer.ptr.prototype.terminateCell = function(htab) {
- var $ptr, b, htab, line, x;
- b = this;
- b.cell.htab = htab;
- line = (x = b.lines, $indexPtr(x.$array, x.$offset + (b.lines.$length - 1 >> 0), ptrType));
- line.$set($append(line.$get(), b.cell));
- $copy(b.cell, new cell.ptr(0, 0, false), cell);
- return line.$get().$length;
- };
- Writer.prototype.terminateCell = function(htab) { return this.$val.terminateCell(htab); };
- handlePanic = function(err, op) {
- var $ptr, _tuple, e, err, nerr, ok, op;
- e = $recover();
- if (!($interfaceIsEqual(e, $ifaceNil))) {
- _tuple = $assertType(e, osError, true); nerr = $clone(_tuple[0], osError); ok = _tuple[1];
- if (ok) {
- err.$set(nerr.err);
- return;
- }
- $panic(new $String("tabwriter: panic during " + op));
- }
- };
- Writer.ptr.prototype.Flush = function() {
- var $ptr, _r, b, err, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; b = $f.b; err = $f.err; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- err[0] = $ifaceNil;
- b = this;
- $deferred.push([$methodVal(b, "reset"), []]);
- $deferred.push([handlePanic, [(err.$ptr || (err.$ptr = new ptrType$1(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, err))), "Flush"]]);
- if (b.cell.size > 0) {
- if (!((b.endChar === 0))) {
- b.endEscape();
- }
- b.terminateCell(false);
- }
- _r = b.format(0, 0, b.lines.$length); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r;
- return err[0];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err[0]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Writer.ptr.prototype.Flush }; } $f.$ptr = $ptr; $f._r = _r; $f.b = b; $f.err = err; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Writer.prototype.Flush = function() { return this.$val.Flush(); };
- Writer.ptr.prototype.Write = function(buf) {
- var $ptr, _i, _r, _ref, _ref$1, b, buf, ch, err, i, j, n, ncells, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; _ref$1 = $f._ref$1; b = $f.b; buf = $f.buf; ch = $f.ch; err = $f.err; i = $f.i; j = $f.j; n = $f.n; ncells = $f.ncells; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = [err];
- n = 0;
- err[0] = $ifaceNil;
- b = this;
- $deferred.push([handlePanic, [(err.$ptr || (err.$ptr = new ptrType$1(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, err))), "Write"]]);
- n = 0;
- _ref = buf;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- ch = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (b.endChar === 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (b.endChar === 0) { */ case 3:
- _ref$1 = ch;
- /* */ if (_ref$1 === 9 || _ref$1 === 11 || _ref$1 === 10 || _ref$1 === 12) { $s = 6; continue; }
- /* */ if (_ref$1 === 255) { $s = 7; continue; }
- /* */ if (_ref$1 === 60 || _ref$1 === 38) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (_ref$1 === 9 || _ref$1 === 11 || _ref$1 === 10 || _ref$1 === 12) { */ case 6:
- b.append($subslice(buf, n, i));
- b.updateWidth();
- n = i + 1 >> 0;
- ncells = b.terminateCell(ch === 9);
- /* */ if ((ch === 10) || (ch === 12)) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if ((ch === 10) || (ch === 12)) { */ case 10:
- b.addLine();
- /* */ if ((ch === 12) || (ncells === 1)) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if ((ch === 12) || (ncells === 1)) { */ case 12:
- _r = b.Flush(); /* */ $s = 14; case 14: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err[0] = _r;
- /* */ if (!($interfaceIsEqual(err[0], $ifaceNil))) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (!($interfaceIsEqual(err[0], $ifaceNil))) { */ case 15:
- return [n, err[0]];
- /* } */ case 16:
- /* */ if ((ch === 12) && !((((b.flags & 32) >>> 0) === 0))) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if ((ch === 12) && !((((b.flags & 32) >>> 0) === 0))) { */ case 17:
- $r = b.write0(hbar); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- /* } */ case 13:
- /* } */ case 11:
- $s = 9; continue;
- /* } else if (_ref$1 === 255) { */ case 7:
- b.append($subslice(buf, n, i));
- b.updateWidth();
- n = i;
- if (!((((b.flags & 2) >>> 0) === 0))) {
- n = n + (1) >> 0;
- }
- b.startEscape(255);
- $s = 9; continue;
- /* } else if (_ref$1 === 60 || _ref$1 === 38) { */ case 8:
- if (!((((b.flags & 1) >>> 0) === 0))) {
- b.append($subslice(buf, n, i));
- b.updateWidth();
- n = i;
- b.startEscape(ch);
- }
- /* } */ case 9:
- $s = 5; continue;
- /* } else { */ case 4:
- if (ch === b.endChar) {
- j = i + 1 >> 0;
- if ((ch === 255) && !((((b.flags & 2) >>> 0) === 0))) {
- j = i;
- }
- b.append($subslice(buf, n, j));
- n = i + 1 >> 0;
- b.endEscape();
- }
- /* } */ case 5:
- _i++;
- /* } */ $s = 1; continue; case 2:
- b.append($subslice(buf, n));
- n = buf.$length;
- return [n, err[0]];
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [n, err[0]]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Writer.ptr.prototype.Write }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f._ref$1 = _ref$1; $f.b = b; $f.buf = buf; $f.ch = ch; $f.err = err; $f.i = i; $f.j = j; $f.n = n; $f.ncells = ncells; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- Writer.prototype.Write = function(buf) { return this.$val.Write(buf); };
- NewWriter = function(output, minwidth, tabwidth, padding, padchar, flags) {
- var $ptr, flags, minwidth, output, padchar, padding, tabwidth;
- return new Writer.ptr().Init(output, minwidth, tabwidth, padding, padchar, flags);
- };
- $pkg.NewWriter = NewWriter;
- ptrType$2.methods = [{prop: "addLine", name: "addLine", pkg: "text/tabwriter", typ: $funcType([], [], false)}, {prop: "reset", name: "reset", pkg: "text/tabwriter", typ: $funcType([], [], false)}, {prop: "Init", name: "Init", pkg: "", typ: $funcType([io.Writer, $Int, $Int, $Int, $Uint8, $Uint], [ptrType$2], false)}, {prop: "dump", name: "dump", pkg: "text/tabwriter", typ: $funcType([], [], false)}, {prop: "write0", name: "write0", pkg: "text/tabwriter", typ: $funcType([sliceType], [], false)}, {prop: "writeN", name: "writeN", pkg: "text/tabwriter", typ: $funcType([sliceType, $Int], [], false)}, {prop: "writePadding", name: "writePadding", pkg: "text/tabwriter", typ: $funcType([$Int, $Int, $Bool], [], false)}, {prop: "writeLines", name: "writeLines", pkg: "text/tabwriter", typ: $funcType([$Int, $Int, $Int], [$Int], false)}, {prop: "format", name: "format", pkg: "text/tabwriter", typ: $funcType([$Int, $Int, $Int], [$Int], false)}, {prop: "append", name: "append", pkg: "text/tabwriter", typ: $funcType([sliceType], [], false)}, {prop: "updateWidth", name: "updateWidth", pkg: "text/tabwriter", typ: $funcType([], [], false)}, {prop: "startEscape", name: "startEscape", pkg: "text/tabwriter", typ: $funcType([$Uint8], [], false)}, {prop: "endEscape", name: "endEscape", pkg: "text/tabwriter", typ: $funcType([], [], false)}, {prop: "terminateCell", name: "terminateCell", pkg: "text/tabwriter", typ: $funcType([$Bool], [$Int], false)}, {prop: "Flush", name: "Flush", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}];
- cell.init([{prop: "size", name: "size", pkg: "text/tabwriter", typ: $Int, tag: ""}, {prop: "width", name: "width", pkg: "text/tabwriter", typ: $Int, tag: ""}, {prop: "htab", name: "htab", pkg: "text/tabwriter", typ: $Bool, tag: ""}]);
- Writer.init([{prop: "output", name: "output", pkg: "text/tabwriter", typ: io.Writer, tag: ""}, {prop: "minwidth", name: "minwidth", pkg: "text/tabwriter", typ: $Int, tag: ""}, {prop: "tabwidth", name: "tabwidth", pkg: "text/tabwriter", typ: $Int, tag: ""}, {prop: "padding", name: "padding", pkg: "text/tabwriter", typ: $Int, tag: ""}, {prop: "padbytes", name: "padbytes", pkg: "text/tabwriter", typ: arrayType, tag: ""}, {prop: "flags", name: "flags", pkg: "text/tabwriter", typ: $Uint, tag: ""}, {prop: "buf", name: "buf", pkg: "text/tabwriter", typ: bytes.Buffer, tag: ""}, {prop: "pos", name: "pos", pkg: "text/tabwriter", typ: $Int, tag: ""}, {prop: "cell", name: "cell", pkg: "text/tabwriter", typ: cell, tag: ""}, {prop: "endChar", name: "endChar", pkg: "text/tabwriter", typ: $Uint8, tag: ""}, {prop: "lines", name: "lines", pkg: "text/tabwriter", typ: sliceType$2, tag: ""}, {prop: "widths", name: "widths", pkg: "text/tabwriter", typ: sliceType$3, tag: ""}]);
- osError.init([{prop: "err", name: "err", pkg: "text/tabwriter", typ: $error, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- newline = new sliceType([10]);
- tabs = new sliceType($stringToBytes("\t\t\t\t\t\t\t\t"));
- vbar = new sliceType([124]);
- hbar = new sliceType($stringToBytes("---\n"));
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["go/printer"] = (function() {
- var $pkg = {}, $init, bytes, fmt, ast, token, io, os, strconv, strings, tabwriter, unicode, utf8, exprListMode, whiteSpace, pmode, commentInfo, printer, trimmer, Mode, Config, CommentedNode, sliceType, sliceType$1, ptrType, sliceType$2, sliceType$3, ptrType$1, ptrType$2, ptrType$3, sliceType$4, ptrType$4, ptrType$5, sliceType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, ptrType$10, ptrType$11, ptrType$12, ptrType$13, ptrType$14, ptrType$15, ptrType$16, ptrType$17, ptrType$18, ptrType$19, ptrType$20, ptrType$21, ptrType$22, ptrType$23, ptrType$24, ptrType$25, ptrType$26, ptrType$27, ptrType$28, ptrType$29, ptrType$30, ptrType$31, ptrType$32, ptrType$33, ptrType$34, ptrType$35, ptrType$36, ptrType$37, ptrType$38, ptrType$39, ptrType$40, ptrType$41, ptrType$42, ptrType$43, ptrType$44, ptrType$45, ptrType$46, sliceType$6, ptrType$47, ptrType$48, ptrType$49, ptrType$50, ptrType$51, ptrType$52, sliceType$7, ptrType$53, ptrType$54, ptrType$55, sliceType$8, sliceType$9, ptrType$56, ptrType$57, sliceType$10, ptrType$58, mapType, ptrType$59, ptrType$60, aNewline, identListSize, walkBinary, cutoff, diffPrec, reduceDepth, isBinary, isTypeName, stripParens, stripParensAlways, keepTypeColumn, declToken, isBlank, commonPrefix, trimRight, stripCommonPrefix, nlimit, mayCombine, getDoc;
- bytes = $packages["bytes"];
- fmt = $packages["fmt"];
- ast = $packages["go/ast"];
- token = $packages["go/token"];
- io = $packages["io"];
- os = $packages["os"];
- strconv = $packages["strconv"];
- strings = $packages["strings"];
- tabwriter = $packages["text/tabwriter"];
- unicode = $packages["unicode"];
- utf8 = $packages["unicode/utf8"];
- exprListMode = $pkg.exprListMode = $newType(4, $kindUint, "printer.exprListMode", "exprListMode", "go/printer", null);
- whiteSpace = $pkg.whiteSpace = $newType(1, $kindUint8, "printer.whiteSpace", "whiteSpace", "go/printer", null);
- pmode = $pkg.pmode = $newType(4, $kindInt, "printer.pmode", "pmode", "go/printer", null);
- commentInfo = $pkg.commentInfo = $newType(0, $kindStruct, "printer.commentInfo", "commentInfo", "go/printer", function(cindex_, comment_, commentOffset_, commentNewline_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.cindex = 0;
- this.comment = ptrType.nil;
- this.commentOffset = 0;
- this.commentNewline = false;
- return;
- }
- this.cindex = cindex_;
- this.comment = comment_;
- this.commentOffset = commentOffset_;
- this.commentNewline = commentNewline_;
- });
- printer = $pkg.printer = $newType(0, $kindStruct, "printer.printer", "printer", "go/printer", function(Config_, fset_, output_, indent_, mode_, impliedSemi_, lastTok_, prevOpen_, wsbuf_, pos_, out_, last_, linePtr_, comments_, useNodeComments_, commentInfo_, nodeSizes_, cachedPos_, cachedLine_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Config = new Config.ptr();
- this.fset = ptrType$57.nil;
- this.output = sliceType.nil;
- this.indent = 0;
- this.mode = 0;
- this.impliedSemi = false;
- this.lastTok = 0;
- this.prevOpen = 0;
- this.wsbuf = sliceType$7.nil;
- this.pos = new token.Position.ptr();
- this.out = new token.Position.ptr();
- this.last = new token.Position.ptr();
- this.linePtr = ptrType$6.nil;
- this.comments = sliceType$2.nil;
- this.useNodeComments = false;
- this.commentInfo = new commentInfo.ptr();
- this.nodeSizes = false;
- this.cachedPos = 0;
- this.cachedLine = 0;
- return;
- }
- this.Config = Config_;
- this.fset = fset_;
- this.output = output_;
- this.indent = indent_;
- this.mode = mode_;
- this.impliedSemi = impliedSemi_;
- this.lastTok = lastTok_;
- this.prevOpen = prevOpen_;
- this.wsbuf = wsbuf_;
- this.pos = pos_;
- this.out = out_;
- this.last = last_;
- this.linePtr = linePtr_;
- this.comments = comments_;
- this.useNodeComments = useNodeComments_;
- this.commentInfo = commentInfo_;
- this.nodeSizes = nodeSizes_;
- this.cachedPos = cachedPos_;
- this.cachedLine = cachedLine_;
- });
- trimmer = $pkg.trimmer = $newType(0, $kindStruct, "printer.trimmer", "trimmer", "go/printer", function(output_, state_, space_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.output = $ifaceNil;
- this.state = 0;
- this.space = sliceType.nil;
- return;
- }
- this.output = output_;
- this.state = state_;
- this.space = space_;
- });
- Mode = $pkg.Mode = $newType(4, $kindUint, "printer.Mode", "Mode", "go/printer", null);
- Config = $pkg.Config = $newType(0, $kindStruct, "printer.Config", "Config", "go/printer", function(Mode_, Tabwidth_, Indent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Mode = 0;
- this.Tabwidth = 0;
- this.Indent = 0;
- return;
- }
- this.Mode = Mode_;
- this.Tabwidth = Tabwidth_;
- this.Indent = Indent_;
- });
- CommentedNode = $pkg.CommentedNode = $newType(0, $kindStruct, "printer.CommentedNode", "CommentedNode", "go/printer", function(Node_, Comments_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Node = $ifaceNil;
- this.Comments = sliceType$2.nil;
- return;
- }
- this.Node = Node_;
- this.Comments = Comments_;
- });
- sliceType = $sliceType($Uint8);
- sliceType$1 = $sliceType($emptyInterface);
- ptrType = $ptrType(ast.CommentGroup);
- sliceType$2 = $sliceType(ptrType);
- sliceType$3 = $sliceType(ast.Expr);
- ptrType$1 = $ptrType(ast.KeyValueExpr);
- ptrType$2 = $ptrType(ast.FieldList);
- ptrType$3 = $ptrType(ast.Ident);
- sliceType$4 = $sliceType(ptrType$3);
- ptrType$4 = $ptrType(ast.BasicLit);
- ptrType$5 = $ptrType(ast.Comment);
- sliceType$5 = $sliceType(ptrType$5);
- ptrType$6 = $ptrType($Int);
- ptrType$7 = $ptrType(ast.FuncType);
- ptrType$8 = $ptrType(ast.BinaryExpr);
- ptrType$9 = $ptrType(ast.StarExpr);
- ptrType$10 = $ptrType(ast.UnaryExpr);
- ptrType$11 = $ptrType(ast.BadExpr);
- ptrType$12 = $ptrType(ast.FuncLit);
- ptrType$13 = $ptrType(ast.ParenExpr);
- ptrType$14 = $ptrType(ast.SelectorExpr);
- ptrType$15 = $ptrType(ast.TypeAssertExpr);
- ptrType$16 = $ptrType(ast.IndexExpr);
- ptrType$17 = $ptrType(ast.SliceExpr);
- ptrType$18 = $ptrType(ast.CallExpr);
- ptrType$19 = $ptrType(ast.CompositeLit);
- ptrType$20 = $ptrType(ast.Ellipsis);
- ptrType$21 = $ptrType(ast.ArrayType);
- ptrType$22 = $ptrType(ast.StructType);
- ptrType$23 = $ptrType(ast.InterfaceType);
- ptrType$24 = $ptrType(ast.MapType);
- ptrType$25 = $ptrType(ast.ChanType);
- ptrType$26 = $ptrType(ast.EmptyStmt);
- ptrType$27 = $ptrType(ast.LabeledStmt);
- ptrType$28 = $ptrType(ast.BadStmt);
- ptrType$29 = $ptrType(ast.DeclStmt);
- ptrType$30 = $ptrType(ast.ExprStmt);
- ptrType$31 = $ptrType(ast.SendStmt);
- ptrType$32 = $ptrType(ast.IncDecStmt);
- ptrType$33 = $ptrType(ast.AssignStmt);
- ptrType$34 = $ptrType(ast.GoStmt);
- ptrType$35 = $ptrType(ast.DeferStmt);
- ptrType$36 = $ptrType(ast.ReturnStmt);
- ptrType$37 = $ptrType(ast.BranchStmt);
- ptrType$38 = $ptrType(ast.BlockStmt);
- ptrType$39 = $ptrType(ast.IfStmt);
- ptrType$40 = $ptrType(ast.CaseClause);
- ptrType$41 = $ptrType(ast.SwitchStmt);
- ptrType$42 = $ptrType(ast.TypeSwitchStmt);
- ptrType$43 = $ptrType(ast.CommClause);
- ptrType$44 = $ptrType(ast.SelectStmt);
- ptrType$45 = $ptrType(ast.ForStmt);
- ptrType$46 = $ptrType(ast.RangeStmt);
- sliceType$6 = $sliceType($Bool);
- ptrType$47 = $ptrType(ast.ValueSpec);
- ptrType$48 = $ptrType(ast.ImportSpec);
- ptrType$49 = $ptrType(ast.TypeSpec);
- ptrType$50 = $ptrType(ast.BadDecl);
- ptrType$51 = $ptrType(ast.GenDecl);
- ptrType$52 = $ptrType(ast.FuncDecl);
- sliceType$7 = $sliceType(whiteSpace);
- ptrType$53 = $ptrType(ast.Field);
- ptrType$54 = $ptrType(ast.File);
- ptrType$55 = $ptrType(CommentedNode);
- sliceType$8 = $sliceType(ast.Stmt);
- sliceType$9 = $sliceType(ast.Decl);
- ptrType$56 = $ptrType(tabwriter.Writer);
- ptrType$57 = $ptrType(token.FileSet);
- sliceType$10 = $sliceType(ptrType$53);
- ptrType$58 = $ptrType(Config);
- mapType = $mapType(ast.Node, $Int);
- ptrType$59 = $ptrType(printer);
- ptrType$60 = $ptrType(trimmer);
- printer.ptr.prototype.linebreak = function(line, min, ws, newSection) {
- var $ptr, line, min, n, newSection, p, printedBreak, ws, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; line = $f.line; min = $f.min; n = $f.n; newSection = $f.newSection; p = $f.p; printedBreak = $f.printedBreak; ws = $f.ws; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- printedBreak = false;
- p = this;
- n = nlimit(line - p.pos.Line >> 0);
- if (n < min) {
- n = min;
- }
- /* */ if (n > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (n > 0) { */ case 1:
- $r = p.print(new sliceType$1([new whiteSpace(ws)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (newSection) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (newSection) { */ case 4:
- $r = p.print(new sliceType$1([new whiteSpace(12)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = n - (1) >> 0;
- /* } */ case 5:
- /* while (true) { */ case 7:
- /* if (!(n > 0)) { break; } */ if(!(n > 0)) { $s = 8; continue; }
- $r = p.print(new sliceType$1([new whiteSpace(10)])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = n - (1) >> 0;
- /* } */ $s = 7; continue; case 8:
- printedBreak = true;
- /* } */ case 2:
- return printedBreak;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.linebreak }; } $f.$ptr = $ptr; $f.line = line; $f.min = min; $f.n = n; $f.newSection = newSection; $f.p = p; $f.printedBreak = printedBreak; $f.ws = ws; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.linebreak = function(line, min, ws, newSection) { return this.$val.linebreak(line, min, ws, newSection); };
- printer.ptr.prototype.setComment = function(g) {
- var $ptr, _r, _r$1, g, p, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; g = $f.g; p = $f.p; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- if (g === ptrType.nil || !p.useNodeComments) {
- return;
- }
- /* */ if (p.comments === sliceType$2.nil) { $s = 1; continue; }
- /* */ if (p.commentInfo.cindex < p.comments.$length) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (p.comments === sliceType$2.nil) { */ case 1:
- p.comments = $makeSlice(sliceType$2, 1);
- $s = 3; continue;
- /* } else if (p.commentInfo.cindex < p.comments.$length) { */ case 2:
- _r = p.posFor((x = g.List, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Pos()); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.flush(_r, 0); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- p.comments = $subslice(p.comments, 0, 1);
- $r = p.internalError(new sliceType$1([new $String("setComment found pending comments")])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- (x$1 = p.comments, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0] = g));
- p.commentInfo.cindex = 0;
- /* */ if (p.commentInfo.commentOffset === 1073741824) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (p.commentInfo.commentOffset === 1073741824) { */ case 7:
- $r = p.nextComment(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.setComment }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.g = g; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.setComment = function(g) { return this.$val.setComment(g); };
- printer.ptr.prototype.identList = function(list, indent) {
- var $ptr, _i, _ref, i, indent, list, mode, p, x, xlist, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; i = $f.i; indent = $f.indent; list = $f.list; mode = $f.mode; p = $f.p; x = $f.x; xlist = $f.xlist; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- xlist = $makeSlice(sliceType$3, list.$length);
- _ref = list;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= xlist.$length) ? $throwRuntimeError("index out of range") : xlist.$array[xlist.$offset + i] = x);
- _i++;
- }
- mode = 0;
- if (!indent) {
- mode = 2;
- }
- $r = p.exprList(0, xlist, 1, mode, 0); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.identList }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.i = i; $f.indent = indent; $f.list = list; $f.mode = mode; $f.p = p; $f.x = x; $f.xlist = xlist; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.identList = function(list, indent) { return this.$val.identList(list, indent); };
- printer.ptr.prototype.exprList = function(prev0, list, depth, mode, next0) {
- var $ptr, _i, _i$1, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _tuple, _v, depth, endLine, i, i$1, isPair, line, list, mode, needsBlank, needsLinebreak, next, next0, p, pair, prev, prev0, prevBreak, prevLine, prevSize, ratio, size, useFF, ws, x, x$1, x$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _v = $f._v; depth = $f.depth; endLine = $f.endLine; i = $f.i; i$1 = $f.i$1; isPair = $f.isPair; line = $f.line; list = $f.list; mode = $f.mode; needsBlank = $f.needsBlank; needsLinebreak = $f.needsLinebreak; next = $f.next; next0 = $f.next0; p = $f.p; pair = $f.pair; prev = $f.prev; prev0 = $f.prev0; prevBreak = $f.prevBreak; prevLine = $f.prevLine; prevSize = $f.prevSize; ratio = $f.ratio; size = $f.size; useFF = $f.useFF; ws = $f.ws; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- if (list.$length === 0) {
- return;
- }
- _r = p.posFor(prev0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- prev = $clone(_r, token.Position);
- _r$1 = p.posFor(next0); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- next = $clone(_r$1, token.Position);
- _r$2 = (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]).Pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.lineFor(_r$2); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- line = _r$3;
- _r$4 = (x = list.$length - 1 >> 0, ((x < 0 || x >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + x])).End(); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.lineFor(_r$4); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- endLine = _r$5;
- /* */ if (prev.IsValid() && (prev.Line === line) && (line === endLine)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (prev.IsValid() && (prev.Line === line) && (line === endLine)) { */ case 7:
- _ref = list;
- _i = 0;
- /* while (true) { */ case 9:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 10; continue; }
- i = _i;
- x$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (i > 0) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (i > 0) { */ case 11:
- _r$6 = x$1.Pos(); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(_r$6), new token.Token(52), new whiteSpace(32)])); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 12:
- $r = p.expr0(x$1, depth); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 9; continue; case 10:
- return;
- /* } */ case 8:
- ws = 0;
- if (((mode & 2) >>> 0) === 0) {
- ws = 62;
- }
- prevBreak = -1;
- if (!(prev.IsValid() && prev.Line < line)) { _v = false; $s = 18; continue s; }
- _r$7 = p.linebreak(line, 0, ws, true); /* */ $s = 19; case 19: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _v = _r$7; case 18:
- /* */ if (_v) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (_v) { */ case 16:
- ws = 0;
- prevBreak = 0;
- /* } */ case 17:
- size = 0;
- prevLine = prev.Line;
- _ref$1 = list;
- _i$1 = 0;
- /* while (true) { */ case 20:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 21; continue; }
- i$1 = _i$1;
- x$2 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _r$8 = x$2.Pos(); /* */ $s = 22; case 22: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = p.lineFor(_r$8); /* */ $s = 23; case 23: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- line = _r$9;
- useFF = true;
- prevSize = size;
- _r$10 = p.nodeSize(x$2, 1000000); /* */ $s = 24; case 24: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- size = _r$10;
- _tuple = $assertType(x$2, ptrType$1, true); pair = _tuple[0]; isPair = _tuple[1];
- /* */ if (size <= 1000000 && prev.IsValid() && next.IsValid()) { $s = 25; continue; }
- /* */ $s = 26; continue;
- /* if (size <= 1000000 && prev.IsValid() && next.IsValid()) { */ case 25:
- /* */ if (isPair) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (isPair) { */ case 28:
- _r$11 = p.nodeSize(pair.Key, 1000000); /* */ $s = 30; case 30: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- size = _r$11;
- /* } */ case 29:
- $s = 27; continue;
- /* } else { */ case 26:
- size = 0;
- /* } */ case 27:
- if (prevSize > 0 && size > 0) {
- if (prevSize <= 20 && size <= 20) {
- useFF = false;
- } else {
- ratio = size / prevSize;
- useFF = ratio <= 0.25 || 4 <= ratio;
- }
- }
- needsLinebreak = 0 < prevLine && prevLine < line;
- /* */ if (i$1 > 0) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (i$1 > 0) { */ case 31:
- /* */ if (!needsLinebreak) { $s = 33; continue; }
- /* */ $s = 34; continue;
- /* if (!needsLinebreak) { */ case 33:
- _r$12 = x$2.Pos(); /* */ $s = 35; case 35: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(_r$12)])); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 34:
- $r = p.print(new sliceType$1([new token.Token(52)])); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- needsBlank = true;
- /* */ if (needsLinebreak) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (needsLinebreak) { */ case 38:
- _r$13 = p.linebreak(line, 0, ws, useFF || (prevBreak + 1 >> 0) < i$1); /* */ $s = 42; case 42: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- /* */ if (_r$13) { $s = 40; continue; }
- /* */ $s = 41; continue;
- /* if (_r$13) { */ case 40:
- ws = 0;
- prevBreak = i$1;
- needsBlank = false;
- /* } */ case 41:
- /* } */ case 39:
- /* */ if (needsBlank) { $s = 43; continue; }
- /* */ $s = 44; continue;
- /* if (needsBlank) { */ case 43:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 44:
- /* } */ case 32:
- /* */ if (list.$length > 1 && isPair && size > 0 && needsLinebreak) { $s = 46; continue; }
- /* */ $s = 47; continue;
- /* if (list.$length > 1 && isPair && size > 0 && needsLinebreak) { */ case 46:
- $r = p.expr(pair.Key); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(pair.Colon), new token.Token(58), new whiteSpace(11)])); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(pair.Value); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 48; continue;
- /* } else { */ case 47:
- $r = p.expr0(x$2, depth); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 48:
- prevLine = line;
- _i$1++;
- /* } */ $s = 20; continue; case 21:
- /* */ if (!((((mode & 1) >>> 0) === 0)) && next.IsValid() && p.pos.Line < next.Line) { $s = 53; continue; }
- /* */ $s = 54; continue;
- /* if (!((((mode & 1) >>> 0) === 0)) && next.IsValid() && p.pos.Line < next.Line) { */ case 53:
- $r = p.print(new sliceType$1([new token.Token(52)])); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((ws === 0) && (((mode & 2) >>> 0) === 0)) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if ((ws === 0) && (((mode & 2) >>> 0) === 0)) { */ case 56:
- $r = p.print(new sliceType$1([new whiteSpace(60)])); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 57:
- $r = p.print(new sliceType$1([new whiteSpace(12)])); /* */ $s = 59; case 59: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 54:
- /* */ if ((ws === 0) && (((mode & 2) >>> 0) === 0)) { $s = 60; continue; }
- /* */ $s = 61; continue;
- /* if ((ws === 0) && (((mode & 2) >>> 0) === 0)) { */ case 60:
- $r = p.print(new sliceType$1([new whiteSpace(60)])); /* */ $s = 62; case 62: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 61:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.exprList }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._v = _v; $f.depth = depth; $f.endLine = endLine; $f.i = i; $f.i$1 = i$1; $f.isPair = isPair; $f.line = line; $f.list = list; $f.mode = mode; $f.needsBlank = needsBlank; $f.needsLinebreak = needsLinebreak; $f.next = next; $f.next0 = next0; $f.p = p; $f.pair = pair; $f.prev = prev; $f.prev0 = prev0; $f.prevBreak = prevBreak; $f.prevLine = prevLine; $f.prevSize = prevSize; $f.ratio = ratio; $f.size = size; $f.useFF = useFF; $f.ws = ws; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.exprList = function(prev0, list, depth, mode, next0) { return this.$val.exprList(prev0, list, depth, mode, next0); };
- printer.ptr.prototype.parameters = function(fields) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _v, closing, fields, i, needsLinebreak, p, par, parLineBeg, parLineEnd, prevLine, ws, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _v = $f._v; closing = $f.closing; fields = $f.fields; i = $f.i; needsLinebreak = $f.needsLinebreak; p = $f.p; par = $f.par; parLineBeg = $f.parLineBeg; parLineEnd = $f.parLineEnd; prevLine = $f.prevLine; ws = $f.ws; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.print(new sliceType$1([new token.Pos(fields.Opening), new token.Token(49)])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (fields.List.$length > 0) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (fields.List.$length > 0) { */ case 2:
- _r = p.lineFor(fields.Opening); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- prevLine = _r;
- ws = 62;
- _ref = fields.List;
- _i = 0;
- /* while (true) { */ case 5:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 6; continue; }
- i = _i;
- par = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- parLineBeg = 0;
- /* */ if (par.Names.$length > 0) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (par.Names.$length > 0) { */ case 7:
- _r$1 = p.lineFor((x = par.Names, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Pos()); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- parLineBeg = _r$1;
- $s = 9; continue;
- /* } else { */ case 8:
- _r$2 = par.Type.Pos(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.lineFor(_r$2); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- parLineBeg = _r$3;
- /* } */ case 9:
- _r$4 = par.Type.End(); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.lineFor(_r$4); /* */ $s = 14; case 14: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- parLineEnd = _r$5;
- needsLinebreak = 0 < prevLine && prevLine < parLineBeg;
- /* */ if (i > 0) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (i > 0) { */ case 15:
- /* */ if (!needsLinebreak) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (!needsLinebreak) { */ case 17:
- _r$6 = par.Pos(); /* */ $s = 19; case 19: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(_r$6)])); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 18:
- $r = p.print(new sliceType$1([new token.Token(52)])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 16:
- if (!(needsLinebreak)) { _v = false; $s = 25; continue s; }
- _r$7 = p.linebreak(parLineBeg, 0, ws, true); /* */ $s = 26; case 26: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _v = _r$7; case 25:
- /* */ if (_v) { $s = 22; continue; }
- /* */ if (i > 0) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (_v) { */ case 22:
- ws = 0;
- $s = 24; continue;
- /* } else if (i > 0) { */ case 23:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 24:
- /* */ if (par.Names.$length > 0) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (par.Names.$length > 0) { */ case 28:
- $r = p.identList(par.Names, ws === 62); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 29:
- $r = p.expr(stripParensAlways(par.Type)); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- prevLine = parLineEnd;
- _i++;
- /* } */ $s = 5; continue; case 6:
- _r$8 = p.lineFor(fields.Closing); /* */ $s = 33; case 33: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- closing = _r$8;
- /* */ if (0 < prevLine && prevLine < closing) { $s = 34; continue; }
- /* */ $s = 35; continue;
- /* if (0 < prevLine && prevLine < closing) { */ case 34:
- $r = p.print(new sliceType$1([new token.Token(52)])); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$9 = p.linebreak(closing, 0, 0, true); /* */ $s = 37; case 37: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$9;
- /* } */ case 35:
- /* */ if (ws === 0) { $s = 38; continue; }
- /* */ $s = 39; continue;
- /* if (ws === 0) { */ case 38:
- $r = p.print(new sliceType$1([new whiteSpace(60)])); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 39:
- /* } */ case 3:
- $r = p.print(new sliceType$1([new token.Pos(fields.Closing), new token.Token(54)])); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.parameters }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._v = _v; $f.closing = closing; $f.fields = fields; $f.i = i; $f.needsLinebreak = needsLinebreak; $f.p = p; $f.par = par; $f.parLineBeg = parLineBeg; $f.parLineEnd = parLineEnd; $f.prevLine = prevLine; $f.ws = ws; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.parameters = function(fields) { return this.$val.parameters(fields); };
- printer.ptr.prototype.signature = function(params, result) {
- var $ptr, n, p, params, result, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; n = $f.n; p = $f.p; params = $f.params; result = $f.result; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (!(params === ptrType$2.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(params === ptrType$2.nil)) { */ case 1:
- $r = p.parameters(params); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 3; continue;
- /* } else { */ case 2:
- $r = p.print(new sliceType$1([new token.Token(49), new token.Token(54)])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- n = result.NumFields();
- /* */ if (n > 0) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (n > 0) { */ case 6:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if ((n === 1) && (x = result.List, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Names === sliceType$4.nil) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if ((n === 1) && (x = result.List, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).Names === sliceType$4.nil) { */ case 9:
- $r = p.expr(stripParensAlways((x$1 = result.List, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])).Type)); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 10:
- $r = p.parameters(result); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.signature }; } $f.$ptr = $ptr; $f.n = n; $f.p = p; $f.params = params; $f.result = result; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.signature = function(params, result) { return this.$val.signature(params, result); };
- identListSize = function(list, maxSize) {
- var $ptr, _i, _ref, i, list, maxSize, size, x;
- size = 0;
- _ref = list;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (i > 0) {
- size = size + (2) >> 0;
- }
- size = size + (utf8.RuneCountInString(x.Name)) >> 0;
- if (size >= maxSize) {
- break;
- }
- _i++;
- }
- return size;
- };
- printer.ptr.prototype.isOneLineFieldList = function(list) {
- var $ptr, _r, f, list, namesSize, p, typeSize, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; list = $f.list; namesSize = $f.namesSize; p = $f.p; typeSize = $f.typeSize; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- if (!((list.$length === 1))) {
- return false;
- }
- f = (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]);
- if (!(f.Tag === ptrType$4.nil) || !(f.Comment === ptrType.nil)) {
- return false;
- }
- namesSize = identListSize(f.Names, 30);
- if (namesSize > 0) {
- namesSize = 1;
- }
- _r = p.nodeSize(f.Type, 30); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- typeSize = _r;
- return (namesSize + typeSize >> 0) <= 30;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.isOneLineFieldList }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.list = list; $f.namesSize = namesSize; $f.p = p; $f.typeSize = typeSize; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.isOneLineFieldList = function(list) { return this.$val.isOneLineFieldList(list); };
- printer.ptr.prototype.setLineComment = function(text) {
- var $ptr, p, text, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; text = $f.text; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.setComment(new ast.CommentGroup.ptr(new sliceType$5([new ast.Comment.ptr(0, text)]))); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.setLineComment }; } $f.$ptr = $ptr; $f.p = p; $f.text = text; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.setLineComment = function(text) { return this.$val.setLineComment(text); };
- printer.ptr.prototype.fieldList = function(fields, isStruct, isIncomplete) {
- var $ptr, _i, _i$1, _i$2, _r, _r$1, _r$10, _r$11, _r$12, _r$13, _r$14, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _tuple, _v, _v$1, _v$2, extraTabs, f, f$1, f$2, fields, ftyp, hasComments, i, i$1, i$2, isFtyp, isIncomplete, isStruct, lbrace, line, line$1, list, p, rbrace, sep, srcIsOneLine, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _r = $f._r; _r$1 = $f._r$1; _r$10 = $f._r$10; _r$11 = $f._r$11; _r$12 = $f._r$12; _r$13 = $f._r$13; _r$14 = $f._r$14; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; _v = $f._v; _v$1 = $f._v$1; _v$2 = $f._v$2; extraTabs = $f.extraTabs; f = $f.f; f$1 = $f.f$1; f$2 = $f.f$2; fields = $f.fields; ftyp = $f.ftyp; hasComments = $f.hasComments; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; isFtyp = $f.isFtyp; isIncomplete = $f.isIncomplete; isStruct = $f.isStruct; lbrace = $f.lbrace; line = $f.line; line$1 = $f.line$1; list = $f.list; p = $f.p; rbrace = $f.rbrace; sep = $f.sep; srcIsOneLine = $f.srcIsOneLine; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- line = [line];
- line$1 = [line$1];
- p = this;
- lbrace = fields.Opening;
- list = fields.List;
- rbrace = fields.Closing;
- if (isIncomplete) { _v = true; $s = 1; continue s; }
- _r = p.posFor(rbrace); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.commentBefore(_r); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1; case 1:
- hasComments = _v;
- if (!(new token.Pos(lbrace).IsValid() && new token.Pos(rbrace).IsValid())) { _v$1 = false; $s = 4; continue s; }
- _r$2 = p.lineFor(lbrace); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.lineFor(rbrace); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _v$1 = _r$2 === _r$3; case 4:
- srcIsOneLine = _v$1;
- /* */ if (!hasComments && srcIsOneLine) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!hasComments && srcIsOneLine) { */ case 7:
- /* */ if (list.$length === 0) { $s = 9; continue; }
- if (!(isStruct)) { _v$2 = false; $s = 12; continue s; }
- _r$4 = p.isOneLineFieldList(list); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _v$2 = _r$4; case 12:
- /* */ if (_v$2) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (list.$length === 0) { */ case 9:
- $r = p.print(new sliceType$1([new token.Pos(lbrace), new token.Token(51), new token.Pos(rbrace), new token.Token(56)])); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- $s = 11; continue;
- /* } else if (_v$2) { */ case 10:
- $r = p.print(new sliceType$1([new token.Pos(lbrace), new token.Token(51), new whiteSpace(32)])); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- f = (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]);
- _ref = f.Names;
- _i = 0;
- /* while (true) { */ case 16:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 17; continue; }
- i = _i;
- x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (i > 0) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (i > 0) { */ case 18:
- $r = p.print(new sliceType$1([new token.Token(52), new whiteSpace(32)])); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 19:
- $r = p.expr(x); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 16; continue; case 17:
- /* */ if (f.Names.$length > 0) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (f.Names.$length > 0) { */ case 22:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 23:
- $r = p.expr(f.Type); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Pos(rbrace), new token.Token(56)])); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 11:
- /* } */ case 8:
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Pos(lbrace), new token.Token(51), new whiteSpace(62)])); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (hasComments || list.$length > 0) { $s = 28; continue; }
- /* */ $s = 29; continue;
- /* if (hasComments || list.$length > 0) { */ case 28:
- $r = p.print(new sliceType$1([new whiteSpace(12)])); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 29:
- /* */ if (isStruct) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (isStruct) { */ case 31:
- sep = 11;
- if (list.$length === 1) {
- sep = 32;
- }
- line[0] = 0;
- _ref$1 = list;
- _i$1 = 0;
- /* while (true) { */ case 34:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 35; continue; }
- i$1 = _i$1;
- f$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- /* */ if (i$1 > 0) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (i$1 > 0) { */ case 36:
- _r$5 = f$1.Pos(); /* */ $s = 38; case 38: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = p.lineFor(_r$5); /* */ $s = 39; case 39: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = p.linebreak(_r$6, 1, 0, p.linesFrom(line[0]) > 0); /* */ $s = 40; case 40: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _r$7;
- /* } */ case 37:
- extraTabs = 0;
- $r = p.setComment(f$1.Doc); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.recordLine((line.$ptr || (line.$ptr = new ptrType$6(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, line))));
- /* */ if (f$1.Names.$length > 0) { $s = 42; continue; }
- /* */ $s = 43; continue;
- /* if (f$1.Names.$length > 0) { */ case 42:
- $r = p.identList(f$1.Names, false); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(sep)])); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(f$1.Type); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = 1;
- $s = 44; continue;
- /* } else { */ case 43:
- $r = p.expr(f$1.Type); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = 2;
- /* } */ case 44:
- /* */ if (!(f$1.Tag === ptrType$4.nil)) { $s = 49; continue; }
- /* */ $s = 50; continue;
- /* if (!(f$1.Tag === ptrType$4.nil)) { */ case 49:
- /* */ if (f$1.Names.$length > 0 && (sep === 11)) { $s = 51; continue; }
- /* */ $s = 52; continue;
- /* if (f$1.Names.$length > 0 && (sep === 11)) { */ case 51:
- $r = p.print(new sliceType$1([new whiteSpace(sep)])); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 52:
- $r = p.print(new sliceType$1([new whiteSpace(sep)])); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(f$1.Tag); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = 0;
- /* } */ case 50:
- /* */ if (!(f$1.Comment === ptrType.nil)) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if (!(f$1.Comment === ptrType.nil)) { */ case 56:
- /* while (true) { */ case 58:
- /* if (!(extraTabs > 0)) { break; } */ if(!(extraTabs > 0)) { $s = 59; continue; }
- $r = p.print(new sliceType$1([new whiteSpace(sep)])); /* */ $s = 60; case 60: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = extraTabs - (1) >> 0;
- /* } */ $s = 58; continue; case 59:
- $r = p.setComment(f$1.Comment); /* */ $s = 61; case 61: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 57:
- _i$1++;
- /* } */ $s = 34; continue; case 35:
- /* */ if (isIncomplete) { $s = 62; continue; }
- /* */ $s = 63; continue;
- /* if (isIncomplete) { */ case 62:
- /* */ if (list.$length > 0) { $s = 64; continue; }
- /* */ $s = 65; continue;
- /* if (list.$length > 0) { */ case 64:
- $r = p.print(new sliceType$1([new whiteSpace(12)])); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 65:
- _r$8 = p.posFor(rbrace); /* */ $s = 67; case 67: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _r$9 = p.flush(_r$8, 56); /* */ $s = 68; case 68: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$9;
- $r = p.setLineComment("// contains filtered or unexported fields"); /* */ $s = 69; case 69: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 63:
- $s = 33; continue;
- /* } else { */ case 32:
- line$1[0] = 0;
- _ref$2 = list;
- _i$2 = 0;
- /* while (true) { */ case 70:
- /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 71; continue; }
- i$2 = _i$2;
- f$2 = ((_i$2 < 0 || _i$2 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$2]);
- /* */ if (i$2 > 0) { $s = 72; continue; }
- /* */ $s = 73; continue;
- /* if (i$2 > 0) { */ case 72:
- _r$10 = f$2.Pos(); /* */ $s = 74; case 74: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _r$11 = p.lineFor(_r$10); /* */ $s = 75; case 75: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- _r$12 = p.linebreak(_r$11, 1, 0, p.linesFrom(line$1[0]) > 0); /* */ $s = 76; case 76: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; }
- _r$12;
- /* } */ case 73:
- $r = p.setComment(f$2.Doc); /* */ $s = 77; case 77: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.recordLine((line$1.$ptr || (line$1.$ptr = new ptrType$6(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, line$1))));
- _tuple = $assertType(f$2.Type, ptrType$7, true); ftyp = _tuple[0]; isFtyp = _tuple[1];
- /* */ if (isFtyp) { $s = 78; continue; }
- /* */ $s = 79; continue;
- /* if (isFtyp) { */ case 78:
- $r = p.expr((x$1 = f$2.Names, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0]))); /* */ $s = 81; case 81: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.signature(ftyp.Params, ftyp.Results); /* */ $s = 82; case 82: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 80; continue;
- /* } else { */ case 79:
- $r = p.expr(f$2.Type); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 80:
- $r = p.setComment(f$2.Comment); /* */ $s = 84; case 84: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$2++;
- /* } */ $s = 70; continue; case 71:
- /* */ if (isIncomplete) { $s = 85; continue; }
- /* */ $s = 86; continue;
- /* if (isIncomplete) { */ case 85:
- /* */ if (list.$length > 0) { $s = 87; continue; }
- /* */ $s = 88; continue;
- /* if (list.$length > 0) { */ case 87:
- $r = p.print(new sliceType$1([new whiteSpace(12)])); /* */ $s = 89; case 89: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 88:
- _r$13 = p.posFor(rbrace); /* */ $s = 90; case 90: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; }
- _r$14 = p.flush(_r$13, 56); /* */ $s = 91; case 91: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; }
- _r$14;
- $r = p.setLineComment("// contains filtered or unexported methods"); /* */ $s = 92; case 92: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 86:
- /* } */ case 33:
- $r = p.print(new sliceType$1([new whiteSpace(60), new whiteSpace(12), new token.Pos(rbrace), new token.Token(56)])); /* */ $s = 93; case 93: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.fieldList }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._r = _r; $f._r$1 = _r$1; $f._r$10 = _r$10; $f._r$11 = _r$11; $f._r$12 = _r$12; $f._r$13 = _r$13; $f._r$14 = _r$14; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f._v = _v; $f._v$1 = _v$1; $f._v$2 = _v$2; $f.extraTabs = extraTabs; $f.f = f; $f.f$1 = f$1; $f.f$2 = f$2; $f.fields = fields; $f.ftyp = ftyp; $f.hasComments = hasComments; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.isFtyp = isFtyp; $f.isIncomplete = isIncomplete; $f.isStruct = isStruct; $f.lbrace = lbrace; $f.line = line; $f.line$1 = line$1; $f.list = list; $f.p = p; $f.rbrace = rbrace; $f.sep = sep; $f.srcIsOneLine = srcIsOneLine; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.fieldList = function(fields, isStruct, isIncomplete) { return this.$val.fieldList(fields, isStruct, isIncomplete); };
- walkBinary = function(e) {
- var $ptr, _ref, _ref$1, _ref$2, _ref$3, _tuple, _tuple$1, e, h4, h4$1, h5, h5$1, has4, has5, l, maxProblem, mp, mp$1, r, r$1, r$2;
- has4 = false;
- has5 = false;
- maxProblem = 0;
- _ref = new token.Token(e.Op).Precedence();
- if (_ref === 4) {
- has4 = true;
- } else if (_ref === 5) {
- has5 = true;
- }
- _ref$1 = e.X;
- switch (0) { default: if ($assertType(_ref$1, ptrType$8, true)[1]) {
- l = _ref$1.$val;
- if (new token.Token(l.Op).Precedence() < new token.Token(e.Op).Precedence()) {
- break;
- }
- _tuple = walkBinary(l); h4 = _tuple[0]; h5 = _tuple[1]; mp = _tuple[2];
- has4 = has4 || h4;
- has5 = has5 || h5;
- if (maxProblem < mp) {
- maxProblem = mp;
- }
- } }
- _ref$2 = e.Y;
- switch (0) { default: if ($assertType(_ref$2, ptrType$8, true)[1]) {
- r = _ref$2.$val;
- if (new token.Token(r.Op).Precedence() <= new token.Token(e.Op).Precedence()) {
- break;
- }
- _tuple$1 = walkBinary(r); h4$1 = _tuple$1[0]; h5$1 = _tuple$1[1]; mp$1 = _tuple$1[2];
- has4 = has4 || h4$1;
- has5 = has5 || h5$1;
- if (maxProblem < mp$1) {
- maxProblem = mp$1;
- }
- } else if ($assertType(_ref$2, ptrType$9, true)[1]) {
- r$1 = _ref$2.$val;
- if (e.Op === 15) {
- maxProblem = 5;
- }
- } else if ($assertType(_ref$2, ptrType$10, true)[1]) {
- r$2 = _ref$2.$val;
- _ref$3 = new token.Token(e.Op).String() + new token.Token(r$2.Op).String();
- if (_ref$3 === "/*" || _ref$3 === "&&" || _ref$3 === "&^") {
- maxProblem = 5;
- } else if (_ref$3 === "++" || _ref$3 === "--") {
- if (maxProblem < 4) {
- maxProblem = 4;
- }
- }
- } }
- return [has4, has5, maxProblem];
- };
- cutoff = function(e, depth) {
- var $ptr, _tuple, depth, e, has4, has5, maxProblem;
- _tuple = walkBinary(e); has4 = _tuple[0]; has5 = _tuple[1]; maxProblem = _tuple[2];
- if (maxProblem > 0) {
- return maxProblem + 1 >> 0;
- }
- if (has4 && has5) {
- if (depth === 1) {
- return 5;
- }
- return 4;
- }
- if (depth === 1) {
- return 6;
- }
- return 4;
- };
- diffPrec = function(expr, prec) {
- var $ptr, _tuple, expr, ok, prec, x;
- _tuple = $assertType(expr, ptrType$8, true); x = _tuple[0]; ok = _tuple[1];
- if (!ok || !((prec === new token.Token(x.Op).Precedence()))) {
- return 1;
- }
- return 0;
- };
- reduceDepth = function(depth) {
- var $ptr, depth;
- depth = depth - (1) >> 0;
- if (depth < 1) {
- depth = 1;
- }
- return depth;
- };
- printer.ptr.prototype.binaryExpr = function(x, prec1, cutoff$1, depth) {
- var $ptr, _r, _r$1, _r$2, cutoff$1, depth, p, prec, prec1, printBlank, ws, x, xline, yline, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; cutoff$1 = $f.cutoff$1; depth = $f.depth; p = $f.p; prec = $f.prec; prec1 = $f.prec1; printBlank = $f.printBlank; ws = $f.ws; x = $f.x; xline = $f.xline; yline = $f.yline; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- prec = new token.Token(x.Op).Precedence();
- /* */ if (prec < prec1) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (prec < prec1) { */ case 1:
- $r = p.print(new sliceType$1([new token.Token(49)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr0(x, reduceDepth(depth)); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(54)])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- printBlank = prec < cutoff$1;
- ws = 62;
- $r = p.expr1(x.X, prec, depth + diffPrec(x.X, prec) >> 0); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (printBlank) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (printBlank) { */ case 7:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- xline = p.pos.Line;
- _r = x.Y.Pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.lineFor(_r); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- yline = _r$1;
- $r = p.print(new sliceType$1([new token.Pos(x.OpPos), new token.Token(x.Op)])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!((xline === yline)) && xline > 0 && yline > 0) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!((xline === yline)) && xline > 0 && yline > 0) { */ case 13:
- _r$2 = p.linebreak(yline, 1, ws, true); /* */ $s = 17; case 17: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- /* */ if (_r$2) { $s = 15; continue; }
- /* */ $s = 16; continue;
- /* if (_r$2) { */ case 15:
- ws = 0;
- printBlank = false;
- /* } */ case 16:
- /* } */ case 14:
- /* */ if (printBlank) { $s = 18; continue; }
- /* */ $s = 19; continue;
- /* if (printBlank) { */ case 18:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 19:
- $r = p.expr1(x.Y, prec + 1 >> 0, depth + 1 >> 0); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (ws === 0) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (ws === 0) { */ case 22:
- $r = p.print(new sliceType$1([new whiteSpace(60)])); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 23:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.binaryExpr }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.cutoff$1 = cutoff$1; $f.depth = depth; $f.p = p; $f.prec = prec; $f.prec1 = prec1; $f.printBlank = printBlank; $f.ws = ws; $f.x = x; $f.xline = xline; $f.yline = yline; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.binaryExpr = function(x, prec1, cutoff$1, depth) { return this.$val.binaryExpr(x, prec1, cutoff$1, depth); };
- isBinary = function(expr) {
- var $ptr, _tuple, expr, ok;
- _tuple = $assertType(expr, ptrType$8, true); ok = _tuple[1];
- return ok;
- };
- printer.ptr.prototype.expr1 = function(expr, prec1, depth) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _ref, _ref$1, _ref$2, _tuple, _tuple$1, _v, depth, expr, hasParens, i, indices, line, mode, ok, p, prec1, x, x$1, x$10, x$11, x$12, x$13, x$14, x$15, x$16, x$17, x$18, x$19, x$2, x$20, x$21, x$22, x$23, x$24, x$3, x$4, x$5, x$6, x$7, x$8, x$9, y, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; depth = $f.depth; expr = $f.expr; hasParens = $f.hasParens; i = $f.i; indices = $f.indices; line = $f.line; mode = $f.mode; ok = $f.ok; p = $f.p; prec1 = $f.prec1; x = $f.x; x$1 = $f.x$1; x$10 = $f.x$10; x$11 = $f.x$11; x$12 = $f.x$12; x$13 = $f.x$13; x$14 = $f.x$14; x$15 = $f.x$15; x$16 = $f.x$16; x$17 = $f.x$17; x$18 = $f.x$18; x$19 = $f.x$19; x$2 = $f.x$2; x$20 = $f.x$20; x$21 = $f.x$21; x$22 = $f.x$22; x$23 = $f.x$23; x$24 = $f.x$24; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = expr.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(_r)])); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = expr;
- /* */ if ($assertType(_ref, ptrType$11, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$3, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$8, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$1, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$9, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$10, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$4, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$12, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$13, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$14, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$15, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, ptrType$16, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$17, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$18, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, ptrType$19, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref, ptrType$20, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref, ptrType$21, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref, ptrType$22, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref, ptrType$7, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref, ptrType$23, true)[1]) { $s = 22; continue; }
- /* */ if ($assertType(_ref, ptrType$24, true)[1]) { $s = 23; continue; }
- /* */ if ($assertType(_ref, ptrType$25, true)[1]) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if ($assertType(_ref, ptrType$11, true)[1]) { */ case 3:
- x = _ref.$val;
- $r = p.print(new sliceType$1([new $String("BadExpr")])); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$3, true)[1]) { */ case 4:
- x$1 = _ref.$val;
- $r = p.print(new sliceType$1([x$1])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$8, true)[1]) { */ case 5:
- x$2 = _ref.$val;
- /* */ if (depth < 1) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (depth < 1) { */ case 29:
- $r = p.internalError(new sliceType$1([new $String("depth < 1:"), new $Int(depth)])); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- depth = 1;
- /* } */ case 30:
- $r = p.binaryExpr(x$2, prec1, cutoff(x$2, depth), depth); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$1, true)[1]) { */ case 6:
- x$3 = _ref.$val;
- $r = p.expr(x$3.Key); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(x$3.Colon), new token.Token(58), new whiteSpace(32)])); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$3.Value); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$9, true)[1]) { */ case 7:
- x$4 = _ref.$val;
- /* */ if (6 < prec1) { $s = 36; continue; }
- /* */ $s = 37; continue;
- /* if (6 < prec1) { */ case 36:
- $r = p.print(new sliceType$1([new token.Token(49)])); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(14)])); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$4.X); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(54)])); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 38; continue;
- /* } else { */ case 37:
- $r = p.print(new sliceType$1([new token.Token(14)])); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$4.X); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 38:
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$10, true)[1]) { */ case 8:
- x$5 = _ref.$val;
- /* */ if (6 < prec1) { $s = 45; continue; }
- /* */ $s = 46; continue;
- /* if (6 < prec1) { */ case 45:
- $r = p.print(new sliceType$1([new token.Token(49)])); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$5); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(54)])); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 47; continue;
- /* } else { */ case 46:
- $r = p.print(new sliceType$1([new token.Token(x$5.Op)])); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (x$5.Op === 79) { $s = 52; continue; }
- /* */ $s = 53; continue;
- /* if (x$5.Op === 79) { */ case 52:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 53:
- $r = p.expr1(x$5.X, 6, depth); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 47:
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$4, true)[1]) { */ case 9:
- x$6 = _ref.$val;
- $r = p.print(new sliceType$1([x$6])); /* */ $s = 56; case 56: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$12, true)[1]) { */ case 10:
- x$7 = _ref.$val;
- $r = p.expr(x$7.Type); /* */ $s = 57; case 57: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = x$7.Type.Pos(); /* */ $s = 58; case 58: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.distanceFrom(_r$1); /* */ $s = 59; case 59: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = p.adjBlock(_r$2, 32, x$7.Body); /* */ $s = 60; case 60: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$13, true)[1]) { */ case 11:
- x$8 = _ref.$val;
- _tuple = $assertType(x$8.X, ptrType$13, true); hasParens = _tuple[1];
- /* */ if (hasParens) { $s = 61; continue; }
- /* */ $s = 62; continue;
- /* if (hasParens) { */ case 61:
- $r = p.expr0(x$8.X, depth); /* */ $s = 64; case 64: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 63; continue;
- /* } else { */ case 62:
- $r = p.print(new sliceType$1([new token.Token(49)])); /* */ $s = 65; case 65: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr0(x$8.X, reduceDepth(depth)); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(x$8.Rparen), new token.Token(54)])); /* */ $s = 67; case 67: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 63:
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$14, true)[1]) { */ case 12:
- x$9 = _ref.$val;
- $r = p.expr1(x$9.X, 7, depth); /* */ $s = 68; case 68: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(53)])); /* */ $s = 69; case 69: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = p.lineFor(x$9.Sel.Pos()); /* */ $s = 70; case 70: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- line = _r$3;
- /* */ if (p.pos.IsValid() && p.pos.Line < line) { $s = 71; continue; }
- /* */ $s = 72; continue;
- /* if (p.pos.IsValid() && p.pos.Line < line) { */ case 71:
- $r = p.print(new sliceType$1([new whiteSpace(62), new whiteSpace(10), new token.Pos(x$9.Sel.Pos()), x$9.Sel, new whiteSpace(60)])); /* */ $s = 74; case 74: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 73; continue;
- /* } else { */ case 72:
- $r = p.print(new sliceType$1([new token.Pos(x$9.Sel.Pos()), x$9.Sel])); /* */ $s = 75; case 75: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 73:
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$15, true)[1]) { */ case 13:
- x$10 = _ref.$val;
- $r = p.expr1(x$10.X, 7, depth); /* */ $s = 76; case 76: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(53), new token.Pos(x$10.Lparen), new token.Token(49)])); /* */ $s = 77; case 77: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(x$10.Type, $ifaceNil))) { $s = 78; continue; }
- /* */ $s = 79; continue;
- /* if (!($interfaceIsEqual(x$10.Type, $ifaceNil))) { */ case 78:
- $r = p.expr(x$10.Type); /* */ $s = 81; case 81: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 80; continue;
- /* } else { */ case 79:
- $r = p.print(new sliceType$1([new token.Token(84)])); /* */ $s = 82; case 82: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 80:
- $r = p.print(new sliceType$1([new token.Pos(x$10.Rparen), new token.Token(54)])); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$16, true)[1]) { */ case 14:
- x$11 = _ref.$val;
- $r = p.expr1(x$11.X, 7, 1); /* */ $s = 84; case 84: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(x$11.Lbrack), new token.Token(50)])); /* */ $s = 85; case 85: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr0(x$11.Index, depth + 1 >> 0); /* */ $s = 86; case 86: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(x$11.Rbrack), new token.Token(55)])); /* */ $s = 87; case 87: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$17, true)[1]) { */ case 15:
- x$12 = _ref.$val;
- $r = p.expr1(x$12.X, 7, 1); /* */ $s = 88; case 88: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(x$12.Lbrack), new token.Token(50)])); /* */ $s = 89; case 89: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- indices = new sliceType$3([x$12.Low, x$12.High]);
- if (!($interfaceIsEqual(x$12.Max, $ifaceNil))) {
- indices = $append(indices, x$12.Max);
- }
- _ref$1 = indices;
- _i = 0;
- /* while (true) { */ case 90:
- /* if (!(_i < _ref$1.$length)) { break; } */ if(!(_i < _ref$1.$length)) { $s = 91; continue; }
- i = _i;
- y = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- /* */ if (i > 0) { $s = 92; continue; }
- /* */ $s = 93; continue;
- /* if (i > 0) { */ case 92:
- x$14 = (x$13 = i - 1 >> 0, ((x$13 < 0 || x$13 >= indices.$length) ? $throwRuntimeError("index out of range") : indices.$array[indices.$offset + x$13]));
- /* */ if (depth <= 1 && !($interfaceIsEqual(x$14, $ifaceNil)) && !($interfaceIsEqual(y, $ifaceNil)) && (isBinary(x$14) || isBinary(y))) { $s = 94; continue; }
- /* */ $s = 95; continue;
- /* if (depth <= 1 && !($interfaceIsEqual(x$14, $ifaceNil)) && !($interfaceIsEqual(y, $ifaceNil)) && (isBinary(x$14) || isBinary(y))) { */ case 94:
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Token(58), new whiteSpace(32)])); /* */ $s = 97; case 97: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 96; continue;
- /* } else { */ case 95:
- $r = p.print(new sliceType$1([new token.Token(58)])); /* */ $s = 98; case 98: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 96:
- /* } */ case 93:
- /* */ if (!($interfaceIsEqual(y, $ifaceNil))) { $s = 99; continue; }
- /* */ $s = 100; continue;
- /* if (!($interfaceIsEqual(y, $ifaceNil))) { */ case 99:
- $r = p.expr0(y, depth + 1 >> 0); /* */ $s = 101; case 101: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 100:
- _i++;
- /* } */ $s = 90; continue; case 91:
- $r = p.print(new sliceType$1([new token.Pos(x$12.Rbrack), new token.Token(55)])); /* */ $s = 102; case 102: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$18, true)[1]) { */ case 16:
- x$15 = _ref.$val;
- if (x$15.Args.$length > 1) {
- depth = depth + (1) >> 0;
- }
- _tuple$1 = $assertType(x$15.Fun, ptrType$7, true); ok = _tuple$1[1];
- /* */ if (ok) { $s = 103; continue; }
- /* */ $s = 104; continue;
- /* if (ok) { */ case 103:
- $r = p.print(new sliceType$1([new token.Token(49)])); /* */ $s = 106; case 106: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr1(x$15.Fun, 7, depth); /* */ $s = 107; case 107: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(54)])); /* */ $s = 108; case 108: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 105; continue;
- /* } else { */ case 104:
- $r = p.expr1(x$15.Fun, 7, depth); /* */ $s = 109; case 109: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 105:
- $r = p.print(new sliceType$1([new token.Pos(x$15.Lparen), new token.Token(49)])); /* */ $s = 110; case 110: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (new token.Pos(x$15.Ellipsis).IsValid()) { $s = 111; continue; }
- /* */ $s = 112; continue;
- /* if (new token.Pos(x$15.Ellipsis).IsValid()) { */ case 111:
- $r = p.exprList(x$15.Lparen, x$15.Args, depth, 0, x$15.Ellipsis); /* */ $s = 114; case 114: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(x$15.Ellipsis), new token.Token(48)])); /* */ $s = 115; case 115: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (!(new token.Pos(x$15.Rparen).IsValid())) { _v = false; $s = 118; continue s; }
- _r$4 = p.lineFor(x$15.Ellipsis); /* */ $s = 119; case 119: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.lineFor(x$15.Rparen); /* */ $s = 120; case 120: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _v = _r$4 < _r$5; case 118:
- /* */ if (_v) { $s = 116; continue; }
- /* */ $s = 117; continue;
- /* if (_v) { */ case 116:
- $r = p.print(new sliceType$1([new token.Token(52), new whiteSpace(12)])); /* */ $s = 121; case 121: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 117:
- $s = 113; continue;
- /* } else { */ case 112:
- $r = p.exprList(x$15.Lparen, x$15.Args, depth, 1, x$15.Rparen); /* */ $s = 122; case 122: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 113:
- $r = p.print(new sliceType$1([new token.Pos(x$15.Rparen), new token.Token(54)])); /* */ $s = 123; case 123: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$19, true)[1]) { */ case 17:
- x$16 = _ref.$val;
- /* */ if (!($interfaceIsEqual(x$16.Type, $ifaceNil))) { $s = 124; continue; }
- /* */ $s = 125; continue;
- /* if (!($interfaceIsEqual(x$16.Type, $ifaceNil))) { */ case 124:
- $r = p.expr1(x$16.Type, 7, depth); /* */ $s = 126; case 126: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 125:
- $r = p.print(new sliceType$1([new token.Pos(x$16.Lbrace), new token.Token(51)])); /* */ $s = 127; case 127: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.exprList(x$16.Lbrace, x$16.Elts, 1, 1, x$16.Rbrace); /* */ $s = 128; case 128: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- mode = 2;
- if (x$16.Elts.$length > 0) {
- mode = mode | (1);
- }
- $r = p.print(new sliceType$1([new pmode(mode), new token.Pos(x$16.Rbrace), new token.Token(56), new pmode(mode)])); /* */ $s = 129; case 129: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$20, true)[1]) { */ case 18:
- x$17 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(48)])); /* */ $s = 130; case 130: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(x$17.Elt, $ifaceNil))) { $s = 131; continue; }
- /* */ $s = 132; continue;
- /* if (!($interfaceIsEqual(x$17.Elt, $ifaceNil))) { */ case 131:
- $r = p.expr(x$17.Elt); /* */ $s = 133; case 133: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 132:
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$21, true)[1]) { */ case 19:
- x$18 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(50)])); /* */ $s = 134; case 134: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(x$18.Len, $ifaceNil))) { $s = 135; continue; }
- /* */ $s = 136; continue;
- /* if (!($interfaceIsEqual(x$18.Len, $ifaceNil))) { */ case 135:
- $r = p.expr(x$18.Len); /* */ $s = 137; case 137: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 136:
- $r = p.print(new sliceType$1([new token.Token(55)])); /* */ $s = 138; case 138: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$18.Elt); /* */ $s = 139; case 139: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$22, true)[1]) { */ case 20:
- x$19 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(82)])); /* */ $s = 140; case 140: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.fieldList(x$19.Fields, true, x$19.Incomplete); /* */ $s = 141; case 141: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$7, true)[1]) { */ case 21:
- x$20 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(71)])); /* */ $s = 142; case 142: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.signature(x$20.Params, x$20.Results); /* */ $s = 143; case 143: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$23, true)[1]) { */ case 22:
- x$21 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(76)])); /* */ $s = 144; case 144: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.fieldList(x$21.Methods, false, x$21.Incomplete); /* */ $s = 145; case 145: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$24, true)[1]) { */ case 23:
- x$22 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(77), new token.Token(50)])); /* */ $s = 146; case 146: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$22.Key); /* */ $s = 147; case 147: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(55)])); /* */ $s = 148; case 148: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$22.Value); /* */ $s = 149; case 149: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else if ($assertType(_ref, ptrType$25, true)[1]) { */ case 24:
- x$23 = _ref.$val;
- _ref$2 = x$23.Dir;
- /* */ if (_ref$2 === 3) { $s = 150; continue; }
- /* */ if (_ref$2 === 2) { $s = 151; continue; }
- /* */ if (_ref$2 === 1) { $s = 152; continue; }
- /* */ $s = 153; continue;
- /* if (_ref$2 === 3) { */ case 150:
- $r = p.print(new sliceType$1([new token.Token(63)])); /* */ $s = 154; case 154: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 153; continue;
- /* } else if (_ref$2 === 2) { */ case 151:
- $r = p.print(new sliceType$1([new token.Token(36), new token.Token(63)])); /* */ $s = 155; case 155: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 153; continue;
- /* } else if (_ref$2 === 1) { */ case 152:
- $r = p.print(new sliceType$1([new token.Token(63), new token.Pos(x$23.Arrow), new token.Token(36)])); /* */ $s = 156; case 156: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 153:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 157; case 157: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(x$23.Value); /* */ $s = 158; case 158: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 26; continue;
- /* } else { */ case 25:
- x$24 = _ref;
- $panic(new $String("unreachable"));
- /* } */ case 26:
- return;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.expr1 }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f.depth = depth; $f.expr = expr; $f.hasParens = hasParens; $f.i = i; $f.indices = indices; $f.line = line; $f.mode = mode; $f.ok = ok; $f.p = p; $f.prec1 = prec1; $f.x = x; $f.x$1 = x$1; $f.x$10 = x$10; $f.x$11 = x$11; $f.x$12 = x$12; $f.x$13 = x$13; $f.x$14 = x$14; $f.x$15 = x$15; $f.x$16 = x$16; $f.x$17 = x$17; $f.x$18 = x$18; $f.x$19 = x$19; $f.x$2 = x$2; $f.x$20 = x$20; $f.x$21 = x$21; $f.x$22 = x$22; $f.x$23 = x$23; $f.x$24 = x$24; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.y = y; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.expr1 = function(expr, prec1, depth) { return this.$val.expr1(expr, prec1, depth); };
- printer.ptr.prototype.expr0 = function(x, depth) {
- var $ptr, depth, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; depth = $f.depth; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.expr1(x, 0, depth); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.expr0 }; } $f.$ptr = $ptr; $f.depth = depth; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.expr0 = function(x, depth) { return this.$val.expr0(x, depth); };
- printer.ptr.prototype.expr = function(x) {
- var $ptr, p, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.expr1(x, 0, 1); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.expr }; } $f.$ptr = $ptr; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.expr = function(x) { return this.$val.expr(x); };
- printer.ptr.prototype.stmtList = function(list, nindent, nextIsRBrace) {
- var $ptr, _i, _r, _r$1, _r$2, _ref, _tuple, _tuple$1, i, isEmpty, line, list, lt, nextIsRBrace, nindent, p, s, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; i = $f.i; isEmpty = $f.isEmpty; line = $f.line; list = $f.list; lt = $f.lt; nextIsRBrace = $f.nextIsRBrace; nindent = $f.nindent; p = $f.p; s = $f.s; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- line = [line];
- p = this;
- /* */ if (nindent > 0) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (nindent > 0) { */ case 1:
- $r = p.print(new sliceType$1([new whiteSpace(62)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- line[0] = 0;
- i = 0;
- _ref = list;
- _i = 0;
- /* while (true) { */ case 4:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 5; continue; }
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _tuple = $assertType(s, ptrType$26, true); isEmpty = _tuple[1];
- /* */ if (!isEmpty) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!isEmpty) { */ case 6:
- /* */ if (p.output.$length > 0) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (p.output.$length > 0) { */ case 8:
- _r = s.Pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.lineFor(_r); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.linebreak(_r$1, 1, 0, (i === 0) || (nindent === 0) || p.linesFrom(line[0]) > 0); /* */ $s = 12; case 12: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* } */ case 9:
- p.recordLine((line.$ptr || (line.$ptr = new ptrType$6(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, line))));
- $r = p.stmt(s, nextIsRBrace && (i === (list.$length - 1 >> 0))); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- t = s;
- while (true) {
- _tuple$1 = $assertType(t, ptrType$27, true); lt = _tuple$1[0];
- if (lt === ptrType$27.nil) {
- break;
- }
- line[0] = line[0] + (1) >> 0;
- t = lt.Stmt;
- }
- i = i + (1) >> 0;
- /* } */ case 7:
- _i++;
- /* } */ $s = 4; continue; case 5:
- /* */ if (nindent > 0) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (nindent > 0) { */ case 14:
- $r = p.print(new sliceType$1([new whiteSpace(60)])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.stmtList }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.i = i; $f.isEmpty = isEmpty; $f.line = line; $f.list = list; $f.lt = lt; $f.nextIsRBrace = nextIsRBrace; $f.nindent = nindent; $f.p = p; $f.s = s; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.stmtList = function(list, nindent, nextIsRBrace) { return this.$val.stmtList(list, nindent, nextIsRBrace); };
- printer.ptr.prototype.block = function(b, nindent) {
- var $ptr, _r, _r$1, b, nindent, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; b = $f.b; nindent = $f.nindent; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.print(new sliceType$1([new token.Pos(b.Lbrace), new token.Token(51)])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.stmtList(b.List, nindent, true); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = p.lineFor(b.Rbrace); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.linebreak(_r, 1, 0, true); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- $r = p.print(new sliceType$1([new token.Pos(b.Rbrace), new token.Token(56)])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.block }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.b = b; $f.nindent = nindent; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.block = function(b, nindent) { return this.$val.block(b, nindent); };
- isTypeName = function(x) {
- var $ptr, _ref, t, t$1, x;
- _ref = x;
- if ($assertType(_ref, ptrType$3, true)[1]) {
- t = _ref.$val;
- return true;
- } else if ($assertType(_ref, ptrType$14, true)[1]) {
- t$1 = _ref.$val;
- return isTypeName(t$1.X);
- }
- return false;
- };
- stripParens = function(x) {
- var $ptr, _r, _tuple, px, strip, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; px = $f.px; strip = $f.strip; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- strip = [strip];
- _tuple = $assertType(x, ptrType$13, true); px = _tuple[0]; strip[0] = _tuple[1];
- /* */ if (strip[0]) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (strip[0]) { */ case 1:
- $r = ast.Inspect(px.X, (function(strip) { return function(node) {
- var $ptr, _ref, node, x$1, x$2;
- _ref = node;
- if ($assertType(_ref, ptrType$13, true)[1]) {
- x$1 = _ref.$val;
- return false;
- } else if ($assertType(_ref, ptrType$19, true)[1]) {
- x$2 = _ref.$val;
- if (isTypeName(x$2.Type)) {
- strip[0] = false;
- }
- return false;
- }
- return true;
- }; })(strip)); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (strip[0]) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (strip[0]) { */ case 4:
- _r = stripParens(px.X); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* } */ case 5:
- /* } */ case 2:
- return x;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: stripParens }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.px = px; $f.strip = strip; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- stripParensAlways = function(x) {
- var $ptr, _tuple, ok, x, x$1;
- _tuple = $assertType(x, ptrType$13, true); x$1 = _tuple[0]; ok = _tuple[1];
- if (ok) {
- return stripParensAlways(x$1.X);
- }
- return x;
- };
- printer.ptr.prototype.controlClause = function(isForStmt, init, expr, post) {
- var $ptr, _r, _r$1, expr, init, isForStmt, needsBlank, p, post, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; expr = $f.expr; init = $f.init; isForStmt = $f.isForStmt; needsBlank = $f.needsBlank; p = $f.p; post = $f.post; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- needsBlank = false;
- /* */ if ($interfaceIsEqual(init, $ifaceNil) && $interfaceIsEqual(post, $ifaceNil)) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if ($interfaceIsEqual(init, $ifaceNil) && $interfaceIsEqual(post, $ifaceNil)) { */ case 2:
- /* */ if (!($interfaceIsEqual(expr, $ifaceNil))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!($interfaceIsEqual(expr, $ifaceNil))) { */ case 5:
- _r = stripParens(expr); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.expr(_r); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- needsBlank = true;
- /* } */ case 6:
- $s = 4; continue;
- /* } else { */ case 3:
- /* */ if (!($interfaceIsEqual(init, $ifaceNil))) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!($interfaceIsEqual(init, $ifaceNil))) { */ case 9:
- $r = p.stmt(init, false); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- $r = p.print(new sliceType$1([new token.Token(57), new whiteSpace(32)])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(expr, $ifaceNil))) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!($interfaceIsEqual(expr, $ifaceNil))) { */ case 13:
- _r$1 = stripParens(expr); /* */ $s = 15; case 15: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- $r = p.expr(_r$1); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- needsBlank = true;
- /* } */ case 14:
- /* */ if (isForStmt) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (isForStmt) { */ case 17:
- $r = p.print(new sliceType$1([new token.Token(57), new whiteSpace(32)])); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- needsBlank = false;
- /* */ if (!($interfaceIsEqual(post, $ifaceNil))) { $s = 20; continue; }
- /* */ $s = 21; continue;
- /* if (!($interfaceIsEqual(post, $ifaceNil))) { */ case 20:
- $r = p.stmt(post, false); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- needsBlank = true;
- /* } */ case 21:
- /* } */ case 18:
- /* } */ case 4:
- /* */ if (needsBlank) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (needsBlank) { */ case 23:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 24:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.controlClause }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.expr = expr; $f.init = init; $f.isForStmt = isForStmt; $f.needsBlank = needsBlank; $f.p = p; $f.post = post; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.controlClause = function(isForStmt, init, expr, post) { return this.$val.controlClause(isForStmt, init, expr, post); };
- printer.ptr.prototype.indentList = function(list) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _ref, b, e, line, list, n, p, x, x$1, xb, xe, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _ref = $f._ref; b = $f.b; e = $f.e; line = $f.line; list = $f.list; n = $f.n; p = $f.p; x = $f.x; x$1 = $f.x$1; xb = $f.xb; xe = $f.xe; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (list.$length >= 2) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (list.$length >= 2) { */ case 1:
- _r = (0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]).Pos(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.lineFor(_r); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- b = _r$1;
- _r$2 = (x = list.$length - 1 >> 0, ((x < 0 || x >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + x])).End(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.lineFor(_r$2); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- e = _r$3;
- /* */ if (0 < b && b < e) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (0 < b && b < e) { */ case 7:
- n = 0;
- line = b;
- _ref = list;
- _i = 0;
- /* while (true) { */ case 9:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 10; continue; }
- x$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$4 = x$1.Pos(); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.lineFor(_r$4); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- xb = _r$5;
- _r$6 = x$1.End(); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = p.lineFor(_r$6); /* */ $s = 14; case 14: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- xe = _r$7;
- if (line < xb) {
- return true;
- }
- if (xb < xe) {
- n = n + (1) >> 0;
- }
- line = xe;
- _i++;
- /* } */ $s = 9; continue; case 10:
- return n > 1;
- /* } */ case 8:
- /* } */ case 2:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.indentList }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._ref = _ref; $f.b = b; $f.e = e; $f.line = line; $f.list = list; $f.n = n; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.xb = xb; $f.xe = xe; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.indentList = function(list) { return this.$val.indentList(list); };
- printer.ptr.prototype.stmt = function(stmt, nextIsRBrace) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _tuple, _v, body, depth, e, isEmpty, nextIsRBrace, p, s, s$1, s$10, s$11, s$12, s$13, s$14, s$15, s$16, s$17, s$18, s$19, s$2, s$20, s$21, s$3, s$4, s$5, s$6, s$7, s$8, s$9, stmt, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _v = $f._v; body = $f.body; depth = $f.depth; e = $f.e; isEmpty = $f.isEmpty; nextIsRBrace = $f.nextIsRBrace; p = $f.p; s = $f.s; s$1 = $f.s$1; s$10 = $f.s$10; s$11 = $f.s$11; s$12 = $f.s$12; s$13 = $f.s$13; s$14 = $f.s$14; s$15 = $f.s$15; s$16 = $f.s$16; s$17 = $f.s$17; s$18 = $f.s$18; s$19 = $f.s$19; s$2 = $f.s$2; s$20 = $f.s$20; s$21 = $f.s$21; s$3 = $f.s$3; s$4 = $f.s$4; s$5 = $f.s$5; s$6 = $f.s$6; s$7 = $f.s$7; s$8 = $f.s$8; s$9 = $f.s$9; stmt = $f.stmt; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = stmt.Pos(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(_r)])); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = stmt;
- /* */ if ($assertType(_ref, ptrType$28, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref, ptrType$29, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref, ptrType$26, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref, ptrType$27, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref, ptrType$30, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref, ptrType$31, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref, ptrType$32, true)[1]) { $s = 9; continue; }
- /* */ if ($assertType(_ref, ptrType$33, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ptrType$34, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ptrType$35, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ptrType$36, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, ptrType$37, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, ptrType$38, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$39, true)[1]) { $s = 16; continue; }
- /* */ if ($assertType(_ref, ptrType$40, true)[1]) { $s = 17; continue; }
- /* */ if ($assertType(_ref, ptrType$41, true)[1]) { $s = 18; continue; }
- /* */ if ($assertType(_ref, ptrType$42, true)[1]) { $s = 19; continue; }
- /* */ if ($assertType(_ref, ptrType$43, true)[1]) { $s = 20; continue; }
- /* */ if ($assertType(_ref, ptrType$44, true)[1]) { $s = 21; continue; }
- /* */ if ($assertType(_ref, ptrType$45, true)[1]) { $s = 22; continue; }
- /* */ if ($assertType(_ref, ptrType$46, true)[1]) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* switch (0) { default: if ($assertType(_ref, ptrType$28, true)[1]) { */ case 3:
- s = _ref.$val;
- $r = p.print(new sliceType$1([new $String("BadStmt")])); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$29, true)[1]) { */ case 4:
- s$1 = _ref.$val;
- $r = p.decl(s$1.Decl); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$26, true)[1]) { */ case 5:
- s$2 = _ref.$val;
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$27, true)[1]) { */ case 6:
- s$3 = _ref.$val;
- $r = p.print(new sliceType$1([new whiteSpace(60)])); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(s$3.Label); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(s$3.Colon), new token.Token(58), new whiteSpace(62)])); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _tuple = $assertType(s$3.Stmt, ptrType$26, true); e = _tuple[0]; isEmpty = _tuple[1];
- /* */ if (isEmpty) { $s = 31; continue; }
- /* */ $s = 32; continue;
- /* if (isEmpty) { */ case 31:
- /* */ if (!nextIsRBrace) { $s = 34; continue; }
- /* */ $s = 35; continue;
- /* if (!nextIsRBrace) { */ case 34:
- $r = p.print(new sliceType$1([new whiteSpace(10), new token.Pos(e.Pos()), new token.Token(57)])); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* break; */ $s = 25; continue;
- /* } */ case 35:
- $s = 33; continue;
- /* } else { */ case 32:
- _r$1 = s$3.Stmt.Pos(); /* */ $s = 37; case 37: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.lineFor(_r$1); /* */ $s = 38; case 38: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.linebreak(_r$2, 1, 0, true); /* */ $s = 39; case 39: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* } */ case 33:
- $r = p.stmt(s$3.Stmt, nextIsRBrace); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$30, true)[1]) { */ case 7:
- s$4 = _ref.$val;
- $r = p.expr0(s$4.X, 1); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$31, true)[1]) { */ case 8:
- s$5 = _ref.$val;
- $r = p.expr0(s$5.Chan, 1); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Pos(s$5.Arrow), new token.Token(36), new whiteSpace(32)])); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr0(s$5.Value, 1); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$32, true)[1]) { */ case 9:
- s$6 = _ref.$val;
- $r = p.expr0(s$6.X, 2); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(s$6.TokPos), new token.Token(s$6.Tok)])); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$33, true)[1]) { */ case 10:
- s$7 = _ref.$val;
- depth = 1;
- if (s$7.Lhs.$length > 1 && s$7.Rhs.$length > 1) {
- depth = depth + (1) >> 0;
- }
- _r$4 = s$7.Pos(); /* */ $s = 47; case 47: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = p.exprList(_r$4, s$7.Lhs, depth, 0, s$7.TokPos); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Pos(s$7.TokPos), new token.Token(s$7.Tok), new whiteSpace(32)])); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.exprList(s$7.TokPos, s$7.Rhs, depth, 0, 0); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$34, true)[1]) { */ case 11:
- s$8 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(72), new whiteSpace(32)])); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(s$8.Call); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$35, true)[1]) { */ case 12:
- s$9 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(67), new whiteSpace(32)])); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(s$9.Call); /* */ $s = 54; case 54: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$36, true)[1]) { */ case 13:
- s$10 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(80)])); /* */ $s = 55; case 55: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(s$10.Results === sliceType$3.nil)) { $s = 56; continue; }
- /* */ $s = 57; continue;
- /* if (!(s$10.Results === sliceType$3.nil)) { */ case 56:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 58; case 58: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$5 = p.indentList(s$10.Results); /* */ $s = 62; case 62: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- /* */ if (_r$5) { $s = 59; continue; }
- /* */ $s = 60; continue;
- /* if (_r$5) { */ case 59:
- $r = p.print(new sliceType$1([new whiteSpace(62)])); /* */ $s = 63; case 63: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.exprList(s$10.Pos(), s$10.Results, 1, 2, 0); /* */ $s = 64; case 64: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(60)])); /* */ $s = 65; case 65: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 61; continue;
- /* } else { */ case 60:
- $r = p.exprList(s$10.Pos(), s$10.Results, 1, 0, 0); /* */ $s = 66; case 66: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 61:
- /* } */ case 57:
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$37, true)[1]) { */ case 14:
- s$11 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(s$11.Tok)])); /* */ $s = 67; case 67: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(s$11.Label === ptrType$3.nil)) { $s = 68; continue; }
- /* */ $s = 69; continue;
- /* if (!(s$11.Label === ptrType$3.nil)) { */ case 68:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 70; case 70: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(s$11.Label); /* */ $s = 71; case 71: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 69:
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$38, true)[1]) { */ case 15:
- s$12 = _ref.$val;
- $r = p.block(s$12, 1); /* */ $s = 72; case 72: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$39, true)[1]) { */ case 16:
- s$13 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(74)])); /* */ $s = 73; case 73: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.controlClause(false, s$13.Init, s$13.Cond, $ifaceNil); /* */ $s = 74; case 74: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.block(s$13.Body, 1); /* */ $s = 75; case 75: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$13.Else, $ifaceNil))) { $s = 76; continue; }
- /* */ $s = 77; continue;
- /* if (!($interfaceIsEqual(s$13.Else, $ifaceNil))) { */ case 76:
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Token(68), new whiteSpace(32)])); /* */ $s = 78; case 78: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref$1 = s$13.Else;
- /* */ if ($assertType(_ref$1, ptrType$38, true)[1] || $assertType(_ref$1, ptrType$39, true)[1]) { $s = 79; continue; }
- /* */ $s = 80; continue;
- /* if ($assertType(_ref$1, ptrType$38, true)[1] || $assertType(_ref$1, ptrType$39, true)[1]) { */ case 79:
- $r = p.stmt(s$13.Else, nextIsRBrace); /* */ $s = 82; case 82: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 81; continue;
- /* } else { */ case 80:
- $r = p.print(new sliceType$1([new token.Token(51), new whiteSpace(62), new whiteSpace(12)])); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.stmt(s$13.Else, true); /* */ $s = 84; case 84: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(60), new whiteSpace(12), new token.Token(56)])); /* */ $s = 85; case 85: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 81:
- /* } */ case 77:
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$40, true)[1]) { */ case 17:
- s$14 = _ref.$val;
- /* */ if (!(s$14.List === sliceType$3.nil)) { $s = 86; continue; }
- /* */ $s = 87; continue;
- /* if (!(s$14.List === sliceType$3.nil)) { */ case 86:
- $r = p.print(new sliceType$1([new token.Token(62), new whiteSpace(32)])); /* */ $s = 89; case 89: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.exprList(s$14.Pos(), s$14.List, 1, 0, s$14.Colon); /* */ $s = 90; case 90: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 88; continue;
- /* } else { */ case 87:
- $r = p.print(new sliceType$1([new token.Token(66)])); /* */ $s = 91; case 91: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 88:
- $r = p.print(new sliceType$1([new token.Pos(s$14.Colon), new token.Token(58)])); /* */ $s = 92; case 92: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.stmtList(s$14.Body, 1, nextIsRBrace); /* */ $s = 93; case 93: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$41, true)[1]) { */ case 18:
- s$15 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(83)])); /* */ $s = 94; case 94: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.controlClause(false, s$15.Init, s$15.Tag, $ifaceNil); /* */ $s = 95; case 95: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.block(s$15.Body, 0); /* */ $s = 96; case 96: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$42, true)[1]) { */ case 19:
- s$16 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(83)])); /* */ $s = 97; case 97: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$16.Init, $ifaceNil))) { $s = 98; continue; }
- /* */ $s = 99; continue;
- /* if (!($interfaceIsEqual(s$16.Init, $ifaceNil))) { */ case 98:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 100; case 100: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.stmt(s$16.Init, false); /* */ $s = 101; case 101: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Token(57)])); /* */ $s = 102; case 102: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 99:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 103; case 103: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.stmt(s$16.Assign, false); /* */ $s = 104; case 104: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 105; case 105: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.block(s$16.Body, 0); /* */ $s = 106; case 106: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$43, true)[1]) { */ case 20:
- s$17 = _ref.$val;
- /* */ if (!($interfaceIsEqual(s$17.Comm, $ifaceNil))) { $s = 107; continue; }
- /* */ $s = 108; continue;
- /* if (!($interfaceIsEqual(s$17.Comm, $ifaceNil))) { */ case 107:
- $r = p.print(new sliceType$1([new token.Token(62), new whiteSpace(32)])); /* */ $s = 110; case 110: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.stmt(s$17.Comm, false); /* */ $s = 111; case 111: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 109; continue;
- /* } else { */ case 108:
- $r = p.print(new sliceType$1([new token.Token(66)])); /* */ $s = 112; case 112: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 109:
- $r = p.print(new sliceType$1([new token.Pos(s$17.Colon), new token.Token(58)])); /* */ $s = 113; case 113: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.stmtList(s$17.Body, 1, nextIsRBrace); /* */ $s = 114; case 114: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$44, true)[1]) { */ case 21:
- s$18 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(81), new whiteSpace(32)])); /* */ $s = 115; case 115: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- body = s$18.Body;
- if (!(body.List.$length === 0)) { _v = false; $s = 119; continue s; }
- _r$6 = p.posFor(body.Rbrace); /* */ $s = 120; case 120: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$7 = p.commentBefore(_r$6); /* */ $s = 121; case 121: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _v = !_r$7; case 119:
- /* */ if (_v) { $s = 116; continue; }
- /* */ $s = 117; continue;
- /* if (_v) { */ case 116:
- $r = p.print(new sliceType$1([new token.Pos(body.Lbrace), new token.Token(51), new token.Pos(body.Rbrace), new token.Token(56)])); /* */ $s = 122; case 122: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 118; continue;
- /* } else { */ case 117:
- $r = p.block(body, 0); /* */ $s = 123; case 123: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 118:
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$45, true)[1]) { */ case 22:
- s$19 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(70)])); /* */ $s = 124; case 124: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.controlClause(true, s$19.Init, s$19.Cond, s$19.Post); /* */ $s = 125; case 125: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.block(s$19.Body, 1); /* */ $s = 126; case 126: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else if ($assertType(_ref, ptrType$46, true)[1]) { */ case 23:
- s$20 = _ref.$val;
- $r = p.print(new sliceType$1([new token.Token(70), new whiteSpace(32)])); /* */ $s = 127; case 127: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$20.Key, $ifaceNil))) { $s = 128; continue; }
- /* */ $s = 129; continue;
- /* if (!($interfaceIsEqual(s$20.Key, $ifaceNil))) { */ case 128:
- $r = p.expr(s$20.Key); /* */ $s = 130; case 130: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$20.Value, $ifaceNil))) { $s = 131; continue; }
- /* */ $s = 132; continue;
- /* if (!($interfaceIsEqual(s$20.Value, $ifaceNil))) { */ case 131:
- _r$8 = s$20.Value.Pos(); /* */ $s = 133; case 133: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(_r$8), new token.Token(52), new whiteSpace(32)])); /* */ $s = 134; case 134: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(s$20.Value); /* */ $s = 135; case 135: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 132:
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Pos(s$20.TokPos), new token.Token(s$20.Tok), new whiteSpace(32)])); /* */ $s = 136; case 136: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 129:
- $r = p.print(new sliceType$1([new token.Token(79), new whiteSpace(32)])); /* */ $s = 137; case 137: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$9 = stripParens(s$20.X); /* */ $s = 138; case 138: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- $r = p.expr(_r$9); /* */ $s = 139; case 139: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 140; case 140: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.block(s$20.Body, 1); /* */ $s = 141; case 141: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 25; continue;
- /* } else { */ case 24:
- s$21 = _ref;
- $panic(new $String("unreachable"));
- /* } } */ case 25:
- return;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.stmt }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._v = _v; $f.body = body; $f.depth = depth; $f.e = e; $f.isEmpty = isEmpty; $f.nextIsRBrace = nextIsRBrace; $f.p = p; $f.s = s; $f.s$1 = s$1; $f.s$10 = s$10; $f.s$11 = s$11; $f.s$12 = s$12; $f.s$13 = s$13; $f.s$14 = s$14; $f.s$15 = s$15; $f.s$16 = s$16; $f.s$17 = s$17; $f.s$18 = s$18; $f.s$19 = s$19; $f.s$2 = s$2; $f.s$20 = s$20; $f.s$21 = s$21; $f.s$3 = s$3; $f.s$4 = s$4; $f.s$5 = s$5; $f.s$6 = s$6; $f.s$7 = s$7; $f.s$8 = s$8; $f.s$9 = s$9; $f.stmt = stmt; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.stmt = function(stmt, nextIsRBrace) { return this.$val.stmt(stmt, nextIsRBrace); };
- keepTypeColumn = function(specs) {
- var $ptr, _i, _ref, i, i0, keepType, m, populate, s, specs, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; i = $f.i; i0 = $f.i0; keepType = $f.keepType; m = $f.m; populate = $f.populate; s = $f.s; specs = $f.specs; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- m = [m];
- m[0] = $makeSlice(sliceType$6, specs.$length);
- populate = (function(m) { return function(i, j, keepType) {
- var $ptr, i, j, keepType;
- if (keepType) {
- while (true) {
- if (!(i < j)) { break; }
- ((i < 0 || i >= m[0].$length) ? $throwRuntimeError("index out of range") : m[0].$array[m[0].$offset + i] = true);
- i = i + (1) >> 0;
- }
- }
- }; })(m);
- i0 = -1;
- keepType = false;
- _ref = specs;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- i = _i;
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- t = $assertType(s, ptrType$47);
- /* */ if (!(t.Values === sliceType$3.nil)) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!(t.Values === sliceType$3.nil)) { */ case 3:
- if (i0 < 0) {
- i0 = i;
- keepType = false;
- }
- $s = 5; continue;
- /* } else { */ case 4:
- /* */ if (i0 >= 0) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (i0 >= 0) { */ case 6:
- $r = populate(i0, i, keepType); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i0 = -1;
- /* } */ case 7:
- /* } */ case 5:
- if (!($interfaceIsEqual(t.Type, $ifaceNil))) {
- keepType = true;
- }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ if (i0 >= 0) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (i0 >= 0) { */ case 9:
- $r = populate(i0, specs.$length, keepType); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 10:
- return m[0];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: keepTypeColumn }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.i = i; $f.i0 = i0; $f.keepType = keepType; $f.m = m; $f.populate = populate; $f.s = s; $f.specs = specs; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.ptr.prototype.valueSpec = function(s, keepType) {
- var $ptr, extraTabs, keepType, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; extraTabs = $f.extraTabs; keepType = $f.keepType; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.setComment(s.Doc); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.identList(s.Names, false); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = 3;
- /* */ if (!($interfaceIsEqual(s.Type, $ifaceNil)) || keepType) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (!($interfaceIsEqual(s.Type, $ifaceNil)) || keepType) { */ case 3:
- $r = p.print(new sliceType$1([new whiteSpace(11)])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = extraTabs - (1) >> 0;
- /* } */ case 4:
- /* */ if (!($interfaceIsEqual(s.Type, $ifaceNil))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!($interfaceIsEqual(s.Type, $ifaceNil))) { */ case 6:
- $r = p.expr(s.Type); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 7:
- /* */ if (!(s.Values === sliceType$3.nil)) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!(s.Values === sliceType$3.nil)) { */ case 9:
- $r = p.print(new sliceType$1([new whiteSpace(11), new token.Token(42), new whiteSpace(32)])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.exprList(0, s.Values, 1, 0, 0); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = extraTabs - (1) >> 0;
- /* } */ case 10:
- /* */ if (!(s.Comment === ptrType.nil)) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (!(s.Comment === ptrType.nil)) { */ case 13:
- /* while (true) { */ case 15:
- /* if (!(extraTabs > 0)) { break; } */ if(!(extraTabs > 0)) { $s = 16; continue; }
- $r = p.print(new sliceType$1([new whiteSpace(11)])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- extraTabs = extraTabs - (1) >> 0;
- /* } */ $s = 15; continue; case 16:
- $r = p.setComment(s.Comment); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 14:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.valueSpec }; } $f.$ptr = $ptr; $f.extraTabs = extraTabs; $f.keepType = keepType; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.valueSpec = function(s, keepType) { return this.$val.valueSpec(s, keepType); };
- printer.ptr.prototype.spec = function(spec, n, doIndent) {
- var $ptr, _ref, doIndent, n, p, s, s$1, s$2, s$3, spec, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; doIndent = $f.doIndent; n = $f.n; p = $f.p; s = $f.s; s$1 = $f.s$1; s$2 = $f.s$2; s$3 = $f.s$3; spec = $f.spec; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = spec;
- /* */ if ($assertType(_ref, ptrType$48, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$47, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$49, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref, ptrType$48, true)[1]) { */ case 1:
- s = _ref.$val;
- $r = p.setComment(s.Doc); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(s.Name === ptrType$3.nil)) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (!(s.Name === ptrType$3.nil)) { */ case 7:
- $r = p.expr(s.Name); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- $r = p.expr(s.Path); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.setComment(s.Comment); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(s.EndPos)])); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else if ($assertType(_ref, ptrType$47, true)[1]) { */ case 2:
- s$1 = _ref.$val;
- /* */ if (!((n === 1))) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (!((n === 1))) { */ case 14:
- $r = p.internalError(new sliceType$1([new $String("expected n = 1; got"), new $Int(n)])); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- $r = p.setComment(s$1.Doc); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.identList(s$1.Names, doIndent); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!($interfaceIsEqual(s$1.Type, $ifaceNil))) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!($interfaceIsEqual(s$1.Type, $ifaceNil))) { */ case 19:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(s$1.Type); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- /* */ if (!(s$1.Values === sliceType$3.nil)) { $s = 23; continue; }
- /* */ $s = 24; continue;
- /* if (!(s$1.Values === sliceType$3.nil)) { */ case 23:
- $r = p.print(new sliceType$1([new whiteSpace(32), new token.Token(42), new whiteSpace(32)])); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.exprList(0, s$1.Values, 1, 0, 0); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 24:
- $r = p.setComment(s$1.Comment); /* */ $s = 27; case 27: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else if ($assertType(_ref, ptrType$49, true)[1]) { */ case 3:
- s$2 = _ref.$val;
- $r = p.setComment(s$2.Doc); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(s$2.Name); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (n === 1) { $s = 30; continue; }
- /* */ $s = 31; continue;
- /* if (n === 1) { */ case 30:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 32; continue;
- /* } else { */ case 31:
- $r = p.print(new sliceType$1([new whiteSpace(11)])); /* */ $s = 34; case 34: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 32:
- $r = p.expr(s$2.Type); /* */ $s = 35; case 35: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.setComment(s$2.Comment); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else { */ case 4:
- s$3 = _ref;
- $panic(new $String("unreachable"));
- /* } */ case 5:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.spec }; } $f.$ptr = $ptr; $f._ref = _ref; $f.doIndent = doIndent; $f.n = n; $f.p = p; $f.s = s; $f.s$1 = s$1; $f.s$2 = s$2; $f.s$3 = s$3; $f.spec = spec; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.spec = function(spec, n, doIndent) { return this.$val.spec(spec, n, doIndent); };
- printer.ptr.prototype.genDecl = function(d) {
- var $ptr, _i, _i$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _ref$1, d, i, i$1, keepType, line, line$1, n, p, s, s$1, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _ref = $f._ref; _ref$1 = $f._ref$1; d = $f.d; i = $f.i; i$1 = $f.i$1; keepType = $f.keepType; line = $f.line; line$1 = $f.line$1; n = $f.n; p = $f.p; s = $f.s; s$1 = $f.s$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- line = [line];
- line$1 = [line$1];
- p = this;
- $r = p.setComment(d.Doc); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(d.Pos()), new token.Token(d.Tok), new whiteSpace(32)])); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (new token.Pos(d.Lparen).IsValid()) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (new token.Pos(d.Lparen).IsValid()) { */ case 3:
- $r = p.print(new sliceType$1([new token.Pos(d.Lparen), new token.Token(49)])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = d.Specs.$length;
- /* */ if (n > 0) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (n > 0) { */ case 7:
- $r = p.print(new sliceType$1([new whiteSpace(62), new whiteSpace(12)])); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (n > 1 && ((d.Tok === 64) || (d.Tok === 85))) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (n > 1 && ((d.Tok === 64) || (d.Tok === 85))) { */ case 10:
- _r = keepTypeColumn(d.Specs); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- keepType = _r;
- line[0] = 0;
- _ref = d.Specs;
- _i = 0;
- /* while (true) { */ case 14:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 15; continue; }
- i = _i;
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (i > 0) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (i > 0) { */ case 16:
- _r$1 = s.Pos(); /* */ $s = 18; case 18: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.lineFor(_r$1); /* */ $s = 19; case 19: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.linebreak(_r$2, 1, 0, p.linesFrom(line[0]) > 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* } */ case 17:
- p.recordLine((line.$ptr || (line.$ptr = new ptrType$6(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, line))));
- $r = p.valueSpec($assertType(s, ptrType$47), ((i < 0 || i >= keepType.$length) ? $throwRuntimeError("index out of range") : keepType.$array[keepType.$offset + i])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 14; continue; case 15:
- $s = 12; continue;
- /* } else { */ case 11:
- line$1[0] = 0;
- _ref$1 = d.Specs;
- _i$1 = 0;
- /* while (true) { */ case 22:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 23; continue; }
- i$1 = _i$1;
- s$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- /* */ if (i$1 > 0) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (i$1 > 0) { */ case 24:
- _r$4 = s$1.Pos(); /* */ $s = 26; case 26: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = p.lineFor(_r$4); /* */ $s = 27; case 27: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _r$6 = p.linebreak(_r$5, 1, 0, p.linesFrom(line$1[0]) > 0); /* */ $s = 28; case 28: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _r$6;
- /* } */ case 25:
- p.recordLine((line$1.$ptr || (line$1.$ptr = new ptrType$6(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, line$1))));
- $r = p.spec(s$1, n, false); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i$1++;
- /* } */ $s = 22; continue; case 23:
- /* } */ case 12:
- $r = p.print(new sliceType$1([new whiteSpace(60), new whiteSpace(12)])); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- $r = p.print(new sliceType$1([new token.Pos(d.Rparen), new token.Token(54)])); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else { */ case 4:
- $r = p.spec((x = d.Specs, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])), 1, true); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.genDecl }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._ref = _ref; $f._ref$1 = _ref$1; $f.d = d; $f.i = i; $f.i$1 = i$1; $f.keepType = keepType; $f.line = line; $f.line$1 = line$1; $f.n = n; $f.p = p; $f.s = s; $f.s$1 = s$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.genDecl = function(d) { return this.$val.genDecl(d); };
- printer.ptr.prototype.nodeSize = function(n, maxSize) {
- var $ptr, _entry, _i, _key, _key$1, _r, _ref, _tuple, buf, cfg, ch, err, found, maxSize, n, p, size, size$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _key = $f._key; _key$1 = $f._key$1; _r = $f._r; _ref = $f._ref; _tuple = $f._tuple; buf = $f.buf; cfg = $f.cfg; ch = $f.ch; err = $f.err; found = $f.found; maxSize = $f.maxSize; n = $f.n; p = $f.p; size = $f.size; size$1 = $f.size$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- size = 0;
- p = this;
- _tuple = (_entry = p.nodeSizes[ast.Node.keyFor(n)], _entry !== undefined ? [_entry.v, true] : [0, false]); size$1 = _tuple[0]; found = _tuple[1];
- if (found) {
- size = size$1;
- return size;
- }
- size = maxSize + 1 >> 0;
- _key = n; (p.nodeSizes || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key)] = { k: _key, v: size };
- cfg = new Config.ptr(1, 0, 0);
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _r = cfg.fprint(buf[0], p.fset, n, p.nodeSizes); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- return size;
- /* } */ case 3:
- if (buf[0].Len() <= maxSize) {
- _ref = buf[0].Bytes();
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- ch = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (ch < 32) {
- return size;
- }
- _i++;
- }
- size = buf[0].Len();
- _key$1 = n; (p.nodeSizes || $throwRuntimeError("assignment to entry in nil map"))[ast.Node.keyFor(_key$1)] = { k: _key$1, v: size };
- }
- return size;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.nodeSize }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._key = _key; $f._key$1 = _key$1; $f._r = _r; $f._ref = _ref; $f._tuple = _tuple; $f.buf = buf; $f.cfg = cfg; $f.ch = ch; $f.err = err; $f.found = found; $f.maxSize = maxSize; $f.n = n; $f.p = p; $f.size = size; $f.size$1 = size$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.nodeSize = function(n, maxSize) { return this.$val.nodeSize(n, maxSize); };
- printer.ptr.prototype.bodySize = function(b, maxSize) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _ref, _v, b, bodySize, i, maxSize, p, pos1, pos2, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; _v = $f._v; b = $f.b; bodySize = $f.bodySize; i = $f.i; maxSize = $f.maxSize; p = $f.p; pos1 = $f.pos1; pos2 = $f.pos2; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- pos1 = b.Pos();
- pos2 = b.Rbrace;
- if (!(new token.Pos(pos1).IsValid() && new token.Pos(pos2).IsValid())) { _v = false; $s = 3; continue s; }
- _r = p.lineFor(pos1); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.lineFor(pos2); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = !((_r === _r$1)); case 3:
- /* */ if (_v) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (_v) { */ case 1:
- return maxSize + 1 >> 0;
- /* } */ case 2:
- if (b.List.$length > 5) {
- return maxSize + 1 >> 0;
- }
- _r$2 = p.posFor(pos2); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = p.commentSizeBefore(_r$2); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- bodySize = _r$3;
- _ref = b.List;
- _i = 0;
- /* while (true) { */ case 8:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 9; continue; }
- i = _i;
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (bodySize > maxSize) {
- /* break; */ $s = 9; continue;
- }
- if (i > 0) {
- bodySize = bodySize + (2) >> 0;
- }
- _r$4 = p.nodeSize(s, maxSize); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- bodySize = bodySize + (_r$4) >> 0;
- _i++;
- /* } */ $s = 8; continue; case 9:
- return bodySize;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.bodySize }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f._v = _v; $f.b = b; $f.bodySize = bodySize; $f.i = i; $f.maxSize = maxSize; $f.p = p; $f.pos1 = pos1; $f.pos2 = pos2; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.bodySize = function(b, maxSize) { return this.$val.bodySize(b, maxSize); };
- printer.ptr.prototype.adjBlock = function(headerSize, sep, b) {
- var $ptr, _i, _r, _ref, b, headerSize, i, p, s, sep, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; b = $f.b; headerSize = $f.headerSize; i = $f.i; p = $f.p; s = $f.s; sep = $f.sep; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- if (b === ptrType$38.nil) {
- return;
- }
- _r = p.bodySize(b, 100); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- /* */ if ((headerSize + _r >> 0) <= 100) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if ((headerSize + _r >> 0) <= 100) { */ case 1:
- $r = p.print(new sliceType$1([new whiteSpace(sep), new token.Pos(b.Lbrace), new token.Token(51)])); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (b.List.$length > 0) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (b.List.$length > 0) { */ case 5:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = b.List;
- _i = 0;
- /* while (true) { */ case 8:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 9; continue; }
- i = _i;
- s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- /* */ if (i > 0) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (i > 0) { */ case 10:
- $r = p.print(new sliceType$1([new token.Token(57), new whiteSpace(32)])); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 11:
- $r = p.stmt(s, i === (b.List.$length - 1 >> 0)); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 8; continue; case 9:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 6:
- $r = p.print(new sliceType$1([new pmode(2), new token.Pos(b.Rbrace), new token.Token(56), new pmode(2)])); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- /* */ if (!((sep === 0))) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (!((sep === 0))) { */ case 16:
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 17:
- $r = p.block(b, 1); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.adjBlock }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.b = b; $f.headerSize = headerSize; $f.i = i; $f.p = p; $f.s = s; $f.sep = sep; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.adjBlock = function(headerSize, sep, b) { return this.$val.adjBlock(headerSize, sep, b); };
- printer.ptr.prototype.distanceFrom = function(from) {
- var $ptr, _r, f, from, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; from = $f.from; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (new token.Pos(from).IsValid() && p.pos.IsValid()) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (new token.Pos(from).IsValid() && p.pos.IsValid()) { */ case 1:
- _r = p.posFor(from); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- f = $clone(_r, token.Position);
- /* */ if (f.Line === p.pos.Line) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (f.Line === p.pos.Line) { */ case 4:
- return p.pos.Column - f.Column >> 0;
- /* } */ case 5:
- /* } */ case 2:
- return 1073741824;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.distanceFrom }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.from = from; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.distanceFrom = function(from) { return this.$val.distanceFrom(from); };
- printer.ptr.prototype.funcDecl = function(d) {
- var $ptr, _r, _r$1, _r$2, d, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; d = $f.d; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.setComment(d.Doc); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r = d.Pos(); /* */ $s = 2; case 2: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(_r), new token.Token(71), new whiteSpace(32)])); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (!(d.Recv === ptrType$2.nil)) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!(d.Recv === ptrType$2.nil)) { */ case 4:
- $r = p.parameters(d.Recv); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(32)])); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 5:
- $r = p.expr(d.Name); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.signature(d.Type.Params, d.Type.Results); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$1 = d.Pos(); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.distanceFrom(_r$1); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- $r = p.adjBlock(_r$2, 11, d.Body); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.funcDecl }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.d = d; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.funcDecl = function(d) { return this.$val.funcDecl(d); };
- printer.ptr.prototype.decl = function(decl) {
- var $ptr, _ref, d, d$1, d$2, d$3, decl, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; d = $f.d; d$1 = $f.d$1; d$2 = $f.d$2; d$3 = $f.d$3; decl = $f.decl; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = decl;
- /* */ if ($assertType(_ref, ptrType$50, true)[1]) { $s = 1; continue; }
- /* */ if ($assertType(_ref, ptrType$51, true)[1]) { $s = 2; continue; }
- /* */ if ($assertType(_ref, ptrType$52, true)[1]) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if ($assertType(_ref, ptrType$50, true)[1]) { */ case 1:
- d = _ref.$val;
- $r = p.print(new sliceType$1([new token.Pos(d.Pos()), new $String("BadDecl")])); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else if ($assertType(_ref, ptrType$51, true)[1]) { */ case 2:
- d$1 = _ref.$val;
- $r = p.genDecl(d$1); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else if ($assertType(_ref, ptrType$52, true)[1]) { */ case 3:
- d$2 = _ref.$val;
- $r = p.funcDecl(d$2); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 5; continue;
- /* } else { */ case 4:
- d$3 = _ref;
- $panic(new $String("unreachable"));
- /* } */ case 5:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.decl }; } $f.$ptr = $ptr; $f._ref = _ref; $f.d = d; $f.d$1 = d$1; $f.d$2 = d$2; $f.d$3 = d$3; $f.decl = decl; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.decl = function(decl) { return this.$val.decl(decl); };
- declToken = function(decl) {
- var $ptr, _ref, d, d$1, decl, tok;
- tok = 0;
- tok = 0;
- _ref = decl;
- if ($assertType(_ref, ptrType$51, true)[1]) {
- d = _ref.$val;
- tok = d.Tok;
- } else if ($assertType(_ref, ptrType$52, true)[1]) {
- d$1 = _ref.$val;
- tok = 71;
- }
- return tok;
- };
- printer.ptr.prototype.declList = function(list) {
- var $ptr, _i, _r, _r$1, _r$2, _ref, d, list, min, p, prev, tok, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; d = $f.d; list = $f.list; min = $f.min; p = $f.p; prev = $f.prev; tok = $f.tok; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- tok = 0;
- _ref = list;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- d = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- prev = tok;
- tok = declToken(d);
- /* */ if (p.output.$length > 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (p.output.$length > 0) { */ case 3:
- min = 1;
- if (!((prev === tok)) || !(getDoc(d) === ptrType.nil)) {
- min = 2;
- }
- _r = d.Pos(); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = p.lineFor(_r); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = p.linebreak(_r$1, min, 0, false); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2;
- /* } */ case 4:
- $r = p.decl(d); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.declList }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f.d = d; $f.list = list; $f.min = min; $f.p = p; $f.prev = prev; $f.tok = tok; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.declList = function(list) { return this.$val.declList(list); };
- printer.ptr.prototype.file = function(src) {
- var $ptr, p, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; p = $f.p; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- $r = p.setComment(src.Doc); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new token.Pos(src.Pos()), new token.Token(78), new whiteSpace(32)])); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.expr(src.Name); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.declList(src.Decls); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.print(new sliceType$1([new whiteSpace(10)])); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.file }; } $f.$ptr = $ptr; $f.p = p; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.file = function(src) { return this.$val.file(src); };
- printer.ptr.prototype.init = function(cfg, fset, nodeSizes) {
- var $ptr, cfg, fset, nodeSizes, p;
- p = this;
- $copy(p.Config, cfg, Config);
- p.fset = fset;
- $copy(p.pos, new token.Position.ptr("", 0, 1, 1), token.Position);
- $copy(p.out, new token.Position.ptr("", 0, 1, 1), token.Position);
- p.wsbuf = $makeSlice(sliceType$7, 0, 16);
- p.nodeSizes = nodeSizes;
- p.cachedPos = -1;
- };
- printer.prototype.init = function(cfg, fset, nodeSizes) { return this.$val.init(cfg, fset, nodeSizes); };
- printer.ptr.prototype.internalError = function(msg) {
- var $ptr, msg, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; msg = $f.msg; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.internalError }; } $f.$ptr = $ptr; $f.msg = msg; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.internalError = function(msg) { return this.$val.internalError(msg); };
- printer.ptr.prototype.commentsHaveNewline = function(list) {
- var $ptr, _i, _r, _r$1, _ref, _v, c, i, line, list, p, t, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _ref = $f._ref; _v = $f._v; c = $f.c; i = $f.i; line = $f.line; list = $f.list; p = $f.p; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = p.lineFor((0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]).Pos()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- line = _r;
- _ref = list;
- _i = 0;
- /* while (true) { */ case 2:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; }
- i = _i;
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (!(i > 0)) { _v = false; $s = 6; continue s; }
- _r$1 = p.lineFor(((i < 0 || i >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + i]).Pos()); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = !((_r$1 === line)); case 6:
- /* */ if (_v) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (_v) { */ case 4:
- return true;
- /* } */ case 5:
- t = c.Text;
- if (t.length >= 2 && ((t.charCodeAt(1) === 47) || strings.Contains(t, "\n"))) {
- return true;
- }
- _i++;
- /* } */ $s = 2; continue; case 3:
- return false;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.commentsHaveNewline }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._ref = _ref; $f._v = _v; $f.c = c; $f.i = i; $f.line = line; $f.list = list; $f.p = p; $f.t = t; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.commentsHaveNewline = function(list) { return this.$val.commentsHaveNewline(list); };
- printer.ptr.prototype.nextComment = function() {
- var $ptr, _r, _r$1, c, list, p, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; c = $f.c; list = $f.list; p = $f.p; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* while (true) { */ case 1:
- /* if (!(p.commentInfo.cindex < p.comments.$length)) { break; } */ if(!(p.commentInfo.cindex < p.comments.$length)) { $s = 2; continue; }
- c = (x = p.comments, x$1 = p.commentInfo.cindex, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1]));
- p.commentInfo.cindex = p.commentInfo.cindex + (1) >> 0;
- list = c.List;
- /* */ if (list.$length > 0) { $s = 3; continue; }
- /* */ $s = 4; continue;
- /* if (list.$length > 0) { */ case 3:
- p.commentInfo.comment = c;
- _r = p.posFor((0 >= list.$length ? $throwRuntimeError("index out of range") : list.$array[list.$offset + 0]).Pos()); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- p.commentInfo.commentOffset = _r.Offset;
- _r$1 = p.commentsHaveNewline(list); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- p.commentInfo.commentNewline = _r$1;
- return;
- /* } */ case 4:
- /* } */ $s = 1; continue; case 2:
- p.commentInfo.commentOffset = 1073741824;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.nextComment }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.c = c; $f.list = list; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.nextComment = function() { return this.$val.nextComment(); };
- printer.ptr.prototype.commentBefore = function(next) {
- var $ptr, next, p;
- p = this;
- next = $clone(next, token.Position);
- return p.commentInfo.commentOffset < next.Offset && (!p.impliedSemi || !p.commentInfo.commentNewline);
- };
- printer.prototype.commentBefore = function(next) { return this.$val.commentBefore(next); };
- printer.ptr.prototype.commentSizeBefore = function(next) {
- var $ptr, _i, _ref, c, next, p, size, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; c = $f.c; next = $f.next; p = $f.p; size = $f.size; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- p = [p];
- p[0] = this;
- next = $clone(next, token.Position);
- $deferred.push([(function(p) { return function(info) {
- var $ptr, info;
- $copy(p[0].commentInfo, info, commentInfo);
- }; })(p), [$clone(p[0].commentInfo, commentInfo)]]);
- size = 0;
- /* while (true) { */ case 1:
- /* if (!(p[0].commentBefore(next))) { break; } */ if(!(p[0].commentBefore(next))) { $s = 2; continue; }
- _ref = p[0].commentInfo.comment.List;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- size = size + (c.Text.length) >> 0;
- _i++;
- }
- $r = p[0].nextComment(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- return size;
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; return 0; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: printer.ptr.prototype.commentSizeBefore }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f.c = c; $f.next = next; $f.p = p; $f.size = size; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- printer.prototype.commentSizeBefore = function(next) { return this.$val.commentSizeBefore(next); };
- printer.ptr.prototype.recordLine = function(linePtr) {
- var $ptr, linePtr, p;
- p = this;
- p.linePtr = linePtr;
- };
- printer.prototype.recordLine = function(linePtr) { return this.$val.recordLine(linePtr); };
- printer.ptr.prototype.linesFrom = function(line) {
- var $ptr, line, p;
- p = this;
- return p.out.Line - line >> 0;
- };
- printer.prototype.linesFrom = function(line) { return this.$val.linesFrom(line); };
- printer.ptr.prototype.posFor = function(pos) {
- var $ptr, _r, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _r = p.fset.Position(pos); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.posFor }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.posFor = function(pos) { return this.$val.posFor(pos); };
- printer.ptr.prototype.lineFor = function(pos) {
- var $ptr, _r, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (!((pos === p.cachedPos))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((pos === p.cachedPos))) { */ case 1:
- p.cachedPos = pos;
- _r = p.fset.Position(pos); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- p.cachedLine = _r.Line;
- /* } */ case 2:
- return p.cachedLine;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.lineFor }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.lineFor = function(pos) { return this.$val.lineFor(pos); };
- printer.ptr.prototype.atLineBegin = function(pos) {
- var $ptr, _r, i, n, p, pos, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; n = $f.n; p = $f.p; pos = $f.pos; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- pos = $clone(pos, token.Position);
- /* */ if (!((((p.Config.Mode & 8) >>> 0) === 0)) && pos.IsValid() && (!((p.out.Line === pos.Line)) || !(p.out.Filename === pos.Filename))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!((((p.Config.Mode & 8) >>> 0) === 0)) && pos.IsValid() && (!((p.out.Line === pos.Line)) || !(p.out.Filename === pos.Filename))) { */ case 1:
- p.output = $append(p.output, 255);
- _r = fmt.Sprintf("//line %s:%d\n", new sliceType$1([new $String(pos.Filename), new $Int(pos.Line)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- p.output = $appendSlice(p.output, new sliceType($stringToBytes(_r)));
- p.output = $append(p.output, 255);
- p.out.Filename = pos.Filename;
- p.out.Line = pos.Line;
- /* } */ case 2:
- n = p.Config.Indent + p.indent >> 0;
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- p.output = $append(p.output, 9);
- i = i + (1) >> 0;
- }
- p.pos.Offset = p.pos.Offset + (n) >> 0;
- p.pos.Column = p.pos.Column + (n) >> 0;
- p.out.Column = p.out.Column + (n) >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.atLineBegin }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.n = n; $f.p = p; $f.pos = pos; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.atLineBegin = function(pos) { return this.$val.atLineBegin(pos); };
- printer.ptr.prototype.writeByte = function(ch, n) {
- var $ptr, ch, i, n, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ch = $f.ch; i = $f.i; n = $f.n; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- /* */ if (p.out.Column === 1) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.out.Column === 1) { */ case 1:
- $r = p.atLineBegin(p.pos); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- i = 0;
- while (true) {
- if (!(i < n)) { break; }
- p.output = $append(p.output, ch);
- i = i + (1) >> 0;
- }
- p.pos.Offset = p.pos.Offset + (n) >> 0;
- if ((ch === 10) || (ch === 12)) {
- p.pos.Line = p.pos.Line + (n) >> 0;
- p.out.Line = p.out.Line + (n) >> 0;
- p.pos.Column = 1;
- p.out.Column = 1;
- return;
- }
- p.pos.Column = p.pos.Column + (n) >> 0;
- p.out.Column = p.out.Column + (n) >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.writeByte }; } $f.$ptr = $ptr; $f.ch = ch; $f.i = i; $f.n = n; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.writeByte = function(ch, n) { return this.$val.writeByte(ch, n); };
- printer.ptr.prototype.writeString = function(pos, s, isLit) {
- var $ptr, c, i, isLit, li, nlines, p, pos, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; c = $f.c; i = $f.i; isLit = $f.isLit; li = $f.li; nlines = $f.nlines; p = $f.p; pos = $f.pos; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- pos = $clone(pos, token.Position);
- /* */ if (p.out.Column === 1) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.out.Column === 1) { */ case 1:
- $r = p.atLineBegin(pos); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 2:
- if (pos.IsValid()) {
- $copy(p.pos, pos, token.Position);
- }
- if (isLit) {
- p.output = $append(p.output, 255);
- }
- p.output = $appendSlice(p.output, new sliceType($stringToBytes(s)));
- nlines = 0;
- li = 0;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- if (s.charCodeAt(i) === 10) {
- nlines = nlines + (1) >> 0;
- li = i;
- }
- i = i + (1) >> 0;
- }
- p.pos.Offset = p.pos.Offset + (s.length) >> 0;
- if (nlines > 0) {
- p.pos.Line = p.pos.Line + (nlines) >> 0;
- p.out.Line = p.out.Line + (nlines) >> 0;
- c = s.length - li >> 0;
- p.pos.Column = c;
- p.out.Column = c;
- } else {
- p.pos.Column = p.pos.Column + (s.length) >> 0;
- p.out.Column = p.out.Column + (s.length) >> 0;
- }
- if (isLit) {
- p.output = $append(p.output, 255);
- }
- $copy(p.last, p.pos, token.Position);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.writeString }; } $f.$ptr = $ptr; $f.c = c; $f.i = i; $f.isLit = isLit; $f.li = li; $f.nlines = nlines; $f.p = p; $f.pos = pos; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.writeString = function(pos, s, isLit) { return this.$val.writeString(pos, s, isLit); };
- printer.ptr.prototype.writeCommentPrefix = function(pos, next, prev, comment, tok) {
- var $ptr, _i, _i$1, _ref, _ref$1, _ref$2, _ref$3, ch, ch$1, comment, droppedLinebreak, hasSep, i, i$1, j, j$1, n, next, p, pos, prev, sep, tok, x, x$1, x$2, x$3, x$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; ch = $f.ch; ch$1 = $f.ch$1; comment = $f.comment; droppedLinebreak = $f.droppedLinebreak; hasSep = $f.hasSep; i = $f.i; i$1 = $f.i$1; j = $f.j; j$1 = $f.j$1; n = $f.n; next = $f.next; p = $f.p; pos = $f.pos; prev = $f.prev; sep = $f.sep; tok = $f.tok; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- next = $clone(next, token.Position);
- pos = $clone(pos, token.Position);
- if (p.output.$length === 0) {
- return;
- }
- /* */ if (pos.IsValid() && !(pos.Filename === p.last.Filename)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (pos.IsValid() && !(pos.Filename === p.last.Filename)) { */ case 1:
- $r = p.writeByte(12, 2); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 2:
- /* */ if ((pos.Line === p.last.Line) && (prev === ptrType$5.nil || !((prev.Text.charCodeAt(1) === 47)))) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if ((pos.Line === p.last.Line) && (prev === ptrType$5.nil || !((prev.Text.charCodeAt(1) === 47)))) { */ case 4:
- hasSep = false;
- /* */ if (prev === ptrType$5.nil) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (prev === ptrType$5.nil) { */ case 7:
- j = 0;
- _ref = p.wsbuf;
- _i = 0;
- /* while (true) { */ case 9:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 10; continue; }
- i = _i;
- ch = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = ch;
- /* */ if (_ref$1 === 32) { $s = 11; continue; }
- /* */ if (_ref$1 === 11) { $s = 12; continue; }
- /* */ if (_ref$1 === 62) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (_ref$1 === 32) { */ case 11:
- (x = p.wsbuf, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = 0));
- _i++;
- /* continue; */ $s = 9; continue;
- $s = 14; continue;
- /* } else if (_ref$1 === 11) { */ case 12:
- hasSep = true;
- _i++;
- /* continue; */ $s = 9; continue;
- $s = 14; continue;
- /* } else if (_ref$1 === 62) { */ case 13:
- _i++;
- /* continue; */ $s = 9; continue;
- /* } */ case 14:
- j = i;
- /* break; */ $s = 10; continue;
- /* } */ $s = 9; continue; case 10:
- $r = p.writeWhitespace(j); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* */ if (!hasSep) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (!hasSep) { */ case 16:
- sep = 9;
- if (pos.Line === next.Line) {
- sep = 32;
- }
- $r = p.writeByte(sep, 1); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 17:
- $s = 6; continue;
- /* } else { */ case 5:
- droppedLinebreak = false;
- j$1 = 0;
- _ref$2 = p.wsbuf;
- _i$1 = 0;
- /* while (true) { */ case 19:
- /* if (!(_i$1 < _ref$2.$length)) { break; } */ if(!(_i$1 < _ref$2.$length)) { $s = 20; continue; }
- i$1 = _i$1;
- ch$1 = ((_i$1 < 0 || _i$1 >= _ref$2.$length) ? $throwRuntimeError("index out of range") : _ref$2.$array[_ref$2.$offset + _i$1]);
- _ref$3 = ch$1;
- /* */ if (_ref$3 === 32 || _ref$3 === 11) { $s = 21; continue; }
- /* */ if (_ref$3 === 62) { $s = 22; continue; }
- /* */ if (_ref$3 === 60) { $s = 23; continue; }
- /* */ if (_ref$3 === 10 || _ref$3 === 12) { $s = 24; continue; }
- /* */ $s = 25; continue;
- /* if (_ref$3 === 32 || _ref$3 === 11) { */ case 21:
- (x$1 = p.wsbuf, ((i$1 < 0 || i$1 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i$1] = 0));
- _i$1++;
- /* continue; */ $s = 19; continue;
- $s = 25; continue;
- /* } else if (_ref$3 === 62) { */ case 22:
- _i$1++;
- /* continue; */ $s = 19; continue;
- $s = 25; continue;
- /* } else if (_ref$3 === 60) { */ case 23:
- if ((i$1 + 1 >> 0) < p.wsbuf.$length && ((x$2 = p.wsbuf, x$3 = i$1 + 1 >> 0, ((x$3 < 0 || x$3 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + x$3])) === 60)) {
- _i$1++;
- /* continue; */ $s = 19; continue;
- }
- if (!((tok === 56)) && (pos.Column === next.Column)) {
- _i$1++;
- /* continue; */ $s = 19; continue;
- }
- $s = 25; continue;
- /* } else if (_ref$3 === 10 || _ref$3 === 12) { */ case 24:
- (x$4 = p.wsbuf, ((i$1 < 0 || i$1 >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + i$1] = 0));
- droppedLinebreak = prev === ptrType$5.nil;
- /* } */ case 25:
- j$1 = i$1;
- /* break; */ $s = 20; continue;
- /* } */ $s = 19; continue; case 20:
- $r = p.writeWhitespace(j$1); /* */ $s = 26; case 26: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- n = 0;
- if (pos.IsValid() && p.last.IsValid()) {
- n = pos.Line - p.last.Line >> 0;
- if (n < 0) {
- n = 0;
- }
- }
- if ((p.indent === 0) && droppedLinebreak) {
- n = n + (1) >> 0;
- }
- if ((n === 0) && !(prev === ptrType$5.nil) && (prev.Text.charCodeAt(1) === 47)) {
- n = 1;
- }
- /* */ if (n > 0) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (n > 0) { */ case 27:
- $r = p.writeByte(12, nlimit(n)); /* */ $s = 29; case 29: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 28:
- /* } */ case 6:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.writeCommentPrefix }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f.ch = ch; $f.ch$1 = ch$1; $f.comment = comment; $f.droppedLinebreak = droppedLinebreak; $f.hasSep = hasSep; $f.i = i; $f.i$1 = i$1; $f.j = j; $f.j$1 = j$1; $f.n = n; $f.next = next; $f.p = p; $f.pos = pos; $f.prev = prev; $f.sep = sep; $f.tok = tok; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.writeCommentPrefix = function(pos, next, prev, comment, tok) { return this.$val.writeCommentPrefix(pos, next, prev, comment, tok); };
- isBlank = function(s) {
- var $ptr, i, s;
- i = 0;
- while (true) {
- if (!(i < s.length)) { break; }
- if (s.charCodeAt(i) > 32) {
- return false;
- }
- i = i + (1) >> 0;
- }
- return true;
- };
- commonPrefix = function(a, b) {
- var $ptr, a, b, i;
- i = 0;
- while (true) {
- if (!(i < a.length && i < b.length && (a.charCodeAt(i) === b.charCodeAt(i)) && (a.charCodeAt(i) <= 32 || (a.charCodeAt(i) === 42)))) { break; }
- i = i + (1) >> 0;
- }
- return a.substring(0, i);
- };
- trimRight = function(s) {
- var $ptr, _r, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r = strings.TrimRightFunc(s, unicode.IsSpace); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: trimRight }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- stripCommonPrefix = function(lines) {
- var $ptr, _i, _i$1, _ref, _ref$1, _tmp, _tmp$1, closing, first, first$1, i, i$1, i$2, i$3, i$4, last, line, line$1, line$2, lineOfStars, lines, n, n$1, prefix, suffix, x, x$1, x$2;
- if (lines.$length <= 1) {
- return;
- }
- prefix = "";
- if (lines.$length > 2) {
- first = true;
- _ref = $subslice(lines, 1, (lines.$length - 1 >> 0));
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- line = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (isBlank(line)) {
- (x = 1 + i >> 0, ((x < 0 || x >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + x] = ""));
- } else if (first) {
- prefix = commonPrefix(line, line);
- first = false;
- } else {
- prefix = commonPrefix(prefix, line);
- }
- _i++;
- }
- } else {
- line$1 = (1 >= lines.$length ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + 1]);
- prefix = commonPrefix(line$1, line$1);
- }
- lineOfStars = false;
- i$1 = strings.Index(prefix, "*");
- if (i$1 >= 0) {
- if (i$1 > 0 && (prefix.charCodeAt((i$1 - 1 >> 0)) === 32)) {
- i$1 = i$1 - (1) >> 0;
- }
- prefix = prefix.substring(0, i$1);
- lineOfStars = true;
- } else {
- first$1 = (0 >= lines.$length ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + 0]);
- if (isBlank(first$1.substring(2))) {
- i$2 = prefix.length;
- n = 0;
- while (true) {
- if (!(n < 3 && i$2 > 0 && (prefix.charCodeAt((i$2 - 1 >> 0)) === 32))) { break; }
- i$2 = i$2 - (1) >> 0;
- n = n + (1) >> 0;
- }
- if ((i$2 === prefix.length) && i$2 > 0 && (prefix.charCodeAt((i$2 - 1 >> 0)) === 9)) {
- i$2 = i$2 - (1) >> 0;
- }
- prefix = prefix.substring(0, i$2);
- } else {
- suffix = $makeSlice(sliceType, first$1.length);
- n$1 = 2;
- while (true) {
- if (!(n$1 < first$1.length && first$1.charCodeAt(n$1) <= 32)) { break; }
- ((n$1 < 0 || n$1 >= suffix.$length) ? $throwRuntimeError("index out of range") : suffix.$array[suffix.$offset + n$1] = first$1.charCodeAt(n$1));
- n$1 = n$1 + (1) >> 0;
- }
- if (n$1 > 2 && ((2 >= suffix.$length ? $throwRuntimeError("index out of range") : suffix.$array[suffix.$offset + 2]) === 9)) {
- suffix = $subslice(suffix, 2, n$1);
- } else {
- _tmp = 32; _tmp$1 = 32; (0 >= suffix.$length ? $throwRuntimeError("index out of range") : suffix.$array[suffix.$offset + 0] = _tmp); (1 >= suffix.$length ? $throwRuntimeError("index out of range") : suffix.$array[suffix.$offset + 1] = _tmp$1);
- suffix = $subslice(suffix, 0, n$1);
- }
- prefix = strings.TrimSuffix(prefix, $bytesToString(suffix));
- }
- }
- last = (x$1 = lines.$length - 1 >> 0, ((x$1 < 0 || x$1 >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + x$1]));
- closing = "*/";
- i$3 = strings.Index(last, closing);
- if (isBlank(last.substring(0, i$3))) {
- if (lineOfStars) {
- closing = " */";
- }
- (x$2 = lines.$length - 1 >> 0, ((x$2 < 0 || x$2 >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + x$2] = prefix + closing));
- } else {
- prefix = commonPrefix(prefix, last);
- }
- _ref$1 = lines;
- _i$1 = 0;
- while (true) {
- if (!(_i$1 < _ref$1.$length)) { break; }
- i$4 = _i$1;
- line$2 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- if (i$4 > 0 && !(line$2 === "")) {
- ((i$4 < 0 || i$4 >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + i$4] = line$2.substring(prefix.length));
- }
- _i$1++;
- }
- };
- printer.ptr.prototype.writeComment = function(comment) {
- var $ptr, _arg, _arg$1, _arg$2, _arg$3, _i, _i$1, _r, _r$1, _r$2, _r$3, _ref, _ref$1, _tuple, comment, err, i, i$1, i$2, indent, ldir, line, line$1, line$2, lines, p, pos, text, x, $s, $deferred, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _arg$3 = $f._arg$3; _i = $f._i; _i$1 = $f._i$1; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; comment = $f.comment; err = $f.err; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; indent = $f.indent; ldir = $f.ldir; line = $f.line; line$1 = $f.line$1; line$2 = $f.line$2; lines = $f.lines; p = $f.p; pos = $f.pos; text = $f.text; x = $f.x; $s = $f.$s; $deferred = $f.$deferred; $r = $f.$r; } var $err = null; try { s: while (true) { switch ($s) { case 0: $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- i = [i];
- indent = [indent];
- ldir = [ldir];
- line = [line];
- p = [p];
- p[0] = this;
- text = comment.Text;
- _r = p[0].posFor(comment.Pos()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- pos = $clone(_r, token.Position);
- /* */ if (strings.HasPrefix(text, "//line ") && (!pos.IsValid() || (pos.Column === 1))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (strings.HasPrefix(text, "//line ") && (!pos.IsValid() || (pos.Column === 1))) { */ case 2:
- _r$1 = strings.TrimSpace(text.substring(7)); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- ldir[0] = _r$1;
- i[0] = strings.LastIndex(ldir[0], ":");
- if (i[0] >= 0) {
- _tuple = strconv.Atoi(ldir[0].substring((i[0] + 1 >> 0))); line[0] = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $ifaceNil) && line[0] > 0) {
- indent[0] = p[0].indent;
- p[0].indent = 0;
- $deferred.push([(function(i, indent, ldir, line, p) { return function() {
- var $ptr;
- p[0].pos.Filename = ldir[0].substring(0, i[0]);
- p[0].pos.Line = line[0];
- p[0].pos.Column = 1;
- p[0].indent = indent[0];
- }; })(i, indent, ldir, line, p), []]);
- }
- }
- /* } */ case 3:
- /* */ if (text.charCodeAt(1) === 47) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (text.charCodeAt(1) === 47) { */ case 5:
- _arg = pos;
- _r$2 = trimRight(text); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _arg$1 = _r$2;
- $r = p[0].writeString(_arg, _arg$1, true); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return;
- /* } */ case 6:
- lines = strings.Split(text, "\n");
- if (pos.IsValid() && (pos.Column === 1) && p[0].indent > 0) {
- _ref = $subslice(lines, 1);
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i$1 = _i;
- line$1 = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- (x = 1 + i$1 >> 0, ((x < 0 || x >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + x] = " " + line$1));
- _i++;
- }
- }
- stripCommonPrefix(lines);
- _ref$1 = lines;
- _i$1 = 0;
- /* while (true) { */ case 9:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 10; continue; }
- i$2 = _i$1;
- line$2 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- /* */ if (i$2 > 0) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (i$2 > 0) { */ case 11:
- $r = p[0].writeByte(12, 1); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $copy(pos, p[0].pos, token.Position);
- /* } */ case 12:
- /* */ if (line$2.length > 0) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (line$2.length > 0) { */ case 14:
- _arg$2 = pos;
- _r$3 = trimRight(line$2); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _arg$3 = _r$3;
- $r = p[0].writeString(_arg$2, _arg$3, true); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 15:
- _i$1++;
- /* } */ $s = 9; continue; case 10:
- /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: printer.ptr.prototype.writeComment }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._arg$3 = _arg$3; $f._i = _i; $f._i$1 = _i$1; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f.comment = comment; $f.err = err; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.indent = indent; $f.ldir = ldir; $f.line = line; $f.line$1 = line$1; $f.line$2 = line$2; $f.lines = lines; $f.p = p; $f.pos = pos; $f.text = text; $f.x = x; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } }
- };
- printer.prototype.writeComment = function(comment) { return this.$val.writeComment(comment); };
- printer.ptr.prototype.writeCommentSuffix = function(needsLinebreak) {
- var $ptr, _i, _ref, _ref$1, ch, droppedFF, i, needsLinebreak, p, wroteNewline, x, x$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _ref = $f._ref; _ref$1 = $f._ref$1; ch = $f.ch; droppedFF = $f.droppedFF; i = $f.i; needsLinebreak = $f.needsLinebreak; p = $f.p; wroteNewline = $f.wroteNewline; x = $f.x; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- wroteNewline = false;
- droppedFF = false;
- p = this;
- _ref = p.wsbuf;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- ch = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = ch;
- if (_ref$1 === 32 || _ref$1 === 11) {
- (x = p.wsbuf, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = 0));
- } else if (_ref$1 === 62 || _ref$1 === 60) {
- } else if (_ref$1 === 10 || _ref$1 === 12) {
- if (needsLinebreak) {
- needsLinebreak = false;
- wroteNewline = true;
- } else {
- if (ch === 12) {
- droppedFF = true;
- }
- (x$1 = p.wsbuf, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i] = 0));
- }
- }
- _i++;
- }
- $r = p.writeWhitespace(p.wsbuf.$length); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ if (needsLinebreak) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (needsLinebreak) { */ case 2:
- $r = p.writeByte(10, 1); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- wroteNewline = true;
- /* } */ case 3:
- return [wroteNewline, droppedFF];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.writeCommentSuffix }; } $f.$ptr = $ptr; $f._i = _i; $f._ref = _ref; $f._ref$1 = _ref$1; $f.ch = ch; $f.droppedFF = droppedFF; $f.i = i; $f.needsLinebreak = needsLinebreak; $f.p = p; $f.wroteNewline = wroteNewline; $f.x = x; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.writeCommentSuffix = function(needsLinebreak) { return this.$val.writeCommentSuffix(needsLinebreak); };
- printer.ptr.prototype.intersperseComments = function(next, tok) {
- var $ptr, _i, _r, _r$1, _r$2, _ref, _tuple, _v, c, droppedFF, last, needsLinebreak, next, p, tok, wroteNewline, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _tuple = $f._tuple; _v = $f._v; c = $f.c; droppedFF = $f.droppedFF; last = $f.last; needsLinebreak = $f.needsLinebreak; next = $f.next; p = $f.p; tok = $f.tok; wroteNewline = $f.wroteNewline; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- wroteNewline = false;
- droppedFF = false;
- p = this;
- next = $clone(next, token.Position);
- last = ptrType$5.nil;
- /* while (true) { */ case 1:
- /* if (!(p.commentBefore(next))) { break; } */ if(!(p.commentBefore(next))) { $s = 2; continue; }
- _ref = p.commentInfo.comment.List;
- _i = 0;
- /* while (true) { */ case 3:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; }
- c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r = p.posFor(c.Pos()); /* */ $s = 5; case 5: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $r = p.writeCommentPrefix(_r, next, last, c, tok); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = p.writeComment(c); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- last = c;
- _i++;
- /* } */ $s = 3; continue; case 4:
- $r = p.nextComment(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ $s = 1; continue; case 2:
- /* */ if (!(last === ptrType$5.nil)) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (!(last === ptrType$5.nil)) { */ case 9:
- if (!(((p.mode & 1) === 0) && (last.Text.charCodeAt(1) === 42))) { _v = false; $s = 13; continue s; }
- _r$1 = p.lineFor(last.Pos()); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _v = _r$1 === next.Line; case 13:
- /* */ if (_v && !((tok === 52)) && (!((tok === 54)) || (p.prevOpen === 49)) && (!((tok === 55)) || (p.prevOpen === 50))) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (_v && !((tok === 52)) && (!((tok === 54)) || (p.prevOpen === 49)) && (!((tok === 55)) || (p.prevOpen === 50))) { */ case 11:
- $r = p.writeByte(32, 1); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 12:
- needsLinebreak = (last.Text.charCodeAt(1) === 47) || (tok === 56) && ((p.mode & 2) === 0) || (tok === 1);
- _r$2 = p.writeCommentSuffix(needsLinebreak); /* */ $s = 16; case 16: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; wroteNewline = _tuple[0]; droppedFF = _tuple[1];
- return [wroteNewline, droppedFF];
- /* } */ case 10:
- $r = p.internalError(new sliceType$1([new $String("intersperseComments called without pending comments")])); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- return [wroteNewline, droppedFF];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.intersperseComments }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._tuple = _tuple; $f._v = _v; $f.c = c; $f.droppedFF = droppedFF; $f.last = last; $f.needsLinebreak = needsLinebreak; $f.next = next; $f.p = p; $f.tok = tok; $f.wroteNewline = wroteNewline; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.intersperseComments = function(next, tok) { return this.$val.intersperseComments(next, tok); };
- printer.ptr.prototype.writeWhitespace = function(n) {
- var $ptr, _ref, _tmp, _tmp$1, ch, i, l, n, p, x, x$1, x$2, x$3, x$4, x$5, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _ref = $f._ref; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; ch = $f.ch; i = $f.i; l = $f.l; n = $f.n; p = $f.p; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- i = 0;
- /* while (true) { */ case 1:
- /* if (!(i < n)) { break; } */ if(!(i < n)) { $s = 2; continue; }
- ch = (x = p.wsbuf, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]));
- _ref = ch;
- /* */ if (_ref === 0) { $s = 3; continue; }
- /* */ if (_ref === 62) { $s = 4; continue; }
- /* */ if (_ref === 60) { $s = 5; continue; }
- /* */ if (_ref === 10 || _ref === 12) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (_ref === 0) { */ case 3:
- $s = 8; continue;
- /* } else if (_ref === 62) { */ case 4:
- p.indent = p.indent + (1) >> 0;
- $s = 8; continue;
- /* } else if (_ref === 60) { */ case 5:
- p.indent = p.indent - (1) >> 0;
- /* */ if (p.indent < 0) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if (p.indent < 0) { */ case 9:
- $r = p.internalError(new sliceType$1([new $String("negative indentation:"), new $Int(p.indent)])); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.indent = 0;
- /* } */ case 10:
- $s = 8; continue;
- /* } else if (_ref === 10 || _ref === 12) { */ case 6:
- if ((i + 1 >> 0) < n && ((x$1 = p.wsbuf, x$2 = i + 1 >> 0, ((x$2 < 0 || x$2 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + x$2])) === 60)) {
- _tmp = 60; _tmp$1 = 12; (x$3 = p.wsbuf, ((i < 0 || i >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + i] = _tmp)); (x$4 = p.wsbuf, x$5 = i + 1 >> 0, ((x$5 < 0 || x$5 >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + x$5] = _tmp$1));
- i = i - (1) >> 0;
- i = i + (1) >> 0;
- /* continue; */ $s = 1; continue;
- }
- $r = p.writeByte((ch << 24 >>> 24), 1); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 8; continue;
- /* } else { */ case 7:
- $r = p.writeByte((ch << 24 >>> 24), 1); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- i = i + (1) >> 0;
- /* } */ $s = 1; continue; case 2:
- l = $copySlice(p.wsbuf, $subslice(p.wsbuf, n));
- p.wsbuf = $subslice(p.wsbuf, 0, l);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.writeWhitespace }; } $f.$ptr = $ptr; $f._ref = _ref; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.ch = ch; $f.i = i; $f.l = l; $f.n = n; $f.p = p; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.writeWhitespace = function(n) { return this.$val.writeWhitespace(n); };
- nlimit = function(n) {
- var $ptr, n;
- if (n > 2) {
- n = 2;
- }
- return n;
- };
- mayCombine = function(prev, next) {
- var $ptr, _ref, b, next, prev;
- b = false;
- _ref = prev;
- if (_ref === 5) {
- b = next === 46;
- } else if (_ref === 12) {
- b = next === 43;
- } else if (_ref === 13) {
- b = next === 45;
- } else if (_ref === 15) {
- b = next === 42;
- } else if (_ref === 40) {
- b = (next === 45) || (next === 60);
- } else if (_ref === 17) {
- b = (next === 38) || (next === 94);
- }
- return b;
- };
- printer.ptr.prototype.print = function(args) {
- var $ptr, _i, _r, _r$1, _r$2, _ref, _ref$1, _ref$2, _ref$3, _tuple, arg, args, ch, data, droppedFF, i, impliedSemi, isLit, n, next, p, s, wroteNewline, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _tuple = $f._tuple; arg = $f.arg; args = $f.args; ch = $f.ch; data = $f.data; droppedFF = $f.droppedFF; i = $f.i; impliedSemi = $f.impliedSemi; isLit = $f.isLit; n = $f.n; next = $f.next; p = $f.p; s = $f.s; wroteNewline = $f.wroteNewline; x = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; x$3 = $f.x$3; x$4 = $f.x$4; x$5 = $f.x$5; x$6 = $f.x$6; x$7 = $f.x$7; x$8 = $f.x$8; x$9 = $f.x$9; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- _ref = args;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- arg = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- data = "";
- isLit = false;
- impliedSemi = false;
- _ref$1 = p.lastTok;
- if (_ref$1 === 0) {
- } else if (_ref$1 === 49 || _ref$1 === 50) {
- p.prevOpen = p.lastTok;
- } else {
- p.prevOpen = 0;
- }
- _ref$2 = arg;
- /* */ if ($assertType(_ref$2, pmode, true)[1]) { $s = 3; continue; }
- /* */ if ($assertType(_ref$2, whiteSpace, true)[1]) { $s = 4; continue; }
- /* */ if ($assertType(_ref$2, ptrType$3, true)[1]) { $s = 5; continue; }
- /* */ if ($assertType(_ref$2, ptrType$4, true)[1]) { $s = 6; continue; }
- /* */ if ($assertType(_ref$2, token.Token, true)[1]) { $s = 7; continue; }
- /* */ if ($assertType(_ref$2, token.Pos, true)[1]) { $s = 8; continue; }
- /* */ if ($assertType(_ref$2, $String, true)[1]) { $s = 9; continue; }
- /* */ $s = 10; continue;
- /* if ($assertType(_ref$2, pmode, true)[1]) { */ case 3:
- x = _ref$2.$val;
- p.mode = (p.mode ^ (x)) >> 0;
- _i++;
- /* continue; */ $s = 1; continue;
- $s = 11; continue;
- /* } else if ($assertType(_ref$2, whiteSpace, true)[1]) { */ case 4:
- x$1 = _ref$2.$val;
- /* */ if (x$1 === 0) { $s = 12; continue; }
- /* */ $s = 13; continue;
- /* if (x$1 === 0) { */ case 12:
- _i++;
- /* continue; */ $s = 1; continue;
- /* } */ case 13:
- i = p.wsbuf.$length;
- /* */ if (i === p.wsbuf.$capacity) { $s = 14; continue; }
- /* */ $s = 15; continue;
- /* if (i === p.wsbuf.$capacity) { */ case 14:
- $r = p.writeWhitespace(i); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- i = 0;
- /* } */ case 15:
- p.wsbuf = $subslice(p.wsbuf, 0, (i + 1 >> 0));
- (x$2 = p.wsbuf, ((i < 0 || i >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i] = x$1));
- if ((x$1 === 10) || (x$1 === 12)) {
- p.impliedSemi = false;
- }
- p.lastTok = 0;
- _i++;
- /* continue; */ $s = 1; continue;
- $s = 11; continue;
- /* } else if ($assertType(_ref$2, ptrType$3, true)[1]) { */ case 5:
- x$3 = _ref$2.$val;
- data = x$3.Name;
- impliedSemi = true;
- p.lastTok = 4;
- $s = 11; continue;
- /* } else if ($assertType(_ref$2, ptrType$4, true)[1]) { */ case 6:
- x$4 = _ref$2.$val;
- data = x$4.Value;
- isLit = true;
- impliedSemi = true;
- p.lastTok = x$4.Kind;
- $s = 11; continue;
- /* } else if ($assertType(_ref$2, token.Token, true)[1]) { */ case 7:
- x$5 = _ref$2.$val;
- s = new token.Token(x$5).String();
- /* */ if (mayCombine(p.lastTok, s.charCodeAt(0))) { $s = 17; continue; }
- /* */ $s = 18; continue;
- /* if (mayCombine(p.lastTok, s.charCodeAt(0))) { */ case 17:
- /* */ if (!((p.wsbuf.$length === 0))) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if (!((p.wsbuf.$length === 0))) { */ case 19:
- $r = p.internalError(new sliceType$1([new $String("whitespace buffer not empty")])); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 20:
- p.wsbuf = $subslice(p.wsbuf, 0, 1);
- (x$6 = p.wsbuf, (0 >= x$6.$length ? $throwRuntimeError("index out of range") : x$6.$array[x$6.$offset + 0] = 32));
- /* } */ case 18:
- data = s;
- _ref$3 = x$5;
- if (_ref$3 === 61 || _ref$3 === 65 || _ref$3 === 69 || _ref$3 === 80 || _ref$3 === 37 || _ref$3 === 38 || _ref$3 === 54 || _ref$3 === 55 || _ref$3 === 56) {
- impliedSemi = true;
- }
- p.lastTok = x$5;
- $s = 11; continue;
- /* } else if ($assertType(_ref$2, token.Pos, true)[1]) { */ case 8:
- x$7 = _ref$2.$val;
- /* */ if (new token.Pos(x$7).IsValid()) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (new token.Pos(x$7).IsValid()) { */ case 22:
- _r = p.posFor(x$7); /* */ $s = 24; case 24: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- $copy(p.pos, _r, token.Position);
- /* } */ case 23:
- _i++;
- /* continue; */ $s = 1; continue;
- $s = 11; continue;
- /* } else if ($assertType(_ref$2, $String, true)[1]) { */ case 9:
- x$8 = _ref$2.$val;
- data = x$8;
- isLit = true;
- impliedSemi = true;
- p.lastTok = 9;
- $s = 11; continue;
- /* } else { */ case 10:
- x$9 = _ref$2;
- _r$1 = fmt.Fprintf(os.Stderr, "print: unsupported argument %v (%T)\n", new sliceType$1([arg, arg])); /* */ $s = 25; case 25: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- $panic(new $String("go/printer type"));
- /* } */ case 11:
- next = $clone(p.pos, token.Position);
- _r$2 = p.flush(next, p.lastTok); /* */ $s = 26; case 26: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; wroteNewline = _tuple[0]; droppedFF = _tuple[1];
- /* */ if (!p.impliedSemi) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (!p.impliedSemi) { */ case 27:
- n = nlimit(next.Line - p.pos.Line >> 0);
- if (wroteNewline && (n === 2)) {
- n = 1;
- }
- /* */ if (n > 0) { $s = 29; continue; }
- /* */ $s = 30; continue;
- /* if (n > 0) { */ case 29:
- ch = 10;
- if (droppedFF) {
- ch = 12;
- }
- $r = p.writeByte(ch, n); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- impliedSemi = false;
- /* } */ case 30:
- /* } */ case 28:
- if (!(p.linePtr === ptrType$6.nil)) {
- p.linePtr.$set(p.out.Line);
- p.linePtr = ptrType$6.nil;
- }
- $r = p.writeString(next, data, isLit); /* */ $s = 32; case 32: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- p.impliedSemi = impliedSemi;
- _i++;
- /* } */ $s = 1; continue; case 2:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.print }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._tuple = _tuple; $f.arg = arg; $f.args = args; $f.ch = ch; $f.data = data; $f.droppedFF = droppedFF; $f.i = i; $f.impliedSemi = impliedSemi; $f.isLit = isLit; $f.n = n; $f.next = next; $f.p = p; $f.s = s; $f.wroteNewline = wroteNewline; $f.x = x; $f.x$1 = x$1; $f.x$2 = x$2; $f.x$3 = x$3; $f.x$4 = x$4; $f.x$5 = x$5; $f.x$6 = x$6; $f.x$7 = x$7; $f.x$8 = x$8; $f.x$9 = x$9; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.print = function(args) { return this.$val.print(args); };
- printer.ptr.prototype.flush = function(next, tok) {
- var $ptr, _r, _tuple, droppedFF, next, p, tok, wroteNewline, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; droppedFF = $f.droppedFF; next = $f.next; p = $f.p; tok = $f.tok; wroteNewline = $f.wroteNewline; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- wroteNewline = false;
- droppedFF = false;
- p = this;
- next = $clone(next, token.Position);
- /* */ if (p.commentBefore(next)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (p.commentBefore(next)) { */ case 1:
- _r = p.intersperseComments(next, tok); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; wroteNewline = _tuple[0]; droppedFF = _tuple[1];
- $s = 3; continue;
- /* } else { */ case 2:
- $r = p.writeWhitespace(p.wsbuf.$length); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- return [wroteNewline, droppedFF];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.flush }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.droppedFF = droppedFF; $f.next = next; $f.p = p; $f.tok = tok; $f.wroteNewline = wroteNewline; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.flush = function(next, tok) { return this.$val.flush(next, tok); };
- getDoc = function(n) {
- var $ptr, _ref, n, n$1, n$2, n$3, n$4, n$5, n$6, n$7;
- _ref = n;
- if ($assertType(_ref, ptrType$53, true)[1]) {
- n$1 = _ref.$val;
- return n$1.Doc;
- } else if ($assertType(_ref, ptrType$48, true)[1]) {
- n$2 = _ref.$val;
- return n$2.Doc;
- } else if ($assertType(_ref, ptrType$47, true)[1]) {
- n$3 = _ref.$val;
- return n$3.Doc;
- } else if ($assertType(_ref, ptrType$49, true)[1]) {
- n$4 = _ref.$val;
- return n$4.Doc;
- } else if ($assertType(_ref, ptrType$51, true)[1]) {
- n$5 = _ref.$val;
- return n$5.Doc;
- } else if ($assertType(_ref, ptrType$52, true)[1]) {
- n$6 = _ref.$val;
- return n$6.Doc;
- } else if ($assertType(_ref, ptrType$54, true)[1]) {
- n$7 = _ref.$val;
- return n$7.Doc;
- }
- return ptrType.nil;
- };
- printer.ptr.prototype.printNode = function(node) {
- var $ptr, _i, _r, _r$1, _r$2, _ref, _ref$1, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, beg, cnode, comments, doc, end, i, j, n, n$1, n$2, n$3, n$4, n$5, n$6, n$7, n$8, n$9, node, ok, ok$1, ok$2, ok$3, ok$4, p, s, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; beg = $f.beg; cnode = $f.cnode; comments = $f.comments; doc = $f.doc; end = $f.end; i = $f.i; j = $f.j; n = $f.n; n$1 = $f.n$1; n$2 = $f.n$2; n$3 = $f.n$3; n$4 = $f.n$4; n$5 = $f.n$5; n$6 = $f.n$6; n$7 = $f.n$7; n$8 = $f.n$8; n$9 = $f.n$9; node = $f.node; ok = $f.ok; ok$1 = $f.ok$1; ok$2 = $f.ok$2; ok$3 = $f.ok$3; ok$4 = $f.ok$4; p = $f.p; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- p = this;
- comments = sliceType$2.nil;
- _tuple = $assertType(node, ptrType$55, true); cnode = _tuple[0]; ok = _tuple[1];
- if (ok) {
- node = cnode.Node;
- comments = cnode.Comments;
- }
- /* */ if (!(comments === sliceType$2.nil)) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!(comments === sliceType$2.nil)) { */ case 1:
- _tuple$1 = $assertType(node, ast.Node, true); n = _tuple$1[0]; ok$1 = _tuple$1[1];
- /* */ if (!ok$1) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (!ok$1) { */ case 4:
- /* goto unsupported */ $s = 6; continue;
- /* } */ case 5:
- _r = n.Pos(); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- beg = _r;
- _r$1 = n.End(); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- end = _r$1;
- doc = getDoc(n);
- if (!(doc === ptrType.nil)) {
- beg = doc.Pos();
- }
- i = 0;
- while (true) {
- if (!(i < comments.$length && ((i < 0 || i >= comments.$length) ? $throwRuntimeError("index out of range") : comments.$array[comments.$offset + i]).End() < beg)) { break; }
- i = i + (1) >> 0;
- }
- j = i;
- while (true) {
- if (!(j < comments.$length && ((j < 0 || j >= comments.$length) ? $throwRuntimeError("index out of range") : comments.$array[comments.$offset + j]).Pos() < end)) { break; }
- j = j + (1) >> 0;
- }
- if (i < j) {
- p.comments = $subslice(comments, i, j);
- }
- $s = 3; continue;
- /* } else { */ case 2:
- _tuple$2 = $assertType(node, ptrType$54, true); n$1 = _tuple$2[0]; ok$2 = _tuple$2[1];
- if (ok$2) {
- p.comments = n$1.Comments;
- }
- /* } */ case 3:
- p.useNodeComments = p.comments === sliceType$2.nil;
- $r = p.nextComment(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _ref = node;
- /* */ if ($assertType(_ref, ast.Expr, true)[1]) { $s = 10; continue; }
- /* */ if ($assertType(_ref, ast.Stmt, true)[1]) { $s = 11; continue; }
- /* */ if ($assertType(_ref, ast.Decl, true)[1]) { $s = 12; continue; }
- /* */ if ($assertType(_ref, ast.Spec, true)[1]) { $s = 13; continue; }
- /* */ if ($assertType(_ref, sliceType$8, true)[1]) { $s = 14; continue; }
- /* */ if ($assertType(_ref, sliceType$9, true)[1]) { $s = 15; continue; }
- /* */ if ($assertType(_ref, ptrType$54, true)[1]) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if ($assertType(_ref, ast.Expr, true)[1]) { */ case 10:
- n$2 = _ref;
- $r = p.expr(n$2); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if ($assertType(_ref, ast.Stmt, true)[1]) { */ case 11:
- n$3 = _ref;
- _tuple$3 = $assertType(n$3, ptrType$27, true); ok$3 = _tuple$3[1];
- if (ok$3) {
- p.indent = 1;
- }
- $r = p.stmt(n$3, false); /* */ $s = 20; case 20: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if ($assertType(_ref, ast.Decl, true)[1]) { */ case 12:
- n$4 = _ref;
- $r = p.decl(n$4); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if ($assertType(_ref, ast.Spec, true)[1]) { */ case 13:
- n$5 = _ref;
- $r = p.spec(n$5, 1, false); /* */ $s = 22; case 22: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if ($assertType(_ref, sliceType$8, true)[1]) { */ case 14:
- n$6 = _ref.$val;
- _ref$1 = n$6;
- _i = 0;
- while (true) {
- if (!(_i < _ref$1.$length)) { break; }
- s = ((_i < 0 || _i >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i]);
- _tuple$4 = $assertType(s, ptrType$27, true); ok$4 = _tuple$4[1];
- if (ok$4) {
- p.indent = 1;
- }
- _i++;
- }
- $r = p.stmtList(n$6, 0, false); /* */ $s = 23; case 23: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if ($assertType(_ref, sliceType$9, true)[1]) { */ case 15:
- n$7 = _ref.$val;
- $r = p.declList(n$7); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else if ($assertType(_ref, ptrType$54, true)[1]) { */ case 16:
- n$8 = _ref.$val;
- $r = p.file(n$8); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $s = 18; continue;
- /* } else { */ case 17:
- n$9 = _ref;
- /* goto unsupported */ $s = 6; continue;
- /* } */ case 18:
- return $ifaceNil;
- /* unsupported: */ case 6:
- _r$2 = fmt.Errorf("go/printer: unsupported node type %T", new sliceType$1([node])); /* */ $s = 26; case 26: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- return _r$2;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: printer.ptr.prototype.printNode }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.beg = beg; $f.cnode = cnode; $f.comments = comments; $f.doc = doc; $f.end = end; $f.i = i; $f.j = j; $f.n = n; $f.n$1 = n$1; $f.n$2 = n$2; $f.n$3 = n$3; $f.n$4 = n$4; $f.n$5 = n$5; $f.n$6 = n$6; $f.n$7 = n$7; $f.n$8 = n$8; $f.n$9 = n$9; $f.node = node; $f.ok = ok; $f.ok$1 = ok$1; $f.ok$2 = ok$2; $f.ok$3 = ok$3; $f.ok$4 = ok$4; $f.p = p; $f.s = s; $f.$s = $s; $f.$r = $r; return $f;
- };
- printer.prototype.printNode = function(node) { return this.$val.printNode(node); };
- trimmer.ptr.prototype.resetSpace = function() {
- var $ptr, p;
- p = this;
- p.state = 0;
- p.space = $subslice(p.space, 0, 0);
- };
- trimmer.prototype.resetSpace = function() { return this.$val.resetSpace(); };
- trimmer.ptr.prototype.Write = function(data) {
- var $ptr, _i, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, _ref$1, _ref$2, _ref$3, _ref$4, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, b, data, err, m, n, p, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _ref$3 = $f._ref$3; _ref$4 = $f._ref$4; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; _tuple$5 = $f._tuple$5; _tuple$6 = $f._tuple$6; _tuple$7 = $f._tuple$7; _tuple$8 = $f._tuple$8; b = $f.b; data = $f.data; err = $f.err; m = $f.m; n = $f.n; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = 0;
- err = $ifaceNil;
- p = this;
- m = 0;
- b = 0;
- _ref = data;
- _i = 0;
- /* while (true) { */ case 1:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; }
- n = _i;
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- if (b === 11) {
- b = 9;
- }
- _ref$1 = p.state;
- /* */ if (_ref$1 === 0) { $s = 3; continue; }
- /* */ if (_ref$1 === 1) { $s = 4; continue; }
- /* */ if (_ref$1 === 2) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (_ref$1 === 0) { */ case 3:
- _ref$2 = b;
- /* */ if (_ref$2 === 9 || _ref$2 === 32) { $s = 8; continue; }
- /* */ if (_ref$2 === 10 || _ref$2 === 12) { $s = 9; continue; }
- /* */ if (_ref$2 === 255) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (_ref$2 === 9 || _ref$2 === 32) { */ case 8:
- p.space = $append(p.space, b);
- $s = 12; continue;
- /* } else if (_ref$2 === 10 || _ref$2 === 12) { */ case 9:
- p.resetSpace();
- _r = p.output.Write(aNewline); /* */ $s = 13; case 13: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; err = _tuple[1];
- $s = 12; continue;
- /* } else if (_ref$2 === 255) { */ case 10:
- _r$1 = p.output.Write(p.space); /* */ $s = 14; case 14: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _tuple$1 = _r$1; err = _tuple$1[1];
- p.state = 1;
- m = n + 1 >> 0;
- $s = 12; continue;
- /* } else { */ case 11:
- _r$2 = p.output.Write(p.space); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple$2 = _r$2; err = _tuple$2[1];
- p.state = 2;
- m = n;
- /* } */ case 12:
- $s = 7; continue;
- /* } else if (_ref$1 === 1) { */ case 4:
- /* */ if (b === 255) { $s = 16; continue; }
- /* */ $s = 17; continue;
- /* if (b === 255) { */ case 16:
- _r$3 = p.output.Write($subslice(data, m, n)); /* */ $s = 18; case 18: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$3 = _r$3; err = _tuple$3[1];
- p.resetSpace();
- /* } */ case 17:
- $s = 7; continue;
- /* } else if (_ref$1 === 2) { */ case 5:
- _ref$3 = b;
- /* */ if (_ref$3 === 9 || _ref$3 === 32) { $s = 19; continue; }
- /* */ if (_ref$3 === 10 || _ref$3 === 12) { $s = 20; continue; }
- /* */ if (_ref$3 === 255) { $s = 21; continue; }
- /* */ $s = 22; continue;
- /* if (_ref$3 === 9 || _ref$3 === 32) { */ case 19:
- _r$4 = p.output.Write($subslice(data, m, n)); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _tuple$4 = _r$4; err = _tuple$4[1];
- p.resetSpace();
- p.space = $append(p.space, b);
- $s = 22; continue;
- /* } else if (_ref$3 === 10 || _ref$3 === 12) { */ case 20:
- _r$5 = p.output.Write($subslice(data, m, n)); /* */ $s = 24; case 24: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _tuple$5 = _r$5; err = _tuple$5[1];
- p.resetSpace();
- _r$6 = p.output.Write(aNewline); /* */ $s = 25; case 25: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$6 = _r$6; err = _tuple$6[1];
- $s = 22; continue;
- /* } else if (_ref$3 === 255) { */ case 21:
- _r$7 = p.output.Write($subslice(data, m, n)); /* */ $s = 26; case 26: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- _tuple$7 = _r$7; err = _tuple$7[1];
- p.state = 1;
- m = n + 1 >> 0;
- /* } */ case 22:
- $s = 7; continue;
- /* } else { */ case 6:
- $panic(new $String("unreachable"));
- /* } */ case 7:
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [n, err];
- }
- _i++;
- /* } */ $s = 1; continue; case 2:
- n = data.$length;
- _ref$4 = p.state;
- /* */ if (_ref$4 === 1 || _ref$4 === 2) { $s = 27; continue; }
- /* */ $s = 28; continue;
- /* if (_ref$4 === 1 || _ref$4 === 2) { */ case 27:
- _r$8 = p.output.Write($subslice(data, m, n)); /* */ $s = 29; case 29: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _tuple$8 = _r$8; err = _tuple$8[1];
- p.resetSpace();
- /* } */ case 28:
- return [n, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: trimmer.ptr.prototype.Write }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._ref$3 = _ref$3; $f._ref$4 = _ref$4; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f._tuple$5 = _tuple$5; $f._tuple$6 = _tuple$6; $f._tuple$7 = _tuple$7; $f._tuple$8 = _tuple$8; $f.b = b; $f.data = data; $f.err = err; $f.m = m; $f.n = n; $f.p = p; $f.$s = $s; $f.$r = $r; return $f;
- };
- trimmer.prototype.Write = function(data) { return this.$val.Write(data); };
- Config.ptr.prototype.fprint = function(output, fset, node, nodeSizes) {
- var $ptr, _r, _r$1, _r$2, _r$3, _tuple, _tuple$1, cfg, err, fset, minwidth, node, nodeSizes, output, p, padchar, tw, twmode, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; cfg = $f.cfg; err = $f.err; fset = $f.fset; minwidth = $f.minwidth; node = $f.node; nodeSizes = $f.nodeSizes; output = $f.output; p = $f.p; padchar = $f.padchar; tw = $f.tw; twmode = $f.twmode; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- err = $ifaceNil;
- cfg = this;
- p = $clone(new printer.ptr(), printer);
- p.init(cfg, fset, nodeSizes);
- _r = p.printNode(node); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- return err;
- /* } */ case 3:
- p.impliedSemi = false;
- _r$1 = p.flush(new token.Position.ptr("", 1073741824, 1073741824, 0), 1); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$1;
- output = new trimmer.ptr(output, 0, sliceType.nil);
- if (((cfg.Mode & 1) >>> 0) === 0) {
- minwidth = cfg.Tabwidth;
- padchar = 9;
- if (!((((cfg.Mode & 4) >>> 0) === 0))) {
- padchar = 32;
- }
- twmode = 8;
- if (!((((cfg.Mode & 2) >>> 0) === 0))) {
- minwidth = 0;
- twmode = (twmode | (16)) >>> 0;
- }
- output = tabwriter.NewWriter(output, minwidth, cfg.Tabwidth, 1, padchar, twmode);
- }
- _r$2 = output.Write(p.output); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 6; continue; }
- /* */ $s = 7; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 6:
- return err;
- /* } */ case 7:
- _tuple$1 = $assertType(output, ptrType$56, true); tw = _tuple$1[0];
- /* */ if (!(tw === ptrType$56.nil)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if (!(tw === ptrType$56.nil)) { */ case 8:
- _r$3 = tw.Flush(); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- err = _r$3;
- /* } */ case 9:
- return err;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Config.ptr.prototype.fprint }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.cfg = cfg; $f.err = err; $f.fset = fset; $f.minwidth = minwidth; $f.node = node; $f.nodeSizes = nodeSizes; $f.output = output; $f.p = p; $f.padchar = padchar; $f.tw = tw; $f.twmode = twmode; $f.$s = $s; $f.$r = $r; return $f;
- };
- Config.prototype.fprint = function(output, fset, node, nodeSizes) { return this.$val.fprint(output, fset, node, nodeSizes); };
- Config.ptr.prototype.Fprint = function(output, fset, node) {
- var $ptr, _r, cfg, fset, node, output, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; cfg = $f.cfg; fset = $f.fset; node = $f.node; output = $f.output; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- cfg = this;
- _r = cfg.fprint(output, fset, node, new $Map()); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return _r;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Config.ptr.prototype.Fprint }; } $f.$ptr = $ptr; $f._r = _r; $f.cfg = cfg; $f.fset = fset; $f.node = node; $f.output = output; $f.$s = $s; $f.$r = $r; return $f;
- };
- Config.prototype.Fprint = function(output, fset, node) { return this.$val.Fprint(output, fset, node); };
- ptrType$59.methods = [{prop: "linebreak", name: "linebreak", pkg: "go/printer", typ: $funcType([$Int, $Int, whiteSpace, $Bool], [$Bool], false)}, {prop: "setComment", name: "setComment", pkg: "go/printer", typ: $funcType([ptrType], [], false)}, {prop: "identList", name: "identList", pkg: "go/printer", typ: $funcType([sliceType$4, $Bool], [], false)}, {prop: "exprList", name: "exprList", pkg: "go/printer", typ: $funcType([token.Pos, sliceType$3, $Int, exprListMode, token.Pos], [], false)}, {prop: "parameters", name: "parameters", pkg: "go/printer", typ: $funcType([ptrType$2], [], false)}, {prop: "signature", name: "signature", pkg: "go/printer", typ: $funcType([ptrType$2, ptrType$2], [], false)}, {prop: "isOneLineFieldList", name: "isOneLineFieldList", pkg: "go/printer", typ: $funcType([sliceType$10], [$Bool], false)}, {prop: "setLineComment", name: "setLineComment", pkg: "go/printer", typ: $funcType([$String], [], false)}, {prop: "fieldList", name: "fieldList", pkg: "go/printer", typ: $funcType([ptrType$2, $Bool, $Bool], [], false)}, {prop: "binaryExpr", name: "binaryExpr", pkg: "go/printer", typ: $funcType([ptrType$8, $Int, $Int, $Int], [], false)}, {prop: "expr1", name: "expr1", pkg: "go/printer", typ: $funcType([ast.Expr, $Int, $Int], [], false)}, {prop: "expr0", name: "expr0", pkg: "go/printer", typ: $funcType([ast.Expr, $Int], [], false)}, {prop: "expr", name: "expr", pkg: "go/printer", typ: $funcType([ast.Expr], [], false)}, {prop: "stmtList", name: "stmtList", pkg: "go/printer", typ: $funcType([sliceType$8, $Int, $Bool], [], false)}, {prop: "block", name: "block", pkg: "go/printer", typ: $funcType([ptrType$38, $Int], [], false)}, {prop: "controlClause", name: "controlClause", pkg: "go/printer", typ: $funcType([$Bool, ast.Stmt, ast.Expr, ast.Stmt], [], false)}, {prop: "indentList", name: "indentList", pkg: "go/printer", typ: $funcType([sliceType$3], [$Bool], false)}, {prop: "stmt", name: "stmt", pkg: "go/printer", typ: $funcType([ast.Stmt, $Bool], [], false)}, {prop: "valueSpec", name: "valueSpec", pkg: "go/printer", typ: $funcType([ptrType$47, $Bool], [], false)}, {prop: "spec", name: "spec", pkg: "go/printer", typ: $funcType([ast.Spec, $Int, $Bool], [], false)}, {prop: "genDecl", name: "genDecl", pkg: "go/printer", typ: $funcType([ptrType$51], [], false)}, {prop: "nodeSize", name: "nodeSize", pkg: "go/printer", typ: $funcType([ast.Node, $Int], [$Int], false)}, {prop: "bodySize", name: "bodySize", pkg: "go/printer", typ: $funcType([ptrType$38, $Int], [$Int], false)}, {prop: "adjBlock", name: "adjBlock", pkg: "go/printer", typ: $funcType([$Int, whiteSpace, ptrType$38], [], false)}, {prop: "distanceFrom", name: "distanceFrom", pkg: "go/printer", typ: $funcType([token.Pos], [$Int], false)}, {prop: "funcDecl", name: "funcDecl", pkg: "go/printer", typ: $funcType([ptrType$52], [], false)}, {prop: "decl", name: "decl", pkg: "go/printer", typ: $funcType([ast.Decl], [], false)}, {prop: "declList", name: "declList", pkg: "go/printer", typ: $funcType([sliceType$9], [], false)}, {prop: "file", name: "file", pkg: "go/printer", typ: $funcType([ptrType$54], [], false)}, {prop: "init", name: "init", pkg: "go/printer", typ: $funcType([ptrType$58, ptrType$57, mapType], [], false)}, {prop: "internalError", name: "internalError", pkg: "go/printer", typ: $funcType([sliceType$1], [], true)}, {prop: "commentsHaveNewline", name: "commentsHaveNewline", pkg: "go/printer", typ: $funcType([sliceType$5], [$Bool], false)}, {prop: "nextComment", name: "nextComment", pkg: "go/printer", typ: $funcType([], [], false)}, {prop: "commentBefore", name: "commentBefore", pkg: "go/printer", typ: $funcType([token.Position], [$Bool], false)}, {prop: "commentSizeBefore", name: "commentSizeBefore", pkg: "go/printer", typ: $funcType([token.Position], [$Int], false)}, {prop: "recordLine", name: "recordLine", pkg: "go/printer", typ: $funcType([ptrType$6], [], false)}, {prop: "linesFrom", name: "linesFrom", pkg: "go/printer", typ: $funcType([$Int], [$Int], false)}, {prop: "posFor", name: "posFor", pkg: "go/printer", typ: $funcType([token.Pos], [token.Position], false)}, {prop: "lineFor", name: "lineFor", pkg: "go/printer", typ: $funcType([token.Pos], [$Int], false)}, {prop: "atLineBegin", name: "atLineBegin", pkg: "go/printer", typ: $funcType([token.Position], [], false)}, {prop: "writeByte", name: "writeByte", pkg: "go/printer", typ: $funcType([$Uint8, $Int], [], false)}, {prop: "writeString", name: "writeString", pkg: "go/printer", typ: $funcType([token.Position, $String, $Bool], [], false)}, {prop: "writeCommentPrefix", name: "writeCommentPrefix", pkg: "go/printer", typ: $funcType([token.Position, token.Position, ptrType$5, ptrType$5, token.Token], [], false)}, {prop: "writeComment", name: "writeComment", pkg: "go/printer", typ: $funcType([ptrType$5], [], false)}, {prop: "writeCommentSuffix", name: "writeCommentSuffix", pkg: "go/printer", typ: $funcType([$Bool], [$Bool, $Bool], false)}, {prop: "intersperseComments", name: "intersperseComments", pkg: "go/printer", typ: $funcType([token.Position, token.Token], [$Bool, $Bool], false)}, {prop: "writeWhitespace", name: "writeWhitespace", pkg: "go/printer", typ: $funcType([$Int], [], false)}, {prop: "print", name: "print", pkg: "go/printer", typ: $funcType([sliceType$1], [], true)}, {prop: "flush", name: "flush", pkg: "go/printer", typ: $funcType([token.Position, token.Token], [$Bool, $Bool], false)}, {prop: "printNode", name: "printNode", pkg: "go/printer", typ: $funcType([$emptyInterface], [$error], false)}];
- ptrType$60.methods = [{prop: "resetSpace", name: "resetSpace", pkg: "go/printer", typ: $funcType([], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}];
- ptrType$58.methods = [{prop: "fprint", name: "fprint", pkg: "go/printer", typ: $funcType([io.Writer, ptrType$57, $emptyInterface, mapType], [$error], false)}, {prop: "Fprint", name: "Fprint", pkg: "", typ: $funcType([io.Writer, ptrType$57, $emptyInterface], [$error], false)}];
- commentInfo.init([{prop: "cindex", name: "cindex", pkg: "go/printer", typ: $Int, tag: ""}, {prop: "comment", name: "comment", pkg: "go/printer", typ: ptrType, tag: ""}, {prop: "commentOffset", name: "commentOffset", pkg: "go/printer", typ: $Int, tag: ""}, {prop: "commentNewline", name: "commentNewline", pkg: "go/printer", typ: $Bool, tag: ""}]);
- printer.init([{prop: "Config", name: "", pkg: "", typ: Config, tag: ""}, {prop: "fset", name: "fset", pkg: "go/printer", typ: ptrType$57, tag: ""}, {prop: "output", name: "output", pkg: "go/printer", typ: sliceType, tag: ""}, {prop: "indent", name: "indent", pkg: "go/printer", typ: $Int, tag: ""}, {prop: "mode", name: "mode", pkg: "go/printer", typ: pmode, tag: ""}, {prop: "impliedSemi", name: "impliedSemi", pkg: "go/printer", typ: $Bool, tag: ""}, {prop: "lastTok", name: "lastTok", pkg: "go/printer", typ: token.Token, tag: ""}, {prop: "prevOpen", name: "prevOpen", pkg: "go/printer", typ: token.Token, tag: ""}, {prop: "wsbuf", name: "wsbuf", pkg: "go/printer", typ: sliceType$7, tag: ""}, {prop: "pos", name: "pos", pkg: "go/printer", typ: token.Position, tag: ""}, {prop: "out", name: "out", pkg: "go/printer", typ: token.Position, tag: ""}, {prop: "last", name: "last", pkg: "go/printer", typ: token.Position, tag: ""}, {prop: "linePtr", name: "linePtr", pkg: "go/printer", typ: ptrType$6, tag: ""}, {prop: "comments", name: "comments", pkg: "go/printer", typ: sliceType$2, tag: ""}, {prop: "useNodeComments", name: "useNodeComments", pkg: "go/printer", typ: $Bool, tag: ""}, {prop: "commentInfo", name: "", pkg: "go/printer", typ: commentInfo, tag: ""}, {prop: "nodeSizes", name: "nodeSizes", pkg: "go/printer", typ: mapType, tag: ""}, {prop: "cachedPos", name: "cachedPos", pkg: "go/printer", typ: token.Pos, tag: ""}, {prop: "cachedLine", name: "cachedLine", pkg: "go/printer", typ: $Int, tag: ""}]);
- trimmer.init([{prop: "output", name: "output", pkg: "go/printer", typ: io.Writer, tag: ""}, {prop: "state", name: "state", pkg: "go/printer", typ: $Int, tag: ""}, {prop: "space", name: "space", pkg: "go/printer", typ: sliceType, tag: ""}]);
- Config.init([{prop: "Mode", name: "Mode", pkg: "", typ: Mode, tag: ""}, {prop: "Tabwidth", name: "Tabwidth", pkg: "", typ: $Int, tag: ""}, {prop: "Indent", name: "Indent", pkg: "", typ: $Int, tag: ""}]);
- CommentedNode.init([{prop: "Node", name: "Node", pkg: "", typ: $emptyInterface, tag: ""}, {prop: "Comments", name: "Comments", pkg: "", typ: sliceType$2, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = os.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strconv.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = tabwriter.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = unicode.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = utf8.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- aNewline = new sliceType($stringToBytes("\n"));
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["go/format"] = (function() {
- var $pkg = {}, $init, bytes, fmt, ast, parser, printer, token, io, strings, ptrType, sliceType$2, config, Source, parse, format, isSpace;
- bytes = $packages["bytes"];
- fmt = $packages["fmt"];
- ast = $packages["go/ast"];
- parser = $packages["go/parser"];
- printer = $packages["go/printer"];
- token = $packages["go/token"];
- io = $packages["io"];
- strings = $packages["strings"];
- ptrType = $ptrType(ast.File);
- sliceType$2 = $sliceType($Uint8);
- Source = function(src) {
- var $ptr, _r, _r$1, _tuple, err, file, fset, indentAdj, sourceAdj, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; file = $f.file; fset = $f.fset; indentAdj = $f.indentAdj; sourceAdj = $f.sourceAdj; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- fset = token.NewFileSet();
- _r = parse(fset, "", src, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; file = _tuple[0]; sourceAdj = _tuple[1]; indentAdj = _tuple[2]; err = _tuple[3];
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [sliceType$2.nil, err];
- }
- /* */ if (sourceAdj === $throwNilPointerError) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (sourceAdj === $throwNilPointerError) { */ case 2:
- $r = ast.SortImports(fset, file); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 3:
- _r$1 = format(fset, file, sourceAdj, indentAdj, src, config); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Source }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.file = file; $f.fset = fset; $f.indentAdj = indentAdj; $f.sourceAdj = sourceAdj; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.Source = Source;
- parse = function(fset, filename, src, fragmentOk) {
- var $ptr, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _tuple, _tuple$1, _tuple$2, _v, err, file, filename, fragmentOk, fset, fsrc, indentAdj, psrc, sourceAdj, src, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _v = $f._v; err = $f.err; file = $f.file; filename = $f.filename; fragmentOk = $f.fragmentOk; fset = $f.fset; fsrc = $f.fsrc; indentAdj = $f.indentAdj; psrc = $f.psrc; sourceAdj = $f.sourceAdj; src = $f.src; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- file = ptrType.nil;
- sourceAdj = $throwNilPointerError;
- indentAdj = 0;
- err = $ifaceNil;
- _r = parser.ParseFile(fset, filename, src, 4); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _tuple = _r; file = _tuple[0]; err = _tuple[1];
- if ($interfaceIsEqual(err, $ifaceNil) || !fragmentOk) { _v = true; $s = 4; continue s; }
- _r$1 = err.Error(); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- _r$2 = strings.Contains(_r$1, "expected 'package'"); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _v = !_r$2; case 4:
- /* */ if (_v) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (_v) { */ case 2:
- return [file, sourceAdj, indentAdj, err];
- /* } */ case 3:
- psrc = $appendSlice(new sliceType$2($stringToBytes("package p;")), src);
- _r$3 = parser.ParseFile(fset, filename, psrc, 4); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _tuple$1 = _r$3; file = _tuple$1[0]; err = _tuple$1[1];
- /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 8; continue; }
- /* */ $s = 9; continue;
- /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 8:
- sourceAdj = (function $b(src$1, indent) {
- var $ptr, _r$4, indent, src$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$4 = $f._r$4; indent = $f.indent; src$1 = $f.src$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- src$1 = $subslice(src$1, (indent + 10 >> 0));
- _r$4 = bytes.TrimSpace(src$1); /* */ $s = 1; case 1: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- return _r$4;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$4 = _r$4; $f.indent = indent; $f.src$1 = src$1; $f.$s = $s; $f.$r = $r; return $f;
- });
- return [file, sourceAdj, indentAdj, err];
- /* } */ case 9:
- _r$4 = err.Error(); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- _r$5 = strings.Contains(_r$4, "expected declaration"); /* */ $s = 13; case 13: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- /* */ if (!_r$5) { $s = 10; continue; }
- /* */ $s = 11; continue;
- /* if (!_r$5) { */ case 10:
- return [file, sourceAdj, indentAdj, err];
- /* } */ case 11:
- fsrc = $append($appendSlice(new sliceType$2($stringToBytes("package p; func _() {")), src), 10, 125);
- _r$6 = parser.ParseFile(fset, filename, fsrc, 4); /* */ $s = 14; case 14: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- _tuple$2 = _r$6; file = _tuple$2[0]; err = _tuple$2[1];
- if ($interfaceIsEqual(err, $ifaceNil)) {
- sourceAdj = (function $b(src$1, indent) {
- var $ptr, _r$7, indent, src$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$7 = $f._r$7; indent = $f.indent; src$1 = $f.src$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- if (indent < 0) {
- indent = 0;
- }
- src$1 = $subslice(src$1, ((2 * indent >> 0) + 21 >> 0));
- src$1 = $subslice(src$1, 0, (src$1.$length - ((indent + 3 >> 0)) >> 0));
- _r$7 = bytes.TrimSpace(src$1); /* */ $s = 1; case 1: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- return _r$7;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$7 = _r$7; $f.indent = indent; $f.src$1 = src$1; $f.$s = $s; $f.$r = $r; return $f;
- });
- indentAdj = -1;
- }
- return [file, sourceAdj, indentAdj, err];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: parse }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._v = _v; $f.err = err; $f.file = file; $f.filename = filename; $f.fragmentOk = fragmentOk; $f.fset = fset; $f.fsrc = fsrc; $f.indentAdj = indentAdj; $f.psrc = psrc; $f.sourceAdj = sourceAdj; $f.src = src; $f.$s = $s; $f.$r = $r; return $f;
- };
- format = function(fset, file, sourceAdj, indentAdj, src, cfg) {
- var $ptr, _i, _r, _r$1, _r$2, _ref, _ref$1, _tmp, _tmp$1, b, buf, buf$1, cfg, err, err$1, file, fset, hasSpace, i, i$1, indent, indentAdj, j, res, sourceAdj, src, x, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _ref = $f._ref; _ref$1 = $f._ref$1; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; b = $f.b; buf = $f.buf; buf$1 = $f.buf$1; cfg = $f.cfg; err = $f.err; err$1 = $f.err$1; file = $f.file; fset = $f.fset; hasSpace = $f.hasSpace; i = $f.i; i$1 = $f.i$1; indent = $f.indent; indentAdj = $f.indentAdj; j = $f.j; res = $f.res; sourceAdj = $f.sourceAdj; src = $f.src; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- buf = [buf];
- buf$1 = [buf$1];
- cfg = $clone(cfg, printer.Config);
- /* */ if (sourceAdj === $throwNilPointerError) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (sourceAdj === $throwNilPointerError) { */ case 1:
- buf[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _r = cfg.Fprint(buf[0], fset, file); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- err = _r;
- if (!($interfaceIsEqual(err, $ifaceNil))) {
- return [sliceType$2.nil, err];
- }
- return [buf[0].Bytes(), $ifaceNil];
- /* } */ case 2:
- _tmp = 0; _tmp$1 = 0; i = _tmp; j = _tmp$1;
- while (true) {
- if (!(j < src.$length && isSpace(((j < 0 || j >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + j])))) { break; }
- if (((j < 0 || j >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + j]) === 10) {
- i = j + 1 >> 0;
- }
- j = j + (1) >> 0;
- }
- res = sliceType$2.nil;
- res = $appendSlice(res, $subslice(src, 0, i));
- indent = 0;
- hasSpace = false;
- _ref = $subslice(src, i, j);
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- b = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _ref$1 = b;
- if (_ref$1 === 32) {
- hasSpace = true;
- } else if (_ref$1 === 9) {
- indent = indent + (1) >> 0;
- }
- _i++;
- }
- if ((indent === 0) && hasSpace) {
- indent = 1;
- }
- i$1 = 0;
- while (true) {
- if (!(i$1 < indent)) { break; }
- res = $append(res, 9);
- i$1 = i$1 + (1) >> 0;
- }
- cfg.Indent = indent + indentAdj >> 0;
- buf$1[0] = $clone(new bytes.Buffer.ptr(), bytes.Buffer);
- _r$1 = cfg.Fprint(buf$1[0], fset, file); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- err$1 = _r$1;
- if (!($interfaceIsEqual(err$1, $ifaceNil))) {
- return [sliceType$2.nil, err$1];
- }
- _r$2 = sourceAdj(buf$1[0].Bytes(), cfg.Indent); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- res = $appendSlice(res, _r$2);
- i = src.$length;
- while (true) {
- if (!(i > 0 && isSpace((x = i - 1 >> 0, ((x < 0 || x >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + x]))))) { break; }
- i = i - (1) >> 0;
- }
- return [$appendSlice(res, $subslice(src, i)), $ifaceNil];
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: format }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._ref = _ref; $f._ref$1 = _ref$1; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f.b = b; $f.buf = buf; $f.buf$1 = buf$1; $f.cfg = cfg; $f.err = err; $f.err$1 = err$1; $f.file = file; $f.fset = fset; $f.hasSpace = hasSpace; $f.i = i; $f.i$1 = i$1; $f.indent = indent; $f.indentAdj = indentAdj; $f.j = j; $f.res = res; $f.sourceAdj = sourceAdj; $f.src = src; $f.x = x; $f.$s = $s; $f.$r = $r; return $f;
- };
- isSpace = function(b) {
- var $ptr, b;
- return (b === 32) || (b === 9) || (b === 10) || (b === 13);
- };
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = fmt.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = parser.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = printer.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = io.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- config = new printer.Config.ptr(6, 8, 0);
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["honnef.co/go/js/dom"] = (function() {
- var $pkg = {}, $init, js, strings, time, TokenList, Document, document, htmlDocument, URLUtils, Location, HTMLElement, Window, window, Selection, Screen, Navigator, Geolocation, PositionError, PositionOptions, Position, Coordinates, History, Console, DocumentType, DOMImplementation, StyleSheet, Node, BasicNode, Element, ClientRect, BasicHTMLElement, BasicElement, HTMLAnchorElement, HTMLAppletElement, HTMLAreaElement, HTMLAudioElement, HTMLBRElement, HTMLBaseElement, HTMLBodyElement, ValidityState, HTMLButtonElement, HTMLCanvasElement, CanvasRenderingContext2D, HTMLDListElement, HTMLDataElement, HTMLDataListElement, HTMLDirectoryElement, HTMLDivElement, HTMLEmbedElement, HTMLFieldSetElement, HTMLFontElement, HTMLFormElement, HTMLFrameElement, HTMLFrameSetElement, HTMLHRElement, HTMLHeadElement, HTMLHeadingElement, HTMLHtmlElement, HTMLIFrameElement, HTMLImageElement, HTMLInputElement, File, HTMLKeygenElement, HTMLLIElement, HTMLLabelElement, HTMLLegendElement, HTMLLinkElement, HTMLMapElement, HTMLMediaElement, HTMLMenuElement, HTMLMetaElement, HTMLMeterElement, HTMLModElement, HTMLOListElement, HTMLObjectElement, HTMLOptGroupElement, HTMLOptionElement, HTMLOutputElement, HTMLParagraphElement, HTMLParamElement, HTMLPreElement, HTMLProgressElement, HTMLQuoteElement, HTMLScriptElement, HTMLSelectElement, HTMLSourceElement, HTMLSpanElement, HTMLStyleElement, HTMLTableCaptionElement, HTMLTableCellElement, HTMLTableColElement, HTMLTableDataCellElement, HTMLTableElement, HTMLTableHeaderCellElement, HTMLTableRowElement, HTMLTableSectionElement, HTMLTextAreaElement, HTMLTimeElement, HTMLTitleElement, TextTrack, HTMLTrackElement, HTMLUListElement, HTMLUnknownElement, HTMLVideoElement, CSSStyleDeclaration, Text, Event, BasicEvent, AnimationEvent, AudioProcessingEvent, BeforeInputEvent, BeforeUnloadEvent, BlobEvent, ClipboardEvent, CloseEvent, CompositionEvent, CSSFontFaceLoadEvent, CustomEvent, DeviceLightEvent, DeviceMotionEvent, DeviceOrientationEvent, DeviceProximityEvent, DOMTransactionEvent, DragEvent, EditingBeforeInputEvent, ErrorEvent, FocusEvent, GamepadEvent, HashChangeEvent, IDBVersionChangeEvent, KeyboardEvent, MediaStreamEvent, MessageEvent, MouseEvent, MutationEvent, OfflineAudioCompletionEvent, PageTransitionEvent, PointerEvent, PopStateEvent, ProgressEvent, RelatedEvent, RTCPeerConnectionIceEvent, SensorEvent, StorageEvent, SVGEvent, SVGZoomEvent, TimeEvent, TouchEvent, TrackEvent, TransitionEvent, UIEvent, UserProximityEvent, WheelEvent, sliceType, sliceType$1, sliceType$2, sliceType$3, ptrType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, sliceType$4, sliceType$5, sliceType$6, ptrType$5, ptrType$6, sliceType$7, ptrType$7, sliceType$8, ptrType$8, sliceType$9, sliceType$10, ptrType$9, funcType, ptrType$10, funcType$1, ptrType$11, sliceType$11, ptrType$12, sliceType$12, ptrType$13, ptrType$14, sliceType$13, ptrType$15, sliceType$14, ptrType$16, sliceType$15, ptrType$17, ptrType$18, ptrType$19, funcType$2, ptrType$20, ptrType$21, ptrType$22, ptrType$23, ptrType$24, ptrType$25, ptrType$26, ptrType$27, funcType$3, funcType$4, ptrType$28, ptrType$29, ptrType$30, ptrType$31, ptrType$32, ptrType$33, ptrType$34, ptrType$35, ptrType$36, ptrType$37, ptrType$38, ptrType$39, ptrType$40, ptrType$41, ptrType$42, ptrType$43, ptrType$44, ptrType$45, ptrType$46, ptrType$47, ptrType$48, ptrType$49, ptrType$50, mapType, ptrType$51, ptrType$52, callRecover, nodeListToNodes, nodeListToElements, nodeListToHTMLElements, wrapDocument, wrapNode, wrapElement, wrapHTMLElement, getForm, getLabels, GetWindow, wrapEvent;
- js = $packages["github.com/gopherjs/gopherjs/js"];
- strings = $packages["strings"];
- time = $packages["time"];
- TokenList = $pkg.TokenList = $newType(0, $kindStruct, "dom.TokenList", "TokenList", "honnef.co/go/js/dom", function(dtl_, o_, sa_, Length_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.dtl = null;
- this.o = null;
- this.sa = "";
- this.Length = 0;
- return;
- }
- this.dtl = dtl_;
- this.o = o_;
- this.sa = sa_;
- this.Length = Length_;
- });
- Document = $pkg.Document = $newType(8, $kindInterface, "dom.Document", "Document", "honnef.co/go/js/dom", null);
- document = $pkg.document = $newType(0, $kindStruct, "dom.document", "document", "honnef.co/go/js/dom", function(BasicNode_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicNode = ptrType$21.nil;
- return;
- }
- this.BasicNode = BasicNode_;
- });
- htmlDocument = $pkg.htmlDocument = $newType(0, $kindStruct, "dom.htmlDocument", "htmlDocument", "honnef.co/go/js/dom", function(document_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.document = ptrType$22.nil;
- return;
- }
- this.document = document_;
- });
- URLUtils = $pkg.URLUtils = $newType(0, $kindStruct, "dom.URLUtils", "URLUtils", "honnef.co/go/js/dom", function(Object_, Href_, Protocol_, Host_, Hostname_, Port_, Pathname_, Search_, Hash_, Username_, Password_, Origin_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.Href = "";
- this.Protocol = "";
- this.Host = "";
- this.Hostname = "";
- this.Port = "";
- this.Pathname = "";
- this.Search = "";
- this.Hash = "";
- this.Username = "";
- this.Password = "";
- this.Origin = "";
- return;
- }
- this.Object = Object_;
- this.Href = Href_;
- this.Protocol = Protocol_;
- this.Host = Host_;
- this.Hostname = Hostname_;
- this.Port = Port_;
- this.Pathname = Pathname_;
- this.Search = Search_;
- this.Hash = Hash_;
- this.Username = Username_;
- this.Password = Password_;
- this.Origin = Origin_;
- });
- Location = $pkg.Location = $newType(0, $kindStruct, "dom.Location", "Location", "honnef.co/go/js/dom", function(Object_, URLUtils_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.URLUtils = ptrType$1.nil;
- return;
- }
- this.Object = Object_;
- this.URLUtils = URLUtils_;
- });
- HTMLElement = $pkg.HTMLElement = $newType(8, $kindInterface, "dom.HTMLElement", "HTMLElement", "honnef.co/go/js/dom", null);
- Window = $pkg.Window = $newType(8, $kindInterface, "dom.Window", "Window", "honnef.co/go/js/dom", null);
- window = $pkg.window = $newType(0, $kindStruct, "dom.window", "window", "honnef.co/go/js/dom", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- Selection = $pkg.Selection = $newType(8, $kindInterface, "dom.Selection", "Selection", "honnef.co/go/js/dom", null);
- Screen = $pkg.Screen = $newType(0, $kindStruct, "dom.Screen", "Screen", "honnef.co/go/js/dom", function(Object_, AvailTop_, AvailLeft_, AvailHeight_, AvailWidth_, ColorDepth_, Height_, Left_, PixelDepth_, Top_, Width_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.AvailTop = 0;
- this.AvailLeft = 0;
- this.AvailHeight = 0;
- this.AvailWidth = 0;
- this.ColorDepth = 0;
- this.Height = 0;
- this.Left = 0;
- this.PixelDepth = 0;
- this.Top = 0;
- this.Width = 0;
- return;
- }
- this.Object = Object_;
- this.AvailTop = AvailTop_;
- this.AvailLeft = AvailLeft_;
- this.AvailHeight = AvailHeight_;
- this.AvailWidth = AvailWidth_;
- this.ColorDepth = ColorDepth_;
- this.Height = Height_;
- this.Left = Left_;
- this.PixelDepth = PixelDepth_;
- this.Top = Top_;
- this.Width = Width_;
- });
- Navigator = $pkg.Navigator = $newType(8, $kindInterface, "dom.Navigator", "Navigator", "honnef.co/go/js/dom", null);
- Geolocation = $pkg.Geolocation = $newType(8, $kindInterface, "dom.Geolocation", "Geolocation", "honnef.co/go/js/dom", null);
- PositionError = $pkg.PositionError = $newType(0, $kindStruct, "dom.PositionError", "PositionError", "honnef.co/go/js/dom", function(Object_, Code_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.Code = 0;
- return;
- }
- this.Object = Object_;
- this.Code = Code_;
- });
- PositionOptions = $pkg.PositionOptions = $newType(0, $kindStruct, "dom.PositionOptions", "PositionOptions", "honnef.co/go/js/dom", function(EnableHighAccuracy_, Timeout_, MaximumAge_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.EnableHighAccuracy = false;
- this.Timeout = new time.Duration(0, 0);
- this.MaximumAge = new time.Duration(0, 0);
- return;
- }
- this.EnableHighAccuracy = EnableHighAccuracy_;
- this.Timeout = Timeout_;
- this.MaximumAge = MaximumAge_;
- });
- Position = $pkg.Position = $newType(0, $kindStruct, "dom.Position", "Position", "honnef.co/go/js/dom", function(Coords_, Timestamp_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Coords = ptrType$29.nil;
- this.Timestamp = new time.Time.ptr();
- return;
- }
- this.Coords = Coords_;
- this.Timestamp = Timestamp_;
- });
- Coordinates = $pkg.Coordinates = $newType(0, $kindStruct, "dom.Coordinates", "Coordinates", "honnef.co/go/js/dom", function(Object_, Latitude_, Longitude_, Altitude_, Accuracy_, AltitudeAccuracy_, Heading_, Speed_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.Latitude = 0;
- this.Longitude = 0;
- this.Altitude = 0;
- this.Accuracy = 0;
- this.AltitudeAccuracy = 0;
- this.Heading = 0;
- this.Speed = 0;
- return;
- }
- this.Object = Object_;
- this.Latitude = Latitude_;
- this.Longitude = Longitude_;
- this.Altitude = Altitude_;
- this.Accuracy = Accuracy_;
- this.AltitudeAccuracy = AltitudeAccuracy_;
- this.Heading = Heading_;
- this.Speed = Speed_;
- });
- History = $pkg.History = $newType(8, $kindInterface, "dom.History", "History", "honnef.co/go/js/dom", null);
- Console = $pkg.Console = $newType(0, $kindStruct, "dom.Console", "Console", "honnef.co/go/js/dom", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- DocumentType = $pkg.DocumentType = $newType(8, $kindInterface, "dom.DocumentType", "DocumentType", "honnef.co/go/js/dom", null);
- DOMImplementation = $pkg.DOMImplementation = $newType(8, $kindInterface, "dom.DOMImplementation", "DOMImplementation", "honnef.co/go/js/dom", null);
- StyleSheet = $pkg.StyleSheet = $newType(8, $kindInterface, "dom.StyleSheet", "StyleSheet", "honnef.co/go/js/dom", null);
- Node = $pkg.Node = $newType(8, $kindInterface, "dom.Node", "Node", "honnef.co/go/js/dom", null);
- BasicNode = $pkg.BasicNode = $newType(0, $kindStruct, "dom.BasicNode", "BasicNode", "honnef.co/go/js/dom", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- Element = $pkg.Element = $newType(8, $kindInterface, "dom.Element", "Element", "honnef.co/go/js/dom", null);
- ClientRect = $pkg.ClientRect = $newType(0, $kindStruct, "dom.ClientRect", "ClientRect", "honnef.co/go/js/dom", function(Object_, Height_, Width_, Left_, Right_, Top_, Bottom_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.Height = 0;
- this.Width = 0;
- this.Left = 0;
- this.Right = 0;
- this.Top = 0;
- this.Bottom = 0;
- return;
- }
- this.Object = Object_;
- this.Height = Height_;
- this.Width = Width_;
- this.Left = Left_;
- this.Right = Right_;
- this.Top = Top_;
- this.Bottom = Bottom_;
- });
- BasicHTMLElement = $pkg.BasicHTMLElement = $newType(0, $kindStruct, "dom.BasicHTMLElement", "BasicHTMLElement", "honnef.co/go/js/dom", function(BasicElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicElement = ptrType$30.nil;
- return;
- }
- this.BasicElement = BasicElement_;
- });
- BasicElement = $pkg.BasicElement = $newType(0, $kindStruct, "dom.BasicElement", "BasicElement", "honnef.co/go/js/dom", function(BasicNode_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicNode = ptrType$21.nil;
- return;
- }
- this.BasicNode = BasicNode_;
- });
- HTMLAnchorElement = $pkg.HTMLAnchorElement = $newType(0, $kindStruct, "dom.HTMLAnchorElement", "HTMLAnchorElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, URLUtils_, HrefLang_, Media_, TabIndex_, Target_, Text_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.URLUtils = ptrType$1.nil;
- this.HrefLang = "";
- this.Media = "";
- this.TabIndex = 0;
- this.Target = "";
- this.Text = "";
- this.Type = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.URLUtils = URLUtils_;
- this.HrefLang = HrefLang_;
- this.Media = Media_;
- this.TabIndex = TabIndex_;
- this.Target = Target_;
- this.Text = Text_;
- this.Type = Type_;
- });
- HTMLAppletElement = $pkg.HTMLAppletElement = $newType(0, $kindStruct, "dom.HTMLAppletElement", "HTMLAppletElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Alt_, Coords_, HrefLang_, Media_, Search_, Shape_, TabIndex_, Target_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Alt = "";
- this.Coords = "";
- this.HrefLang = "";
- this.Media = "";
- this.Search = "";
- this.Shape = "";
- this.TabIndex = 0;
- this.Target = "";
- this.Type = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Alt = Alt_;
- this.Coords = Coords_;
- this.HrefLang = HrefLang_;
- this.Media = Media_;
- this.Search = Search_;
- this.Shape = Shape_;
- this.TabIndex = TabIndex_;
- this.Target = Target_;
- this.Type = Type_;
- });
- HTMLAreaElement = $pkg.HTMLAreaElement = $newType(0, $kindStruct, "dom.HTMLAreaElement", "HTMLAreaElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, URLUtils_, Alt_, Coords_, HrefLang_, Media_, Search_, Shape_, TabIndex_, Target_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.URLUtils = ptrType$1.nil;
- this.Alt = "";
- this.Coords = "";
- this.HrefLang = "";
- this.Media = "";
- this.Search = "";
- this.Shape = "";
- this.TabIndex = 0;
- this.Target = "";
- this.Type = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.URLUtils = URLUtils_;
- this.Alt = Alt_;
- this.Coords = Coords_;
- this.HrefLang = HrefLang_;
- this.Media = Media_;
- this.Search = Search_;
- this.Shape = Shape_;
- this.TabIndex = TabIndex_;
- this.Target = Target_;
- this.Type = Type_;
- });
- HTMLAudioElement = $pkg.HTMLAudioElement = $newType(0, $kindStruct, "dom.HTMLAudioElement", "HTMLAudioElement", "honnef.co/go/js/dom", function(HTMLMediaElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.HTMLMediaElement = ptrType$2.nil;
- return;
- }
- this.HTMLMediaElement = HTMLMediaElement_;
- });
- HTMLBRElement = $pkg.HTMLBRElement = $newType(0, $kindStruct, "dom.HTMLBRElement", "HTMLBRElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLBaseElement = $pkg.HTMLBaseElement = $newType(0, $kindStruct, "dom.HTMLBaseElement", "HTMLBaseElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLBodyElement = $pkg.HTMLBodyElement = $newType(0, $kindStruct, "dom.HTMLBodyElement", "HTMLBodyElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- ValidityState = $pkg.ValidityState = $newType(0, $kindStruct, "dom.ValidityState", "ValidityState", "honnef.co/go/js/dom", function(Object_, CustomError_, PatternMismatch_, RangeOverflow_, RangeUnderflow_, StepMismatch_, TooLong_, TypeMismatch_, Valid_, ValueMissing_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.CustomError = false;
- this.PatternMismatch = false;
- this.RangeOverflow = false;
- this.RangeUnderflow = false;
- this.StepMismatch = false;
- this.TooLong = false;
- this.TypeMismatch = false;
- this.Valid = false;
- this.ValueMissing = false;
- return;
- }
- this.Object = Object_;
- this.CustomError = CustomError_;
- this.PatternMismatch = PatternMismatch_;
- this.RangeOverflow = RangeOverflow_;
- this.RangeUnderflow = RangeUnderflow_;
- this.StepMismatch = StepMismatch_;
- this.TooLong = TooLong_;
- this.TypeMismatch = TypeMismatch_;
- this.Valid = Valid_;
- this.ValueMissing = ValueMissing_;
- });
- HTMLButtonElement = $pkg.HTMLButtonElement = $newType(0, $kindStruct, "dom.HTMLButtonElement", "HTMLButtonElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, AutoFocus_, Disabled_, FormAction_, FormEncType_, FormMethod_, FormNoValidate_, FormTarget_, Name_, TabIndex_, Type_, ValidationMessage_, Value_, WillValidate_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.AutoFocus = false;
- this.Disabled = false;
- this.FormAction = "";
- this.FormEncType = "";
- this.FormMethod = "";
- this.FormNoValidate = false;
- this.FormTarget = "";
- this.Name = "";
- this.TabIndex = 0;
- this.Type = "";
- this.ValidationMessage = "";
- this.Value = "";
- this.WillValidate = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.AutoFocus = AutoFocus_;
- this.Disabled = Disabled_;
- this.FormAction = FormAction_;
- this.FormEncType = FormEncType_;
- this.FormMethod = FormMethod_;
- this.FormNoValidate = FormNoValidate_;
- this.FormTarget = FormTarget_;
- this.Name = Name_;
- this.TabIndex = TabIndex_;
- this.Type = Type_;
- this.ValidationMessage = ValidationMessage_;
- this.Value = Value_;
- this.WillValidate = WillValidate_;
- });
- HTMLCanvasElement = $pkg.HTMLCanvasElement = $newType(0, $kindStruct, "dom.HTMLCanvasElement", "HTMLCanvasElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Height_, Width_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Height = 0;
- this.Width = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Height = Height_;
- this.Width = Width_;
- });
- CanvasRenderingContext2D = $pkg.CanvasRenderingContext2D = $newType(0, $kindStruct, "dom.CanvasRenderingContext2D", "CanvasRenderingContext2D", "honnef.co/go/js/dom", function(Object_, FillStyle_, StrokeStyle_, ShadowColor_, ShadowBlur_, ShadowOffsetX_, ShadowOffsetY_, LineCap_, LineJoin_, LineWidth_, MiterLimit_, Font_, TextAlign_, TextBaseline_, GlobalAlpha_, GlobalCompositeOperation_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.FillStyle = "";
- this.StrokeStyle = "";
- this.ShadowColor = "";
- this.ShadowBlur = 0;
- this.ShadowOffsetX = 0;
- this.ShadowOffsetY = 0;
- this.LineCap = "";
- this.LineJoin = "";
- this.LineWidth = 0;
- this.MiterLimit = 0;
- this.Font = "";
- this.TextAlign = "";
- this.TextBaseline = "";
- this.GlobalAlpha = 0;
- this.GlobalCompositeOperation = "";
- return;
- }
- this.Object = Object_;
- this.FillStyle = FillStyle_;
- this.StrokeStyle = StrokeStyle_;
- this.ShadowColor = ShadowColor_;
- this.ShadowBlur = ShadowBlur_;
- this.ShadowOffsetX = ShadowOffsetX_;
- this.ShadowOffsetY = ShadowOffsetY_;
- this.LineCap = LineCap_;
- this.LineJoin = LineJoin_;
- this.LineWidth = LineWidth_;
- this.MiterLimit = MiterLimit_;
- this.Font = Font_;
- this.TextAlign = TextAlign_;
- this.TextBaseline = TextBaseline_;
- this.GlobalAlpha = GlobalAlpha_;
- this.GlobalCompositeOperation = GlobalCompositeOperation_;
- });
- HTMLDListElement = $pkg.HTMLDListElement = $newType(0, $kindStruct, "dom.HTMLDListElement", "HTMLDListElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLDataElement = $pkg.HTMLDataElement = $newType(0, $kindStruct, "dom.HTMLDataElement", "HTMLDataElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Value = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Value = Value_;
- });
- HTMLDataListElement = $pkg.HTMLDataListElement = $newType(0, $kindStruct, "dom.HTMLDataListElement", "HTMLDataListElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLDirectoryElement = $pkg.HTMLDirectoryElement = $newType(0, $kindStruct, "dom.HTMLDirectoryElement", "HTMLDirectoryElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLDivElement = $pkg.HTMLDivElement = $newType(0, $kindStruct, "dom.HTMLDivElement", "HTMLDivElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLEmbedElement = $pkg.HTMLEmbedElement = $newType(0, $kindStruct, "dom.HTMLEmbedElement", "HTMLEmbedElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Src_, Type_, Width_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Src = "";
- this.Type = "";
- this.Width = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Src = Src_;
- this.Type = Type_;
- this.Width = Width_;
- });
- HTMLFieldSetElement = $pkg.HTMLFieldSetElement = $newType(0, $kindStruct, "dom.HTMLFieldSetElement", "HTMLFieldSetElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Disabled_, Name_, Type_, ValidationMessage_, WillValidate_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Disabled = false;
- this.Name = "";
- this.Type = "";
- this.ValidationMessage = "";
- this.WillValidate = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Disabled = Disabled_;
- this.Name = Name_;
- this.Type = Type_;
- this.ValidationMessage = ValidationMessage_;
- this.WillValidate = WillValidate_;
- });
- HTMLFontElement = $pkg.HTMLFontElement = $newType(0, $kindStruct, "dom.HTMLFontElement", "HTMLFontElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLFormElement = $pkg.HTMLFormElement = $newType(0, $kindStruct, "dom.HTMLFormElement", "HTMLFormElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, AcceptCharset_, Action_, Autocomplete_, Encoding_, Enctype_, Length_, Method_, Name_, NoValidate_, Target_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.AcceptCharset = "";
- this.Action = "";
- this.Autocomplete = "";
- this.Encoding = "";
- this.Enctype = "";
- this.Length = 0;
- this.Method = "";
- this.Name = "";
- this.NoValidate = false;
- this.Target = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.AcceptCharset = AcceptCharset_;
- this.Action = Action_;
- this.Autocomplete = Autocomplete_;
- this.Encoding = Encoding_;
- this.Enctype = Enctype_;
- this.Length = Length_;
- this.Method = Method_;
- this.Name = Name_;
- this.NoValidate = NoValidate_;
- this.Target = Target_;
- });
- HTMLFrameElement = $pkg.HTMLFrameElement = $newType(0, $kindStruct, "dom.HTMLFrameElement", "HTMLFrameElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLFrameSetElement = $pkg.HTMLFrameSetElement = $newType(0, $kindStruct, "dom.HTMLFrameSetElement", "HTMLFrameSetElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLHRElement = $pkg.HTMLHRElement = $newType(0, $kindStruct, "dom.HTMLHRElement", "HTMLHRElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLHeadElement = $pkg.HTMLHeadElement = $newType(0, $kindStruct, "dom.HTMLHeadElement", "HTMLHeadElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLHeadingElement = $pkg.HTMLHeadingElement = $newType(0, $kindStruct, "dom.HTMLHeadingElement", "HTMLHeadingElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLHtmlElement = $pkg.HTMLHtmlElement = $newType(0, $kindStruct, "dom.HTMLHtmlElement", "HTMLHtmlElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLIFrameElement = $pkg.HTMLIFrameElement = $newType(0, $kindStruct, "dom.HTMLIFrameElement", "HTMLIFrameElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Width_, Height_, Name_, Src_, SrcDoc_, Seamless_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Width = "";
- this.Height = "";
- this.Name = "";
- this.Src = "";
- this.SrcDoc = "";
- this.Seamless = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Width = Width_;
- this.Height = Height_;
- this.Name = Name_;
- this.Src = Src_;
- this.SrcDoc = SrcDoc_;
- this.Seamless = Seamless_;
- });
- HTMLImageElement = $pkg.HTMLImageElement = $newType(0, $kindStruct, "dom.HTMLImageElement", "HTMLImageElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Complete_, CrossOrigin_, Height_, IsMap_, NaturalHeight_, NaturalWidth_, Src_, UseMap_, Width_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Complete = false;
- this.CrossOrigin = "";
- this.Height = 0;
- this.IsMap = false;
- this.NaturalHeight = 0;
- this.NaturalWidth = 0;
- this.Src = "";
- this.UseMap = "";
- this.Width = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Complete = Complete_;
- this.CrossOrigin = CrossOrigin_;
- this.Height = Height_;
- this.IsMap = IsMap_;
- this.NaturalHeight = NaturalHeight_;
- this.NaturalWidth = NaturalWidth_;
- this.Src = Src_;
- this.UseMap = UseMap_;
- this.Width = Width_;
- });
- HTMLInputElement = $pkg.HTMLInputElement = $newType(0, $kindStruct, "dom.HTMLInputElement", "HTMLInputElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Accept_, Alt_, Autocomplete_, Autofocus_, Checked_, DefaultChecked_, DefaultValue_, DirName_, Disabled_, FormAction_, FormEncType_, FormMethod_, FormNoValidate_, FormTarget_, Height_, Indeterminate_, Max_, MaxLength_, Min_, Multiple_, Name_, Pattern_, Placeholder_, ReadOnly_, Required_, SelectionDirection_, SelectionEnd_, SelectionStart_, Size_, Src_, Step_, TabIndex_, Type_, ValidationMessage_, Value_, ValueAsDate_, ValueAsNumber_, Width_, WillValidate_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Accept = "";
- this.Alt = "";
- this.Autocomplete = "";
- this.Autofocus = false;
- this.Checked = false;
- this.DefaultChecked = false;
- this.DefaultValue = "";
- this.DirName = "";
- this.Disabled = false;
- this.FormAction = "";
- this.FormEncType = "";
- this.FormMethod = "";
- this.FormNoValidate = false;
- this.FormTarget = "";
- this.Height = "";
- this.Indeterminate = false;
- this.Max = "";
- this.MaxLength = 0;
- this.Min = "";
- this.Multiple = false;
- this.Name = "";
- this.Pattern = "";
- this.Placeholder = "";
- this.ReadOnly = false;
- this.Required = false;
- this.SelectionDirection = "";
- this.SelectionEnd = 0;
- this.SelectionStart = 0;
- this.Size = 0;
- this.Src = "";
- this.Step = "";
- this.TabIndex = 0;
- this.Type = "";
- this.ValidationMessage = "";
- this.Value = "";
- this.ValueAsDate = new time.Time.ptr();
- this.ValueAsNumber = 0;
- this.Width = "";
- this.WillValidate = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Accept = Accept_;
- this.Alt = Alt_;
- this.Autocomplete = Autocomplete_;
- this.Autofocus = Autofocus_;
- this.Checked = Checked_;
- this.DefaultChecked = DefaultChecked_;
- this.DefaultValue = DefaultValue_;
- this.DirName = DirName_;
- this.Disabled = Disabled_;
- this.FormAction = FormAction_;
- this.FormEncType = FormEncType_;
- this.FormMethod = FormMethod_;
- this.FormNoValidate = FormNoValidate_;
- this.FormTarget = FormTarget_;
- this.Height = Height_;
- this.Indeterminate = Indeterminate_;
- this.Max = Max_;
- this.MaxLength = MaxLength_;
- this.Min = Min_;
- this.Multiple = Multiple_;
- this.Name = Name_;
- this.Pattern = Pattern_;
- this.Placeholder = Placeholder_;
- this.ReadOnly = ReadOnly_;
- this.Required = Required_;
- this.SelectionDirection = SelectionDirection_;
- this.SelectionEnd = SelectionEnd_;
- this.SelectionStart = SelectionStart_;
- this.Size = Size_;
- this.Src = Src_;
- this.Step = Step_;
- this.TabIndex = TabIndex_;
- this.Type = Type_;
- this.ValidationMessage = ValidationMessage_;
- this.Value = Value_;
- this.ValueAsDate = ValueAsDate_;
- this.ValueAsNumber = ValueAsNumber_;
- this.Width = Width_;
- this.WillValidate = WillValidate_;
- });
- File = $pkg.File = $newType(0, $kindStruct, "dom.File", "File", "honnef.co/go/js/dom", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- HTMLKeygenElement = $pkg.HTMLKeygenElement = $newType(0, $kindStruct, "dom.HTMLKeygenElement", "HTMLKeygenElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Autofocus_, Challenge_, Disabled_, Keytype_, Name_, Type_, ValidationMessage_, WillValidate_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Autofocus = false;
- this.Challenge = "";
- this.Disabled = false;
- this.Keytype = "";
- this.Name = "";
- this.Type = "";
- this.ValidationMessage = "";
- this.WillValidate = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Autofocus = Autofocus_;
- this.Challenge = Challenge_;
- this.Disabled = Disabled_;
- this.Keytype = Keytype_;
- this.Name = Name_;
- this.Type = Type_;
- this.ValidationMessage = ValidationMessage_;
- this.WillValidate = WillValidate_;
- });
- HTMLLIElement = $pkg.HTMLLIElement = $newType(0, $kindStruct, "dom.HTMLLIElement", "HTMLLIElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Value = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Value = Value_;
- });
- HTMLLabelElement = $pkg.HTMLLabelElement = $newType(0, $kindStruct, "dom.HTMLLabelElement", "HTMLLabelElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, For_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.For = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.For = For_;
- });
- HTMLLegendElement = $pkg.HTMLLegendElement = $newType(0, $kindStruct, "dom.HTMLLegendElement", "HTMLLegendElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLLinkElement = $pkg.HTMLLinkElement = $newType(0, $kindStruct, "dom.HTMLLinkElement", "HTMLLinkElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Disabled_, Href_, HrefLang_, Media_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Disabled = false;
- this.Href = "";
- this.HrefLang = "";
- this.Media = "";
- this.Type = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Disabled = Disabled_;
- this.Href = Href_;
- this.HrefLang = HrefLang_;
- this.Media = Media_;
- this.Type = Type_;
- });
- HTMLMapElement = $pkg.HTMLMapElement = $newType(0, $kindStruct, "dom.HTMLMapElement", "HTMLMapElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Name_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Name = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Name = Name_;
- });
- HTMLMediaElement = $pkg.HTMLMediaElement = $newType(0, $kindStruct, "dom.HTMLMediaElement", "HTMLMediaElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLMenuElement = $pkg.HTMLMenuElement = $newType(0, $kindStruct, "dom.HTMLMenuElement", "HTMLMenuElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLMetaElement = $pkg.HTMLMetaElement = $newType(0, $kindStruct, "dom.HTMLMetaElement", "HTMLMetaElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Content_, HTTPEquiv_, Name_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Content = "";
- this.HTTPEquiv = "";
- this.Name = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Content = Content_;
- this.HTTPEquiv = HTTPEquiv_;
- this.Name = Name_;
- });
- HTMLMeterElement = $pkg.HTMLMeterElement = $newType(0, $kindStruct, "dom.HTMLMeterElement", "HTMLMeterElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, High_, Low_, Max_, Min_, Optimum_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.High = 0;
- this.Low = 0;
- this.Max = 0;
- this.Min = 0;
- this.Optimum = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.High = High_;
- this.Low = Low_;
- this.Max = Max_;
- this.Min = Min_;
- this.Optimum = Optimum_;
- });
- HTMLModElement = $pkg.HTMLModElement = $newType(0, $kindStruct, "dom.HTMLModElement", "HTMLModElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Cite_, DateTime_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Cite = "";
- this.DateTime = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Cite = Cite_;
- this.DateTime = DateTime_;
- });
- HTMLOListElement = $pkg.HTMLOListElement = $newType(0, $kindStruct, "dom.HTMLOListElement", "HTMLOListElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Reversed_, Start_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Reversed = false;
- this.Start = 0;
- this.Type = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Reversed = Reversed_;
- this.Start = Start_;
- this.Type = Type_;
- });
- HTMLObjectElement = $pkg.HTMLObjectElement = $newType(0, $kindStruct, "dom.HTMLObjectElement", "HTMLObjectElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Data_, Height_, Name_, TabIndex_, Type_, TypeMustMatch_, UseMap_, ValidationMessage_, With_, WillValidate_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Data = "";
- this.Height = "";
- this.Name = "";
- this.TabIndex = 0;
- this.Type = "";
- this.TypeMustMatch = false;
- this.UseMap = "";
- this.ValidationMessage = "";
- this.With = "";
- this.WillValidate = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Data = Data_;
- this.Height = Height_;
- this.Name = Name_;
- this.TabIndex = TabIndex_;
- this.Type = Type_;
- this.TypeMustMatch = TypeMustMatch_;
- this.UseMap = UseMap_;
- this.ValidationMessage = ValidationMessage_;
- this.With = With_;
- this.WillValidate = WillValidate_;
- });
- HTMLOptGroupElement = $pkg.HTMLOptGroupElement = $newType(0, $kindStruct, "dom.HTMLOptGroupElement", "HTMLOptGroupElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Disabled_, Label_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Disabled = false;
- this.Label = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Disabled = Disabled_;
- this.Label = Label_;
- });
- HTMLOptionElement = $pkg.HTMLOptionElement = $newType(0, $kindStruct, "dom.HTMLOptionElement", "HTMLOptionElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, DefaultSelected_, Disabled_, Index_, Label_, Selected_, Text_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.DefaultSelected = false;
- this.Disabled = false;
- this.Index = 0;
- this.Label = "";
- this.Selected = false;
- this.Text = "";
- this.Value = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.DefaultSelected = DefaultSelected_;
- this.Disabled = Disabled_;
- this.Index = Index_;
- this.Label = Label_;
- this.Selected = Selected_;
- this.Text = Text_;
- this.Value = Value_;
- });
- HTMLOutputElement = $pkg.HTMLOutputElement = $newType(0, $kindStruct, "dom.HTMLOutputElement", "HTMLOutputElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, DefaultValue_, Name_, Type_, ValidationMessage_, Value_, WillValidate_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.DefaultValue = "";
- this.Name = "";
- this.Type = "";
- this.ValidationMessage = "";
- this.Value = "";
- this.WillValidate = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.DefaultValue = DefaultValue_;
- this.Name = Name_;
- this.Type = Type_;
- this.ValidationMessage = ValidationMessage_;
- this.Value = Value_;
- this.WillValidate = WillValidate_;
- });
- HTMLParagraphElement = $pkg.HTMLParagraphElement = $newType(0, $kindStruct, "dom.HTMLParagraphElement", "HTMLParagraphElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLParamElement = $pkg.HTMLParamElement = $newType(0, $kindStruct, "dom.HTMLParamElement", "HTMLParamElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Name_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Name = "";
- this.Value = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Name = Name_;
- this.Value = Value_;
- });
- HTMLPreElement = $pkg.HTMLPreElement = $newType(0, $kindStruct, "dom.HTMLPreElement", "HTMLPreElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLProgressElement = $pkg.HTMLProgressElement = $newType(0, $kindStruct, "dom.HTMLProgressElement", "HTMLProgressElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Max_, Position_, Value_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Max = 0;
- this.Position = 0;
- this.Value = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Max = Max_;
- this.Position = Position_;
- this.Value = Value_;
- });
- HTMLQuoteElement = $pkg.HTMLQuoteElement = $newType(0, $kindStruct, "dom.HTMLQuoteElement", "HTMLQuoteElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Cite_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Cite = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Cite = Cite_;
- });
- HTMLScriptElement = $pkg.HTMLScriptElement = $newType(0, $kindStruct, "dom.HTMLScriptElement", "HTMLScriptElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Type_, Src_, Charset_, Async_, Defer_, Text_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Type = "";
- this.Src = "";
- this.Charset = "";
- this.Async = false;
- this.Defer = false;
- this.Text = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Type = Type_;
- this.Src = Src_;
- this.Charset = Charset_;
- this.Async = Async_;
- this.Defer = Defer_;
- this.Text = Text_;
- });
- HTMLSelectElement = $pkg.HTMLSelectElement = $newType(0, $kindStruct, "dom.HTMLSelectElement", "HTMLSelectElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Autofocus_, Disabled_, Length_, Multiple_, Name_, Required_, SelectedIndex_, Size_, Type_, ValidationMessage_, Value_, WillValidate_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Autofocus = false;
- this.Disabled = false;
- this.Length = 0;
- this.Multiple = false;
- this.Name = "";
- this.Required = false;
- this.SelectedIndex = 0;
- this.Size = 0;
- this.Type = "";
- this.ValidationMessage = "";
- this.Value = "";
- this.WillValidate = false;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Autofocus = Autofocus_;
- this.Disabled = Disabled_;
- this.Length = Length_;
- this.Multiple = Multiple_;
- this.Name = Name_;
- this.Required = Required_;
- this.SelectedIndex = SelectedIndex_;
- this.Size = Size_;
- this.Type = Type_;
- this.ValidationMessage = ValidationMessage_;
- this.Value = Value_;
- this.WillValidate = WillValidate_;
- });
- HTMLSourceElement = $pkg.HTMLSourceElement = $newType(0, $kindStruct, "dom.HTMLSourceElement", "HTMLSourceElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Media_, Src_, Type_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Media = "";
- this.Src = "";
- this.Type = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Media = Media_;
- this.Src = Src_;
- this.Type = Type_;
- });
- HTMLSpanElement = $pkg.HTMLSpanElement = $newType(0, $kindStruct, "dom.HTMLSpanElement", "HTMLSpanElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLStyleElement = $pkg.HTMLStyleElement = $newType(0, $kindStruct, "dom.HTMLStyleElement", "HTMLStyleElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLTableCaptionElement = $pkg.HTMLTableCaptionElement = $newType(0, $kindStruct, "dom.HTMLTableCaptionElement", "HTMLTableCaptionElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLTableCellElement = $pkg.HTMLTableCellElement = $newType(0, $kindStruct, "dom.HTMLTableCellElement", "HTMLTableCellElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, ColSpan_, RowSpan_, CellIndex_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.ColSpan = 0;
- this.RowSpan = 0;
- this.CellIndex = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.ColSpan = ColSpan_;
- this.RowSpan = RowSpan_;
- this.CellIndex = CellIndex_;
- });
- HTMLTableColElement = $pkg.HTMLTableColElement = $newType(0, $kindStruct, "dom.HTMLTableColElement", "HTMLTableColElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Span_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Span = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Span = Span_;
- });
- HTMLTableDataCellElement = $pkg.HTMLTableDataCellElement = $newType(0, $kindStruct, "dom.HTMLTableDataCellElement", "HTMLTableDataCellElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLTableElement = $pkg.HTMLTableElement = $newType(0, $kindStruct, "dom.HTMLTableElement", "HTMLTableElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLTableHeaderCellElement = $pkg.HTMLTableHeaderCellElement = $newType(0, $kindStruct, "dom.HTMLTableHeaderCellElement", "HTMLTableHeaderCellElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Abbr_, Scope_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Abbr = "";
- this.Scope = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Abbr = Abbr_;
- this.Scope = Scope_;
- });
- HTMLTableRowElement = $pkg.HTMLTableRowElement = $newType(0, $kindStruct, "dom.HTMLTableRowElement", "HTMLTableRowElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, RowIndex_, SectionRowIndex_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.RowIndex = 0;
- this.SectionRowIndex = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.RowIndex = RowIndex_;
- this.SectionRowIndex = SectionRowIndex_;
- });
- HTMLTableSectionElement = $pkg.HTMLTableSectionElement = $newType(0, $kindStruct, "dom.HTMLTableSectionElement", "HTMLTableSectionElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLTextAreaElement = $pkg.HTMLTextAreaElement = $newType(0, $kindStruct, "dom.HTMLTextAreaElement", "HTMLTextAreaElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Autocomplete_, Autofocus_, Cols_, DefaultValue_, DirName_, Disabled_, MaxLength_, Name_, Placeholder_, ReadOnly_, Required_, Rows_, SelectionDirection_, SelectionStart_, SelectionEnd_, TabIndex_, TextLength_, Type_, ValidationMessage_, Value_, WillValidate_, Wrap_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Autocomplete = "";
- this.Autofocus = false;
- this.Cols = 0;
- this.DefaultValue = "";
- this.DirName = "";
- this.Disabled = false;
- this.MaxLength = 0;
- this.Name = "";
- this.Placeholder = "";
- this.ReadOnly = false;
- this.Required = false;
- this.Rows = 0;
- this.SelectionDirection = "";
- this.SelectionStart = 0;
- this.SelectionEnd = 0;
- this.TabIndex = 0;
- this.TextLength = 0;
- this.Type = "";
- this.ValidationMessage = "";
- this.Value = "";
- this.WillValidate = false;
- this.Wrap = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Autocomplete = Autocomplete_;
- this.Autofocus = Autofocus_;
- this.Cols = Cols_;
- this.DefaultValue = DefaultValue_;
- this.DirName = DirName_;
- this.Disabled = Disabled_;
- this.MaxLength = MaxLength_;
- this.Name = Name_;
- this.Placeholder = Placeholder_;
- this.ReadOnly = ReadOnly_;
- this.Required = Required_;
- this.Rows = Rows_;
- this.SelectionDirection = SelectionDirection_;
- this.SelectionStart = SelectionStart_;
- this.SelectionEnd = SelectionEnd_;
- this.TabIndex = TabIndex_;
- this.TextLength = TextLength_;
- this.Type = Type_;
- this.ValidationMessage = ValidationMessage_;
- this.Value = Value_;
- this.WillValidate = WillValidate_;
- this.Wrap = Wrap_;
- });
- HTMLTimeElement = $pkg.HTMLTimeElement = $newType(0, $kindStruct, "dom.HTMLTimeElement", "HTMLTimeElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, DateTime_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.DateTime = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.DateTime = DateTime_;
- });
- HTMLTitleElement = $pkg.HTMLTitleElement = $newType(0, $kindStruct, "dom.HTMLTitleElement", "HTMLTitleElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Text_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Text = "";
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Text = Text_;
- });
- TextTrack = $pkg.TextTrack = $newType(0, $kindStruct, "dom.TextTrack", "TextTrack", "honnef.co/go/js/dom", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- HTMLTrackElement = $pkg.HTMLTrackElement = $newType(0, $kindStruct, "dom.HTMLTrackElement", "HTMLTrackElement", "honnef.co/go/js/dom", function(BasicHTMLElement_, Kind_, Src_, Srclang_, Label_, Default_, ReadyState_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- this.Kind = "";
- this.Src = "";
- this.Srclang = "";
- this.Label = "";
- this.Default = false;
- this.ReadyState = 0;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- this.Kind = Kind_;
- this.Src = Src_;
- this.Srclang = Srclang_;
- this.Label = Label_;
- this.Default = Default_;
- this.ReadyState = ReadyState_;
- });
- HTMLUListElement = $pkg.HTMLUListElement = $newType(0, $kindStruct, "dom.HTMLUListElement", "HTMLUListElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLUnknownElement = $pkg.HTMLUnknownElement = $newType(0, $kindStruct, "dom.HTMLUnknownElement", "HTMLUnknownElement", "honnef.co/go/js/dom", function(BasicHTMLElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicHTMLElement = ptrType.nil;
- return;
- }
- this.BasicHTMLElement = BasicHTMLElement_;
- });
- HTMLVideoElement = $pkg.HTMLVideoElement = $newType(0, $kindStruct, "dom.HTMLVideoElement", "HTMLVideoElement", "honnef.co/go/js/dom", function(HTMLMediaElement_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.HTMLMediaElement = ptrType$2.nil;
- return;
- }
- this.HTMLMediaElement = HTMLMediaElement_;
- });
- CSSStyleDeclaration = $pkg.CSSStyleDeclaration = $newType(0, $kindStruct, "dom.CSSStyleDeclaration", "CSSStyleDeclaration", "honnef.co/go/js/dom", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- Text = $pkg.Text = $newType(0, $kindStruct, "dom.Text", "Text", "honnef.co/go/js/dom", function(BasicNode_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicNode = ptrType$21.nil;
- return;
- }
- this.BasicNode = BasicNode_;
- });
- Event = $pkg.Event = $newType(8, $kindInterface, "dom.Event", "Event", "honnef.co/go/js/dom", null);
- BasicEvent = $pkg.BasicEvent = $newType(0, $kindStruct, "dom.BasicEvent", "BasicEvent", "honnef.co/go/js/dom", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- AnimationEvent = $pkg.AnimationEvent = $newType(0, $kindStruct, "dom.AnimationEvent", "AnimationEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- AudioProcessingEvent = $pkg.AudioProcessingEvent = $newType(0, $kindStruct, "dom.AudioProcessingEvent", "AudioProcessingEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- BeforeInputEvent = $pkg.BeforeInputEvent = $newType(0, $kindStruct, "dom.BeforeInputEvent", "BeforeInputEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- BeforeUnloadEvent = $pkg.BeforeUnloadEvent = $newType(0, $kindStruct, "dom.BeforeUnloadEvent", "BeforeUnloadEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- BlobEvent = $pkg.BlobEvent = $newType(0, $kindStruct, "dom.BlobEvent", "BlobEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- ClipboardEvent = $pkg.ClipboardEvent = $newType(0, $kindStruct, "dom.ClipboardEvent", "ClipboardEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- CloseEvent = $pkg.CloseEvent = $newType(0, $kindStruct, "dom.CloseEvent", "CloseEvent", "honnef.co/go/js/dom", function(BasicEvent_, Code_, Reason_, WasClean_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- this.Code = 0;
- this.Reason = "";
- this.WasClean = false;
- return;
- }
- this.BasicEvent = BasicEvent_;
- this.Code = Code_;
- this.Reason = Reason_;
- this.WasClean = WasClean_;
- });
- CompositionEvent = $pkg.CompositionEvent = $newType(0, $kindStruct, "dom.CompositionEvent", "CompositionEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- CSSFontFaceLoadEvent = $pkg.CSSFontFaceLoadEvent = $newType(0, $kindStruct, "dom.CSSFontFaceLoadEvent", "CSSFontFaceLoadEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- CustomEvent = $pkg.CustomEvent = $newType(0, $kindStruct, "dom.CustomEvent", "CustomEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- DeviceLightEvent = $pkg.DeviceLightEvent = $newType(0, $kindStruct, "dom.DeviceLightEvent", "DeviceLightEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- DeviceMotionEvent = $pkg.DeviceMotionEvent = $newType(0, $kindStruct, "dom.DeviceMotionEvent", "DeviceMotionEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- DeviceOrientationEvent = $pkg.DeviceOrientationEvent = $newType(0, $kindStruct, "dom.DeviceOrientationEvent", "DeviceOrientationEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- DeviceProximityEvent = $pkg.DeviceProximityEvent = $newType(0, $kindStruct, "dom.DeviceProximityEvent", "DeviceProximityEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- DOMTransactionEvent = $pkg.DOMTransactionEvent = $newType(0, $kindStruct, "dom.DOMTransactionEvent", "DOMTransactionEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- DragEvent = $pkg.DragEvent = $newType(0, $kindStruct, "dom.DragEvent", "DragEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- EditingBeforeInputEvent = $pkg.EditingBeforeInputEvent = $newType(0, $kindStruct, "dom.EditingBeforeInputEvent", "EditingBeforeInputEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- ErrorEvent = $pkg.ErrorEvent = $newType(0, $kindStruct, "dom.ErrorEvent", "ErrorEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- FocusEvent = $pkg.FocusEvent = $newType(0, $kindStruct, "dom.FocusEvent", "FocusEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- GamepadEvent = $pkg.GamepadEvent = $newType(0, $kindStruct, "dom.GamepadEvent", "GamepadEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- HashChangeEvent = $pkg.HashChangeEvent = $newType(0, $kindStruct, "dom.HashChangeEvent", "HashChangeEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- IDBVersionChangeEvent = $pkg.IDBVersionChangeEvent = $newType(0, $kindStruct, "dom.IDBVersionChangeEvent", "IDBVersionChangeEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- KeyboardEvent = $pkg.KeyboardEvent = $newType(0, $kindStruct, "dom.KeyboardEvent", "KeyboardEvent", "honnef.co/go/js/dom", function(BasicEvent_, AltKey_, CharCode_, CtrlKey_, Key_, KeyIdentifier_, KeyCode_, Locale_, Location_, KeyLocation_, MetaKey_, Repeat_, ShiftKey_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- this.AltKey = false;
- this.CharCode = 0;
- this.CtrlKey = false;
- this.Key = "";
- this.KeyIdentifier = "";
- this.KeyCode = 0;
- this.Locale = "";
- this.Location = 0;
- this.KeyLocation = 0;
- this.MetaKey = false;
- this.Repeat = false;
- this.ShiftKey = false;
- return;
- }
- this.BasicEvent = BasicEvent_;
- this.AltKey = AltKey_;
- this.CharCode = CharCode_;
- this.CtrlKey = CtrlKey_;
- this.Key = Key_;
- this.KeyIdentifier = KeyIdentifier_;
- this.KeyCode = KeyCode_;
- this.Locale = Locale_;
- this.Location = Location_;
- this.KeyLocation = KeyLocation_;
- this.MetaKey = MetaKey_;
- this.Repeat = Repeat_;
- this.ShiftKey = ShiftKey_;
- });
- MediaStreamEvent = $pkg.MediaStreamEvent = $newType(0, $kindStruct, "dom.MediaStreamEvent", "MediaStreamEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- MessageEvent = $pkg.MessageEvent = $newType(0, $kindStruct, "dom.MessageEvent", "MessageEvent", "honnef.co/go/js/dom", function(BasicEvent_, Data_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- this.Data = null;
- return;
- }
- this.BasicEvent = BasicEvent_;
- this.Data = Data_;
- });
- MouseEvent = $pkg.MouseEvent = $newType(0, $kindStruct, "dom.MouseEvent", "MouseEvent", "honnef.co/go/js/dom", function(UIEvent_, AltKey_, Button_, ClientX_, ClientY_, CtrlKey_, MetaKey_, MovementX_, MovementY_, ScreenX_, ScreenY_, ShiftKey_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.UIEvent = ptrType$18.nil;
- this.AltKey = false;
- this.Button = 0;
- this.ClientX = 0;
- this.ClientY = 0;
- this.CtrlKey = false;
- this.MetaKey = false;
- this.MovementX = 0;
- this.MovementY = 0;
- this.ScreenX = 0;
- this.ScreenY = 0;
- this.ShiftKey = false;
- return;
- }
- this.UIEvent = UIEvent_;
- this.AltKey = AltKey_;
- this.Button = Button_;
- this.ClientX = ClientX_;
- this.ClientY = ClientY_;
- this.CtrlKey = CtrlKey_;
- this.MetaKey = MetaKey_;
- this.MovementX = MovementX_;
- this.MovementY = MovementY_;
- this.ScreenX = ScreenX_;
- this.ScreenY = ScreenY_;
- this.ShiftKey = ShiftKey_;
- });
- MutationEvent = $pkg.MutationEvent = $newType(0, $kindStruct, "dom.MutationEvent", "MutationEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- OfflineAudioCompletionEvent = $pkg.OfflineAudioCompletionEvent = $newType(0, $kindStruct, "dom.OfflineAudioCompletionEvent", "OfflineAudioCompletionEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- PageTransitionEvent = $pkg.PageTransitionEvent = $newType(0, $kindStruct, "dom.PageTransitionEvent", "PageTransitionEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- PointerEvent = $pkg.PointerEvent = $newType(0, $kindStruct, "dom.PointerEvent", "PointerEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- PopStateEvent = $pkg.PopStateEvent = $newType(0, $kindStruct, "dom.PopStateEvent", "PopStateEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- ProgressEvent = $pkg.ProgressEvent = $newType(0, $kindStruct, "dom.ProgressEvent", "ProgressEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- RelatedEvent = $pkg.RelatedEvent = $newType(0, $kindStruct, "dom.RelatedEvent", "RelatedEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- RTCPeerConnectionIceEvent = $pkg.RTCPeerConnectionIceEvent = $newType(0, $kindStruct, "dom.RTCPeerConnectionIceEvent", "RTCPeerConnectionIceEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- SensorEvent = $pkg.SensorEvent = $newType(0, $kindStruct, "dom.SensorEvent", "SensorEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- StorageEvent = $pkg.StorageEvent = $newType(0, $kindStruct, "dom.StorageEvent", "StorageEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- SVGEvent = $pkg.SVGEvent = $newType(0, $kindStruct, "dom.SVGEvent", "SVGEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- SVGZoomEvent = $pkg.SVGZoomEvent = $newType(0, $kindStruct, "dom.SVGZoomEvent", "SVGZoomEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- TimeEvent = $pkg.TimeEvent = $newType(0, $kindStruct, "dom.TimeEvent", "TimeEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- TouchEvent = $pkg.TouchEvent = $newType(0, $kindStruct, "dom.TouchEvent", "TouchEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- TrackEvent = $pkg.TrackEvent = $newType(0, $kindStruct, "dom.TrackEvent", "TrackEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- TransitionEvent = $pkg.TransitionEvent = $newType(0, $kindStruct, "dom.TransitionEvent", "TransitionEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- UIEvent = $pkg.UIEvent = $newType(0, $kindStruct, "dom.UIEvent", "UIEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- UserProximityEvent = $pkg.UserProximityEvent = $newType(0, $kindStruct, "dom.UserProximityEvent", "UserProximityEvent", "honnef.co/go/js/dom", function(BasicEvent_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- return;
- }
- this.BasicEvent = BasicEvent_;
- });
- WheelEvent = $pkg.WheelEvent = $newType(0, $kindStruct, "dom.WheelEvent", "WheelEvent", "honnef.co/go/js/dom", function(BasicEvent_, DeltaX_, DeltaY_, DeltaZ_, DeltaMode_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.BasicEvent = ptrType$17.nil;
- this.DeltaX = 0;
- this.DeltaY = 0;
- this.DeltaZ = 0;
- this.DeltaMode = 0;
- return;
- }
- this.BasicEvent = BasicEvent_;
- this.DeltaX = DeltaX_;
- this.DeltaY = DeltaY_;
- this.DeltaZ = DeltaZ_;
- this.DeltaMode = DeltaMode_;
- });
- sliceType = $sliceType($emptyInterface);
- sliceType$1 = $sliceType(Node);
- sliceType$2 = $sliceType(Element);
- sliceType$3 = $sliceType(HTMLElement);
- ptrType = $ptrType(BasicHTMLElement);
- ptrType$1 = $ptrType(URLUtils);
- ptrType$2 = $ptrType(HTMLMediaElement);
- ptrType$3 = $ptrType(HTMLFormElement);
- ptrType$4 = $ptrType(HTMLLabelElement);
- sliceType$4 = $sliceType(ptrType$4);
- sliceType$5 = $sliceType($String);
- sliceType$6 = $sliceType(ptrType$3);
- ptrType$5 = $ptrType(HTMLHeadElement);
- ptrType$6 = $ptrType(HTMLImageElement);
- sliceType$7 = $sliceType(ptrType$6);
- ptrType$7 = $ptrType(HTMLEmbedElement);
- sliceType$8 = $sliceType(ptrType$7);
- ptrType$8 = $ptrType(HTMLScriptElement);
- sliceType$9 = $sliceType(ptrType$8);
- sliceType$10 = $sliceType(StyleSheet);
- ptrType$9 = $ptrType(Text);
- funcType = $funcType([], [], false);
- ptrType$10 = $ptrType(js.Object);
- funcType$1 = $funcType([ptrType$10], [], false);
- ptrType$11 = $ptrType(HTMLOptionElement);
- sliceType$11 = $sliceType(ptrType$11);
- ptrType$12 = $ptrType(File);
- sliceType$12 = $sliceType(ptrType$12);
- ptrType$13 = $ptrType(HTMLDataListElement);
- ptrType$14 = $ptrType(HTMLAreaElement);
- sliceType$13 = $sliceType(ptrType$14);
- ptrType$15 = $ptrType(HTMLTableCellElement);
- sliceType$14 = $sliceType(ptrType$15);
- ptrType$16 = $ptrType(HTMLTableRowElement);
- sliceType$15 = $sliceType(ptrType$16);
- ptrType$17 = $ptrType(BasicEvent);
- ptrType$18 = $ptrType(UIEvent);
- ptrType$19 = $ptrType(TokenList);
- funcType$2 = $funcType([Event], [], false);
- ptrType$20 = $ptrType(Location);
- ptrType$21 = $ptrType(BasicNode);
- ptrType$22 = $ptrType(document);
- ptrType$23 = $ptrType(htmlDocument);
- ptrType$24 = $ptrType(CSSStyleDeclaration);
- ptrType$25 = $ptrType(Console);
- ptrType$26 = $ptrType(Screen);
- ptrType$27 = $ptrType(window);
- funcType$3 = $funcType([Position], [], false);
- funcType$4 = $funcType([PositionError], [], false);
- ptrType$28 = $ptrType(PositionError);
- ptrType$29 = $ptrType(Coordinates);
- ptrType$30 = $ptrType(BasicElement);
- ptrType$31 = $ptrType(HTMLAnchorElement);
- ptrType$32 = $ptrType(HTMLAppletElement);
- ptrType$33 = $ptrType(HTMLBaseElement);
- ptrType$34 = $ptrType(ValidityState);
- ptrType$35 = $ptrType(HTMLButtonElement);
- ptrType$36 = $ptrType(CanvasRenderingContext2D);
- ptrType$37 = $ptrType(HTMLCanvasElement);
- ptrType$38 = $ptrType(HTMLFieldSetElement);
- ptrType$39 = $ptrType(HTMLIFrameElement);
- ptrType$40 = $ptrType(HTMLInputElement);
- ptrType$41 = $ptrType(HTMLKeygenElement);
- ptrType$42 = $ptrType(HTMLLegendElement);
- ptrType$43 = $ptrType(HTMLLinkElement);
- ptrType$44 = $ptrType(HTMLMapElement);
- ptrType$45 = $ptrType(HTMLObjectElement);
- ptrType$46 = $ptrType(HTMLOutputElement);
- ptrType$47 = $ptrType(HTMLTableSectionElement);
- ptrType$48 = $ptrType(HTMLTextAreaElement);
- ptrType$49 = $ptrType(TextTrack);
- ptrType$50 = $ptrType(HTMLTrackElement);
- mapType = $mapType($String, $String);
- ptrType$51 = $ptrType(KeyboardEvent);
- ptrType$52 = $ptrType(MouseEvent);
- callRecover = function(o, fn, args) {
- var $ptr, args, err, fn, o, obj, $deferred;
- /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred);
- err = $ifaceNil;
- $deferred.push([(function() {
- var $ptr, _tuple, e, ok, panicErr;
- e = $recover();
- if ($interfaceIsEqual(e, $ifaceNil)) {
- return;
- }
- _tuple = $assertType(e, $error, true); panicErr = _tuple[0]; ok = _tuple[1];
- if (ok && !($interfaceIsEqual(panicErr, $ifaceNil))) {
- err = panicErr;
- } else {
- $panic(e);
- }
- }), []]);
- (obj = o, obj[$externalize(fn, $String)].apply(obj, $externalize(args, sliceType)));
- err = $ifaceNil;
- return err;
- /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return err; } }
- };
- nodeListToNodes = function(o) {
- var $ptr, i, length, o, out;
- out = sliceType$1.nil;
- length = $parseInt(o.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- out = $append(out, wrapNode(o.item(i)));
- i = i + (1) >> 0;
- }
- return out;
- };
- nodeListToElements = function(o) {
- var $ptr, i, length, o, out;
- out = sliceType$2.nil;
- length = $parseInt(o.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- out = $append(out, wrapElement(o.item(i)));
- i = i + (1) >> 0;
- }
- return out;
- };
- nodeListToHTMLElements = function(o) {
- var $ptr, i, length, o, out;
- out = sliceType$3.nil;
- length = $parseInt(o.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- out = $append(out, wrapHTMLElement(o.item(i)));
- i = i + (1) >> 0;
- }
- return out;
- };
- wrapDocument = function(o) {
- var $ptr, _ref, o;
- _ref = o.constructor;
- if (_ref === $global.HTMLDocument) {
- return new htmlDocument.ptr(new document.ptr(new BasicNode.ptr(o)));
- } else {
- return new document.ptr(new BasicNode.ptr(o));
- }
- };
- wrapNode = function(o) {
- var $ptr, _ref, o;
- if (o === null || o === undefined) {
- return $ifaceNil;
- }
- _ref = o.constructor;
- if (_ref === $global.Text) {
- return new Text.ptr(new BasicNode.ptr(o));
- } else {
- return wrapElement(o);
- }
- };
- wrapElement = function(o) {
- var $ptr, _ref, o;
- if (o === null || o === undefined) {
- return $ifaceNil;
- }
- _ref = o.constructor;
- return wrapHTMLElement(o);
- };
- wrapHTMLElement = function(o) {
- var $ptr, _ref, c, el, o;
- if (o === null || o === undefined) {
- return $ifaceNil;
- }
- el = new BasicHTMLElement.ptr(new BasicElement.ptr(new BasicNode.ptr(o)));
- c = o.constructor;
- _ref = c;
- if (_ref === $global.HTMLAnchorElement) {
- return new HTMLAnchorElement.ptr(el, new URLUtils.ptr(o, "", "", "", "", "", "", "", "", "", "", ""), "", "", 0, "", "", "");
- } else if (_ref === $global.HTMLAppletElement) {
- return new HTMLAppletElement.ptr(el, "", "", "", "", "", "", 0, "", "");
- } else if (_ref === $global.HTMLAreaElement) {
- return new HTMLAreaElement.ptr(el, new URLUtils.ptr(o, "", "", "", "", "", "", "", "", "", "", ""), "", "", "", "", "", "", 0, "", "");
- } else if (_ref === $global.HTMLAudioElement) {
- return new HTMLAudioElement.ptr(new HTMLMediaElement.ptr(el));
- } else if (_ref === $global.HTMLBaseElement) {
- return new HTMLBaseElement.ptr(el);
- } else if (_ref === $global.HTMLBodyElement) {
- return new HTMLBodyElement.ptr(el);
- } else if (_ref === $global.HTMLBRElement) {
- return new HTMLBRElement.ptr(el);
- } else if (_ref === $global.HTMLButtonElement) {
- return new HTMLButtonElement.ptr(el, false, false, "", "", "", false, "", "", 0, "", "", "", false);
- } else if (_ref === $global.HTMLCanvasElement) {
- return new HTMLCanvasElement.ptr(el, 0, 0);
- } else if (_ref === $global.HTMLDataElement) {
- return new HTMLDataElement.ptr(el, "");
- } else if (_ref === $global.HTMLDataListElement) {
- return new HTMLDataListElement.ptr(el);
- } else if (_ref === $global.HTMLDirectoryElement) {
- return new HTMLDirectoryElement.ptr(el);
- } else if (_ref === $global.HTMLDivElement) {
- return new HTMLDivElement.ptr(el);
- } else if (_ref === $global.HTMLDListElement) {
- return new HTMLDListElement.ptr(el);
- } else if (_ref === $global.HTMLEmbedElement) {
- return new HTMLEmbedElement.ptr(el, "", "", "");
- } else if (_ref === $global.HTMLFieldSetElement) {
- return new HTMLFieldSetElement.ptr(el, false, "", "", "", false);
- } else if (_ref === $global.HTMLFontElement) {
- return new HTMLFontElement.ptr(el);
- } else if (_ref === $global.HTMLFormElement) {
- return new HTMLFormElement.ptr(el, "", "", "", "", "", 0, "", "", false, "");
- } else if (_ref === $global.HTMLFrameElement) {
- return new HTMLFrameElement.ptr(el);
- } else if (_ref === $global.HTMLFrameSetElement) {
- return new HTMLFrameSetElement.ptr(el);
- } else if (_ref === $global.HTMLHeadElement) {
- return new HTMLHeadElement.ptr(el);
- } else if (_ref === $global.HTMLHeadingElement) {
- return new HTMLHeadingElement.ptr(el);
- } else if (_ref === $global.HTMLHtmlElement) {
- return new HTMLHtmlElement.ptr(el);
- } else if (_ref === $global.HTMLHRElement) {
- return new HTMLHRElement.ptr(el);
- } else if (_ref === $global.HTMLIFrameElement) {
- return new HTMLIFrameElement.ptr(el, "", "", "", "", "", false);
- } else if (_ref === $global.HTMLImageElement) {
- return new HTMLImageElement.ptr(el, false, "", 0, false, 0, 0, "", "", 0);
- } else if (_ref === $global.HTMLInputElement) {
- return new HTMLInputElement.ptr(el, "", "", "", false, false, false, "", "", false, "", "", "", false, "", "", false, "", 0, "", false, "", "", "", false, false, "", 0, 0, 0, "", "", 0, "", "", "", new time.Time.ptr(), 0, "", false);
- } else if (_ref === $global.HTMLKeygenElement) {
- return new HTMLKeygenElement.ptr(el, false, "", false, "", "", "", "", false);
- } else if (_ref === $global.HTMLLabelElement) {
- return new HTMLLabelElement.ptr(el, "");
- } else if (_ref === $global.HTMLLegendElement) {
- return new HTMLLegendElement.ptr(el);
- } else if (_ref === $global.HTMLLIElement) {
- return new HTMLLIElement.ptr(el, 0);
- } else if (_ref === $global.HTMLLinkElement) {
- return new HTMLLinkElement.ptr(el, false, "", "", "", "");
- } else if (_ref === $global.HTMLMapElement) {
- return new HTMLMapElement.ptr(el, "");
- } else if (_ref === $global.HTMLMediaElement) {
- return new HTMLMediaElement.ptr(el);
- } else if (_ref === $global.HTMLMenuElement) {
- return new HTMLMenuElement.ptr(el);
- } else if (_ref === $global.HTMLMetaElement) {
- return new HTMLMetaElement.ptr(el, "", "", "");
- } else if (_ref === $global.HTMLMeterElement) {
- return new HTMLMeterElement.ptr(el, 0, 0, 0, 0, 0);
- } else if (_ref === $global.HTMLModElement) {
- return new HTMLModElement.ptr(el, "", "");
- } else if (_ref === $global.HTMLObjectElement) {
- return new HTMLObjectElement.ptr(el, "", "", "", 0, "", false, "", "", "", false);
- } else if (_ref === $global.HTMLOListElement) {
- return new HTMLOListElement.ptr(el, false, 0, "");
- } else if (_ref === $global.HTMLOptGroupElement) {
- return new HTMLOptGroupElement.ptr(el, false, "");
- } else if (_ref === $global.HTMLOptionElement) {
- return new HTMLOptionElement.ptr(el, false, false, 0, "", false, "", "");
- } else if (_ref === $global.HTMLOutputElement) {
- return new HTMLOutputElement.ptr(el, "", "", "", "", "", false);
- } else if (_ref === $global.HTMLParagraphElement) {
- return new HTMLParagraphElement.ptr(el);
- } else if (_ref === $global.HTMLParamElement) {
- return new HTMLParamElement.ptr(el, "", "");
- } else if (_ref === $global.HTMLPreElement) {
- return new HTMLPreElement.ptr(el);
- } else if (_ref === $global.HTMLProgressElement) {
- return new HTMLProgressElement.ptr(el, 0, 0, 0);
- } else if (_ref === $global.HTMLQuoteElement) {
- return new HTMLQuoteElement.ptr(el, "");
- } else if (_ref === $global.HTMLScriptElement) {
- return new HTMLScriptElement.ptr(el, "", "", "", false, false, "");
- } else if (_ref === $global.HTMLSelectElement) {
- return new HTMLSelectElement.ptr(el, false, false, 0, false, "", false, 0, 0, "", "", "", false);
- } else if (_ref === $global.HTMLSourceElement) {
- return new HTMLSourceElement.ptr(el, "", "", "");
- } else if (_ref === $global.HTMLSpanElement) {
- return new HTMLSpanElement.ptr(el);
- } else if (_ref === $global.HTMLStyleElement) {
- return new HTMLStyleElement.ptr(el);
- } else if (_ref === $global.HTMLTableElement) {
- return new HTMLTableElement.ptr(el);
- } else if (_ref === $global.HTMLTableCaptionElement) {
- return new HTMLTableCaptionElement.ptr(el);
- } else if (_ref === $global.HTMLTableCellElement) {
- return new HTMLTableCellElement.ptr(el, 0, 0, 0);
- } else if (_ref === $global.HTMLTableDataCellElement) {
- return new HTMLTableDataCellElement.ptr(el);
- } else if (_ref === $global.HTMLTableHeaderCellElement) {
- return new HTMLTableHeaderCellElement.ptr(el, "", "");
- } else if (_ref === $global.HTMLTableColElement) {
- return new HTMLTableColElement.ptr(el, 0);
- } else if (_ref === $global.HTMLTableRowElement) {
- return new HTMLTableRowElement.ptr(el, 0, 0);
- } else if (_ref === $global.HTMLTableSectionElement) {
- return new HTMLTableSectionElement.ptr(el);
- } else if (_ref === $global.HTMLTextAreaElement) {
- return new HTMLTextAreaElement.ptr(el, "", false, 0, "", "", false, 0, "", "", false, false, 0, "", 0, 0, 0, 0, "", "", "", false, "");
- } else if (_ref === $global.HTMLTimeElement) {
- return new HTMLTimeElement.ptr(el, "");
- } else if (_ref === $global.HTMLTitleElement) {
- return new HTMLTitleElement.ptr(el, "");
- } else if (_ref === $global.HTMLTrackElement) {
- return new HTMLTrackElement.ptr(el, "", "", "", "", false, 0);
- } else if (_ref === $global.HTMLUListElement) {
- return new HTMLUListElement.ptr(el);
- } else if (_ref === $global.HTMLUnknownElement) {
- return new HTMLUnknownElement.ptr(el);
- } else if (_ref === $global.HTMLVideoElement) {
- return new HTMLVideoElement.ptr(new HTMLMediaElement.ptr(el));
- } else if (_ref === $global.HTMLElement) {
- return el;
- } else {
- return el;
- }
- };
- getForm = function(o) {
- var $ptr, form, o;
- form = wrapHTMLElement(o.form);
- if ($interfaceIsEqual(form, $ifaceNil)) {
- return ptrType$3.nil;
- }
- return $assertType(form, ptrType$3);
- };
- getLabels = function(o) {
- var $ptr, _i, _ref, i, label, labels, o, out;
- labels = nodeListToElements(o.labels);
- out = $makeSlice(sliceType$4, labels.$length);
- _ref = labels;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- label = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i] = $assertType(label, ptrType$4));
- _i++;
- }
- return out;
- };
- GetWindow = function() {
- var $ptr;
- return new window.ptr($global);
- };
- $pkg.GetWindow = GetWindow;
- TokenList.ptr.prototype.Item = function(idx) {
- var $ptr, idx, o, tl;
- tl = this;
- o = tl.dtl.item(idx);
- if (o === null || o === undefined) {
- return "";
- }
- return $internalize(o, $String);
- };
- TokenList.prototype.Item = function(idx) { return this.$val.Item(idx); };
- TokenList.ptr.prototype.Contains = function(token) {
- var $ptr, tl, token;
- tl = this;
- return !!(tl.dtl.contains($externalize(token, $String)));
- };
- TokenList.prototype.Contains = function(token) { return this.$val.Contains(token); };
- TokenList.ptr.prototype.Add = function(token) {
- var $ptr, tl, token;
- tl = this;
- tl.dtl.add($externalize(token, $String));
- };
- TokenList.prototype.Add = function(token) { return this.$val.Add(token); };
- TokenList.ptr.prototype.Remove = function(token) {
- var $ptr, tl, token;
- tl = this;
- tl.dtl.remove($externalize(token, $String));
- };
- TokenList.prototype.Remove = function(token) { return this.$val.Remove(token); };
- TokenList.ptr.prototype.Toggle = function(token) {
- var $ptr, tl, token;
- tl = this;
- tl.dtl.toggle($externalize(token, $String));
- };
- TokenList.prototype.Toggle = function(token) { return this.$val.Toggle(token); };
- TokenList.ptr.prototype.String = function() {
- var $ptr, tl;
- tl = this;
- if (!(tl.sa === "")) {
- return $internalize(tl.o[$externalize(tl.sa, $String)], $String);
- }
- if (tl.dtl.constructor === $global.DOMSettableTokenList) {
- return $internalize(tl.dtl.value, $String);
- }
- return "";
- };
- TokenList.prototype.String = function() { return this.$val.String(); };
- TokenList.ptr.prototype.Slice = function() {
- var $ptr, i, length, out, tl;
- tl = this;
- out = sliceType$5.nil;
- length = $parseInt(tl.dtl.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- out = $append(out, $internalize(tl.dtl.item(i), $String));
- i = i + (1) >> 0;
- }
- return out;
- };
- TokenList.prototype.Slice = function() { return this.$val.Slice(); };
- TokenList.ptr.prototype.SetString = function(s) {
- var $ptr, s, tl;
- tl = this;
- if (!(tl.sa === "")) {
- tl.o[$externalize(tl.sa, $String)] = $externalize(s, $String);
- return;
- }
- if (tl.dtl.constructor === $global.DOMSettableTokenList) {
- tl.dtl.value = $externalize(s, $String);
- return;
- }
- $panic(new $String("no way to SetString on this TokenList"));
- };
- TokenList.prototype.SetString = function(s) { return this.$val.SetString(s); };
- TokenList.ptr.prototype.Set = function(s) {
- var $ptr, s, tl;
- tl = this;
- tl.SetString(strings.Join(s, " "));
- };
- TokenList.prototype.Set = function(s) { return this.$val.Set(s); };
- htmlDocument.ptr.prototype.ActiveElement = function() {
- var $ptr, d;
- d = this;
- return wrapHTMLElement(d.document.BasicNode.Object.activeElement);
- };
- htmlDocument.prototype.ActiveElement = function() { return this.$val.ActiveElement(); };
- htmlDocument.ptr.prototype.Body = function() {
- var $ptr, d;
- d = this;
- return wrapHTMLElement(d.document.BasicNode.Object.body);
- };
- htmlDocument.prototype.Body = function() { return this.$val.Body(); };
- htmlDocument.ptr.prototype.Cookie = function() {
- var $ptr, d;
- d = this;
- return $internalize(d.document.BasicNode.Object.cookie, $String);
- };
- htmlDocument.prototype.Cookie = function() { return this.$val.Cookie(); };
- htmlDocument.ptr.prototype.SetCookie = function(s) {
- var $ptr, d, s;
- d = this;
- d.document.BasicNode.Object.cookie = $externalize(s, $String);
- };
- htmlDocument.prototype.SetCookie = function(s) { return this.$val.SetCookie(s); };
- htmlDocument.ptr.prototype.DefaultView = function() {
- var $ptr, d;
- d = this;
- return new window.ptr(d.document.BasicNode.Object.defaultView);
- };
- htmlDocument.prototype.DefaultView = function() { return this.$val.DefaultView(); };
- htmlDocument.ptr.prototype.DesignMode = function() {
- var $ptr, d, s;
- d = this;
- s = $internalize(d.document.BasicNode.Object.designMode, $String);
- if (s === "off") {
- return false;
- }
- return true;
- };
- htmlDocument.prototype.DesignMode = function() { return this.$val.DesignMode(); };
- htmlDocument.ptr.prototype.SetDesignMode = function(b) {
- var $ptr, b, d, s;
- d = this;
- s = "off";
- if (b) {
- s = "on";
- }
- d.document.BasicNode.Object.designMode = $externalize(s, $String);
- };
- htmlDocument.prototype.SetDesignMode = function(b) { return this.$val.SetDesignMode(b); };
- htmlDocument.ptr.prototype.Domain = function() {
- var $ptr, d;
- d = this;
- return $internalize(d.document.BasicNode.Object.domain, $String);
- };
- htmlDocument.prototype.Domain = function() { return this.$val.Domain(); };
- htmlDocument.ptr.prototype.SetDomain = function(s) {
- var $ptr, d, s;
- d = this;
- d.document.BasicNode.Object.domain = $externalize(s, $String);
- };
- htmlDocument.prototype.SetDomain = function(s) { return this.$val.SetDomain(s); };
- htmlDocument.ptr.prototype.Forms = function() {
- var $ptr, d, els, forms, i, length;
- d = this;
- els = sliceType$6.nil;
- forms = d.document.BasicNode.Object.forms;
- length = $parseInt(forms.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- els = $append(els, $assertType(wrapHTMLElement(forms.item(i)), ptrType$3));
- i = i + (1) >> 0;
- }
- return els;
- };
- htmlDocument.prototype.Forms = function() { return this.$val.Forms(); };
- htmlDocument.ptr.prototype.Head = function() {
- var $ptr, d, head;
- d = this;
- head = wrapElement(d.document.BasicNode.Object.head);
- if ($interfaceIsEqual(head, $ifaceNil)) {
- return ptrType$5.nil;
- }
- return $assertType(head, ptrType$5);
- };
- htmlDocument.prototype.Head = function() { return this.$val.Head(); };
- htmlDocument.ptr.prototype.Images = function() {
- var $ptr, d, els, i, images, length;
- d = this;
- els = sliceType$7.nil;
- images = d.document.BasicNode.Object.images;
- length = $parseInt(images.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- els = $append(els, $assertType(wrapHTMLElement(images.item(i)), ptrType$6));
- i = i + (1) >> 0;
- }
- return els;
- };
- htmlDocument.prototype.Images = function() { return this.$val.Images(); };
- htmlDocument.ptr.prototype.LastModified = function() {
- var $ptr, d;
- d = this;
- return $assertType($internalize(d.document.BasicNode.Object.lastModified, $emptyInterface), time.Time);
- };
- htmlDocument.prototype.LastModified = function() { return this.$val.LastModified(); };
- htmlDocument.ptr.prototype.Links = function() {
- var $ptr, d, els, i, length, links;
- d = this;
- els = sliceType$3.nil;
- links = d.document.BasicNode.Object.links;
- length = $parseInt(links.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- els = $append(els, wrapHTMLElement(links.item(i)));
- i = i + (1) >> 0;
- }
- return els;
- };
- htmlDocument.prototype.Links = function() { return this.$val.Links(); };
- htmlDocument.ptr.prototype.Location = function() {
- var $ptr, d, o;
- d = this;
- o = d.document.BasicNode.Object.location;
- return new Location.ptr(o, new URLUtils.ptr(o, "", "", "", "", "", "", "", "", "", "", ""));
- };
- htmlDocument.prototype.Location = function() { return this.$val.Location(); };
- htmlDocument.ptr.prototype.Plugins = function() {
- var $ptr, d, els, forms, i, length;
- d = this;
- els = sliceType$8.nil;
- forms = d.document.BasicNode.Object.plugins;
- length = $parseInt(forms.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- els = $append(els, $assertType(wrapHTMLElement(forms.item(i)), ptrType$7));
- i = i + (1) >> 0;
- }
- return els;
- };
- htmlDocument.prototype.Plugins = function() { return this.$val.Plugins(); };
- htmlDocument.ptr.prototype.ReadyState = function() {
- var $ptr, d;
- d = this;
- return $internalize(d.document.BasicNode.Object.readyState, $String);
- };
- htmlDocument.prototype.ReadyState = function() { return this.$val.ReadyState(); };
- htmlDocument.ptr.prototype.Referrer = function() {
- var $ptr, d;
- d = this;
- return $internalize(d.document.BasicNode.Object.referrer, $String);
- };
- htmlDocument.prototype.Referrer = function() { return this.$val.Referrer(); };
- htmlDocument.ptr.prototype.Scripts = function() {
- var $ptr, d, els, forms, i, length;
- d = this;
- els = sliceType$9.nil;
- forms = d.document.BasicNode.Object.scripts;
- length = $parseInt(forms.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < length)) { break; }
- els = $append(els, $assertType(wrapHTMLElement(forms.item(i)), ptrType$8));
- i = i + (1) >> 0;
- }
- return els;
- };
- htmlDocument.prototype.Scripts = function() { return this.$val.Scripts(); };
- htmlDocument.ptr.prototype.Title = function() {
- var $ptr, d;
- d = this;
- return $internalize(d.document.BasicNode.Object.title, $String);
- };
- htmlDocument.prototype.Title = function() { return this.$val.Title(); };
- htmlDocument.ptr.prototype.SetTitle = function(s) {
- var $ptr, d, s;
- d = this;
- d.document.BasicNode.Object.title = $externalize(s, $String);
- };
- htmlDocument.prototype.SetTitle = function(s) { return this.$val.SetTitle(s); };
- htmlDocument.ptr.prototype.URL = function() {
- var $ptr, d;
- d = this;
- return $internalize(d.document.BasicNode.Object.url, $String);
- };
- htmlDocument.prototype.URL = function() { return this.$val.URL(); };
- document.ptr.prototype.Async = function() {
- var $ptr, d;
- d = $clone(this, document);
- return !!(d.BasicNode.Object.async);
- };
- document.prototype.Async = function() { return this.$val.Async(); };
- document.ptr.prototype.SetAsync = function(b) {
- var $ptr, b, d;
- d = $clone(this, document);
- d.BasicNode.Object.async = $externalize(b, $Bool);
- };
- document.prototype.SetAsync = function(b) { return this.$val.SetAsync(b); };
- document.ptr.prototype.Doctype = function() {
- var $ptr, d;
- d = $clone(this, document);
- return $ifaceNil;
- };
- document.prototype.Doctype = function() { return this.$val.Doctype(); };
- document.ptr.prototype.DocumentElement = function() {
- var $ptr, d;
- d = $clone(this, document);
- return wrapElement(d.BasicNode.Object.documentElement);
- };
- document.prototype.DocumentElement = function() { return this.$val.DocumentElement(); };
- document.ptr.prototype.DocumentURI = function() {
- var $ptr, d;
- d = $clone(this, document);
- return $internalize(d.BasicNode.Object.documentURI, $String);
- };
- document.prototype.DocumentURI = function() { return this.$val.DocumentURI(); };
- document.ptr.prototype.Implementation = function() {
- var $ptr, d;
- d = $clone(this, document);
- return $ifaceNil;
- };
- document.prototype.Implementation = function() { return this.$val.Implementation(); };
- document.ptr.prototype.LastStyleSheetSet = function() {
- var $ptr, d;
- d = $clone(this, document);
- return $internalize(d.BasicNode.Object.lastStyleSheetSet, $String);
- };
- document.prototype.LastStyleSheetSet = function() { return this.$val.LastStyleSheetSet(); };
- document.ptr.prototype.PreferredStyleSheetSet = function() {
- var $ptr, d;
- d = $clone(this, document);
- return $internalize(d.BasicNode.Object.preferredStyleSheetSet, $String);
- };
- document.prototype.PreferredStyleSheetSet = function() { return this.$val.PreferredStyleSheetSet(); };
- document.ptr.prototype.SelectedStyleSheetSet = function() {
- var $ptr, d;
- d = $clone(this, document);
- return $internalize(d.BasicNode.Object.selectedStyleSheetSet, $String);
- };
- document.prototype.SelectedStyleSheetSet = function() { return this.$val.SelectedStyleSheetSet(); };
- document.ptr.prototype.StyleSheets = function() {
- var $ptr, d;
- d = $clone(this, document);
- return sliceType$10.nil;
- };
- document.prototype.StyleSheets = function() { return this.$val.StyleSheets(); };
- document.ptr.prototype.StyleSheetSets = function() {
- var $ptr, d;
- d = $clone(this, document);
- return sliceType$10.nil;
- };
- document.prototype.StyleSheetSets = function() { return this.$val.StyleSheetSets(); };
- document.ptr.prototype.AdoptNode = function(node) {
- var $ptr, _r, _r$1, d, node, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; d = $f.d; node = $f.node; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- d = $clone(this, document);
- _r = node.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = wrapNode(d.BasicNode.Object.adoptNode(_r)); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- return _r$1;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: document.ptr.prototype.AdoptNode }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.d = d; $f.node = node; $f.$s = $s; $f.$r = $r; return $f;
- };
- document.prototype.AdoptNode = function(node) { return this.$val.AdoptNode(node); };
- document.ptr.prototype.CreateElement = function(name) {
- var $ptr, d, name;
- d = $clone(this, document);
- return wrapElement(d.BasicNode.Object.createElement($externalize(name, $String)));
- };
- document.prototype.CreateElement = function(name) { return this.$val.CreateElement(name); };
- document.ptr.prototype.CreateElementNS = function(ns, name) {
- var $ptr, d, name, ns;
- d = $clone(this, document);
- return wrapElement(d.BasicNode.Object.createElement($externalize(ns, $String), $externalize(name, $String)));
- };
- document.prototype.CreateElementNS = function(ns, name) { return this.$val.CreateElementNS(ns, name); };
- document.ptr.prototype.CreateTextNode = function(s) {
- var $ptr, d, s;
- d = $clone(this, document);
- return $assertType(wrapNode(d.BasicNode.Object.createTextNode($externalize(s, $String))), ptrType$9);
- };
- document.prototype.CreateTextNode = function(s) { return this.$val.CreateTextNode(s); };
- document.ptr.prototype.ElementFromPoint = function(x, y) {
- var $ptr, d, x, y;
- d = $clone(this, document);
- return wrapElement(d.BasicNode.Object.elementFromPoint(x, y));
- };
- document.prototype.ElementFromPoint = function(x, y) { return this.$val.ElementFromPoint(x, y); };
- document.ptr.prototype.EnableStyleSheetsForSet = function(name) {
- var $ptr, d, name;
- d = $clone(this, document);
- d.BasicNode.Object.enableStyleSheetsForSet($externalize(name, $String));
- };
- document.prototype.EnableStyleSheetsForSet = function(name) { return this.$val.EnableStyleSheetsForSet(name); };
- document.ptr.prototype.GetElementsByClassName = function(name) {
- var $ptr, d, name;
- d = $clone(this, document);
- return (new BasicElement.ptr(new BasicNode.ptr(d.BasicNode.Object))).GetElementsByClassName(name);
- };
- document.prototype.GetElementsByClassName = function(name) { return this.$val.GetElementsByClassName(name); };
- document.ptr.prototype.GetElementsByTagName = function(name) {
- var $ptr, d, name;
- d = $clone(this, document);
- return (new BasicElement.ptr(new BasicNode.ptr(d.BasicNode.Object))).GetElementsByTagName(name);
- };
- document.prototype.GetElementsByTagName = function(name) { return this.$val.GetElementsByTagName(name); };
- document.ptr.prototype.GetElementsByTagNameNS = function(ns, name) {
- var $ptr, d, name, ns;
- d = $clone(this, document);
- return (new BasicElement.ptr(new BasicNode.ptr(d.BasicNode.Object))).GetElementsByTagNameNS(ns, name);
- };
- document.prototype.GetElementsByTagNameNS = function(ns, name) { return this.$val.GetElementsByTagNameNS(ns, name); };
- document.ptr.prototype.GetElementByID = function(id) {
- var $ptr, d, id;
- d = $clone(this, document);
- return wrapElement(d.BasicNode.Object.getElementById($externalize(id, $String)));
- };
- document.prototype.GetElementByID = function(id) { return this.$val.GetElementByID(id); };
- document.ptr.prototype.QuerySelector = function(sel) {
- var $ptr, d, sel;
- d = $clone(this, document);
- return (new BasicElement.ptr(new BasicNode.ptr(d.BasicNode.Object))).QuerySelector(sel);
- };
- document.prototype.QuerySelector = function(sel) { return this.$val.QuerySelector(sel); };
- document.ptr.prototype.QuerySelectorAll = function(sel) {
- var $ptr, d, sel;
- d = $clone(this, document);
- return (new BasicElement.ptr(new BasicNode.ptr(d.BasicNode.Object))).QuerySelectorAll(sel);
- };
- document.prototype.QuerySelectorAll = function(sel) { return this.$val.QuerySelectorAll(sel); };
- window.ptr.prototype.Console = function() {
- var $ptr, w;
- w = this;
- return new Console.ptr(w.Object.console);
- };
- window.prototype.Console = function() { return this.$val.Console(); };
- window.ptr.prototype.Document = function() {
- var $ptr, w;
- w = this;
- return wrapDocument(w.Object.document);
- };
- window.prototype.Document = function() { return this.$val.Document(); };
- window.ptr.prototype.FrameElement = function() {
- var $ptr, w;
- w = this;
- return wrapElement(w.Object.frameElement);
- };
- window.prototype.FrameElement = function() { return this.$val.FrameElement(); };
- window.ptr.prototype.Location = function() {
- var $ptr, o, w;
- w = this;
- o = w.Object.location;
- return new Location.ptr(o, new URLUtils.ptr(o, "", "", "", "", "", "", "", "", "", "", ""));
- };
- window.prototype.Location = function() { return this.$val.Location(); };
- window.ptr.prototype.Name = function() {
- var $ptr, w;
- w = this;
- return $internalize(w.Object.name, $String);
- };
- window.prototype.Name = function() { return this.$val.Name(); };
- window.ptr.prototype.SetName = function(s) {
- var $ptr, s, w;
- w = this;
- w.Object.name = $externalize(s, $String);
- };
- window.prototype.SetName = function(s) { return this.$val.SetName(s); };
- window.ptr.prototype.InnerHeight = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.innerHeight) >> 0;
- };
- window.prototype.InnerHeight = function() { return this.$val.InnerHeight(); };
- window.ptr.prototype.InnerWidth = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.innerWidth) >> 0;
- };
- window.prototype.InnerWidth = function() { return this.$val.InnerWidth(); };
- window.ptr.prototype.Length = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.length) >> 0;
- };
- window.prototype.Length = function() { return this.$val.Length(); };
- window.ptr.prototype.Opener = function() {
- var $ptr, w;
- w = this;
- return new window.ptr(w.Object.opener);
- };
- window.prototype.Opener = function() { return this.$val.Opener(); };
- window.ptr.prototype.OuterHeight = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.outerHeight) >> 0;
- };
- window.prototype.OuterHeight = function() { return this.$val.OuterHeight(); };
- window.ptr.prototype.OuterWidth = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.outerWidth) >> 0;
- };
- window.prototype.OuterWidth = function() { return this.$val.OuterWidth(); };
- window.ptr.prototype.ScrollX = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.scrollX) >> 0;
- };
- window.prototype.ScrollX = function() { return this.$val.ScrollX(); };
- window.ptr.prototype.ScrollY = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.scrollY) >> 0;
- };
- window.prototype.ScrollY = function() { return this.$val.ScrollY(); };
- window.ptr.prototype.Parent = function() {
- var $ptr, w;
- w = this;
- return new window.ptr(w.Object.parent);
- };
- window.prototype.Parent = function() { return this.$val.Parent(); };
- window.ptr.prototype.ScreenX = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.screenX) >> 0;
- };
- window.prototype.ScreenX = function() { return this.$val.ScreenX(); };
- window.ptr.prototype.ScreenY = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.screenY) >> 0;
- };
- window.prototype.ScreenY = function() { return this.$val.ScreenY(); };
- window.ptr.prototype.ScrollMaxX = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.scrollMaxX) >> 0;
- };
- window.prototype.ScrollMaxX = function() { return this.$val.ScrollMaxX(); };
- window.ptr.prototype.ScrollMaxY = function() {
- var $ptr, w;
- w = this;
- return $parseInt(w.Object.scrollMaxY) >> 0;
- };
- window.prototype.ScrollMaxY = function() { return this.$val.ScrollMaxY(); };
- window.ptr.prototype.Top = function() {
- var $ptr, w;
- w = this;
- return new window.ptr(w.Object.top);
- };
- window.prototype.Top = function() { return this.$val.Top(); };
- window.ptr.prototype.History = function() {
- var $ptr, w;
- w = this;
- return $ifaceNil;
- };
- window.prototype.History = function() { return this.$val.History(); };
- window.ptr.prototype.Navigator = function() {
- var $ptr, w;
- w = this;
- return $ifaceNil;
- };
- window.prototype.Navigator = function() { return this.$val.Navigator(); };
- window.ptr.prototype.Screen = function() {
- var $ptr, w;
- w = this;
- return new Screen.ptr(w.Object.screen, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
- };
- window.prototype.Screen = function() { return this.$val.Screen(); };
- window.ptr.prototype.Alert = function(msg) {
- var $ptr, msg, w;
- w = this;
- w.Object.alert($externalize(msg, $String));
- };
- window.prototype.Alert = function(msg) { return this.$val.Alert(msg); };
- window.ptr.prototype.Back = function() {
- var $ptr, w;
- w = this;
- w.Object.back();
- };
- window.prototype.Back = function() { return this.$val.Back(); };
- window.ptr.prototype.Blur = function() {
- var $ptr, w;
- w = this;
- w.Object.blur();
- };
- window.prototype.Blur = function() { return this.$val.Blur(); };
- window.ptr.prototype.ClearInterval = function(id) {
- var $ptr, id, w;
- w = this;
- w.Object.clearInterval(id);
- };
- window.prototype.ClearInterval = function(id) { return this.$val.ClearInterval(id); };
- window.ptr.prototype.ClearTimeout = function(id) {
- var $ptr, id, w;
- w = this;
- w.Object.clearTimeout(id);
- };
- window.prototype.ClearTimeout = function(id) { return this.$val.ClearTimeout(id); };
- window.ptr.prototype.Close = function() {
- var $ptr, w;
- w = this;
- w.Object.close();
- };
- window.prototype.Close = function() { return this.$val.Close(); };
- window.ptr.prototype.Confirm = function(prompt) {
- var $ptr, prompt, w;
- w = this;
- return !!(w.Object.confirm($externalize(prompt, $String)));
- };
- window.prototype.Confirm = function(prompt) { return this.$val.Confirm(prompt); };
- window.ptr.prototype.Focus = function() {
- var $ptr, w;
- w = this;
- w.Object.focus();
- };
- window.prototype.Focus = function() { return this.$val.Focus(); };
- window.ptr.prototype.Forward = function() {
- var $ptr, w;
- w = this;
- w.Object.forward();
- };
- window.prototype.Forward = function() { return this.$val.Forward(); };
- window.ptr.prototype.GetComputedStyle = function(el, pseudoElt) {
- var $ptr, _r, el, optArg, pseudoElt, w, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; el = $f.el; optArg = $f.optArg; pseudoElt = $f.pseudoElt; w = $f.w; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- w = this;
- optArg = $ifaceNil;
- if (!(pseudoElt === "")) {
- optArg = new $String(pseudoElt);
- }
- _r = el.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return new CSSStyleDeclaration.ptr(w.Object.getComputedStyle(_r, $externalize(optArg, $emptyInterface)));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: window.ptr.prototype.GetComputedStyle }; } $f.$ptr = $ptr; $f._r = _r; $f.el = el; $f.optArg = optArg; $f.pseudoElt = pseudoElt; $f.w = w; $f.$s = $s; $f.$r = $r; return $f;
- };
- window.prototype.GetComputedStyle = function(el, pseudoElt) { return this.$val.GetComputedStyle(el, pseudoElt); };
- window.ptr.prototype.GetSelection = function() {
- var $ptr, w;
- w = this;
- return $ifaceNil;
- };
- window.prototype.GetSelection = function() { return this.$val.GetSelection(); };
- window.ptr.prototype.Home = function() {
- var $ptr, w;
- w = this;
- w.Object.home();
- };
- window.prototype.Home = function() { return this.$val.Home(); };
- window.ptr.prototype.MoveBy = function(dx, dy) {
- var $ptr, dx, dy, w;
- w = this;
- w.Object.moveBy(dx, dy);
- };
- window.prototype.MoveBy = function(dx, dy) { return this.$val.MoveBy(dx, dy); };
- window.ptr.prototype.MoveTo = function(x, y) {
- var $ptr, w, x, y;
- w = this;
- w.Object.moveTo(x, y);
- };
- window.prototype.MoveTo = function(x, y) { return this.$val.MoveTo(x, y); };
- window.ptr.prototype.Open = function(url, name, features) {
- var $ptr, features, name, url, w;
- w = this;
- return new window.ptr(w.Object.open($externalize(url, $String), $externalize(name, $String), $externalize(features, $String)));
- };
- window.prototype.Open = function(url, name, features) { return this.$val.Open(url, name, features); };
- window.ptr.prototype.OpenDialog = function(url, name, features, args) {
- var $ptr, args, features, name, url, w;
- w = this;
- return new window.ptr(w.Object.openDialog($externalize(url, $String), $externalize(name, $String), $externalize(features, $String), $externalize(args, sliceType)));
- };
- window.prototype.OpenDialog = function(url, name, features, args) { return this.$val.OpenDialog(url, name, features, args); };
- window.ptr.prototype.PostMessage = function(message, target, transfer) {
- var $ptr, message, target, transfer, w;
- w = this;
- w.Object.postMessage($externalize(message, $String), $externalize(target, $String), $externalize(transfer, sliceType));
- };
- window.prototype.PostMessage = function(message, target, transfer) { return this.$val.PostMessage(message, target, transfer); };
- window.ptr.prototype.Print = function() {
- var $ptr, w;
- w = this;
- w.Object.print();
- };
- window.prototype.Print = function() { return this.$val.Print(); };
- window.ptr.prototype.Prompt = function(prompt, initial) {
- var $ptr, initial, prompt, w;
- w = this;
- return $internalize(w.Object.prompt($externalize(prompt, $String), $externalize(initial, $String)), $String);
- };
- window.prototype.Prompt = function(prompt, initial) { return this.$val.Prompt(prompt, initial); };
- window.ptr.prototype.ResizeBy = function(dw, dh) {
- var $ptr, dh, dw, w;
- w = this;
- w.Object.resizeBy(dw, dh);
- };
- window.prototype.ResizeBy = function(dw, dh) { return this.$val.ResizeBy(dw, dh); };
- window.ptr.prototype.ResizeTo = function(width, height) {
- var $ptr, height, w, width;
- w = this;
- w.Object.resizeTo(width, height);
- };
- window.prototype.ResizeTo = function(width, height) { return this.$val.ResizeTo(width, height); };
- window.ptr.prototype.Scroll = function(x, y) {
- var $ptr, w, x, y;
- w = this;
- w.Object.scroll(x, y);
- };
- window.prototype.Scroll = function(x, y) { return this.$val.Scroll(x, y); };
- window.ptr.prototype.ScrollBy = function(dx, dy) {
- var $ptr, dx, dy, w;
- w = this;
- w.Object.scrollBy(dx, dy);
- };
- window.prototype.ScrollBy = function(dx, dy) { return this.$val.ScrollBy(dx, dy); };
- window.ptr.prototype.ScrollByLines = function(i) {
- var $ptr, i, w;
- w = this;
- w.Object.scrollByLines(i);
- };
- window.prototype.ScrollByLines = function(i) { return this.$val.ScrollByLines(i); };
- window.ptr.prototype.ScrollTo = function(x, y) {
- var $ptr, w, x, y;
- w = this;
- w.Object.scrollTo(x, y);
- };
- window.prototype.ScrollTo = function(x, y) { return this.$val.ScrollTo(x, y); };
- window.ptr.prototype.SetCursor = function(name) {
- var $ptr, name, w;
- w = this;
- w.Object.setCursor($externalize(name, $String));
- };
- window.prototype.SetCursor = function(name) { return this.$val.SetCursor(name); };
- window.ptr.prototype.SetInterval = function(fn, delay) {
- var $ptr, delay, fn, w;
- w = this;
- return $parseInt(w.Object.setInterval($externalize(fn, funcType), delay)) >> 0;
- };
- window.prototype.SetInterval = function(fn, delay) { return this.$val.SetInterval(fn, delay); };
- window.ptr.prototype.SetTimeout = function(fn, delay) {
- var $ptr, delay, fn, w;
- w = this;
- return $parseInt(w.Object.setTimeout($externalize(fn, funcType), delay)) >> 0;
- };
- window.prototype.SetTimeout = function(fn, delay) { return this.$val.SetTimeout(fn, delay); };
- window.ptr.prototype.Stop = function() {
- var $ptr, w;
- w = this;
- w.Object.stop();
- };
- window.prototype.Stop = function() { return this.$val.Stop(); };
- window.ptr.prototype.AddEventListener = function(typ, useCapture, listener) {
- var $ptr, listener, typ, useCapture, w, wrapper;
- w = this;
- wrapper = (function $b(o) {
- var $ptr, o, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; o = $f.o; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = listener(wrapEvent(o)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.o = o; $f.$s = $s; $f.$r = $r; return $f;
- });
- w.Object.addEventListener($externalize(typ, $String), $externalize(wrapper, funcType$1), $externalize(useCapture, $Bool));
- return wrapper;
- };
- window.prototype.AddEventListener = function(typ, useCapture, listener) { return this.$val.AddEventListener(typ, useCapture, listener); };
- window.ptr.prototype.RemoveEventListener = function(typ, useCapture, listener) {
- var $ptr, listener, typ, useCapture, w;
- w = this;
- w.Object.removeEventListener($externalize(typ, $String), $externalize(listener, funcType$1), $externalize(useCapture, $Bool));
- };
- window.prototype.RemoveEventListener = function(typ, useCapture, listener) { return this.$val.RemoveEventListener(typ, useCapture, listener); };
- PositionError.ptr.prototype.Error = function() {
- var $ptr, err;
- err = this;
- return $internalize(err.Object.message(), $String);
- };
- PositionError.prototype.Error = function() { return this.$val.Error(); };
- BasicNode.ptr.prototype.Underlying = function() {
- var $ptr, n;
- n = this;
- return n.Object;
- };
- BasicNode.prototype.Underlying = function() { return this.$val.Underlying(); };
- BasicNode.ptr.prototype.AddEventListener = function(typ, useCapture, listener) {
- var $ptr, listener, n, typ, useCapture, wrapper;
- n = this;
- wrapper = (function $b(o) {
- var $ptr, o, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; o = $f.o; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = listener(wrapEvent(o)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.o = o; $f.$s = $s; $f.$r = $r; return $f;
- });
- n.Object.addEventListener($externalize(typ, $String), $externalize(wrapper, funcType$1), $externalize(useCapture, $Bool));
- return wrapper;
- };
- BasicNode.prototype.AddEventListener = function(typ, useCapture, listener) { return this.$val.AddEventListener(typ, useCapture, listener); };
- BasicNode.ptr.prototype.RemoveEventListener = function(typ, useCapture, listener) {
- var $ptr, listener, n, typ, useCapture;
- n = this;
- n.Object.removeEventListener($externalize(typ, $String), $externalize(listener, funcType$1), $externalize(useCapture, $Bool));
- };
- BasicNode.prototype.RemoveEventListener = function(typ, useCapture, listener) { return this.$val.RemoveEventListener(typ, useCapture, listener); };
- BasicNode.ptr.prototype.BaseURI = function() {
- var $ptr, n;
- n = this;
- return $internalize(n.Object.baseURI, $String);
- };
- BasicNode.prototype.BaseURI = function() { return this.$val.BaseURI(); };
- BasicNode.ptr.prototype.ChildNodes = function() {
- var $ptr, n;
- n = this;
- return nodeListToNodes(n.Object.childNodes);
- };
- BasicNode.prototype.ChildNodes = function() { return this.$val.ChildNodes(); };
- BasicNode.ptr.prototype.FirstChild = function() {
- var $ptr, n;
- n = this;
- return wrapNode(n.Object.firstChild);
- };
- BasicNode.prototype.FirstChild = function() { return this.$val.FirstChild(); };
- BasicNode.ptr.prototype.LastChild = function() {
- var $ptr, n;
- n = this;
- return wrapNode(n.Object.lastChild);
- };
- BasicNode.prototype.LastChild = function() { return this.$val.LastChild(); };
- BasicNode.ptr.prototype.NextSibling = function() {
- var $ptr, n;
- n = this;
- return wrapNode(n.Object.nextSibling);
- };
- BasicNode.prototype.NextSibling = function() { return this.$val.NextSibling(); };
- BasicNode.ptr.prototype.NodeName = function() {
- var $ptr, n;
- n = this;
- return $internalize(n.Object.nodeName, $String);
- };
- BasicNode.prototype.NodeName = function() { return this.$val.NodeName(); };
- BasicNode.ptr.prototype.NodeType = function() {
- var $ptr, n;
- n = this;
- return $parseInt(n.Object.nodeType) >> 0;
- };
- BasicNode.prototype.NodeType = function() { return this.$val.NodeType(); };
- BasicNode.ptr.prototype.NodeValue = function() {
- var $ptr, n;
- n = this;
- return $internalize(n.Object.nodeValue, $String);
- };
- BasicNode.prototype.NodeValue = function() { return this.$val.NodeValue(); };
- BasicNode.ptr.prototype.SetNodeValue = function(s) {
- var $ptr, n, s;
- n = this;
- n.Object.nodeValue = $externalize(s, $String);
- };
- BasicNode.prototype.SetNodeValue = function(s) { return this.$val.SetNodeValue(s); };
- BasicNode.ptr.prototype.OwnerDocument = function() {
- var $ptr, n;
- n = this;
- return $ifaceNil;
- };
- BasicNode.prototype.OwnerDocument = function() { return this.$val.OwnerDocument(); };
- BasicNode.ptr.prototype.ParentNode = function() {
- var $ptr, n;
- n = this;
- return wrapNode(n.Object.parentNode);
- };
- BasicNode.prototype.ParentNode = function() { return this.$val.ParentNode(); };
- BasicNode.ptr.prototype.ParentElement = function() {
- var $ptr, n;
- n = this;
- return wrapElement(n.Object.parentElement);
- };
- BasicNode.prototype.ParentElement = function() { return this.$val.ParentElement(); };
- BasicNode.ptr.prototype.PreviousSibling = function() {
- var $ptr, n;
- n = this;
- return wrapNode(n.Object.previousSibling);
- };
- BasicNode.prototype.PreviousSibling = function() { return this.$val.PreviousSibling(); };
- BasicNode.ptr.prototype.TextContent = function() {
- var $ptr, n;
- n = this;
- return $internalize(n.Object.textContent, $String);
- };
- BasicNode.prototype.TextContent = function() { return this.$val.TextContent(); };
- BasicNode.ptr.prototype.SetTextContent = function(s) {
- var $ptr, n, s;
- n = this;
- n.Object.textContent = $externalize(s, $String);
- };
- BasicNode.prototype.SetTextContent = function(s) { return this.$val.SetTextContent(s); };
- BasicNode.ptr.prototype.AppendChild = function(newchild) {
- var $ptr, _r, n, newchild, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; newchild = $f.newchild; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- _r = newchild.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n.Object.appendChild(_r);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BasicNode.ptr.prototype.AppendChild }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.newchild = newchild; $f.$s = $s; $f.$r = $r; return $f;
- };
- BasicNode.prototype.AppendChild = function(newchild) { return this.$val.AppendChild(newchild); };
- BasicNode.ptr.prototype.CloneNode = function(deep) {
- var $ptr, deep, n;
- n = this;
- return wrapNode(n.Object.cloneNode($externalize(deep, $Bool)));
- };
- BasicNode.prototype.CloneNode = function(deep) { return this.$val.CloneNode(deep); };
- BasicNode.ptr.prototype.CompareDocumentPosition = function(other) {
- var $ptr, _r, n, other, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; other = $f.other; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- _r = other.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return $parseInt(n.Object.compareDocumentPosition(_r)) >> 0;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BasicNode.ptr.prototype.CompareDocumentPosition }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.other = other; $f.$s = $s; $f.$r = $r; return $f;
- };
- BasicNode.prototype.CompareDocumentPosition = function(other) { return this.$val.CompareDocumentPosition(other); };
- BasicNode.ptr.prototype.Contains = function(other) {
- var $ptr, _r, n, other, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; other = $f.other; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- _r = other.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return !!(n.Object.contains(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BasicNode.ptr.prototype.Contains }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.other = other; $f.$s = $s; $f.$r = $r; return $f;
- };
- BasicNode.prototype.Contains = function(other) { return this.$val.Contains(other); };
- BasicNode.ptr.prototype.HasChildNodes = function() {
- var $ptr, n;
- n = this;
- return !!(n.Object.hasChildNodes());
- };
- BasicNode.prototype.HasChildNodes = function() { return this.$val.HasChildNodes(); };
- BasicNode.ptr.prototype.InsertBefore = function(which, before) {
- var $ptr, _r, _r$1, before, n, o, which, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; before = $f.before; n = $f.n; o = $f.o; which = $f.which; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- o = $ifaceNil;
- /* */ if (!($interfaceIsEqual(before, $ifaceNil))) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (!($interfaceIsEqual(before, $ifaceNil))) { */ case 1:
- _r = before.Underlying(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- o = new $jsObjectPtr(_r);
- /* } */ case 2:
- _r$1 = which.Underlying(); /* */ $s = 4; case 4: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- n.Object.insertBefore(_r$1, $externalize(o, $emptyInterface));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BasicNode.ptr.prototype.InsertBefore }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.before = before; $f.n = n; $f.o = o; $f.which = which; $f.$s = $s; $f.$r = $r; return $f;
- };
- BasicNode.prototype.InsertBefore = function(which, before) { return this.$val.InsertBefore(which, before); };
- BasicNode.ptr.prototype.IsDefaultNamespace = function(s) {
- var $ptr, n, s;
- n = this;
- return !!(n.Object.isDefaultNamespace($externalize(s, $String)));
- };
- BasicNode.prototype.IsDefaultNamespace = function(s) { return this.$val.IsDefaultNamespace(s); };
- BasicNode.ptr.prototype.IsEqualNode = function(other) {
- var $ptr, _r, n, other, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; other = $f.other; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- _r = other.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- return !!(n.Object.isEqualNode(_r));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BasicNode.ptr.prototype.IsEqualNode }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.other = other; $f.$s = $s; $f.$r = $r; return $f;
- };
- BasicNode.prototype.IsEqualNode = function(other) { return this.$val.IsEqualNode(other); };
- BasicNode.ptr.prototype.LookupPrefix = function() {
- var $ptr, n;
- n = this;
- return $internalize(n.Object.lookupPrefix(), $String);
- };
- BasicNode.prototype.LookupPrefix = function() { return this.$val.LookupPrefix(); };
- BasicNode.ptr.prototype.LookupNamespaceURI = function(s) {
- var $ptr, n, s;
- n = this;
- return $internalize(n.Object.lookupNamespaceURI($externalize(s, $String)), $String);
- };
- BasicNode.prototype.LookupNamespaceURI = function(s) { return this.$val.LookupNamespaceURI(s); };
- BasicNode.ptr.prototype.Normalize = function() {
- var $ptr, n;
- n = this;
- n.Object.normalize();
- };
- BasicNode.prototype.Normalize = function() { return this.$val.Normalize(); };
- BasicNode.ptr.prototype.RemoveChild = function(other) {
- var $ptr, _r, n, other, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; n = $f.n; other = $f.other; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- _r = other.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- n.Object.removeChild(_r);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BasicNode.ptr.prototype.RemoveChild }; } $f.$ptr = $ptr; $f._r = _r; $f.n = n; $f.other = other; $f.$s = $s; $f.$r = $r; return $f;
- };
- BasicNode.prototype.RemoveChild = function(other) { return this.$val.RemoveChild(other); };
- BasicNode.ptr.prototype.ReplaceChild = function(newChild, oldChild) {
- var $ptr, _r, _r$1, n, newChild, oldChild, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; n = $f.n; newChild = $f.newChild; oldChild = $f.oldChild; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- n = this;
- _r = newChild.Underlying(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = oldChild.Underlying(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- n.Object.replaceChild(_r, _r$1);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: BasicNode.ptr.prototype.ReplaceChild }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.n = n; $f.newChild = newChild; $f.oldChild = oldChild; $f.$s = $s; $f.$r = $r; return $f;
- };
- BasicNode.prototype.ReplaceChild = function(newChild, oldChild) { return this.$val.ReplaceChild(newChild, oldChild); };
- BasicHTMLElement.ptr.prototype.AccessKey = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicElement.BasicNode.Object.accessKey, $String);
- };
- BasicHTMLElement.prototype.AccessKey = function() { return this.$val.AccessKey(); };
- BasicHTMLElement.ptr.prototype.SetAccessKey = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicElement.BasicNode.Object.accessKey = $externalize(s, $String);
- };
- BasicHTMLElement.prototype.SetAccessKey = function(s) { return this.$val.SetAccessKey(s); };
- BasicHTMLElement.ptr.prototype.AccessKeyLabel = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicElement.BasicNode.Object.accessKeyLabel, $String);
- };
- BasicHTMLElement.prototype.AccessKeyLabel = function() { return this.$val.AccessKeyLabel(); };
- BasicHTMLElement.ptr.prototype.SetAccessKeyLabel = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicElement.BasicNode.Object.accessKeyLabel = $externalize(s, $String);
- };
- BasicHTMLElement.prototype.SetAccessKeyLabel = function(s) { return this.$val.SetAccessKeyLabel(s); };
- BasicHTMLElement.ptr.prototype.ContentEditable = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicElement.BasicNode.Object.contentEditable, $String);
- };
- BasicHTMLElement.prototype.ContentEditable = function() { return this.$val.ContentEditable(); };
- BasicHTMLElement.ptr.prototype.SetContentEditable = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicElement.BasicNode.Object.contentEditable = $externalize(s, $String);
- };
- BasicHTMLElement.prototype.SetContentEditable = function(s) { return this.$val.SetContentEditable(s); };
- BasicHTMLElement.ptr.prototype.IsContentEditable = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicElement.BasicNode.Object.isContentEditable);
- };
- BasicHTMLElement.prototype.IsContentEditable = function() { return this.$val.IsContentEditable(); };
- BasicHTMLElement.ptr.prototype.Dataset = function() {
- var $ptr, e;
- e = this;
- };
- BasicHTMLElement.prototype.Dataset = function() { return this.$val.Dataset(); };
- BasicHTMLElement.ptr.prototype.Dir = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicElement.BasicNode.Object.dir, $String);
- };
- BasicHTMLElement.prototype.Dir = function() { return this.$val.Dir(); };
- BasicHTMLElement.ptr.prototype.SetDir = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicElement.BasicNode.Object.dir = $externalize(s, $String);
- };
- BasicHTMLElement.prototype.SetDir = function(s) { return this.$val.SetDir(s); };
- BasicHTMLElement.ptr.prototype.Draggable = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicElement.BasicNode.Object.draggable);
- };
- BasicHTMLElement.prototype.Draggable = function() { return this.$val.Draggable(); };
- BasicHTMLElement.ptr.prototype.SetDraggable = function(b) {
- var $ptr, b, e;
- e = this;
- e.BasicElement.BasicNode.Object.draggable = $externalize(b, $Bool);
- };
- BasicHTMLElement.prototype.SetDraggable = function(b) { return this.$val.SetDraggable(b); };
- BasicHTMLElement.ptr.prototype.Lang = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicElement.BasicNode.Object.lang, $String);
- };
- BasicHTMLElement.prototype.Lang = function() { return this.$val.Lang(); };
- BasicHTMLElement.ptr.prototype.SetLang = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicElement.BasicNode.Object.lang = $externalize(s, $String);
- };
- BasicHTMLElement.prototype.SetLang = function(s) { return this.$val.SetLang(s); };
- BasicHTMLElement.ptr.prototype.OffsetHeight = function() {
- var $ptr, e;
- e = this;
- return $parseFloat(e.BasicElement.BasicNode.Object.offsetHeight);
- };
- BasicHTMLElement.prototype.OffsetHeight = function() { return this.$val.OffsetHeight(); };
- BasicHTMLElement.ptr.prototype.OffsetLeft = function() {
- var $ptr, e;
- e = this;
- return $parseFloat(e.BasicElement.BasicNode.Object.offsetLeft);
- };
- BasicHTMLElement.prototype.OffsetLeft = function() { return this.$val.OffsetLeft(); };
- BasicHTMLElement.ptr.prototype.OffsetParent = function() {
- var $ptr, e;
- e = this;
- return wrapHTMLElement(e.BasicElement.BasicNode.Object.offsetParent);
- };
- BasicHTMLElement.prototype.OffsetParent = function() { return this.$val.OffsetParent(); };
- BasicHTMLElement.ptr.prototype.OffsetTop = function() {
- var $ptr, e;
- e = this;
- return $parseFloat(e.BasicElement.BasicNode.Object.offsetTop);
- };
- BasicHTMLElement.prototype.OffsetTop = function() { return this.$val.OffsetTop(); };
- BasicHTMLElement.ptr.prototype.OffsetWidth = function() {
- var $ptr, e;
- e = this;
- return $parseFloat(e.BasicElement.BasicNode.Object.offsetWidth);
- };
- BasicHTMLElement.prototype.OffsetWidth = function() { return this.$val.OffsetWidth(); };
- BasicHTMLElement.ptr.prototype.Style = function() {
- var $ptr, e;
- e = this;
- return new CSSStyleDeclaration.ptr(e.BasicElement.BasicNode.Object.style);
- };
- BasicHTMLElement.prototype.Style = function() { return this.$val.Style(); };
- BasicHTMLElement.ptr.prototype.TabIndex = function() {
- var $ptr, e;
- e = this;
- return $parseInt(e.BasicElement.BasicNode.Object.tabIndex) >> 0;
- };
- BasicHTMLElement.prototype.TabIndex = function() { return this.$val.TabIndex(); };
- BasicHTMLElement.ptr.prototype.SetTabIndex = function(i) {
- var $ptr, e, i;
- e = this;
- e.BasicElement.BasicNode.Object.tabIndex = i;
- };
- BasicHTMLElement.prototype.SetTabIndex = function(i) { return this.$val.SetTabIndex(i); };
- BasicHTMLElement.ptr.prototype.Title = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicElement.BasicNode.Object.title, $String);
- };
- BasicHTMLElement.prototype.Title = function() { return this.$val.Title(); };
- BasicHTMLElement.ptr.prototype.SetTitle = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicElement.BasicNode.Object.title = $externalize(s, $String);
- };
- BasicHTMLElement.prototype.SetTitle = function(s) { return this.$val.SetTitle(s); };
- BasicHTMLElement.ptr.prototype.Blur = function() {
- var $ptr, e;
- e = this;
- e.BasicElement.BasicNode.Object.blur();
- };
- BasicHTMLElement.prototype.Blur = function() { return this.$val.Blur(); };
- BasicHTMLElement.ptr.prototype.Click = function() {
- var $ptr, e;
- e = this;
- e.BasicElement.BasicNode.Object.click();
- };
- BasicHTMLElement.prototype.Click = function() { return this.$val.Click(); };
- BasicHTMLElement.ptr.prototype.Focus = function() {
- var $ptr, e;
- e = this;
- e.BasicElement.BasicNode.Object.focus();
- };
- BasicHTMLElement.prototype.Focus = function() { return this.$val.Focus(); };
- BasicElement.ptr.prototype.GetBoundingClientRect = function() {
- var $ptr, e, obj;
- e = this;
- obj = e.BasicNode.Object.getBoundingClientRect();
- return new ClientRect.ptr(obj, 0, 0, 0, 0, 0, 0);
- };
- BasicElement.prototype.GetBoundingClientRect = function() { return this.$val.GetBoundingClientRect(); };
- BasicElement.ptr.prototype.PreviousElementSibling = function() {
- var $ptr, e;
- e = this;
- return wrapElement(e.BasicNode.Object.previousElementSibling);
- };
- BasicElement.prototype.PreviousElementSibling = function() { return this.$val.PreviousElementSibling(); };
- BasicElement.ptr.prototype.NextElementSibling = function() {
- var $ptr, e;
- e = this;
- return wrapElement(e.BasicNode.Object.nextElementSibling);
- };
- BasicElement.prototype.NextElementSibling = function() { return this.$val.NextElementSibling(); };
- BasicElement.ptr.prototype.Class = function() {
- var $ptr, e;
- e = this;
- return new TokenList.ptr(e.BasicNode.Object.classList, e.BasicNode.Object, "className", 0);
- };
- BasicElement.prototype.Class = function() { return this.$val.Class(); };
- BasicElement.ptr.prototype.SetClass = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicNode.Object.className = $externalize(s, $String);
- };
- BasicElement.prototype.SetClass = function(s) { return this.$val.SetClass(s); };
- BasicElement.ptr.prototype.ID = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicNode.Object.id, $String);
- };
- BasicElement.prototype.ID = function() { return this.$val.ID(); };
- BasicElement.ptr.prototype.SetID = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicNode.Object.id = $externalize(s, $String);
- };
- BasicElement.prototype.SetID = function(s) { return this.$val.SetID(s); };
- BasicElement.ptr.prototype.TagName = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicNode.Object.tagName, $String);
- };
- BasicElement.prototype.TagName = function() { return this.$val.TagName(); };
- BasicElement.ptr.prototype.GetAttribute = function(name) {
- var $ptr, e, name;
- e = this;
- return $internalize(e.BasicNode.Object.getAttribute($externalize(name, $String)), $String);
- };
- BasicElement.prototype.GetAttribute = function(name) { return this.$val.GetAttribute(name); };
- BasicElement.ptr.prototype.GetAttributeNS = function(ns, name) {
- var $ptr, e, name, ns;
- e = this;
- return $internalize(e.BasicNode.Object.getAttributeNS($externalize(ns, $String), $externalize(name, $String)), $String);
- };
- BasicElement.prototype.GetAttributeNS = function(ns, name) { return this.$val.GetAttributeNS(ns, name); };
- BasicElement.ptr.prototype.GetElementsByClassName = function(s) {
- var $ptr, e, s;
- e = this;
- return nodeListToElements(e.BasicNode.Object.getElementsByClassName($externalize(s, $String)));
- };
- BasicElement.prototype.GetElementsByClassName = function(s) { return this.$val.GetElementsByClassName(s); };
- BasicElement.ptr.prototype.GetElementsByTagName = function(s) {
- var $ptr, e, s;
- e = this;
- return nodeListToElements(e.BasicNode.Object.getElementsByTagName($externalize(s, $String)));
- };
- BasicElement.prototype.GetElementsByTagName = function(s) { return this.$val.GetElementsByTagName(s); };
- BasicElement.ptr.prototype.GetElementsByTagNameNS = function(ns, name) {
- var $ptr, e, name, ns;
- e = this;
- return nodeListToElements(e.BasicNode.Object.getElementsByTagNameNS($externalize(ns, $String), $externalize(name, $String)));
- };
- BasicElement.prototype.GetElementsByTagNameNS = function(ns, name) { return this.$val.GetElementsByTagNameNS(ns, name); };
- BasicElement.ptr.prototype.HasAttribute = function(s) {
- var $ptr, e, s;
- e = this;
- return !!(e.BasicNode.Object.hasAttribute($externalize(s, $String)));
- };
- BasicElement.prototype.HasAttribute = function(s) { return this.$val.HasAttribute(s); };
- BasicElement.ptr.prototype.HasAttributeNS = function(ns, name) {
- var $ptr, e, name, ns;
- e = this;
- return !!(e.BasicNode.Object.hasAttributeNS($externalize(ns, $String), $externalize(name, $String)));
- };
- BasicElement.prototype.HasAttributeNS = function(ns, name) { return this.$val.HasAttributeNS(ns, name); };
- BasicElement.ptr.prototype.QuerySelector = function(s) {
- var $ptr, e, s;
- e = this;
- return wrapElement(e.BasicNode.Object.querySelector($externalize(s, $String)));
- };
- BasicElement.prototype.QuerySelector = function(s) { return this.$val.QuerySelector(s); };
- BasicElement.ptr.prototype.QuerySelectorAll = function(s) {
- var $ptr, e, s;
- e = this;
- return nodeListToElements(e.BasicNode.Object.querySelectorAll($externalize(s, $String)));
- };
- BasicElement.prototype.QuerySelectorAll = function(s) { return this.$val.QuerySelectorAll(s); };
- BasicElement.ptr.prototype.RemoveAttribute = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicNode.Object.removeAttribute($externalize(s, $String));
- };
- BasicElement.prototype.RemoveAttribute = function(s) { return this.$val.RemoveAttribute(s); };
- BasicElement.ptr.prototype.RemoveAttributeNS = function(ns, name) {
- var $ptr, e, name, ns;
- e = this;
- e.BasicNode.Object.removeAttributeNS($externalize(ns, $String), $externalize(name, $String));
- };
- BasicElement.prototype.RemoveAttributeNS = function(ns, name) { return this.$val.RemoveAttributeNS(ns, name); };
- BasicElement.ptr.prototype.SetAttribute = function(name, value) {
- var $ptr, e, name, value;
- e = this;
- e.BasicNode.Object.setAttribute($externalize(name, $String), $externalize(value, $String));
- };
- BasicElement.prototype.SetAttribute = function(name, value) { return this.$val.SetAttribute(name, value); };
- BasicElement.ptr.prototype.SetAttributeNS = function(ns, name, value) {
- var $ptr, e, name, ns, value;
- e = this;
- e.BasicNode.Object.setAttributeNS($externalize(ns, $String), $externalize(name, $String), $externalize(value, $String));
- };
- BasicElement.prototype.SetAttributeNS = function(ns, name, value) { return this.$val.SetAttributeNS(ns, name, value); };
- BasicElement.ptr.prototype.InnerHTML = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicNode.Object.innerHTML, $String);
- };
- BasicElement.prototype.InnerHTML = function() { return this.$val.InnerHTML(); };
- BasicElement.ptr.prototype.SetInnerHTML = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicNode.Object.innerHTML = $externalize(s, $String);
- };
- BasicElement.prototype.SetInnerHTML = function(s) { return this.$val.SetInnerHTML(s); };
- HTMLAnchorElement.ptr.prototype.Rel = function() {
- var $ptr, e;
- e = this;
- return new TokenList.ptr(e.URLUtils.Object.relList, e.URLUtils.Object, "rel", 0);
- };
- HTMLAnchorElement.prototype.Rel = function() { return this.$val.Rel(); };
- HTMLAppletElement.ptr.prototype.Rel = function() {
- var $ptr, e;
- e = this;
- return new TokenList.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.relList, e.BasicHTMLElement.BasicElement.BasicNode.Object, "rel", 0);
- };
- HTMLAppletElement.prototype.Rel = function() { return this.$val.Rel(); };
- HTMLAreaElement.ptr.prototype.Rel = function() {
- var $ptr, e;
- e = this;
- return new TokenList.ptr(e.URLUtils.Object.relList, e.URLUtils.Object, "rel", 0);
- };
- HTMLAreaElement.prototype.Rel = function() { return this.$val.Rel(); };
- HTMLButtonElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLButtonElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLButtonElement.ptr.prototype.Labels = function() {
- var $ptr, e;
- e = this;
- return getLabels(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLButtonElement.prototype.Labels = function() { return this.$val.Labels(); };
- HTMLButtonElement.ptr.prototype.Validity = function() {
- var $ptr, e;
- e = this;
- return new ValidityState.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.validity, false, false, false, false, false, false, false, false, false);
- };
- HTMLButtonElement.prototype.Validity = function() { return this.$val.Validity(); };
- HTMLButtonElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLButtonElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLButtonElement.ptr.prototype.SetCustomValidity = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setCustomValidity($externalize(s, $String));
- };
- HTMLButtonElement.prototype.SetCustomValidity = function(s) { return this.$val.SetCustomValidity(s); };
- HTMLCanvasElement.ptr.prototype.GetContext2d = function() {
- var $ptr, ctx, e;
- e = this;
- ctx = e.GetContext("2d");
- return new CanvasRenderingContext2D.ptr(ctx, "", "", "", 0, 0, 0, "", "", 0, 0, "", "", "", 0, "");
- };
- HTMLCanvasElement.prototype.GetContext2d = function() { return this.$val.GetContext2d(); };
- HTMLCanvasElement.ptr.prototype.GetContext = function(param) {
- var $ptr, e, param;
- e = this;
- return e.BasicHTMLElement.BasicElement.BasicNode.Object.getContext($externalize(param, $String));
- };
- HTMLCanvasElement.prototype.GetContext = function(param) { return this.$val.GetContext(param); };
- CanvasRenderingContext2D.ptr.prototype.CreateLinearGradient = function(x0, y0, x1, y1) {
- var $ptr, ctx, x0, x1, y0, y1;
- ctx = this;
- ctx.Object.createLinearGradient(x0, y0, x1, y1);
- };
- CanvasRenderingContext2D.prototype.CreateLinearGradient = function(x0, y0, x1, y1) { return this.$val.CreateLinearGradient(x0, y0, x1, y1); };
- CanvasRenderingContext2D.ptr.prototype.Rect = function(x, y, width, height) {
- var $ptr, ctx, height, width, x, y;
- ctx = this;
- ctx.Object.rect(x, y, width, height);
- };
- CanvasRenderingContext2D.prototype.Rect = function(x, y, width, height) { return this.$val.Rect(x, y, width, height); };
- CanvasRenderingContext2D.ptr.prototype.FillRect = function(x, y, width, height) {
- var $ptr, ctx, height, width, x, y;
- ctx = this;
- ctx.Object.fillRect(x, y, width, height);
- };
- CanvasRenderingContext2D.prototype.FillRect = function(x, y, width, height) { return this.$val.FillRect(x, y, width, height); };
- CanvasRenderingContext2D.ptr.prototype.StrokeRect = function(x, y, width, height) {
- var $ptr, ctx, height, width, x, y;
- ctx = this;
- ctx.Object.strokeRect(x, y, width, height);
- };
- CanvasRenderingContext2D.prototype.StrokeRect = function(x, y, width, height) { return this.$val.StrokeRect(x, y, width, height); };
- CanvasRenderingContext2D.ptr.prototype.ClearRect = function(x, y, width, height) {
- var $ptr, ctx, height, width, x, y;
- ctx = this;
- ctx.Object.clearRect(x, y, width, height);
- };
- CanvasRenderingContext2D.prototype.ClearRect = function(x, y, width, height) { return this.$val.ClearRect(x, y, width, height); };
- CanvasRenderingContext2D.ptr.prototype.Fill = function() {
- var $ptr, ctx;
- ctx = this;
- ctx.Object.fill();
- };
- CanvasRenderingContext2D.prototype.Fill = function() { return this.$val.Fill(); };
- CanvasRenderingContext2D.ptr.prototype.Stroke = function() {
- var $ptr, ctx;
- ctx = this;
- ctx.Object.stroke();
- };
- CanvasRenderingContext2D.prototype.Stroke = function() { return this.$val.Stroke(); };
- CanvasRenderingContext2D.ptr.prototype.BeginPath = function() {
- var $ptr, ctx;
- ctx = this;
- ctx.Object.beginPath();
- };
- CanvasRenderingContext2D.prototype.BeginPath = function() { return this.$val.BeginPath(); };
- CanvasRenderingContext2D.ptr.prototype.MoveTo = function(x, y) {
- var $ptr, ctx, x, y;
- ctx = this;
- ctx.Object.moveTo(x, y);
- };
- CanvasRenderingContext2D.prototype.MoveTo = function(x, y) { return this.$val.MoveTo(x, y); };
- CanvasRenderingContext2D.ptr.prototype.ClosePath = function() {
- var $ptr, ctx;
- ctx = this;
- ctx.Object.closePath();
- };
- CanvasRenderingContext2D.prototype.ClosePath = function() { return this.$val.ClosePath(); };
- CanvasRenderingContext2D.ptr.prototype.LineTo = function(x, y) {
- var $ptr, ctx, x, y;
- ctx = this;
- ctx.Object.lineTo(x, y);
- };
- CanvasRenderingContext2D.prototype.LineTo = function(x, y) { return this.$val.LineTo(x, y); };
- CanvasRenderingContext2D.ptr.prototype.Clip = function() {
- var $ptr, ctx;
- ctx = this;
- ctx.Object.clip();
- };
- CanvasRenderingContext2D.prototype.Clip = function() { return this.$val.Clip(); };
- CanvasRenderingContext2D.ptr.prototype.QuadraticCurveTo = function(cpx, cpy, x, y) {
- var $ptr, cpx, cpy, ctx, x, y;
- ctx = this;
- ctx.Object.quadraticCurveTo(cpx, cpy, x, y);
- };
- CanvasRenderingContext2D.prototype.QuadraticCurveTo = function(cpx, cpy, x, y) { return this.$val.QuadraticCurveTo(cpx, cpy, x, y); };
- CanvasRenderingContext2D.ptr.prototype.BezierCurveTo = function(cp1x, cp1y, cp2x, cp2y, x, y) {
- var $ptr, cp1x, cp1y, cp2x, cp2y, ctx, x, y;
- ctx = this;
- ctx.Object.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
- };
- CanvasRenderingContext2D.prototype.BezierCurveTo = function(cp1x, cp1y, cp2x, cp2y, x, y) { return this.$val.BezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y); };
- CanvasRenderingContext2D.ptr.prototype.Arc = function(x, y, r, sAngle, eAngle, counterclockwise) {
- var $ptr, counterclockwise, ctx, eAngle, r, sAngle, x, y;
- ctx = this;
- ctx.Object.arc(x, y, r, sAngle, eAngle, $externalize(counterclockwise, $Bool));
- };
- CanvasRenderingContext2D.prototype.Arc = function(x, y, r, sAngle, eAngle, counterclockwise) { return this.$val.Arc(x, y, r, sAngle, eAngle, counterclockwise); };
- CanvasRenderingContext2D.ptr.prototype.ArcTo = function(x1, y1, x2, y2, r) {
- var $ptr, ctx, r, x1, x2, y1, y2;
- ctx = this;
- ctx.Object.arcTo(x1, y1, x2, y2, r);
- };
- CanvasRenderingContext2D.prototype.ArcTo = function(x1, y1, x2, y2, r) { return this.$val.ArcTo(x1, y1, x2, y2, r); };
- CanvasRenderingContext2D.ptr.prototype.IsPointInPath = function(x, y) {
- var $ptr, ctx, x, y;
- ctx = this;
- return !!(ctx.Object.isPointInPath(x, y));
- };
- CanvasRenderingContext2D.prototype.IsPointInPath = function(x, y) { return this.$val.IsPointInPath(x, y); };
- CanvasRenderingContext2D.ptr.prototype.Scale = function(scaleWidth, scaleHeight) {
- var $ptr, ctx, scaleHeight, scaleWidth;
- ctx = this;
- ctx.Object.scale(scaleWidth, scaleHeight);
- };
- CanvasRenderingContext2D.prototype.Scale = function(scaleWidth, scaleHeight) { return this.$val.Scale(scaleWidth, scaleHeight); };
- CanvasRenderingContext2D.ptr.prototype.Rotate = function(angle) {
- var $ptr, angle, ctx;
- ctx = this;
- ctx.Object.rotate(angle);
- };
- CanvasRenderingContext2D.prototype.Rotate = function(angle) { return this.$val.Rotate(angle); };
- CanvasRenderingContext2D.ptr.prototype.Translate = function(x, y) {
- var $ptr, ctx, x, y;
- ctx = this;
- ctx.Object.translate(x, y);
- };
- CanvasRenderingContext2D.prototype.Translate = function(x, y) { return this.$val.Translate(x, y); };
- CanvasRenderingContext2D.ptr.prototype.Transform = function(a, b, c, d, e, f) {
- var $ptr, a, b, c, ctx, d, e, f;
- ctx = this;
- ctx.Object.transform(a, b, c, d, e, f);
- };
- CanvasRenderingContext2D.prototype.Transform = function(a, b, c, d, e, f) { return this.$val.Transform(a, b, c, d, e, f); };
- CanvasRenderingContext2D.ptr.prototype.SetTransform = function(a, b, c, d, e, f) {
- var $ptr, a, b, c, ctx, d, e, f;
- ctx = this;
- ctx.Object.setTransform(a, b, c, d, e, f);
- };
- CanvasRenderingContext2D.prototype.SetTransform = function(a, b, c, d, e, f) { return this.$val.SetTransform(a, b, c, d, e, f); };
- CanvasRenderingContext2D.ptr.prototype.FillText = function(text, x, y, maxWidth) {
- var $ptr, ctx, maxWidth, text, x, y;
- ctx = this;
- if (maxWidth === -1) {
- ctx.Object.fillText($externalize(text, $String), x, y);
- return;
- }
- ctx.Object.fillText($externalize(text, $String), x, y, maxWidth);
- };
- CanvasRenderingContext2D.prototype.FillText = function(text, x, y, maxWidth) { return this.$val.FillText(text, x, y, maxWidth); };
- CanvasRenderingContext2D.ptr.prototype.StrokeText = function(text, x, y, maxWidth) {
- var $ptr, ctx, maxWidth, text, x, y;
- ctx = this;
- if (maxWidth === -1) {
- ctx.Object.strokeText($externalize(text, $String), x, y);
- return;
- }
- ctx.Object.strokeText($externalize(text, $String), x, y, maxWidth);
- };
- CanvasRenderingContext2D.prototype.StrokeText = function(text, x, y, maxWidth) { return this.$val.StrokeText(text, x, y, maxWidth); };
- HTMLDataListElement.ptr.prototype.Options = function() {
- var $ptr, _i, _ref, e, i, option, options, out;
- e = this;
- options = nodeListToElements(e.BasicHTMLElement.BasicElement.BasicNode.Object.options);
- out = $makeSlice(sliceType$11, options.$length);
- _ref = options;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- option = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i] = $assertType(option, ptrType$11));
- _i++;
- }
- return out;
- };
- HTMLDataListElement.prototype.Options = function() { return this.$val.Options(); };
- HTMLFieldSetElement.ptr.prototype.Elements = function() {
- var $ptr, e;
- e = this;
- return nodeListToHTMLElements(e.BasicHTMLElement.BasicElement.BasicNode.Object.elements);
- };
- HTMLFieldSetElement.prototype.Elements = function() { return this.$val.Elements(); };
- HTMLFieldSetElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLFieldSetElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLFieldSetElement.ptr.prototype.Validity = function() {
- var $ptr, e;
- e = this;
- return new ValidityState.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.validity, false, false, false, false, false, false, false, false, false);
- };
- HTMLFieldSetElement.prototype.Validity = function() { return this.$val.Validity(); };
- HTMLFieldSetElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLFieldSetElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLFieldSetElement.ptr.prototype.SetCustomValidity = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setCustomValidity($externalize(s, $String));
- };
- HTMLFieldSetElement.prototype.SetCustomValidity = function(s) { return this.$val.SetCustomValidity(s); };
- HTMLFormElement.ptr.prototype.Elements = function() {
- var $ptr, e;
- e = this;
- return nodeListToHTMLElements(e.BasicHTMLElement.BasicElement.BasicNode.Object.elements);
- };
- HTMLFormElement.prototype.Elements = function() { return this.$val.Elements(); };
- HTMLFormElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLFormElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLFormElement.ptr.prototype.Submit = function() {
- var $ptr, e;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.submit();
- };
- HTMLFormElement.prototype.Submit = function() { return this.$val.Submit(); };
- HTMLFormElement.ptr.prototype.Reset = function() {
- var $ptr, e;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.reset();
- };
- HTMLFormElement.prototype.Reset = function() { return this.$val.Reset(); };
- HTMLFormElement.ptr.prototype.Item = function(index) {
- var $ptr, e, index;
- e = this;
- return wrapHTMLElement(e.BasicHTMLElement.BasicElement.BasicNode.Object.item(index));
- };
- HTMLFormElement.prototype.Item = function(index) { return this.$val.Item(index); };
- HTMLFormElement.ptr.prototype.NamedItem = function(name) {
- var $ptr, e, name;
- e = this;
- return wrapHTMLElement(e.BasicHTMLElement.BasicElement.BasicNode.Object.namedItem($externalize(name, $String)));
- };
- HTMLFormElement.prototype.NamedItem = function(name) { return this.$val.NamedItem(name); };
- HTMLIFrameElement.ptr.prototype.ContentDocument = function() {
- var $ptr, e;
- e = this;
- return wrapDocument(e.BasicHTMLElement.BasicElement.BasicNode.Object.contentDocument);
- };
- HTMLIFrameElement.prototype.ContentDocument = function() { return this.$val.ContentDocument(); };
- HTMLIFrameElement.ptr.prototype.ContentWindow = function() {
- var $ptr, e;
- e = this;
- return new window.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.contentWindow);
- };
- HTMLIFrameElement.prototype.ContentWindow = function() { return this.$val.ContentWindow(); };
- HTMLInputElement.ptr.prototype.Files = function() {
- var $ptr, _i, _ref, e, files, i, out;
- e = this;
- files = e.BasicHTMLElement.BasicElement.BasicNode.Object.files;
- out = $makeSlice(sliceType$12, ($parseInt(files.length) >> 0));
- _ref = out;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- ((i < 0 || i >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i] = new File.ptr(files.item(i)));
- _i++;
- }
- return out;
- };
- HTMLInputElement.prototype.Files = function() { return this.$val.Files(); };
- HTMLInputElement.ptr.prototype.List = function() {
- var $ptr, e, list;
- e = this;
- list = wrapHTMLElement(e.BasicHTMLElement.BasicElement.BasicNode.Object.list);
- if ($interfaceIsEqual(list, $ifaceNil)) {
- return ptrType$13.nil;
- }
- return $assertType(list, ptrType$13);
- };
- HTMLInputElement.prototype.List = function() { return this.$val.List(); };
- HTMLInputElement.ptr.prototype.Labels = function() {
- var $ptr, e;
- e = this;
- return getLabels(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLInputElement.prototype.Labels = function() { return this.$val.Labels(); };
- HTMLInputElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLInputElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLInputElement.ptr.prototype.Validity = function() {
- var $ptr, e;
- e = this;
- return new ValidityState.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.validity, false, false, false, false, false, false, false, false, false);
- };
- HTMLInputElement.prototype.Validity = function() { return this.$val.Validity(); };
- HTMLInputElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLInputElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLInputElement.ptr.prototype.SetCustomValidity = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setCustomValidity($externalize(s, $String));
- };
- HTMLInputElement.prototype.SetCustomValidity = function(s) { return this.$val.SetCustomValidity(s); };
- HTMLInputElement.ptr.prototype.Select = function() {
- var $ptr, e;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.select();
- };
- HTMLInputElement.prototype.Select = function() { return this.$val.Select(); };
- HTMLInputElement.ptr.prototype.SetSelectionRange = function(start, end, direction) {
- var $ptr, direction, e, end, start;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setSelectionRange(start, end, $externalize(direction, $String));
- };
- HTMLInputElement.prototype.SetSelectionRange = function(start, end, direction) { return this.$val.SetSelectionRange(start, end, direction); };
- HTMLInputElement.ptr.prototype.StepDown = function(n) {
- var $ptr, e, n;
- e = this;
- return callRecover(e.BasicHTMLElement.BasicElement.BasicNode.Object, "stepDown", new sliceType([new $Int(n)]));
- };
- HTMLInputElement.prototype.StepDown = function(n) { return this.$val.StepDown(n); };
- HTMLInputElement.ptr.prototype.StepUp = function(n) {
- var $ptr, e, n;
- e = this;
- return callRecover(e.BasicHTMLElement.BasicElement.BasicNode.Object, "stepUp", new sliceType([new $Int(n)]));
- };
- HTMLInputElement.prototype.StepUp = function(n) { return this.$val.StepUp(n); };
- HTMLKeygenElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLKeygenElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLKeygenElement.ptr.prototype.Labels = function() {
- var $ptr, e;
- e = this;
- return getLabels(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLKeygenElement.prototype.Labels = function() { return this.$val.Labels(); };
- HTMLKeygenElement.ptr.prototype.Validity = function() {
- var $ptr, e;
- e = this;
- return new ValidityState.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.validity, false, false, false, false, false, false, false, false, false);
- };
- HTMLKeygenElement.prototype.Validity = function() { return this.$val.Validity(); };
- HTMLKeygenElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLKeygenElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLKeygenElement.ptr.prototype.SetCustomValidity = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setCustomValidity($externalize(s, $String));
- };
- HTMLKeygenElement.prototype.SetCustomValidity = function(s) { return this.$val.SetCustomValidity(s); };
- HTMLLabelElement.ptr.prototype.Control = function() {
- var $ptr, e;
- e = this;
- return wrapHTMLElement(e.BasicHTMLElement.BasicElement.BasicNode.Object.control);
- };
- HTMLLabelElement.prototype.Control = function() { return this.$val.Control(); };
- HTMLLabelElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLLabelElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLLegendElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLLegendElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLLinkElement.ptr.prototype.Rel = function() {
- var $ptr, e;
- e = this;
- return new TokenList.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.relList, e.BasicHTMLElement.BasicElement.BasicNode.Object, "rel", 0);
- };
- HTMLLinkElement.prototype.Rel = function() { return this.$val.Rel(); };
- HTMLLinkElement.ptr.prototype.Sizes = function() {
- var $ptr, e;
- e = this;
- return new TokenList.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.sizes, e.BasicHTMLElement.BasicElement.BasicNode.Object, "", 0);
- };
- HTMLLinkElement.prototype.Sizes = function() { return this.$val.Sizes(); };
- HTMLLinkElement.ptr.prototype.Sheet = function() {
- var $ptr, e;
- e = this;
- return $ifaceNil;
- };
- HTMLLinkElement.prototype.Sheet = function() { return this.$val.Sheet(); };
- HTMLMapElement.ptr.prototype.Areas = function() {
- var $ptr, _i, _ref, area, areas, e, i, out;
- e = this;
- areas = nodeListToElements(e.BasicHTMLElement.BasicElement.BasicNode.Object.areas);
- out = $makeSlice(sliceType$13, areas.$length);
- _ref = areas;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- area = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i] = $assertType(area, ptrType$14));
- _i++;
- }
- return out;
- };
- HTMLMapElement.prototype.Areas = function() { return this.$val.Areas(); };
- HTMLMapElement.ptr.prototype.Images = function() {
- var $ptr, e;
- e = this;
- return nodeListToHTMLElements(e.BasicHTMLElement.BasicElement.BasicNode.Object.areas);
- };
- HTMLMapElement.prototype.Images = function() { return this.$val.Images(); };
- HTMLMeterElement.ptr.prototype.Labels = function() {
- var $ptr, e;
- e = $clone(this, HTMLMeterElement);
- return getLabels(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLMeterElement.prototype.Labels = function() { return this.$val.Labels(); };
- HTMLObjectElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLObjectElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLObjectElement.ptr.prototype.ContentDocument = function() {
- var $ptr, e;
- e = this;
- return wrapDocument(e.BasicHTMLElement.BasicElement.BasicNode.Object.contentDocument);
- };
- HTMLObjectElement.prototype.ContentDocument = function() { return this.$val.ContentDocument(); };
- HTMLObjectElement.ptr.prototype.ContentWindow = function() {
- var $ptr, e;
- e = this;
- return new window.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.contentWindow);
- };
- HTMLObjectElement.prototype.ContentWindow = function() { return this.$val.ContentWindow(); };
- HTMLObjectElement.ptr.prototype.Validity = function() {
- var $ptr, e;
- e = this;
- return new ValidityState.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.validity, false, false, false, false, false, false, false, false, false);
- };
- HTMLObjectElement.prototype.Validity = function() { return this.$val.Validity(); };
- HTMLObjectElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLObjectElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLObjectElement.ptr.prototype.SetCustomValidity = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setCustomValidity($externalize(s, $String));
- };
- HTMLObjectElement.prototype.SetCustomValidity = function(s) { return this.$val.SetCustomValidity(s); };
- HTMLOptionElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLOptionElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLOutputElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLOutputElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLOutputElement.ptr.prototype.Labels = function() {
- var $ptr, e;
- e = this;
- return getLabels(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLOutputElement.prototype.Labels = function() { return this.$val.Labels(); };
- HTMLOutputElement.ptr.prototype.Validity = function() {
- var $ptr, e;
- e = this;
- return new ValidityState.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.validity, false, false, false, false, false, false, false, false, false);
- };
- HTMLOutputElement.prototype.Validity = function() { return this.$val.Validity(); };
- HTMLOutputElement.ptr.prototype.For = function() {
- var $ptr, e;
- e = this;
- return new TokenList.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.htmlFor, e.BasicHTMLElement.BasicElement.BasicNode.Object, "", 0);
- };
- HTMLOutputElement.prototype.For = function() { return this.$val.For(); };
- HTMLOutputElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLOutputElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLOutputElement.ptr.prototype.SetCustomValidity = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setCustomValidity($externalize(s, $String));
- };
- HTMLOutputElement.prototype.SetCustomValidity = function(s) { return this.$val.SetCustomValidity(s); };
- HTMLProgressElement.ptr.prototype.Labels = function() {
- var $ptr, e;
- e = $clone(this, HTMLProgressElement);
- return getLabels(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLProgressElement.prototype.Labels = function() { return this.$val.Labels(); };
- HTMLTableRowElement.ptr.prototype.Cells = function() {
- var $ptr, _i, _ref, cell, cells, e, i, out;
- e = this;
- cells = nodeListToElements(e.BasicHTMLElement.BasicElement.BasicNode.Object.cells);
- out = $makeSlice(sliceType$14, cells.$length);
- _ref = cells;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- cell = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i] = $assertType(cell, ptrType$15));
- _i++;
- }
- return out;
- };
- HTMLTableRowElement.prototype.Cells = function() { return this.$val.Cells(); };
- HTMLTableRowElement.ptr.prototype.InsertCell = function(index) {
- var $ptr, e, index;
- e = this;
- return $assertType(wrapHTMLElement(e.BasicHTMLElement.BasicElement.BasicNode.Object.insertCell(index)), ptrType$15);
- };
- HTMLTableRowElement.prototype.InsertCell = function(index) { return this.$val.InsertCell(index); };
- HTMLTableRowElement.ptr.prototype.DeleteCell = function(index) {
- var $ptr, e, index;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.deleteCell(index);
- };
- HTMLTableRowElement.prototype.DeleteCell = function(index) { return this.$val.DeleteCell(index); };
- HTMLTableSectionElement.ptr.prototype.Rows = function() {
- var $ptr, _i, _ref, e, i, out, row, rows;
- e = this;
- rows = nodeListToElements(e.BasicHTMLElement.BasicElement.BasicNode.Object.rows);
- out = $makeSlice(sliceType$15, rows.$length);
- _ref = rows;
- _i = 0;
- while (true) {
- if (!(_i < _ref.$length)) { break; }
- i = _i;
- row = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- ((i < 0 || i >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i] = $assertType(row, ptrType$16));
- _i++;
- }
- return out;
- };
- HTMLTableSectionElement.prototype.Rows = function() { return this.$val.Rows(); };
- HTMLTableSectionElement.ptr.prototype.DeleteRow = function(index) {
- var $ptr, e, index;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.deleteRow(index);
- };
- HTMLTableSectionElement.prototype.DeleteRow = function(index) { return this.$val.DeleteRow(index); };
- HTMLTableSectionElement.ptr.prototype.InsertRow = function(index) {
- var $ptr, e, index;
- e = this;
- return $assertType(wrapHTMLElement(e.BasicHTMLElement.BasicElement.BasicNode.Object.insertRow(index)), ptrType$16);
- };
- HTMLTableSectionElement.prototype.InsertRow = function(index) { return this.$val.InsertRow(index); };
- HTMLTextAreaElement.ptr.prototype.Form = function() {
- var $ptr, e;
- e = this;
- return getForm(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLTextAreaElement.prototype.Form = function() { return this.$val.Form(); };
- HTMLTextAreaElement.ptr.prototype.Labels = function() {
- var $ptr, e;
- e = this;
- return getLabels(e.BasicHTMLElement.BasicElement.BasicNode.Object);
- };
- HTMLTextAreaElement.prototype.Labels = function() { return this.$val.Labels(); };
- HTMLTextAreaElement.ptr.prototype.Validity = function() {
- var $ptr, e;
- e = this;
- return new ValidityState.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.validity, false, false, false, false, false, false, false, false, false);
- };
- HTMLTextAreaElement.prototype.Validity = function() { return this.$val.Validity(); };
- HTMLTextAreaElement.ptr.prototype.CheckValidity = function() {
- var $ptr, e;
- e = this;
- return !!(e.BasicHTMLElement.BasicElement.BasicNode.Object.checkValidity());
- };
- HTMLTextAreaElement.prototype.CheckValidity = function() { return this.$val.CheckValidity(); };
- HTMLTextAreaElement.ptr.prototype.SetCustomValidity = function(s) {
- var $ptr, e, s;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setCustomValidity($externalize(s, $String));
- };
- HTMLTextAreaElement.prototype.SetCustomValidity = function(s) { return this.$val.SetCustomValidity(s); };
- HTMLTextAreaElement.ptr.prototype.Select = function() {
- var $ptr, e;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.select();
- };
- HTMLTextAreaElement.prototype.Select = function() { return this.$val.Select(); };
- HTMLTextAreaElement.ptr.prototype.SetSelectionRange = function(start, end, direction) {
- var $ptr, direction, e, end, start;
- e = this;
- e.BasicHTMLElement.BasicElement.BasicNode.Object.setSelectionRange(start, end, $externalize(direction, $String));
- };
- HTMLTextAreaElement.prototype.SetSelectionRange = function(start, end, direction) { return this.$val.SetSelectionRange(start, end, direction); };
- HTMLTrackElement.ptr.prototype.Track = function() {
- var $ptr, e;
- e = this;
- return new TextTrack.ptr(e.BasicHTMLElement.BasicElement.BasicNode.Object.track);
- };
- HTMLTrackElement.prototype.Track = function() { return this.$val.Track(); };
- HTMLBaseElement.ptr.prototype.Href = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicHTMLElement.BasicElement.BasicNode.Object.href, $String);
- };
- HTMLBaseElement.prototype.Href = function() { return this.$val.Href(); };
- HTMLBaseElement.ptr.prototype.Target = function() {
- var $ptr, e;
- e = this;
- return $internalize(e.BasicHTMLElement.BasicElement.BasicNode.Object.target, $String);
- };
- HTMLBaseElement.prototype.Target = function() { return this.$val.Target(); };
- CSSStyleDeclaration.ptr.prototype.ToMap = function() {
- var $ptr, N, _key, css, i, m, name, value;
- css = this;
- m = new $Map();
- N = $parseInt(css.Object.length) >> 0;
- i = 0;
- while (true) {
- if (!(i < N)) { break; }
- name = $internalize(css.Object.index(i), $String);
- value = $internalize(css.Object.getPropertyValue(), $String);
- _key = name; (m || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: value };
- i = i + (1) >> 0;
- }
- return m;
- };
- CSSStyleDeclaration.prototype.ToMap = function() { return this.$val.ToMap(); };
- CSSStyleDeclaration.ptr.prototype.RemoveProperty = function(name) {
- var $ptr, css, name;
- css = this;
- css.Object.remoteProperty($externalize(name, $String));
- };
- CSSStyleDeclaration.prototype.RemoveProperty = function(name) { return this.$val.RemoveProperty(name); };
- CSSStyleDeclaration.ptr.prototype.GetPropertyValue = function(name) {
- var $ptr, css, name;
- css = this;
- return $internalize(css.Object.getPropertyValue($externalize(name, $String)), $String);
- };
- CSSStyleDeclaration.prototype.GetPropertyValue = function(name) { return this.$val.GetPropertyValue(name); };
- CSSStyleDeclaration.ptr.prototype.GetPropertyPriority = function(name) {
- var $ptr, css, name;
- css = this;
- return $internalize(css.Object.getPropertyPriority($externalize(name, $String)), $String);
- };
- CSSStyleDeclaration.prototype.GetPropertyPriority = function(name) { return this.$val.GetPropertyPriority(name); };
- CSSStyleDeclaration.ptr.prototype.SetProperty = function(name, value, priority) {
- var $ptr, css, name, priority, value;
- css = this;
- css.Object.setProperty($externalize(name, $String), $externalize(value, $String), $externalize(priority, $String));
- };
- CSSStyleDeclaration.prototype.SetProperty = function(name, value, priority) { return this.$val.SetProperty(name, value, priority); };
- CSSStyleDeclaration.ptr.prototype.Index = function(idx) {
- var $ptr, css, idx;
- css = this;
- return $internalize(css.Object.index(idx), $String);
- };
- CSSStyleDeclaration.prototype.Index = function(idx) { return this.$val.Index(idx); };
- CSSStyleDeclaration.ptr.prototype.Length = function() {
- var $ptr, css;
- css = this;
- return $parseInt(css.Object.length) >> 0;
- };
- CSSStyleDeclaration.prototype.Length = function() { return this.$val.Length(); };
- wrapEvent = function(o) {
- var $ptr, _ref, c, ev, o;
- if (o === null || o === undefined) {
- return $ifaceNil;
- }
- ev = new BasicEvent.ptr(o);
- c = o.constructor;
- _ref = c;
- if (_ref === $global.AnimationEvent) {
- return new AnimationEvent.ptr(ev);
- } else if (_ref === $global.AudioProcessingEvent) {
- return new AudioProcessingEvent.ptr(ev);
- } else if (_ref === $global.BeforeInputEvent) {
- return new BeforeInputEvent.ptr(ev);
- } else if (_ref === $global.BeforeUnloadEvent) {
- return new BeforeUnloadEvent.ptr(ev);
- } else if (_ref === $global.BlobEvent) {
- return new BlobEvent.ptr(ev);
- } else if (_ref === $global.ClipboardEvent) {
- return new ClipboardEvent.ptr(ev);
- } else if (_ref === $global.CloseEvent) {
- return new CloseEvent.ptr(ev, 0, "", false);
- } else if (_ref === $global.CompositionEvent) {
- return new CompositionEvent.ptr(ev);
- } else if (_ref === $global.CSSFontFaceLoadEvent) {
- return new CSSFontFaceLoadEvent.ptr(ev);
- } else if (_ref === $global.CustomEvent) {
- return new CustomEvent.ptr(ev);
- } else if (_ref === $global.DeviceLightEvent) {
- return new DeviceLightEvent.ptr(ev);
- } else if (_ref === $global.DeviceMotionEvent) {
- return new DeviceMotionEvent.ptr(ev);
- } else if (_ref === $global.DeviceOrientationEvent) {
- return new DeviceOrientationEvent.ptr(ev);
- } else if (_ref === $global.DeviceProximityEvent) {
- return new DeviceProximityEvent.ptr(ev);
- } else if (_ref === $global.DOMTransactionEvent) {
- return new DOMTransactionEvent.ptr(ev);
- } else if (_ref === $global.DragEvent) {
- return new DragEvent.ptr(ev);
- } else if (_ref === $global.EditingBeforeInputEvent) {
- return new EditingBeforeInputEvent.ptr(ev);
- } else if (_ref === $global.ErrorEvent) {
- return new ErrorEvent.ptr(ev);
- } else if (_ref === $global.FocusEvent) {
- return new FocusEvent.ptr(ev);
- } else if (_ref === $global.GamepadEvent) {
- return new GamepadEvent.ptr(ev);
- } else if (_ref === $global.HashChangeEvent) {
- return new HashChangeEvent.ptr(ev);
- } else if (_ref === $global.IDBVersionChangeEvent) {
- return new IDBVersionChangeEvent.ptr(ev);
- } else if (_ref === $global.KeyboardEvent) {
- return new KeyboardEvent.ptr(ev, false, 0, false, "", "", 0, "", 0, 0, false, false, false);
- } else if (_ref === $global.MediaStreamEvent) {
- return new MediaStreamEvent.ptr(ev);
- } else if (_ref === $global.MessageEvent) {
- return new MessageEvent.ptr(ev, null);
- } else if (_ref === $global.MouseEvent) {
- return new MouseEvent.ptr(new UIEvent.ptr(ev), false, 0, 0, 0, false, false, 0, 0, 0, 0, false);
- } else if (_ref === $global.MutationEvent) {
- return new MutationEvent.ptr(ev);
- } else if (_ref === $global.OfflineAudioCompletionEvent) {
- return new OfflineAudioCompletionEvent.ptr(ev);
- } else if (_ref === $global.PageTransitionEvent) {
- return new PageTransitionEvent.ptr(ev);
- } else if (_ref === $global.PointerEvent) {
- return new PointerEvent.ptr(ev);
- } else if (_ref === $global.PopStateEvent) {
- return new PopStateEvent.ptr(ev);
- } else if (_ref === $global.ProgressEvent) {
- return new ProgressEvent.ptr(ev);
- } else if (_ref === $global.RelatedEvent) {
- return new RelatedEvent.ptr(ev);
- } else if (_ref === $global.RTCPeerConnectionIceEvent) {
- return new RTCPeerConnectionIceEvent.ptr(ev);
- } else if (_ref === $global.SensorEvent) {
- return new SensorEvent.ptr(ev);
- } else if (_ref === $global.StorageEvent) {
- return new StorageEvent.ptr(ev);
- } else if (_ref === $global.SVGEvent) {
- return new SVGEvent.ptr(ev);
- } else if (_ref === $global.SVGZoomEvent) {
- return new SVGZoomEvent.ptr(ev);
- } else if (_ref === $global.TimeEvent) {
- return new TimeEvent.ptr(ev);
- } else if (_ref === $global.TouchEvent) {
- return new TouchEvent.ptr(ev);
- } else if (_ref === $global.TrackEvent) {
- return new TrackEvent.ptr(ev);
- } else if (_ref === $global.TransitionEvent) {
- return new TransitionEvent.ptr(ev);
- } else if (_ref === $global.UIEvent) {
- return new UIEvent.ptr(ev);
- } else if (_ref === $global.UserProximityEvent) {
- return new UserProximityEvent.ptr(ev);
- } else if (_ref === $global.WheelEvent) {
- return new WheelEvent.ptr(ev, 0, 0, 0, 0);
- } else {
- return ev;
- }
- };
- BasicEvent.ptr.prototype.Bubbles = function() {
- var $ptr, ev;
- ev = this;
- return !!(ev.Object.bubbles);
- };
- BasicEvent.prototype.Bubbles = function() { return this.$val.Bubbles(); };
- BasicEvent.ptr.prototype.Cancelable = function() {
- var $ptr, ev;
- ev = this;
- return !!(ev.Object.cancelable);
- };
- BasicEvent.prototype.Cancelable = function() { return this.$val.Cancelable(); };
- BasicEvent.ptr.prototype.CurrentTarget = function() {
- var $ptr, ev;
- ev = this;
- return wrapElement(ev.Object.currentTarget);
- };
- BasicEvent.prototype.CurrentTarget = function() { return this.$val.CurrentTarget(); };
- BasicEvent.ptr.prototype.DefaultPrevented = function() {
- var $ptr, ev;
- ev = this;
- return !!(ev.Object.defaultPrevented);
- };
- BasicEvent.prototype.DefaultPrevented = function() { return this.$val.DefaultPrevented(); };
- BasicEvent.ptr.prototype.EventPhase = function() {
- var $ptr, ev;
- ev = this;
- return $parseInt(ev.Object.eventPhase) >> 0;
- };
- BasicEvent.prototype.EventPhase = function() { return this.$val.EventPhase(); };
- BasicEvent.ptr.prototype.Target = function() {
- var $ptr, ev;
- ev = this;
- return wrapElement(ev.Object.target);
- };
- BasicEvent.prototype.Target = function() { return this.$val.Target(); };
- BasicEvent.ptr.prototype.Timestamp = function() {
- var $ptr, _q, _r, ev, ms, ns, s;
- ev = this;
- ms = $parseInt(ev.Object.timeStamp) >> 0;
- s = (_q = ms / 1000, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"));
- ns = ((_r = ms % 1000, _r === _r ? _r : $throwRuntimeError("integer divide by zero")) * 1000000 >> 0);
- return time.Unix(new $Int64(0, s), new $Int64(0, ns));
- };
- BasicEvent.prototype.Timestamp = function() { return this.$val.Timestamp(); };
- BasicEvent.ptr.prototype.Type = function() {
- var $ptr, ev;
- ev = this;
- return $internalize(ev.Object.type, $String);
- };
- BasicEvent.prototype.Type = function() { return this.$val.Type(); };
- BasicEvent.ptr.prototype.PreventDefault = function() {
- var $ptr, ev;
- ev = this;
- ev.Object.preventDefault();
- };
- BasicEvent.prototype.PreventDefault = function() { return this.$val.PreventDefault(); };
- BasicEvent.ptr.prototype.StopImmediatePropagation = function() {
- var $ptr, ev;
- ev = this;
- ev.Object.stopImmediatePropagation();
- };
- BasicEvent.prototype.StopImmediatePropagation = function() { return this.$val.StopImmediatePropagation(); };
- BasicEvent.ptr.prototype.StopPropagation = function() {
- var $ptr, ev;
- ev = this;
- ev.Object.stopPropagation();
- };
- BasicEvent.prototype.StopPropagation = function() { return this.$val.StopPropagation(); };
- KeyboardEvent.ptr.prototype.ModifierState = function(mod) {
- var $ptr, ev, mod;
- ev = this;
- return !!(ev.BasicEvent.Object.getModifierState($externalize(mod, $String)));
- };
- KeyboardEvent.prototype.ModifierState = function(mod) { return this.$val.ModifierState(mod); };
- MouseEvent.ptr.prototype.RelatedTarget = function() {
- var $ptr, ev;
- ev = this;
- return wrapElement(ev.UIEvent.BasicEvent.Object.target);
- };
- MouseEvent.prototype.RelatedTarget = function() { return this.$val.RelatedTarget(); };
- MouseEvent.ptr.prototype.ModifierState = function(mod) {
- var $ptr, ev, mod;
- ev = this;
- return !!(ev.UIEvent.BasicEvent.Object.getModifierState($externalize(mod, $String)));
- };
- MouseEvent.prototype.ModifierState = function(mod) { return this.$val.ModifierState(mod); };
- ptrType$19.methods = [{prop: "Item", name: "Item", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "Contains", name: "Contains", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "Add", name: "Add", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Remove", name: "Remove", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Toggle", name: "Toggle", pkg: "", typ: $funcType([$String], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Slice", name: "Slice", pkg: "", typ: $funcType([], [sliceType$5], false)}, {prop: "SetString", name: "SetString", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([sliceType$5], [], false)}];
- document.methods = [{prop: "Async", name: "Async", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetAsync", name: "SetAsync", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "Doctype", name: "Doctype", pkg: "", typ: $funcType([], [DocumentType], false)}, {prop: "DocumentElement", name: "DocumentElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "DocumentURI", name: "DocumentURI", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Implementation", name: "Implementation", pkg: "", typ: $funcType([], [DOMImplementation], false)}, {prop: "LastStyleSheetSet", name: "LastStyleSheetSet", pkg: "", typ: $funcType([], [$String], false)}, {prop: "PreferredStyleSheetSet", name: "PreferredStyleSheetSet", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SelectedStyleSheetSet", name: "SelectedStyleSheetSet", pkg: "", typ: $funcType([], [$String], false)}, {prop: "StyleSheets", name: "StyleSheets", pkg: "", typ: $funcType([], [sliceType$10], false)}, {prop: "StyleSheetSets", name: "StyleSheetSets", pkg: "", typ: $funcType([], [sliceType$10], false)}, {prop: "AdoptNode", name: "AdoptNode", pkg: "", typ: $funcType([Node], [Node], false)}, {prop: "CreateElement", name: "CreateElement", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "CreateElementNS", name: "CreateElementNS", pkg: "", typ: $funcType([$String, $String], [Element], false)}, {prop: "CreateTextNode", name: "CreateTextNode", pkg: "", typ: $funcType([$String], [ptrType$9], false)}, {prop: "ElementFromPoint", name: "ElementFromPoint", pkg: "", typ: $funcType([$Int, $Int], [Element], false)}, {prop: "EnableStyleSheetsForSet", name: "EnableStyleSheetsForSet", pkg: "", typ: $funcType([$String], [], false)}, {prop: "GetElementsByClassName", name: "GetElementsByClassName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagName", name: "GetElementsByTagName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagNameNS", name: "GetElementsByTagNameNS", pkg: "", typ: $funcType([$String, $String], [sliceType$2], false)}, {prop: "GetElementByID", name: "GetElementByID", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "QuerySelector", name: "QuerySelector", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "QuerySelectorAll", name: "QuerySelectorAll", pkg: "", typ: $funcType([$String], [sliceType$2], false)}];
- ptrType$23.methods = [{prop: "ActiveElement", name: "ActiveElement", pkg: "", typ: $funcType([], [HTMLElement], false)}, {prop: "Body", name: "Body", pkg: "", typ: $funcType([], [HTMLElement], false)}, {prop: "Cookie", name: "Cookie", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetCookie", name: "SetCookie", pkg: "", typ: $funcType([$String], [], false)}, {prop: "DefaultView", name: "DefaultView", pkg: "", typ: $funcType([], [Window], false)}, {prop: "DesignMode", name: "DesignMode", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetDesignMode", name: "SetDesignMode", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "Domain", name: "Domain", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetDomain", name: "SetDomain", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Forms", name: "Forms", pkg: "", typ: $funcType([], [sliceType$6], false)}, {prop: "Head", name: "Head", pkg: "", typ: $funcType([], [ptrType$5], false)}, {prop: "Images", name: "Images", pkg: "", typ: $funcType([], [sliceType$7], false)}, {prop: "LastModified", name: "LastModified", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Links", name: "Links", pkg: "", typ: $funcType([], [sliceType$3], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$20], false)}, {prop: "Plugins", name: "Plugins", pkg: "", typ: $funcType([], [sliceType$8], false)}, {prop: "ReadyState", name: "ReadyState", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Referrer", name: "Referrer", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Scripts", name: "Scripts", pkg: "", typ: $funcType([], [sliceType$9], false)}, {prop: "Title", name: "Title", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetTitle", name: "SetTitle", pkg: "", typ: $funcType([$String], [], false)}, {prop: "URL", name: "URL", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$27.methods = [{prop: "Console", name: "Console", pkg: "", typ: $funcType([], [ptrType$25], false)}, {prop: "Document", name: "Document", pkg: "", typ: $funcType([], [Document], false)}, {prop: "FrameElement", name: "FrameElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$20], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetName", name: "SetName", pkg: "", typ: $funcType([$String], [], false)}, {prop: "InnerHeight", name: "InnerHeight", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "InnerWidth", name: "InnerWidth", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Opener", name: "Opener", pkg: "", typ: $funcType([], [Window], false)}, {prop: "OuterHeight", name: "OuterHeight", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "OuterWidth", name: "OuterWidth", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScrollX", name: "ScrollX", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScrollY", name: "ScrollY", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Parent", name: "Parent", pkg: "", typ: $funcType([], [Window], false)}, {prop: "ScreenX", name: "ScreenX", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScreenY", name: "ScreenY", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScrollMaxX", name: "ScrollMaxX", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScrollMaxY", name: "ScrollMaxY", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Top", name: "Top", pkg: "", typ: $funcType([], [Window], false)}, {prop: "History", name: "History", pkg: "", typ: $funcType([], [History], false)}, {prop: "Navigator", name: "Navigator", pkg: "", typ: $funcType([], [Navigator], false)}, {prop: "Screen", name: "Screen", pkg: "", typ: $funcType([], [ptrType$26], false)}, {prop: "Alert", name: "Alert", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Back", name: "Back", pkg: "", typ: $funcType([], [], false)}, {prop: "Blur", name: "Blur", pkg: "", typ: $funcType([], [], false)}, {prop: "ClearInterval", name: "ClearInterval", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "ClearTimeout", name: "ClearTimeout", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [], false)}, {prop: "Confirm", name: "Confirm", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "Focus", name: "Focus", pkg: "", typ: $funcType([], [], false)}, {prop: "Forward", name: "Forward", pkg: "", typ: $funcType([], [], false)}, {prop: "GetComputedStyle", name: "GetComputedStyle", pkg: "", typ: $funcType([Element, $String], [ptrType$24], false)}, {prop: "GetSelection", name: "GetSelection", pkg: "", typ: $funcType([], [Selection], false)}, {prop: "Home", name: "Home", pkg: "", typ: $funcType([], [], false)}, {prop: "MoveBy", name: "MoveBy", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "MoveTo", name: "MoveTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Open", name: "Open", pkg: "", typ: $funcType([$String, $String, $String], [Window], false)}, {prop: "OpenDialog", name: "OpenDialog", pkg: "", typ: $funcType([$String, $String, $String, sliceType], [Window], false)}, {prop: "PostMessage", name: "PostMessage", pkg: "", typ: $funcType([$String, $String, sliceType], [], false)}, {prop: "Print", name: "Print", pkg: "", typ: $funcType([], [], false)}, {prop: "Prompt", name: "Prompt", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "ResizeBy", name: "ResizeBy", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ResizeTo", name: "ResizeTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Scroll", name: "Scroll", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ScrollBy", name: "ScrollBy", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ScrollByLines", name: "ScrollByLines", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "ScrollTo", name: "ScrollTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "SetCursor", name: "SetCursor", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetInterval", name: "SetInterval", pkg: "", typ: $funcType([funcType, $Int], [$Int], false)}, {prop: "SetTimeout", name: "SetTimeout", pkg: "", typ: $funcType([funcType, $Int], [$Int], false)}, {prop: "Stop", name: "Stop", pkg: "", typ: $funcType([], [], false)}, {prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$2], [funcType$1], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$1], [], false)}];
- ptrType$28.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$21.methods = [{prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [ptrType$10], false)}, {prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$2], [funcType$1], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$1], [], false)}, {prop: "BaseURI", name: "BaseURI", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChildNodes", name: "ChildNodes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "FirstChild", name: "FirstChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "LastChild", name: "LastChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "NextSibling", name: "NextSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "NodeName", name: "NodeName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NodeType", name: "NodeType", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NodeValue", name: "NodeValue", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetNodeValue", name: "SetNodeValue", pkg: "", typ: $funcType([$String], [], false)}, {prop: "OwnerDocument", name: "OwnerDocument", pkg: "", typ: $funcType([], [Document], false)}, {prop: "ParentNode", name: "ParentNode", pkg: "", typ: $funcType([], [Node], false)}, {prop: "ParentElement", name: "ParentElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "PreviousSibling", name: "PreviousSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "TextContent", name: "TextContent", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetTextContent", name: "SetTextContent", pkg: "", typ: $funcType([$String], [], false)}, {prop: "AppendChild", name: "AppendChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "CloneNode", name: "CloneNode", pkg: "", typ: $funcType([$Bool], [Node], false)}, {prop: "CompareDocumentPosition", name: "CompareDocumentPosition", pkg: "", typ: $funcType([Node], [$Int], false)}, {prop: "Contains", name: "Contains", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "HasChildNodes", name: "HasChildNodes", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "InsertBefore", name: "InsertBefore", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "IsDefaultNamespace", name: "IsDefaultNamespace", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "IsEqualNode", name: "IsEqualNode", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "LookupPrefix", name: "LookupPrefix", pkg: "", typ: $funcType([], [$String], false)}, {prop: "LookupNamespaceURI", name: "LookupNamespaceURI", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [], false)}, {prop: "RemoveChild", name: "RemoveChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "ReplaceChild", name: "ReplaceChild", pkg: "", typ: $funcType([Node, Node], [], false)}];
- ptrType.methods = [{prop: "AccessKey", name: "AccessKey", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetAccessKey", name: "SetAccessKey", pkg: "", typ: $funcType([$String], [], false)}, {prop: "AccessKeyLabel", name: "AccessKeyLabel", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetAccessKeyLabel", name: "SetAccessKeyLabel", pkg: "", typ: $funcType([$String], [], false)}, {prop: "ContentEditable", name: "ContentEditable", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetContentEditable", name: "SetContentEditable", pkg: "", typ: $funcType([$String], [], false)}, {prop: "IsContentEditable", name: "IsContentEditable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Dataset", name: "Dataset", pkg: "", typ: $funcType([], [], false)}, {prop: "Dir", name: "Dir", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetDir", name: "SetDir", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Draggable", name: "Draggable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetDraggable", name: "SetDraggable", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "Lang", name: "Lang", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetLang", name: "SetLang", pkg: "", typ: $funcType([$String], [], false)}, {prop: "OffsetHeight", name: "OffsetHeight", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "OffsetLeft", name: "OffsetLeft", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "OffsetParent", name: "OffsetParent", pkg: "", typ: $funcType([], [HTMLElement], false)}, {prop: "OffsetTop", name: "OffsetTop", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "OffsetWidth", name: "OffsetWidth", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "Style", name: "Style", pkg: "", typ: $funcType([], [ptrType$24], false)}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SetTabIndex", name: "SetTabIndex", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Title", name: "Title", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetTitle", name: "SetTitle", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Blur", name: "Blur", pkg: "", typ: $funcType([], [], false)}, {prop: "Click", name: "Click", pkg: "", typ: $funcType([], [], false)}, {prop: "Focus", name: "Focus", pkg: "", typ: $funcType([], [], false)}];
- ptrType$30.methods = [{prop: "GetBoundingClientRect", name: "GetBoundingClientRect", pkg: "", typ: $funcType([], [ClientRect], false)}, {prop: "PreviousElementSibling", name: "PreviousElementSibling", pkg: "", typ: $funcType([], [Element], false)}, {prop: "NextElementSibling", name: "NextElementSibling", pkg: "", typ: $funcType([], [Element], false)}, {prop: "Class", name: "Class", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "SetClass", name: "SetClass", pkg: "", typ: $funcType([$String], [], false)}, {prop: "ID", name: "ID", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetID", name: "SetID", pkg: "", typ: $funcType([$String], [], false)}, {prop: "TagName", name: "TagName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "GetAttribute", name: "GetAttribute", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "GetAttributeNS", name: "GetAttributeNS", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "GetElementsByClassName", name: "GetElementsByClassName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagName", name: "GetElementsByTagName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagNameNS", name: "GetElementsByTagNameNS", pkg: "", typ: $funcType([$String, $String], [sliceType$2], false)}, {prop: "HasAttribute", name: "HasAttribute", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "HasAttributeNS", name: "HasAttributeNS", pkg: "", typ: $funcType([$String, $String], [$Bool], false)}, {prop: "QuerySelector", name: "QuerySelector", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "QuerySelectorAll", name: "QuerySelectorAll", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "RemoveAttribute", name: "RemoveAttribute", pkg: "", typ: $funcType([$String], [], false)}, {prop: "RemoveAttributeNS", name: "RemoveAttributeNS", pkg: "", typ: $funcType([$String, $String], [], false)}, {prop: "SetAttribute", name: "SetAttribute", pkg: "", typ: $funcType([$String, $String], [], false)}, {prop: "SetAttributeNS", name: "SetAttributeNS", pkg: "", typ: $funcType([$String, $String, $String], [], false)}, {prop: "InnerHTML", name: "InnerHTML", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetInnerHTML", name: "SetInnerHTML", pkg: "", typ: $funcType([$String], [], false)}];
- ptrType$31.methods = [{prop: "Rel", name: "Rel", pkg: "", typ: $funcType([], [ptrType$19], false)}];
- ptrType$32.methods = [{prop: "Rel", name: "Rel", pkg: "", typ: $funcType([], [ptrType$19], false)}];
- ptrType$14.methods = [{prop: "Rel", name: "Rel", pkg: "", typ: $funcType([], [ptrType$19], false)}];
- ptrType$33.methods = [{prop: "Href", name: "Href", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Target", name: "Target", pkg: "", typ: $funcType([], [$String], false)}];
- ptrType$35.methods = [{prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}, {prop: "Labels", name: "Labels", pkg: "", typ: $funcType([], [sliceType$4], false)}, {prop: "Validity", name: "Validity", pkg: "", typ: $funcType([], [ptrType$34], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetCustomValidity", name: "SetCustomValidity", pkg: "", typ: $funcType([$String], [], false)}];
- ptrType$37.methods = [{prop: "GetContext2d", name: "GetContext2d", pkg: "", typ: $funcType([], [ptrType$36], false)}, {prop: "GetContext", name: "GetContext", pkg: "", typ: $funcType([$String], [ptrType$10], false)}];
- ptrType$36.methods = [{prop: "CreateLinearGradient", name: "CreateLinearGradient", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int], [], false)}, {prop: "Rect", name: "Rect", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int], [], false)}, {prop: "FillRect", name: "FillRect", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int], [], false)}, {prop: "StrokeRect", name: "StrokeRect", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int], [], false)}, {prop: "ClearRect", name: "ClearRect", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int], [], false)}, {prop: "Fill", name: "Fill", pkg: "", typ: $funcType([], [], false)}, {prop: "Stroke", name: "Stroke", pkg: "", typ: $funcType([], [], false)}, {prop: "BeginPath", name: "BeginPath", pkg: "", typ: $funcType([], [], false)}, {prop: "MoveTo", name: "MoveTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ClosePath", name: "ClosePath", pkg: "", typ: $funcType([], [], false)}, {prop: "LineTo", name: "LineTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Clip", name: "Clip", pkg: "", typ: $funcType([], [], false)}, {prop: "QuadraticCurveTo", name: "QuadraticCurveTo", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int], [], false)}, {prop: "BezierCurveTo", name: "BezierCurveTo", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int, $Int, $Int], [], false)}, {prop: "Arc", name: "Arc", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int, $Int, $Bool], [], false)}, {prop: "ArcTo", name: "ArcTo", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int, $Int], [], false)}, {prop: "IsPointInPath", name: "IsPointInPath", pkg: "", typ: $funcType([$Int, $Int], [$Bool], false)}, {prop: "Scale", name: "Scale", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Rotate", name: "Rotate", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Translate", name: "Translate", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Transform", name: "Transform", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int, $Int, $Int], [], false)}, {prop: "SetTransform", name: "SetTransform", pkg: "", typ: $funcType([$Int, $Int, $Int, $Int, $Int, $Int], [], false)}, {prop: "FillText", name: "FillText", pkg: "", typ: $funcType([$String, $Int, $Int, $Int], [], false)}, {prop: "StrokeText", name: "StrokeText", pkg: "", typ: $funcType([$String, $Int, $Int, $Int], [], false)}];
- ptrType$13.methods = [{prop: "Options", name: "Options", pkg: "", typ: $funcType([], [sliceType$11], false)}];
- ptrType$38.methods = [{prop: "Elements", name: "Elements", pkg: "", typ: $funcType([], [sliceType$3], false)}, {prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}, {prop: "Validity", name: "Validity", pkg: "", typ: $funcType([], [ptrType$34], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetCustomValidity", name: "SetCustomValidity", pkg: "", typ: $funcType([$String], [], false)}];
- ptrType$3.methods = [{prop: "Elements", name: "Elements", pkg: "", typ: $funcType([], [sliceType$3], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Submit", name: "Submit", pkg: "", typ: $funcType([], [], false)}, {prop: "Reset", name: "Reset", pkg: "", typ: $funcType([], [], false)}, {prop: "Item", name: "Item", pkg: "", typ: $funcType([$Int], [HTMLElement], false)}, {prop: "NamedItem", name: "NamedItem", pkg: "", typ: $funcType([$String], [HTMLElement], false)}];
- ptrType$39.methods = [{prop: "ContentDocument", name: "ContentDocument", pkg: "", typ: $funcType([], [Document], false)}, {prop: "ContentWindow", name: "ContentWindow", pkg: "", typ: $funcType([], [Window], false)}];
- ptrType$40.methods = [{prop: "Files", name: "Files", pkg: "", typ: $funcType([], [sliceType$12], false)}, {prop: "List", name: "List", pkg: "", typ: $funcType([], [ptrType$13], false)}, {prop: "Labels", name: "Labels", pkg: "", typ: $funcType([], [sliceType$4], false)}, {prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}, {prop: "Validity", name: "Validity", pkg: "", typ: $funcType([], [ptrType$34], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetCustomValidity", name: "SetCustomValidity", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Select", name: "Select", pkg: "", typ: $funcType([], [], false)}, {prop: "SetSelectionRange", name: "SetSelectionRange", pkg: "", typ: $funcType([$Int, $Int, $String], [], false)}, {prop: "StepDown", name: "StepDown", pkg: "", typ: $funcType([$Int], [$error], false)}, {prop: "StepUp", name: "StepUp", pkg: "", typ: $funcType([$Int], [$error], false)}];
- ptrType$41.methods = [{prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}, {prop: "Labels", name: "Labels", pkg: "", typ: $funcType([], [sliceType$4], false)}, {prop: "Validity", name: "Validity", pkg: "", typ: $funcType([], [ptrType$34], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetCustomValidity", name: "SetCustomValidity", pkg: "", typ: $funcType([$String], [], false)}];
- ptrType$4.methods = [{prop: "Control", name: "Control", pkg: "", typ: $funcType([], [HTMLElement], false)}, {prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}];
- ptrType$42.methods = [{prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}];
- ptrType$43.methods = [{prop: "Rel", name: "Rel", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "Sizes", name: "Sizes", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "Sheet", name: "Sheet", pkg: "", typ: $funcType([], [StyleSheet], false)}];
- ptrType$44.methods = [{prop: "Areas", name: "Areas", pkg: "", typ: $funcType([], [sliceType$13], false)}, {prop: "Images", name: "Images", pkg: "", typ: $funcType([], [sliceType$3], false)}];
- HTMLMeterElement.methods = [{prop: "Labels", name: "Labels", pkg: "", typ: $funcType([], [sliceType$4], false)}];
- ptrType$45.methods = [{prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}, {prop: "ContentDocument", name: "ContentDocument", pkg: "", typ: $funcType([], [Document], false)}, {prop: "ContentWindow", name: "ContentWindow", pkg: "", typ: $funcType([], [Window], false)}, {prop: "Validity", name: "Validity", pkg: "", typ: $funcType([], [ptrType$34], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetCustomValidity", name: "SetCustomValidity", pkg: "", typ: $funcType([$String], [], false)}];
- ptrType$11.methods = [{prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}];
- ptrType$46.methods = [{prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}, {prop: "Labels", name: "Labels", pkg: "", typ: $funcType([], [sliceType$4], false)}, {prop: "Validity", name: "Validity", pkg: "", typ: $funcType([], [ptrType$34], false)}, {prop: "For", name: "For", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetCustomValidity", name: "SetCustomValidity", pkg: "", typ: $funcType([$String], [], false)}];
- HTMLProgressElement.methods = [{prop: "Labels", name: "Labels", pkg: "", typ: $funcType([], [sliceType$4], false)}];
- ptrType$16.methods = [{prop: "Cells", name: "Cells", pkg: "", typ: $funcType([], [sliceType$14], false)}, {prop: "InsertCell", name: "InsertCell", pkg: "", typ: $funcType([$Int], [ptrType$15], false)}, {prop: "DeleteCell", name: "DeleteCell", pkg: "", typ: $funcType([$Int], [], false)}];
- ptrType$47.methods = [{prop: "Rows", name: "Rows", pkg: "", typ: $funcType([], [sliceType$15], false)}, {prop: "DeleteRow", name: "DeleteRow", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "InsertRow", name: "InsertRow", pkg: "", typ: $funcType([$Int], [ptrType$16], false)}];
- ptrType$48.methods = [{prop: "Form", name: "Form", pkg: "", typ: $funcType([], [ptrType$3], false)}, {prop: "Labels", name: "Labels", pkg: "", typ: $funcType([], [sliceType$4], false)}, {prop: "Validity", name: "Validity", pkg: "", typ: $funcType([], [ptrType$34], false)}, {prop: "CheckValidity", name: "CheckValidity", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "SetCustomValidity", name: "SetCustomValidity", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Select", name: "Select", pkg: "", typ: $funcType([], [], false)}, {prop: "SetSelectionRange", name: "SetSelectionRange", pkg: "", typ: $funcType([$Int, $Int, $String], [], false)}];
- ptrType$50.methods = [{prop: "Track", name: "Track", pkg: "", typ: $funcType([], [ptrType$49], false)}];
- ptrType$24.methods = [{prop: "ToMap", name: "ToMap", pkg: "", typ: $funcType([], [mapType], false)}, {prop: "RemoveProperty", name: "RemoveProperty", pkg: "", typ: $funcType([$String], [], false)}, {prop: "GetPropertyValue", name: "GetPropertyValue", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "GetPropertyPriority", name: "GetPropertyPriority", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "SetProperty", name: "SetProperty", pkg: "", typ: $funcType([$String, $String, $String], [], false)}, {prop: "Index", name: "Index", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}];
- ptrType$17.methods = [{prop: "Bubbles", name: "Bubbles", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Cancelable", name: "Cancelable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "CurrentTarget", name: "CurrentTarget", pkg: "", typ: $funcType([], [Element], false)}, {prop: "DefaultPrevented", name: "DefaultPrevented", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "EventPhase", name: "EventPhase", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Target", name: "Target", pkg: "", typ: $funcType([], [Element], false)}, {prop: "Timestamp", name: "Timestamp", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [$String], false)}, {prop: "PreventDefault", name: "PreventDefault", pkg: "", typ: $funcType([], [], false)}, {prop: "StopImmediatePropagation", name: "StopImmediatePropagation", pkg: "", typ: $funcType([], [], false)}, {prop: "StopPropagation", name: "StopPropagation", pkg: "", typ: $funcType([], [], false)}];
- ptrType$51.methods = [{prop: "ModifierState", name: "ModifierState", pkg: "", typ: $funcType([$String], [$Bool], false)}];
- ptrType$52.methods = [{prop: "RelatedTarget", name: "RelatedTarget", pkg: "", typ: $funcType([], [Element], false)}, {prop: "ModifierState", name: "ModifierState", pkg: "", typ: $funcType([$String], [$Bool], false)}];
- TokenList.init([{prop: "dtl", name: "dtl", pkg: "honnef.co/go/js/dom", typ: ptrType$10, tag: ""}, {prop: "o", name: "o", pkg: "honnef.co/go/js/dom", typ: ptrType$10, tag: ""}, {prop: "sa", name: "sa", pkg: "honnef.co/go/js/dom", typ: $String, tag: ""}, {prop: "Length", name: "Length", pkg: "", typ: $Int, tag: "js:\"length\""}]);
- Document.init([{prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$2], [funcType$1], false)}, {prop: "AdoptNode", name: "AdoptNode", pkg: "", typ: $funcType([Node], [Node], false)}, {prop: "AppendChild", name: "AppendChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "Async", name: "Async", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "BaseURI", name: "BaseURI", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChildNodes", name: "ChildNodes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "CloneNode", name: "CloneNode", pkg: "", typ: $funcType([$Bool], [Node], false)}, {prop: "CompareDocumentPosition", name: "CompareDocumentPosition", pkg: "", typ: $funcType([Node], [$Int], false)}, {prop: "Contains", name: "Contains", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "CreateElement", name: "CreateElement", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "CreateElementNS", name: "CreateElementNS", pkg: "", typ: $funcType([$String, $String], [Element], false)}, {prop: "CreateTextNode", name: "CreateTextNode", pkg: "", typ: $funcType([$String], [ptrType$9], false)}, {prop: "Doctype", name: "Doctype", pkg: "", typ: $funcType([], [DocumentType], false)}, {prop: "DocumentElement", name: "DocumentElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "DocumentURI", name: "DocumentURI", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ElementFromPoint", name: "ElementFromPoint", pkg: "", typ: $funcType([$Int, $Int], [Element], false)}, {prop: "EnableStyleSheetsForSet", name: "EnableStyleSheetsForSet", pkg: "", typ: $funcType([$String], [], false)}, {prop: "FirstChild", name: "FirstChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "GetElementByID", name: "GetElementByID", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "GetElementsByClassName", name: "GetElementsByClassName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagName", name: "GetElementsByTagName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagNameNS", name: "GetElementsByTagNameNS", pkg: "", typ: $funcType([$String, $String], [sliceType$2], false)}, {prop: "HasChildNodes", name: "HasChildNodes", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Implementation", name: "Implementation", pkg: "", typ: $funcType([], [DOMImplementation], false)}, {prop: "InsertBefore", name: "InsertBefore", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "IsDefaultNamespace", name: "IsDefaultNamespace", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "IsEqualNode", name: "IsEqualNode", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "LastChild", name: "LastChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "LastStyleSheetSet", name: "LastStyleSheetSet", pkg: "", typ: $funcType([], [$String], false)}, {prop: "LookupNamespaceURI", name: "LookupNamespaceURI", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "LookupPrefix", name: "LookupPrefix", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NextSibling", name: "NextSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "NodeName", name: "NodeName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NodeType", name: "NodeType", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NodeValue", name: "NodeValue", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [], false)}, {prop: "OwnerDocument", name: "OwnerDocument", pkg: "", typ: $funcType([], [Document], false)}, {prop: "ParentElement", name: "ParentElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "ParentNode", name: "ParentNode", pkg: "", typ: $funcType([], [Node], false)}, {prop: "PreferredStyleSheetSet", name: "PreferredStyleSheetSet", pkg: "", typ: $funcType([], [$String], false)}, {prop: "PreviousSibling", name: "PreviousSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "QuerySelector", name: "QuerySelector", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "QuerySelectorAll", name: "QuerySelectorAll", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "RemoveChild", name: "RemoveChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$1], [], false)}, {prop: "ReplaceChild", name: "ReplaceChild", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "SelectedStyleSheetSet", name: "SelectedStyleSheetSet", pkg: "", typ: $funcType([], [$String], false)}, {prop: "SetAsync", name: "SetAsync", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "SetNodeValue", name: "SetNodeValue", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetTextContent", name: "SetTextContent", pkg: "", typ: $funcType([$String], [], false)}, {prop: "StyleSheetSets", name: "StyleSheetSets", pkg: "", typ: $funcType([], [sliceType$10], false)}, {prop: "StyleSheets", name: "StyleSheets", pkg: "", typ: $funcType([], [sliceType$10], false)}, {prop: "TextContent", name: "TextContent", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [ptrType$10], false)}]);
- document.init([{prop: "BasicNode", name: "", pkg: "", typ: ptrType$21, tag: ""}]);
- htmlDocument.init([{prop: "document", name: "", pkg: "honnef.co/go/js/dom", typ: ptrType$22, tag: ""}]);
- URLUtils.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "Href", name: "Href", pkg: "", typ: $String, tag: "js:\"href\""}, {prop: "Protocol", name: "Protocol", pkg: "", typ: $String, tag: "js:\"protocol\""}, {prop: "Host", name: "Host", pkg: "", typ: $String, tag: "js:\"host\""}, {prop: "Hostname", name: "Hostname", pkg: "", typ: $String, tag: "js:\"hostname\""}, {prop: "Port", name: "Port", pkg: "", typ: $String, tag: "js:\"port\""}, {prop: "Pathname", name: "Pathname", pkg: "", typ: $String, tag: "js:\"pathname\""}, {prop: "Search", name: "Search", pkg: "", typ: $String, tag: "js:\"search\""}, {prop: "Hash", name: "Hash", pkg: "", typ: $String, tag: "js:\"hash\""}, {prop: "Username", name: "Username", pkg: "", typ: $String, tag: "js:\"username\""}, {prop: "Password", name: "Password", pkg: "", typ: $String, tag: "js:\"password\""}, {prop: "Origin", name: "Origin", pkg: "", typ: $String, tag: "js:\"origin\""}]);
- Location.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "URLUtils", name: "", pkg: "", typ: ptrType$1, tag: ""}]);
- HTMLElement.init([{prop: "AccessKey", name: "AccessKey", pkg: "", typ: $funcType([], [$String], false)}, {prop: "AccessKeyLabel", name: "AccessKeyLabel", pkg: "", typ: $funcType([], [$String], false)}, {prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$2], [funcType$1], false)}, {prop: "AppendChild", name: "AppendChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "BaseURI", name: "BaseURI", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Blur", name: "Blur", pkg: "", typ: $funcType([], [], false)}, {prop: "ChildNodes", name: "ChildNodes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "Class", name: "Class", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "Click", name: "Click", pkg: "", typ: $funcType([], [], false)}, {prop: "CloneNode", name: "CloneNode", pkg: "", typ: $funcType([$Bool], [Node], false)}, {prop: "CompareDocumentPosition", name: "CompareDocumentPosition", pkg: "", typ: $funcType([Node], [$Int], false)}, {prop: "Contains", name: "Contains", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "ContentEditable", name: "ContentEditable", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Dataset", name: "Dataset", pkg: "", typ: $funcType([], [], false)}, {prop: "Dir", name: "Dir", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Draggable", name: "Draggable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "FirstChild", name: "FirstChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "Focus", name: "Focus", pkg: "", typ: $funcType([], [], false)}, {prop: "GetAttribute", name: "GetAttribute", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "GetAttributeNS", name: "GetAttributeNS", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "GetBoundingClientRect", name: "GetBoundingClientRect", pkg: "", typ: $funcType([], [ClientRect], false)}, {prop: "GetElementsByClassName", name: "GetElementsByClassName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagName", name: "GetElementsByTagName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagNameNS", name: "GetElementsByTagNameNS", pkg: "", typ: $funcType([$String, $String], [sliceType$2], false)}, {prop: "HasAttribute", name: "HasAttribute", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "HasAttributeNS", name: "HasAttributeNS", pkg: "", typ: $funcType([$String, $String], [$Bool], false)}, {prop: "HasChildNodes", name: "HasChildNodes", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ID", name: "ID", pkg: "", typ: $funcType([], [$String], false)}, {prop: "InnerHTML", name: "InnerHTML", pkg: "", typ: $funcType([], [$String], false)}, {prop: "InsertBefore", name: "InsertBefore", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "IsContentEditable", name: "IsContentEditable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "IsDefaultNamespace", name: "IsDefaultNamespace", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "IsEqualNode", name: "IsEqualNode", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "Lang", name: "Lang", pkg: "", typ: $funcType([], [$String], false)}, {prop: "LastChild", name: "LastChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "LookupNamespaceURI", name: "LookupNamespaceURI", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "LookupPrefix", name: "LookupPrefix", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NextElementSibling", name: "NextElementSibling", pkg: "", typ: $funcType([], [Element], false)}, {prop: "NextSibling", name: "NextSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "NodeName", name: "NodeName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NodeType", name: "NodeType", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NodeValue", name: "NodeValue", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [], false)}, {prop: "OffsetHeight", name: "OffsetHeight", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "OffsetLeft", name: "OffsetLeft", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "OffsetParent", name: "OffsetParent", pkg: "", typ: $funcType([], [HTMLElement], false)}, {prop: "OffsetTop", name: "OffsetTop", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "OffsetWidth", name: "OffsetWidth", pkg: "", typ: $funcType([], [$Float64], false)}, {prop: "OwnerDocument", name: "OwnerDocument", pkg: "", typ: $funcType([], [Document], false)}, {prop: "ParentElement", name: "ParentElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "ParentNode", name: "ParentNode", pkg: "", typ: $funcType([], [Node], false)}, {prop: "PreviousElementSibling", name: "PreviousElementSibling", pkg: "", typ: $funcType([], [Element], false)}, {prop: "PreviousSibling", name: "PreviousSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "QuerySelector", name: "QuerySelector", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "QuerySelectorAll", name: "QuerySelectorAll", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "RemoveAttribute", name: "RemoveAttribute", pkg: "", typ: $funcType([$String], [], false)}, {prop: "RemoveAttributeNS", name: "RemoveAttributeNS", pkg: "", typ: $funcType([$String, $String], [], false)}, {prop: "RemoveChild", name: "RemoveChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$1], [], false)}, {prop: "ReplaceChild", name: "ReplaceChild", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "SetAccessKey", name: "SetAccessKey", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetAccessKeyLabel", name: "SetAccessKeyLabel", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetAttribute", name: "SetAttribute", pkg: "", typ: $funcType([$String, $String], [], false)}, {prop: "SetAttributeNS", name: "SetAttributeNS", pkg: "", typ: $funcType([$String, $String, $String], [], false)}, {prop: "SetContentEditable", name: "SetContentEditable", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetDir", name: "SetDir", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetDraggable", name: "SetDraggable", pkg: "", typ: $funcType([$Bool], [], false)}, {prop: "SetID", name: "SetID", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetInnerHTML", name: "SetInnerHTML", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetLang", name: "SetLang", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetNodeValue", name: "SetNodeValue", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetTextContent", name: "SetTextContent", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetTitle", name: "SetTitle", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Style", name: "Style", pkg: "", typ: $funcType([], [ptrType$24], false)}, {prop: "TagName", name: "TagName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "TextContent", name: "TextContent", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Title", name: "Title", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [ptrType$10], false)}]);
- Window.init([{prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$2], [funcType$1], false)}, {prop: "Alert", name: "Alert", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Back", name: "Back", pkg: "", typ: $funcType([], [], false)}, {prop: "Blur", name: "Blur", pkg: "", typ: $funcType([], [], false)}, {prop: "ClearInterval", name: "ClearInterval", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "ClearTimeout", name: "ClearTimeout", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [], false)}, {prop: "Confirm", name: "Confirm", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "Console", name: "Console", pkg: "", typ: $funcType([], [ptrType$25], false)}, {prop: "Document", name: "Document", pkg: "", typ: $funcType([], [Document], false)}, {prop: "Focus", name: "Focus", pkg: "", typ: $funcType([], [], false)}, {prop: "Forward", name: "Forward", pkg: "", typ: $funcType([], [], false)}, {prop: "FrameElement", name: "FrameElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "GetComputedStyle", name: "GetComputedStyle", pkg: "", typ: $funcType([Element, $String], [ptrType$24], false)}, {prop: "GetSelection", name: "GetSelection", pkg: "", typ: $funcType([], [Selection], false)}, {prop: "History", name: "History", pkg: "", typ: $funcType([], [History], false)}, {prop: "Home", name: "Home", pkg: "", typ: $funcType([], [], false)}, {prop: "InnerHeight", name: "InnerHeight", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "InnerWidth", name: "InnerWidth", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$20], false)}, {prop: "MoveBy", name: "MoveBy", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "MoveTo", name: "MoveTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Navigator", name: "Navigator", pkg: "", typ: $funcType([], [Navigator], false)}, {prop: "Open", name: "Open", pkg: "", typ: $funcType([$String, $String, $String], [Window], false)}, {prop: "OpenDialog", name: "OpenDialog", pkg: "", typ: $funcType([$String, $String, $String, sliceType], [Window], false)}, {prop: "Opener", name: "Opener", pkg: "", typ: $funcType([], [Window], false)}, {prop: "OuterHeight", name: "OuterHeight", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "OuterWidth", name: "OuterWidth", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Parent", name: "Parent", pkg: "", typ: $funcType([], [Window], false)}, {prop: "PostMessage", name: "PostMessage", pkg: "", typ: $funcType([$String, $String, sliceType], [], false)}, {prop: "Print", name: "Print", pkg: "", typ: $funcType([], [], false)}, {prop: "Prompt", name: "Prompt", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$1], [], false)}, {prop: "ResizeBy", name: "ResizeBy", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ResizeTo", name: "ResizeTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "Screen", name: "Screen", pkg: "", typ: $funcType([], [ptrType$26], false)}, {prop: "ScreenX", name: "ScreenX", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScreenY", name: "ScreenY", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Scroll", name: "Scroll", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ScrollBy", name: "ScrollBy", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ScrollByLines", name: "ScrollByLines", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "ScrollMaxX", name: "ScrollMaxX", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScrollMaxY", name: "ScrollMaxY", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScrollTo", name: "ScrollTo", pkg: "", typ: $funcType([$Int, $Int], [], false)}, {prop: "ScrollX", name: "ScrollX", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "ScrollY", name: "ScrollY", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "SetCursor", name: "SetCursor", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetInterval", name: "SetInterval", pkg: "", typ: $funcType([funcType, $Int], [$Int], false)}, {prop: "SetName", name: "SetName", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetTimeout", name: "SetTimeout", pkg: "", typ: $funcType([funcType, $Int], [$Int], false)}, {prop: "Stop", name: "Stop", pkg: "", typ: $funcType([], [], false)}, {prop: "Top", name: "Top", pkg: "", typ: $funcType([], [Window], false)}]);
- window.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}]);
- Selection.init([]);
- Screen.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "AvailTop", name: "AvailTop", pkg: "", typ: $Int, tag: "js:\"availTop\""}, {prop: "AvailLeft", name: "AvailLeft", pkg: "", typ: $Int, tag: "js:\"availLeft\""}, {prop: "AvailHeight", name: "AvailHeight", pkg: "", typ: $Int, tag: "js:\"availHeight\""}, {prop: "AvailWidth", name: "AvailWidth", pkg: "", typ: $Int, tag: "js:\"availWidth\""}, {prop: "ColorDepth", name: "ColorDepth", pkg: "", typ: $Int, tag: "js:\"colorDepth\""}, {prop: "Height", name: "Height", pkg: "", typ: $Int, tag: "js:\"height\""}, {prop: "Left", name: "Left", pkg: "", typ: $Int, tag: "js:\"left\""}, {prop: "PixelDepth", name: "PixelDepth", pkg: "", typ: $Int, tag: "js:\"pixelDepth\""}, {prop: "Top", name: "Top", pkg: "", typ: $Int, tag: "js:\"top\""}, {prop: "Width", name: "Width", pkg: "", typ: $Int, tag: "js:\"width\""}]);
- Navigator.init([{prop: "AppName", name: "AppName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "AppVersion", name: "AppVersion", pkg: "", typ: $funcType([], [$String], false)}, {prop: "CookieEnabled", name: "CookieEnabled", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "DoNotTrack", name: "DoNotTrack", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Geolocation", name: "Geolocation", pkg: "", typ: $funcType([], [Geolocation], false)}, {prop: "Language", name: "Language", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Online", name: "Online", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Platform", name: "Platform", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Product", name: "Product", pkg: "", typ: $funcType([], [$String], false)}, {prop: "RegisterProtocolHandler", name: "RegisterProtocolHandler", pkg: "", typ: $funcType([$String, $String, $String], [], false)}, {prop: "UserAgent", name: "UserAgent", pkg: "", typ: $funcType([], [$String], false)}]);
- Geolocation.init([{prop: "ClearWatch", name: "ClearWatch", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "CurrentPosition", name: "CurrentPosition", pkg: "", typ: $funcType([funcType$3, funcType$4, PositionOptions], [Position], false)}, {prop: "WatchPosition", name: "WatchPosition", pkg: "", typ: $funcType([funcType$3, funcType$4, PositionOptions], [$Int], false)}]);
- PositionError.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "Code", name: "Code", pkg: "", typ: $Int, tag: "js:\"code\""}]);
- PositionOptions.init([{prop: "EnableHighAccuracy", name: "EnableHighAccuracy", pkg: "", typ: $Bool, tag: ""}, {prop: "Timeout", name: "Timeout", pkg: "", typ: time.Duration, tag: ""}, {prop: "MaximumAge", name: "MaximumAge", pkg: "", typ: time.Duration, tag: ""}]);
- Position.init([{prop: "Coords", name: "Coords", pkg: "", typ: ptrType$29, tag: ""}, {prop: "Timestamp", name: "Timestamp", pkg: "", typ: time.Time, tag: ""}]);
- Coordinates.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "Latitude", name: "Latitude", pkg: "", typ: $Float64, tag: "js:\"latitude\""}, {prop: "Longitude", name: "Longitude", pkg: "", typ: $Float64, tag: "js:\"longitude\""}, {prop: "Altitude", name: "Altitude", pkg: "", typ: $Float64, tag: "js:\"altitude\""}, {prop: "Accuracy", name: "Accuracy", pkg: "", typ: $Float64, tag: "js:\"accuracy\""}, {prop: "AltitudeAccuracy", name: "AltitudeAccuracy", pkg: "", typ: $Float64, tag: "js:\"altitudeAccuracy\""}, {prop: "Heading", name: "Heading", pkg: "", typ: $Float64, tag: "js:\"heading\""}, {prop: "Speed", name: "Speed", pkg: "", typ: $Float64, tag: "js:\"speed\""}]);
- History.init([{prop: "Back", name: "Back", pkg: "", typ: $funcType([], [], false)}, {prop: "Forward", name: "Forward", pkg: "", typ: $funcType([], [], false)}, {prop: "Go", name: "Go", pkg: "", typ: $funcType([$Int], [], false)}, {prop: "Length", name: "Length", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "PushState", name: "PushState", pkg: "", typ: $funcType([$emptyInterface, $String, $String], [], false)}, {prop: "ReplaceState", name: "ReplaceState", pkg: "", typ: $funcType([$emptyInterface, $String, $String], [], false)}, {prop: "State", name: "State", pkg: "", typ: $funcType([], [$emptyInterface], false)}]);
- Console.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}]);
- DocumentType.init([]);
- DOMImplementation.init([]);
- StyleSheet.init([]);
- Node.init([{prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$2], [funcType$1], false)}, {prop: "AppendChild", name: "AppendChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "BaseURI", name: "BaseURI", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChildNodes", name: "ChildNodes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "CloneNode", name: "CloneNode", pkg: "", typ: $funcType([$Bool], [Node], false)}, {prop: "CompareDocumentPosition", name: "CompareDocumentPosition", pkg: "", typ: $funcType([Node], [$Int], false)}, {prop: "Contains", name: "Contains", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "FirstChild", name: "FirstChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "HasChildNodes", name: "HasChildNodes", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "InsertBefore", name: "InsertBefore", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "IsDefaultNamespace", name: "IsDefaultNamespace", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "IsEqualNode", name: "IsEqualNode", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "LastChild", name: "LastChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "LookupNamespaceURI", name: "LookupNamespaceURI", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "LookupPrefix", name: "LookupPrefix", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NextSibling", name: "NextSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "NodeName", name: "NodeName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NodeType", name: "NodeType", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NodeValue", name: "NodeValue", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [], false)}, {prop: "OwnerDocument", name: "OwnerDocument", pkg: "", typ: $funcType([], [Document], false)}, {prop: "ParentElement", name: "ParentElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "ParentNode", name: "ParentNode", pkg: "", typ: $funcType([], [Node], false)}, {prop: "PreviousSibling", name: "PreviousSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "RemoveChild", name: "RemoveChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$1], [], false)}, {prop: "ReplaceChild", name: "ReplaceChild", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "SetNodeValue", name: "SetNodeValue", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetTextContent", name: "SetTextContent", pkg: "", typ: $funcType([$String], [], false)}, {prop: "TextContent", name: "TextContent", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [ptrType$10], false)}]);
- BasicNode.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}]);
- Element.init([{prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$2], [funcType$1], false)}, {prop: "AppendChild", name: "AppendChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "BaseURI", name: "BaseURI", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ChildNodes", name: "ChildNodes", pkg: "", typ: $funcType([], [sliceType$1], false)}, {prop: "Class", name: "Class", pkg: "", typ: $funcType([], [ptrType$19], false)}, {prop: "CloneNode", name: "CloneNode", pkg: "", typ: $funcType([$Bool], [Node], false)}, {prop: "CompareDocumentPosition", name: "CompareDocumentPosition", pkg: "", typ: $funcType([Node], [$Int], false)}, {prop: "Contains", name: "Contains", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "FirstChild", name: "FirstChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "GetAttribute", name: "GetAttribute", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "GetAttributeNS", name: "GetAttributeNS", pkg: "", typ: $funcType([$String, $String], [$String], false)}, {prop: "GetBoundingClientRect", name: "GetBoundingClientRect", pkg: "", typ: $funcType([], [ClientRect], false)}, {prop: "GetElementsByClassName", name: "GetElementsByClassName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagName", name: "GetElementsByTagName", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "GetElementsByTagNameNS", name: "GetElementsByTagNameNS", pkg: "", typ: $funcType([$String, $String], [sliceType$2], false)}, {prop: "HasAttribute", name: "HasAttribute", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "HasAttributeNS", name: "HasAttributeNS", pkg: "", typ: $funcType([$String, $String], [$Bool], false)}, {prop: "HasChildNodes", name: "HasChildNodes", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "ID", name: "ID", pkg: "", typ: $funcType([], [$String], false)}, {prop: "InnerHTML", name: "InnerHTML", pkg: "", typ: $funcType([], [$String], false)}, {prop: "InsertBefore", name: "InsertBefore", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "IsDefaultNamespace", name: "IsDefaultNamespace", pkg: "", typ: $funcType([$String], [$Bool], false)}, {prop: "IsEqualNode", name: "IsEqualNode", pkg: "", typ: $funcType([Node], [$Bool], false)}, {prop: "LastChild", name: "LastChild", pkg: "", typ: $funcType([], [Node], false)}, {prop: "LookupNamespaceURI", name: "LookupNamespaceURI", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "LookupPrefix", name: "LookupPrefix", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NextElementSibling", name: "NextElementSibling", pkg: "", typ: $funcType([], [Element], false)}, {prop: "NextSibling", name: "NextSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "NodeName", name: "NodeName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NodeType", name: "NodeType", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "NodeValue", name: "NodeValue", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Normalize", name: "Normalize", pkg: "", typ: $funcType([], [], false)}, {prop: "OwnerDocument", name: "OwnerDocument", pkg: "", typ: $funcType([], [Document], false)}, {prop: "ParentElement", name: "ParentElement", pkg: "", typ: $funcType([], [Element], false)}, {prop: "ParentNode", name: "ParentNode", pkg: "", typ: $funcType([], [Node], false)}, {prop: "PreviousElementSibling", name: "PreviousElementSibling", pkg: "", typ: $funcType([], [Element], false)}, {prop: "PreviousSibling", name: "PreviousSibling", pkg: "", typ: $funcType([], [Node], false)}, {prop: "QuerySelector", name: "QuerySelector", pkg: "", typ: $funcType([$String], [Element], false)}, {prop: "QuerySelectorAll", name: "QuerySelectorAll", pkg: "", typ: $funcType([$String], [sliceType$2], false)}, {prop: "RemoveAttribute", name: "RemoveAttribute", pkg: "", typ: $funcType([$String], [], false)}, {prop: "RemoveAttributeNS", name: "RemoveAttributeNS", pkg: "", typ: $funcType([$String, $String], [], false)}, {prop: "RemoveChild", name: "RemoveChild", pkg: "", typ: $funcType([Node], [], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType$1], [], false)}, {prop: "ReplaceChild", name: "ReplaceChild", pkg: "", typ: $funcType([Node, Node], [], false)}, {prop: "SetAttribute", name: "SetAttribute", pkg: "", typ: $funcType([$String, $String], [], false)}, {prop: "SetAttributeNS", name: "SetAttributeNS", pkg: "", typ: $funcType([$String, $String, $String], [], false)}, {prop: "SetID", name: "SetID", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetInnerHTML", name: "SetInnerHTML", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetNodeValue", name: "SetNodeValue", pkg: "", typ: $funcType([$String], [], false)}, {prop: "SetTextContent", name: "SetTextContent", pkg: "", typ: $funcType([$String], [], false)}, {prop: "TagName", name: "TagName", pkg: "", typ: $funcType([], [$String], false)}, {prop: "TextContent", name: "TextContent", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Underlying", name: "Underlying", pkg: "", typ: $funcType([], [ptrType$10], false)}]);
- ClientRect.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "Height", name: "Height", pkg: "", typ: $Int, tag: "js:\"height\""}, {prop: "Width", name: "Width", pkg: "", typ: $Int, tag: "js:\"width\""}, {prop: "Left", name: "Left", pkg: "", typ: $Int, tag: "js:\"left\""}, {prop: "Right", name: "Right", pkg: "", typ: $Int, tag: "js:\"right\""}, {prop: "Top", name: "Top", pkg: "", typ: $Int, tag: "js:\"top\""}, {prop: "Bottom", name: "Bottom", pkg: "", typ: $Int, tag: "js:\"bottom\""}]);
- BasicHTMLElement.init([{prop: "BasicElement", name: "", pkg: "", typ: ptrType$30, tag: ""}]);
- BasicElement.init([{prop: "BasicNode", name: "", pkg: "", typ: ptrType$21, tag: ""}]);
- HTMLAnchorElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "URLUtils", name: "", pkg: "", typ: ptrType$1, tag: ""}, {prop: "HrefLang", name: "HrefLang", pkg: "", typ: $String, tag: "js:\"hreflang\""}, {prop: "Media", name: "Media", pkg: "", typ: $String, tag: "js:\"media\""}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $Int, tag: "js:\"tabIndex\""}, {prop: "Target", name: "Target", pkg: "", typ: $String, tag: "js:\"target\""}, {prop: "Text", name: "Text", pkg: "", typ: $String, tag: "js:\"text\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}]);
- HTMLAppletElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Alt", name: "Alt", pkg: "", typ: $String, tag: "js:\"alt\""}, {prop: "Coords", name: "Coords", pkg: "", typ: $String, tag: "js:\"coords\""}, {prop: "HrefLang", name: "HrefLang", pkg: "", typ: $String, tag: "js:\"hreflang\""}, {prop: "Media", name: "Media", pkg: "", typ: $String, tag: "js:\"media\""}, {prop: "Search", name: "Search", pkg: "", typ: $String, tag: "js:\"search\""}, {prop: "Shape", name: "Shape", pkg: "", typ: $String, tag: "js:\"shape\""}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $Int, tag: "js:\"tabIndex\""}, {prop: "Target", name: "Target", pkg: "", typ: $String, tag: "js:\"target\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}]);
- HTMLAreaElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "URLUtils", name: "", pkg: "", typ: ptrType$1, tag: ""}, {prop: "Alt", name: "Alt", pkg: "", typ: $String, tag: "js:\"alt\""}, {prop: "Coords", name: "Coords", pkg: "", typ: $String, tag: "js:\"coords\""}, {prop: "HrefLang", name: "HrefLang", pkg: "", typ: $String, tag: "js:\"hreflang\""}, {prop: "Media", name: "Media", pkg: "", typ: $String, tag: "js:\"media\""}, {prop: "Search", name: "Search", pkg: "", typ: $String, tag: "js:\"search\""}, {prop: "Shape", name: "Shape", pkg: "", typ: $String, tag: "js:\"shape\""}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $Int, tag: "js:\"tabIndex\""}, {prop: "Target", name: "Target", pkg: "", typ: $String, tag: "js:\"target\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}]);
- HTMLAudioElement.init([{prop: "HTMLMediaElement", name: "", pkg: "", typ: ptrType$2, tag: ""}]);
- HTMLBRElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLBaseElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLBodyElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- ValidityState.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "CustomError", name: "CustomError", pkg: "", typ: $Bool, tag: "js:\"customError\""}, {prop: "PatternMismatch", name: "PatternMismatch", pkg: "", typ: $Bool, tag: "js:\"patternMismatch\""}, {prop: "RangeOverflow", name: "RangeOverflow", pkg: "", typ: $Bool, tag: "js:\"rangeOverflow\""}, {prop: "RangeUnderflow", name: "RangeUnderflow", pkg: "", typ: $Bool, tag: "js:\"rangeUnderflow\""}, {prop: "StepMismatch", name: "StepMismatch", pkg: "", typ: $Bool, tag: "js:\"stepMismatch\""}, {prop: "TooLong", name: "TooLong", pkg: "", typ: $Bool, tag: "js:\"tooLong\""}, {prop: "TypeMismatch", name: "TypeMismatch", pkg: "", typ: $Bool, tag: "js:\"typeMismatch\""}, {prop: "Valid", name: "Valid", pkg: "", typ: $Bool, tag: "js:\"valid\""}, {prop: "ValueMissing", name: "ValueMissing", pkg: "", typ: $Bool, tag: "js:\"valueMissing\""}]);
- HTMLButtonElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "AutoFocus", name: "AutoFocus", pkg: "", typ: $Bool, tag: "js:\"autofocus\""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "FormAction", name: "FormAction", pkg: "", typ: $String, tag: "js:\"formAction\""}, {prop: "FormEncType", name: "FormEncType", pkg: "", typ: $String, tag: "js:\"formEncType\""}, {prop: "FormMethod", name: "FormMethod", pkg: "", typ: $String, tag: "js:\"formMethod\""}, {prop: "FormNoValidate", name: "FormNoValidate", pkg: "", typ: $Bool, tag: "js:\"formNoValidate\""}, {prop: "FormTarget", name: "FormTarget", pkg: "", typ: $String, tag: "js:\"formTarget\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $Int, tag: "js:\"tabIndex\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}]);
- HTMLCanvasElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Height", name: "Height", pkg: "", typ: $Int, tag: "js:\"height\""}, {prop: "Width", name: "Width", pkg: "", typ: $Int, tag: "js:\"width\""}]);
- CanvasRenderingContext2D.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}, {prop: "FillStyle", name: "FillStyle", pkg: "", typ: $String, tag: "js:\"fillStyle\""}, {prop: "StrokeStyle", name: "StrokeStyle", pkg: "", typ: $String, tag: "js:\"strokeStyle\""}, {prop: "ShadowColor", name: "ShadowColor", pkg: "", typ: $String, tag: "js:\"shadowColor\""}, {prop: "ShadowBlur", name: "ShadowBlur", pkg: "", typ: $Int, tag: "js:\"shadowBlur\""}, {prop: "ShadowOffsetX", name: "ShadowOffsetX", pkg: "", typ: $Int, tag: "js:\"shadowOffsetX\""}, {prop: "ShadowOffsetY", name: "ShadowOffsetY", pkg: "", typ: $Int, tag: "js:\"shadowOffsetY\""}, {prop: "LineCap", name: "LineCap", pkg: "", typ: $String, tag: "js:\"lineCap\""}, {prop: "LineJoin", name: "LineJoin", pkg: "", typ: $String, tag: "js:\"lineJoin\""}, {prop: "LineWidth", name: "LineWidth", pkg: "", typ: $Int, tag: "js:\"lineWidth\""}, {prop: "MiterLimit", name: "MiterLimit", pkg: "", typ: $Int, tag: "js:\"miterLimit\""}, {prop: "Font", name: "Font", pkg: "", typ: $String, tag: "js:\"font\""}, {prop: "TextAlign", name: "TextAlign", pkg: "", typ: $String, tag: "js:\"textAlign\""}, {prop: "TextBaseline", name: "TextBaseline", pkg: "", typ: $String, tag: "js:\"textBaseline\""}, {prop: "GlobalAlpha", name: "GlobalAlpha", pkg: "", typ: $Float64, tag: "js:\"globalAlpha\""}, {prop: "GlobalCompositeOperation", name: "GlobalCompositeOperation", pkg: "", typ: $String, tag: "js:\"globalCompositeOperation\""}]);
- HTMLDListElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLDataElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}]);
- HTMLDataListElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLDirectoryElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLDivElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLEmbedElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Src", name: "Src", pkg: "", typ: $String, tag: "js:\"src\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "Width", name: "Width", pkg: "", typ: $String, tag: "js:\"width\""}]);
- HTMLFieldSetElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}]);
- HTMLFontElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLFormElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "AcceptCharset", name: "AcceptCharset", pkg: "", typ: $String, tag: "js:\"acceptCharset\""}, {prop: "Action", name: "Action", pkg: "", typ: $String, tag: "js:\"action\""}, {prop: "Autocomplete", name: "Autocomplete", pkg: "", typ: $String, tag: "js:\"autocomplete\""}, {prop: "Encoding", name: "Encoding", pkg: "", typ: $String, tag: "js:\"encoding\""}, {prop: "Enctype", name: "Enctype", pkg: "", typ: $String, tag: "js:\"enctype\""}, {prop: "Length", name: "Length", pkg: "", typ: $Int, tag: "js:\"length\""}, {prop: "Method", name: "Method", pkg: "", typ: $String, tag: "js:\"method\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "NoValidate", name: "NoValidate", pkg: "", typ: $Bool, tag: "js:\"noValidate\""}, {prop: "Target", name: "Target", pkg: "", typ: $String, tag: "js:\"target\""}]);
- HTMLFrameElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLFrameSetElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLHRElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLHeadElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLHeadingElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLHtmlElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLIFrameElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Width", name: "Width", pkg: "", typ: $String, tag: "js:\"width\""}, {prop: "Height", name: "Height", pkg: "", typ: $String, tag: "js:\"height\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Src", name: "Src", pkg: "", typ: $String, tag: "js:\"src\""}, {prop: "SrcDoc", name: "SrcDoc", pkg: "", typ: $String, tag: "js:\"srcdoc\""}, {prop: "Seamless", name: "Seamless", pkg: "", typ: $Bool, tag: "js:\"seamless\""}]);
- HTMLImageElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Complete", name: "Complete", pkg: "", typ: $Bool, tag: "js:\"complete\""}, {prop: "CrossOrigin", name: "CrossOrigin", pkg: "", typ: $String, tag: "js:\"crossOrigin\""}, {prop: "Height", name: "Height", pkg: "", typ: $Int, tag: "js:\"height\""}, {prop: "IsMap", name: "IsMap", pkg: "", typ: $Bool, tag: "js:\"isMap\""}, {prop: "NaturalHeight", name: "NaturalHeight", pkg: "", typ: $Int, tag: "js:\"naturalHeight\""}, {prop: "NaturalWidth", name: "NaturalWidth", pkg: "", typ: $Int, tag: "js:\"naturalWidth\""}, {prop: "Src", name: "Src", pkg: "", typ: $String, tag: "js:\"src\""}, {prop: "UseMap", name: "UseMap", pkg: "", typ: $String, tag: "js:\"useMap\""}, {prop: "Width", name: "Width", pkg: "", typ: $Int, tag: "js:\"width\""}]);
- HTMLInputElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Accept", name: "Accept", pkg: "", typ: $String, tag: "js:\"accept\""}, {prop: "Alt", name: "Alt", pkg: "", typ: $String, tag: "js:\"alt\""}, {prop: "Autocomplete", name: "Autocomplete", pkg: "", typ: $String, tag: "js:\"autocomplete\""}, {prop: "Autofocus", name: "Autofocus", pkg: "", typ: $Bool, tag: "js:\"autofocus\""}, {prop: "Checked", name: "Checked", pkg: "", typ: $Bool, tag: "js:\"checked\""}, {prop: "DefaultChecked", name: "DefaultChecked", pkg: "", typ: $Bool, tag: "js:\"defaultChecked\""}, {prop: "DefaultValue", name: "DefaultValue", pkg: "", typ: $String, tag: "js:\"defaultValue\""}, {prop: "DirName", name: "DirName", pkg: "", typ: $String, tag: "js:\"dirName\""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "FormAction", name: "FormAction", pkg: "", typ: $String, tag: "js:\"formAction\""}, {prop: "FormEncType", name: "FormEncType", pkg: "", typ: $String, tag: "js:\"formEncType\""}, {prop: "FormMethod", name: "FormMethod", pkg: "", typ: $String, tag: "js:\"formMethod\""}, {prop: "FormNoValidate", name: "FormNoValidate", pkg: "", typ: $Bool, tag: "js:\"formNoValidate\""}, {prop: "FormTarget", name: "FormTarget", pkg: "", typ: $String, tag: "js:\"formTarget\""}, {prop: "Height", name: "Height", pkg: "", typ: $String, tag: "js:\"height\""}, {prop: "Indeterminate", name: "Indeterminate", pkg: "", typ: $Bool, tag: "js:\"indeterminate\""}, {prop: "Max", name: "Max", pkg: "", typ: $String, tag: "js:\"max\""}, {prop: "MaxLength", name: "MaxLength", pkg: "", typ: $Int, tag: "js:\"maxLength\""}, {prop: "Min", name: "Min", pkg: "", typ: $String, tag: "js:\"min\""}, {prop: "Multiple", name: "Multiple", pkg: "", typ: $Bool, tag: "js:\"multiple\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Pattern", name: "Pattern", pkg: "", typ: $String, tag: "js:\"pattern\""}, {prop: "Placeholder", name: "Placeholder", pkg: "", typ: $String, tag: "js:\"placeholder\""}, {prop: "ReadOnly", name: "ReadOnly", pkg: "", typ: $Bool, tag: "js:\"readOnly\""}, {prop: "Required", name: "Required", pkg: "", typ: $Bool, tag: "js:\"required\""}, {prop: "SelectionDirection", name: "SelectionDirection", pkg: "", typ: $String, tag: "js:\"selectionDirection\""}, {prop: "SelectionEnd", name: "SelectionEnd", pkg: "", typ: $Int, tag: "js:\"selectionEnd\""}, {prop: "SelectionStart", name: "SelectionStart", pkg: "", typ: $Int, tag: "js:\"selectionStart\""}, {prop: "Size", name: "Size", pkg: "", typ: $Int, tag: "js:\"size\""}, {prop: "Src", name: "Src", pkg: "", typ: $String, tag: "js:\"src\""}, {prop: "Step", name: "Step", pkg: "", typ: $String, tag: "js:\"step\""}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $Int, tag: "js:\"tabIndex\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}, {prop: "ValueAsDate", name: "ValueAsDate", pkg: "", typ: time.Time, tag: "js:\"valueAsDate\""}, {prop: "ValueAsNumber", name: "ValueAsNumber", pkg: "", typ: $Float64, tag: "js:\"valueAsNumber\""}, {prop: "Width", name: "Width", pkg: "", typ: $String, tag: "js:\"width\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}]);
- File.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}]);
- HTMLKeygenElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Autofocus", name: "Autofocus", pkg: "", typ: $Bool, tag: "js:\"autofocus\""}, {prop: "Challenge", name: "Challenge", pkg: "", typ: $String, tag: "js:\"challenge\""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "Keytype", name: "Keytype", pkg: "", typ: $String, tag: "js:\"keytype\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}]);
- HTMLLIElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: $Int, tag: "js:\"value\""}]);
- HTMLLabelElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "For", name: "For", pkg: "", typ: $String, tag: "js:\"htmlFor\""}]);
- HTMLLegendElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLLinkElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "Href", name: "Href", pkg: "", typ: $String, tag: "js:\"href\""}, {prop: "HrefLang", name: "HrefLang", pkg: "", typ: $String, tag: "js:\"hrefLang\""}, {prop: "Media", name: "Media", pkg: "", typ: $String, tag: "js:\"media\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}]);
- HTMLMapElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}]);
- HTMLMediaElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLMenuElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLMetaElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Content", name: "Content", pkg: "", typ: $String, tag: "js:\"content\""}, {prop: "HTTPEquiv", name: "HTTPEquiv", pkg: "", typ: $String, tag: "js:\"httpEquiv\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}]);
- HTMLMeterElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "High", name: "High", pkg: "", typ: $Float64, tag: "js:\"high\""}, {prop: "Low", name: "Low", pkg: "", typ: $Float64, tag: "js:\"low\""}, {prop: "Max", name: "Max", pkg: "", typ: $Float64, tag: "js:\"max\""}, {prop: "Min", name: "Min", pkg: "", typ: $Float64, tag: "js:\"min\""}, {prop: "Optimum", name: "Optimum", pkg: "", typ: $Float64, tag: "js:\"optimum\""}]);
- HTMLModElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Cite", name: "Cite", pkg: "", typ: $String, tag: "js:\"cite\""}, {prop: "DateTime", name: "DateTime", pkg: "", typ: $String, tag: "js:\"dateTime\""}]);
- HTMLOListElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Reversed", name: "Reversed", pkg: "", typ: $Bool, tag: "js:\"reversed\""}, {prop: "Start", name: "Start", pkg: "", typ: $Int, tag: "js:\"start\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}]);
- HTMLObjectElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Data", name: "Data", pkg: "", typ: $String, tag: "js:\"data\""}, {prop: "Height", name: "Height", pkg: "", typ: $String, tag: "js:\"height\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $Int, tag: "js:\"tabIndex\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "TypeMustMatch", name: "TypeMustMatch", pkg: "", typ: $Bool, tag: "js:\"typeMustMatch\""}, {prop: "UseMap", name: "UseMap", pkg: "", typ: $String, tag: "js:\"useMap\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "With", name: "With", pkg: "", typ: $String, tag: "js:\"with\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}]);
- HTMLOptGroupElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "Label", name: "Label", pkg: "", typ: $String, tag: "js:\"label\""}]);
- HTMLOptionElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "DefaultSelected", name: "DefaultSelected", pkg: "", typ: $Bool, tag: "js:\"defaultSelected\""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "Index", name: "Index", pkg: "", typ: $Int, tag: "js:\"index\""}, {prop: "Label", name: "Label", pkg: "", typ: $String, tag: "js:\"label\""}, {prop: "Selected", name: "Selected", pkg: "", typ: $Bool, tag: "js:\"selected\""}, {prop: "Text", name: "Text", pkg: "", typ: $String, tag: "js:\"text\""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}]);
- HTMLOutputElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "DefaultValue", name: "DefaultValue", pkg: "", typ: $String, tag: "js:\"defaultValue\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}]);
- HTMLParagraphElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLParamElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}]);
- HTMLPreElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLProgressElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Max", name: "Max", pkg: "", typ: $Float64, tag: "js:\"max\""}, {prop: "Position", name: "Position", pkg: "", typ: $Float64, tag: "js:\"position\""}, {prop: "Value", name: "Value", pkg: "", typ: $Float64, tag: "js:\"value\""}]);
- HTMLQuoteElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Cite", name: "Cite", pkg: "", typ: $String, tag: "js:\"cite\""}]);
- HTMLScriptElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "Src", name: "Src", pkg: "", typ: $String, tag: "js:\"src\""}, {prop: "Charset", name: "Charset", pkg: "", typ: $String, tag: "js:\"charset\""}, {prop: "Async", name: "Async", pkg: "", typ: $Bool, tag: "js:\"async\""}, {prop: "Defer", name: "Defer", pkg: "", typ: $Bool, tag: "js:\"defer\""}, {prop: "Text", name: "Text", pkg: "", typ: $String, tag: "js:\"text\""}]);
- HTMLSelectElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Autofocus", name: "Autofocus", pkg: "", typ: $Bool, tag: "js:\"autofocus\""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "Length", name: "Length", pkg: "", typ: $Int, tag: "js:\"length\""}, {prop: "Multiple", name: "Multiple", pkg: "", typ: $Bool, tag: "js:\"multiple\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Required", name: "Required", pkg: "", typ: $Bool, tag: "js:\"required\""}, {prop: "SelectedIndex", name: "SelectedIndex", pkg: "", typ: $Int, tag: "js:\"selectedIndex\""}, {prop: "Size", name: "Size", pkg: "", typ: $Int, tag: "js:\"size\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}]);
- HTMLSourceElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Media", name: "Media", pkg: "", typ: $String, tag: "js:\"media\""}, {prop: "Src", name: "Src", pkg: "", typ: $String, tag: "js:\"src\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}]);
- HTMLSpanElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLStyleElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLTableCaptionElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLTableCellElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "ColSpan", name: "ColSpan", pkg: "", typ: $Int, tag: "js:\"colSpan\""}, {prop: "RowSpan", name: "RowSpan", pkg: "", typ: $Int, tag: "js:\"rowSpan\""}, {prop: "CellIndex", name: "CellIndex", pkg: "", typ: $Int, tag: "js:\"cellIndex\""}]);
- HTMLTableColElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Span", name: "Span", pkg: "", typ: $Int, tag: "js:\"span\""}]);
- HTMLTableDataCellElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLTableElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLTableHeaderCellElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Abbr", name: "Abbr", pkg: "", typ: $String, tag: "js:\"abbr\""}, {prop: "Scope", name: "Scope", pkg: "", typ: $String, tag: "js:\"scope\""}]);
- HTMLTableRowElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "RowIndex", name: "RowIndex", pkg: "", typ: $Int, tag: "js:\"rowIndex\""}, {prop: "SectionRowIndex", name: "SectionRowIndex", pkg: "", typ: $Int, tag: "js:\"sectionRowIndex\""}]);
- HTMLTableSectionElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLTextAreaElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Autocomplete", name: "Autocomplete", pkg: "", typ: $String, tag: "js:\"autocomplete\""}, {prop: "Autofocus", name: "Autofocus", pkg: "", typ: $Bool, tag: "js:\"autofocus\""}, {prop: "Cols", name: "Cols", pkg: "", typ: $Int, tag: "js:\"cols\""}, {prop: "DefaultValue", name: "DefaultValue", pkg: "", typ: $String, tag: "js:\"defaultValue\""}, {prop: "DirName", name: "DirName", pkg: "", typ: $String, tag: "js:\"dirName\""}, {prop: "Disabled", name: "Disabled", pkg: "", typ: $Bool, tag: "js:\"disabled\""}, {prop: "MaxLength", name: "MaxLength", pkg: "", typ: $Int, tag: "js:\"maxLength\""}, {prop: "Name", name: "Name", pkg: "", typ: $String, tag: "js:\"name\""}, {prop: "Placeholder", name: "Placeholder", pkg: "", typ: $String, tag: "js:\"placeholder\""}, {prop: "ReadOnly", name: "ReadOnly", pkg: "", typ: $Bool, tag: "js:\"readOnly\""}, {prop: "Required", name: "Required", pkg: "", typ: $Bool, tag: "js:\"required\""}, {prop: "Rows", name: "Rows", pkg: "", typ: $Int, tag: "js:\"rows\""}, {prop: "SelectionDirection", name: "SelectionDirection", pkg: "", typ: $String, tag: "js:\"selectionDirection\""}, {prop: "SelectionStart", name: "SelectionStart", pkg: "", typ: $Int, tag: "js:\"selectionStart\""}, {prop: "SelectionEnd", name: "SelectionEnd", pkg: "", typ: $Int, tag: "js:\"selectionEnd\""}, {prop: "TabIndex", name: "TabIndex", pkg: "", typ: $Int, tag: "js:\"tabIndex\""}, {prop: "TextLength", name: "TextLength", pkg: "", typ: $Int, tag: "js:\"textLength\""}, {prop: "Type", name: "Type", pkg: "", typ: $String, tag: "js:\"type\""}, {prop: "ValidationMessage", name: "ValidationMessage", pkg: "", typ: $String, tag: "js:\"validationMessage\""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: "js:\"value\""}, {prop: "WillValidate", name: "WillValidate", pkg: "", typ: $Bool, tag: "js:\"willValidate\""}, {prop: "Wrap", name: "Wrap", pkg: "", typ: $String, tag: "js:\"wrap\""}]);
- HTMLTimeElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "DateTime", name: "DateTime", pkg: "", typ: $String, tag: "js:\"dateTime\""}]);
- HTMLTitleElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Text", name: "Text", pkg: "", typ: $String, tag: "js:\"text\""}]);
- TextTrack.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}]);
- HTMLTrackElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}, {prop: "Kind", name: "Kind", pkg: "", typ: $String, tag: "js:\"kind\""}, {prop: "Src", name: "Src", pkg: "", typ: $String, tag: "js:\"src\""}, {prop: "Srclang", name: "Srclang", pkg: "", typ: $String, tag: "js:\"srclang\""}, {prop: "Label", name: "Label", pkg: "", typ: $String, tag: "js:\"label\""}, {prop: "Default", name: "Default", pkg: "", typ: $Bool, tag: "js:\"default\""}, {prop: "ReadyState", name: "ReadyState", pkg: "", typ: $Int, tag: "js:\"readyState\""}]);
- HTMLUListElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLUnknownElement.init([{prop: "BasicHTMLElement", name: "", pkg: "", typ: ptrType, tag: ""}]);
- HTMLVideoElement.init([{prop: "HTMLMediaElement", name: "", pkg: "", typ: ptrType$2, tag: ""}]);
- CSSStyleDeclaration.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}]);
- Text.init([{prop: "BasicNode", name: "", pkg: "", typ: ptrType$21, tag: ""}]);
- Event.init([{prop: "Bubbles", name: "Bubbles", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Cancelable", name: "Cancelable", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "CurrentTarget", name: "CurrentTarget", pkg: "", typ: $funcType([], [Element], false)}, {prop: "DefaultPrevented", name: "DefaultPrevented", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "EventPhase", name: "EventPhase", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "PreventDefault", name: "PreventDefault", pkg: "", typ: $funcType([], [], false)}, {prop: "StopImmediatePropagation", name: "StopImmediatePropagation", pkg: "", typ: $funcType([], [], false)}, {prop: "StopPropagation", name: "StopPropagation", pkg: "", typ: $funcType([], [], false)}, {prop: "Target", name: "Target", pkg: "", typ: $funcType([], [Element], false)}, {prop: "Timestamp", name: "Timestamp", pkg: "", typ: $funcType([], [time.Time], false)}, {prop: "Type", name: "Type", pkg: "", typ: $funcType([], [$String], false)}]);
- BasicEvent.init([{prop: "Object", name: "", pkg: "", typ: ptrType$10, tag: ""}]);
- AnimationEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- AudioProcessingEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- BeforeInputEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- BeforeUnloadEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- BlobEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- ClipboardEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- CloseEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}, {prop: "Code", name: "Code", pkg: "", typ: $Int, tag: "js:\"code\""}, {prop: "Reason", name: "Reason", pkg: "", typ: $String, tag: "js:\"reason\""}, {prop: "WasClean", name: "WasClean", pkg: "", typ: $Bool, tag: "js:\"wasClean\""}]);
- CompositionEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- CSSFontFaceLoadEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- CustomEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- DeviceLightEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- DeviceMotionEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- DeviceOrientationEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- DeviceProximityEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- DOMTransactionEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- DragEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- EditingBeforeInputEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- ErrorEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- FocusEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- GamepadEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- HashChangeEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- IDBVersionChangeEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- KeyboardEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}, {prop: "AltKey", name: "AltKey", pkg: "", typ: $Bool, tag: "js:\"altKey\""}, {prop: "CharCode", name: "CharCode", pkg: "", typ: $Int, tag: "js:\"charCode\""}, {prop: "CtrlKey", name: "CtrlKey", pkg: "", typ: $Bool, tag: "js:\"ctrlKey\""}, {prop: "Key", name: "Key", pkg: "", typ: $String, tag: "js:\"key\""}, {prop: "KeyIdentifier", name: "KeyIdentifier", pkg: "", typ: $String, tag: "js:\"keyIdentifier\""}, {prop: "KeyCode", name: "KeyCode", pkg: "", typ: $Int, tag: "js:\"keyCode\""}, {prop: "Locale", name: "Locale", pkg: "", typ: $String, tag: "js:\"locale\""}, {prop: "Location", name: "Location", pkg: "", typ: $Int, tag: "js:\"location\""}, {prop: "KeyLocation", name: "KeyLocation", pkg: "", typ: $Int, tag: "js:\"keyLocation\""}, {prop: "MetaKey", name: "MetaKey", pkg: "", typ: $Bool, tag: "js:\"metaKey\""}, {prop: "Repeat", name: "Repeat", pkg: "", typ: $Bool, tag: "js:\"repeat\""}, {prop: "ShiftKey", name: "ShiftKey", pkg: "", typ: $Bool, tag: "js:\"shiftKey\""}]);
- MediaStreamEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- MessageEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}, {prop: "Data", name: "Data", pkg: "", typ: ptrType$10, tag: "js:\"data\""}]);
- MouseEvent.init([{prop: "UIEvent", name: "", pkg: "", typ: ptrType$18, tag: ""}, {prop: "AltKey", name: "AltKey", pkg: "", typ: $Bool, tag: "js:\"altKey\""}, {prop: "Button", name: "Button", pkg: "", typ: $Int, tag: "js:\"button\""}, {prop: "ClientX", name: "ClientX", pkg: "", typ: $Int, tag: "js:\"clientX\""}, {prop: "ClientY", name: "ClientY", pkg: "", typ: $Int, tag: "js:\"clientY\""}, {prop: "CtrlKey", name: "CtrlKey", pkg: "", typ: $Bool, tag: "js:\"ctrlKey\""}, {prop: "MetaKey", name: "MetaKey", pkg: "", typ: $Bool, tag: "js:\"metaKey\""}, {prop: "MovementX", name: "MovementX", pkg: "", typ: $Int, tag: "js:\"movementX\""}, {prop: "MovementY", name: "MovementY", pkg: "", typ: $Int, tag: "js:\"movementY\""}, {prop: "ScreenX", name: "ScreenX", pkg: "", typ: $Int, tag: "js:\"screenX\""}, {prop: "ScreenY", name: "ScreenY", pkg: "", typ: $Int, tag: "js:\"screenY\""}, {prop: "ShiftKey", name: "ShiftKey", pkg: "", typ: $Bool, tag: "js:\"shiftKey\""}]);
- MutationEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- OfflineAudioCompletionEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- PageTransitionEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- PointerEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- PopStateEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- ProgressEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- RelatedEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- RTCPeerConnectionIceEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- SensorEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- StorageEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- SVGEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- SVGZoomEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- TimeEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- TouchEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- TrackEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- TransitionEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- UIEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- UserProximityEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}]);
- WheelEvent.init([{prop: "BasicEvent", name: "", pkg: "", typ: ptrType$17, tag: ""}, {prop: "DeltaX", name: "DeltaX", pkg: "", typ: $Float64, tag: "js:\"deltaX\""}, {prop: "DeltaY", name: "DeltaY", pkg: "", typ: $Float64, tag: "js:\"deltaY\""}, {prop: "DeltaZ", name: "DeltaZ", pkg: "", typ: $Float64, tag: "js:\"deltaZ\""}, {prop: "DeltaMode", name: "DeltaMode", pkg: "", typ: $Int, tag: "js:\"deltaMode\""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = time.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["honnef.co/go/js/util"] = (function() {
- var $pkg = {}, $init, js, EventTarget, ptrType, funcType;
- js = $packages["github.com/gopherjs/gopherjs/js"];
- EventTarget = $pkg.EventTarget = $newType(0, $kindStruct, "util.EventTarget", "EventTarget", "honnef.co/go/js/util", function(Object_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- return;
- }
- this.Object = Object_;
- });
- ptrType = $ptrType(js.Object);
- funcType = $funcType([ptrType], [], false);
- EventTarget.ptr.prototype.AddEventListener = function(typ, useCapture, listener) {
- var $ptr, listener, t, typ, useCapture;
- t = $clone(this, EventTarget);
- t.Object.addEventListener($externalize(typ, $String), $externalize(listener, funcType), $externalize(useCapture, $Bool));
- };
- EventTarget.prototype.AddEventListener = function(typ, useCapture, listener) { return this.$val.AddEventListener(typ, useCapture, listener); };
- EventTarget.ptr.prototype.RemoveEventListener = function(typ, useCapture, listener) {
- var $ptr, listener, t, typ, useCapture;
- t = $clone(this, EventTarget);
- t.Object.removeEventListener($externalize(typ, $String), $externalize(listener, funcType), $externalize(useCapture, $Bool));
- };
- EventTarget.prototype.RemoveEventListener = function(typ, useCapture, listener) { return this.$val.RemoveEventListener(typ, useCapture, listener); };
- EventTarget.methods = [{prop: "AddEventListener", name: "AddEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType], [], false)}, {prop: "RemoveEventListener", name: "RemoveEventListener", pkg: "", typ: $funcType([$String, $Bool, funcType], [], false)}];
- EventTarget.init([{prop: "Object", name: "", pkg: "", typ: ptrType, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = js.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["honnef.co/go/js/xhr"] = (function() {
- var $pkg = {}, $init, errors, js, util, Request, Upload, chanType, ptrType, ptrType$1, ptrType$2, NewRequest;
- errors = $packages["errors"];
- js = $packages["github.com/gopherjs/gopherjs/js"];
- util = $packages["honnef.co/go/js/util"];
- Request = $pkg.Request = $newType(0, $kindStruct, "xhr.Request", "Request", "honnef.co/go/js/xhr", function(Object_, EventTarget_, ReadyState_, Response_, ResponseText_, ResponseType_, ResponseXML_, Status_, StatusText_, Timeout_, WithCredentials_, ch_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.EventTarget = new util.EventTarget.ptr();
- this.ReadyState = 0;
- this.Response = null;
- this.ResponseText = "";
- this.ResponseType = "";
- this.ResponseXML = null;
- this.Status = 0;
- this.StatusText = "";
- this.Timeout = 0;
- this.WithCredentials = false;
- this.ch = chanType.nil;
- return;
- }
- this.Object = Object_;
- this.EventTarget = EventTarget_;
- this.ReadyState = ReadyState_;
- this.Response = Response_;
- this.ResponseText = ResponseText_;
- this.ResponseType = ResponseType_;
- this.ResponseXML = ResponseXML_;
- this.Status = Status_;
- this.StatusText = StatusText_;
- this.Timeout = Timeout_;
- this.WithCredentials = WithCredentials_;
- this.ch = ch_;
- });
- Upload = $pkg.Upload = $newType(0, $kindStruct, "xhr.Upload", "Upload", "honnef.co/go/js/xhr", function(Object_, EventTarget_) {
- this.$val = this;
- if (arguments.length === 0) {
- this.Object = null;
- this.EventTarget = new util.EventTarget.ptr();
- return;
- }
- this.Object = Object_;
- this.EventTarget = EventTarget_;
- });
- chanType = $chanType($error, false, false);
- ptrType = $ptrType(Upload);
- ptrType$1 = $ptrType(Request);
- ptrType$2 = $ptrType(js.Object);
- Request.ptr.prototype.Upload = function() {
- var $ptr, o, r;
- r = this;
- o = r.Object.upload;
- return new Upload.ptr(o, new util.EventTarget.ptr(o));
- };
- Request.prototype.Upload = function() { return this.$val.Upload(); };
- NewRequest = function(method, url) {
- var $ptr, method, o, r, url;
- o = new ($global.XMLHttpRequest)();
- r = new Request.ptr(o, new util.EventTarget.ptr(o), 0, null, "", "", null, 0, "", 0, false, chanType.nil);
- r.Object.open($externalize(method, $String), $externalize(url, $String), $externalize(true, $Bool));
- return r;
- };
- $pkg.NewRequest = NewRequest;
- Request.ptr.prototype.ResponseHeaders = function() {
- var $ptr, r;
- r = this;
- return $internalize(r.Object.getAllResponseHeaders(), $String);
- };
- Request.prototype.ResponseHeaders = function() { return this.$val.ResponseHeaders(); };
- Request.ptr.prototype.ResponseHeader = function(name) {
- var $ptr, name, r, value;
- r = this;
- value = r.Object.getResponseHeader($externalize(name, $String));
- if (value === null) {
- return "";
- }
- return $internalize(value, $String);
- };
- Request.prototype.ResponseHeader = function(name) { return this.$val.ResponseHeader(name); };
- Request.ptr.prototype.Abort = function() {
- var $ptr, _selection, r, $r;
- /* */ var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _selection = $f._selection; r = $f.r; $r = $f.$r; }
- r = this;
- if (r.ch === chanType.nil) {
- return;
- }
- r.Object.abort();
- _selection = $select([[r.ch, $pkg.ErrAborted], []]);
- /* */ if ($f === undefined) { $f = { $blk: Request.ptr.prototype.Abort }; } $f.$ptr = $ptr; $f._selection = _selection; $f.r = r; $f.$r = $r; return $f;
- };
- Request.prototype.Abort = function() { return this.$val.Abort(); };
- Request.ptr.prototype.OverrideMimeType = function(mimetype) {
- var $ptr, mimetype, r;
- r = this;
- r.Object.overrideMimeType($externalize(mimetype, $String));
- };
- Request.prototype.OverrideMimeType = function(mimetype) { return this.$val.OverrideMimeType(mimetype); };
- Request.ptr.prototype.Send = function(data) {
- var $ptr, _r, data, r, val, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; data = $f.data; r = $f.r; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- r = [r];
- r[0] = this;
- if (!(r[0].ch === chanType.nil)) {
- $panic(new $String("must not use a Request for multiple requests"));
- }
- r[0].ch = new chanType(1);
- r[0].EventTarget.AddEventListener("load", false, (function(r) { return function(param) {
- var $ptr, param;
- $go((function(r) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = $send(r[0].ch, $ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(r), []);
- }; })(r));
- r[0].EventTarget.AddEventListener("error", false, (function(r) { return function(o) {
- var $ptr, o;
- $go((function(r) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = $send(r[0].ch, $pkg.ErrFailure); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(r), []);
- }; })(r));
- r[0].EventTarget.AddEventListener("timeout", false, (function(r) { return function(param) {
- var $ptr, param;
- $go((function(r) { return function $b() {
- var $ptr, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = $send(r[0].ch, $pkg.ErrTimeout); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f;
- }; })(r), []);
- }; })(r));
- r[0].Object.send($externalize(data, $emptyInterface));
- _r = $recv(r[0].ch); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- val = _r[0];
- return val;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Request.ptr.prototype.Send }; } $f.$ptr = $ptr; $f._r = _r; $f.data = data; $f.r = r; $f.val = val; $f.$s = $s; $f.$r = $r; return $f;
- };
- Request.prototype.Send = function(data) { return this.$val.Send(data); };
- Request.ptr.prototype.SetRequestHeader = function(header, value) {
- var $ptr, header, r, value;
- r = this;
- r.Object.setRequestHeader($externalize(header, $String), $externalize(value, $String));
- };
- Request.prototype.SetRequestHeader = function(header, value) { return this.$val.SetRequestHeader(header, value); };
- ptrType$1.methods = [{prop: "Upload", name: "Upload", pkg: "", typ: $funcType([], [ptrType], false)}, {prop: "ResponseHeaders", name: "ResponseHeaders", pkg: "", typ: $funcType([], [$String], false)}, {prop: "ResponseHeader", name: "ResponseHeader", pkg: "", typ: $funcType([$String], [$String], false)}, {prop: "Abort", name: "Abort", pkg: "", typ: $funcType([], [], false)}, {prop: "OverrideMimeType", name: "OverrideMimeType", pkg: "", typ: $funcType([$String], [], false)}, {prop: "Send", name: "Send", pkg: "", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "SetRequestHeader", name: "SetRequestHeader", pkg: "", typ: $funcType([$String, $String], [], false)}];
- Request.init([{prop: "Object", name: "", pkg: "", typ: ptrType$2, tag: ""}, {prop: "EventTarget", name: "", pkg: "", typ: util.EventTarget, tag: ""}, {prop: "ReadyState", name: "ReadyState", pkg: "", typ: $Int, tag: "js:\"readyState\""}, {prop: "Response", name: "Response", pkg: "", typ: ptrType$2, tag: "js:\"response\""}, {prop: "ResponseText", name: "ResponseText", pkg: "", typ: $String, tag: "js:\"responseText\""}, {prop: "ResponseType", name: "ResponseType", pkg: "", typ: $String, tag: "js:\"responseType\""}, {prop: "ResponseXML", name: "ResponseXML", pkg: "", typ: ptrType$2, tag: "js:\"responseXML\""}, {prop: "Status", name: "Status", pkg: "", typ: $Int, tag: "js:\"status\""}, {prop: "StatusText", name: "StatusText", pkg: "", typ: $String, tag: "js:\"statusText\""}, {prop: "Timeout", name: "Timeout", pkg: "", typ: $Int, tag: "js:\"timeout\""}, {prop: "WithCredentials", name: "WithCredentials", pkg: "", typ: $Bool, tag: "js:\"withCredentials\""}, {prop: "ch", name: "ch", pkg: "honnef.co/go/js/xhr", typ: chanType, tag: ""}]);
- Upload.init([{prop: "Object", name: "", pkg: "", typ: ptrType$2, tag: ""}, {prop: "EventTarget", name: "", pkg: "", typ: util.EventTarget, tag: ""}]);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = errors.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = js.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = util.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $pkg.ErrAborted = errors.New("request aborted");
- $pkg.ErrTimeout = errors.New("request timed out");
- $pkg.ErrFailure = errors.New("send failed");
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
-$packages["github.com/gopherjs/gopherjs.github.io/playground"] = (function() {
- var $pkg = {}, $init, bytes, compiler, js, angularjs, ast, format, parser, scanner, token, dom, xhr, strings, time, Line, sliceType, structType, chanType, sliceType$1, sliceType$2, ptrType, ptrType$1, sliceType$3, ptrType$2, ptrType$3, sliceType$4, sliceType$5, ptrType$4, funcType, funcType$1, ptrType$5, output, main, setupEnvironment;
- bytes = $packages["bytes"];
- compiler = $packages["github.com/gopherjs/gopherjs/compiler"];
- js = $packages["github.com/gopherjs/gopherjs/js"];
- angularjs = $packages["github.com/neelance/go-angularjs"];
- ast = $packages["go/ast"];
- format = $packages["go/format"];
- parser = $packages["go/parser"];
- scanner = $packages["go/scanner"];
- token = $packages["go/token"];
- dom = $packages["honnef.co/go/js/dom"];
- xhr = $packages["honnef.co/go/js/xhr"];
- strings = $packages["strings"];
- time = $packages["time"];
- Line = $pkg.Line = $newType(4, $kindMap, "main.Line", "Line", "github.com/gopherjs/gopherjs.github.io/playground", null);
- sliceType = $sliceType(Line);
- structType = $structType([]);
- chanType = $chanType(structType, false, false);
- sliceType$1 = $sliceType($String);
- sliceType$2 = $sliceType($Uint8);
- ptrType = $ptrType(compiler.Archive);
- ptrType$1 = $ptrType(compiler.Decl);
- sliceType$3 = $sliceType(ptrType$1);
- ptrType$2 = $ptrType($packages["golang.org/x/tools/go/types"].Package);
- ptrType$3 = $ptrType(ast.File);
- sliceType$4 = $sliceType(ptrType$3);
- sliceType$5 = $sliceType(ptrType);
- ptrType$4 = $ptrType(token.FileSet);
- funcType = $funcType([$Bool], [], false);
- funcType$1 = $funcType([], [], false);
- ptrType$5 = $ptrType(dom.HTMLInputElement);
- main = function() {
- var $ptr, _r, _r$1, app, codeReady, location, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; app = $f.app; codeReady = $f.codeReady; location = $f.location; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- codeReady = [codeReady];
- location = [location];
- _r = dom.GetWindow().Top(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; }
- _r$1 = _r.Location(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; }
- location[0] = _r$1;
- codeReady[0] = new chanType(0);
- app = angularjs.NewModule("playground", sliceType$1.nil, $throwNilPointerError);
- app.NewController("PlaygroundCtrl", (function(codeReady, location) { return function $b(scope) {
- var $ptr, _r$2, _r$3, codeArea, fileSet, id, importContext, packages, pkgsReceived, pkgsToLoad, req, run, scope, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; codeArea = $f.codeArea; fileSet = $f.fileSet; id = $f.id; importContext = $f.importContext; packages = $f.packages; pkgsReceived = $f.pkgsReceived; pkgsToLoad = $f.pkgsToLoad; req = $f.req; run = $f.run; scope = $f.scope; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- codeArea = [codeArea];
- fileSet = [fileSet];
- id = [id];
- importContext = [importContext];
- packages = [packages];
- pkgsReceived = [pkgsReceived];
- pkgsToLoad = [pkgsToLoad];
- req = [req];
- run = [run];
- scope = [scope];
- /* */ if (strings.HasPrefix($internalize(location[0].URLUtils.Object.hash, $String), "#/")) { $s = 1; continue; }
- /* */ $s = 2; continue;
- /* if (strings.HasPrefix($internalize(location[0].URLUtils.Object.hash, $String), "#/")) { */ case 1:
- id[0] = $internalize(location[0].URLUtils.Object.hash, $String).substring(2);
- req[0] = xhr.NewRequest("GET", "http://snippets.gopherjs.org/p/" + id[0]);
- req[0].Object.responseType = $externalize("arraybuffer", $String);
- $go((function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function $b() {
- var $ptr, _r$2, data, err, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; data = $f.data; err = $f.err; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- data = [data];
- _r$2 = req[0].Send($ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- err = _r$2;
- if (!($interfaceIsEqual(err, $ifaceNil)) || !((($parseInt(req[0].Object.status) >> 0) === 200))) {
- scope[0].Apply((function(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function() {
- var $ptr, _key, _map;
- scope[0].Object.output = $externalize(new sliceType([(_map = new $Map(), _key = "type", _map[$String.keyFor(_key)] = { k: _key, v: "err" }, _key = "content", _map[$String.keyFor(_key)] = { k: _key, v: "failed to load snippet \"" + id[0] + "\"" }, _map)]), sliceType);
- }; })(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- return;
- }
- data[0] = $assertType($internalize(new ($global.Uint8Array)(req[0].Object.response), $emptyInterface), sliceType$2);
- scope[0].Apply((function(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function() {
- var $ptr;
- scope[0].Object.code = $externalize($bytesToString(data[0]), $String);
- $close(codeReady[0]);
- }; })(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.data = data; $f.err = err; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope), []);
- $s = 3; continue;
- /* } else { */ case 2:
- scope[0].Object.code = $externalize("package main\n\nimport (\n\t\"fmt\"\n\t\"github.com/gopherjs/gopherjs/js\"\n)\n\nfunc main() {\n\tfmt.Println(\"Hello, playground\")\n\tjs.Global.Call(\"alert\", \"Hello, JavaScript\")\n\tprintln(\"Hello, JS console\")\n}\n", $String);
- $close(codeReady[0]);
- /* } */ case 3:
- scope[0].Object.shareUrl = $externalize("", $String);
- scope[0].Object.showShareUrl = $externalize(false, $Bool);
- packages[0] = new $Map();
- pkgsToLoad[0] = false;
- importContext[0] = compiler.NewImportContext((function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function(path) {
- var $ptr, _entry, _key, _tuple, found, path, pkg;
- _tuple = (_entry = packages[0][$String.keyFor(path)], _entry !== undefined ? [_entry.v, true] : [ptrType.nil, false]); pkg = _tuple[0]; found = _tuple[1];
- if (found) {
- return [pkg, $ifaceNil];
- }
- _key = path; (pkgsToLoad[0] || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: new structType.ptr() };
- return [new compiler.Archive.ptr("", "", sliceType$1.nil, sliceType$2.nil, sliceType$3.nil, sliceType$2.nil, false, ptrType$2.nil), $ifaceNil];
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- fileSet[0] = token.NewFileSet();
- pkgsReceived[0] = 0;
- setupEnvironment(scope[0]);
- codeArea[0] = angularjs.ElementById("code");
- codeArea[0].On("input", (function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function(e) {
- var $ptr, e;
- scope[0].Object.showShareUrl = $externalize(false, $Bool);
- location[0].URLUtils.Object.hash = $externalize("", $String);
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- codeArea[0].On("keydown", (function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function(e) {
- var $ptr, _ref, c, code, code$1, e, end, i, start, start$1, toInsert;
- toInsert = "";
- _ref = $parseInt(e.Object.keyCode) >> 0;
- if (_ref === 9) {
- toInsert = "\t";
- } else if (_ref === 13) {
- toInsert = "\n";
- start = $parseInt(codeArea[0].Prop("selectionStart")) >> 0;
- code = $internalize(scope[0].Object.code, $String);
- i = strings.LastIndex(code.substring(0, start), "\n") + 1 >> 0;
- while (true) {
- if (!(i < start)) { break; }
- c = code.charCodeAt(i);
- if (!((c === 32)) && !((c === 9))) {
- break;
- }
- toInsert = toInsert + ($encodeRune(c));
- i = i + (1) >> 0;
- }
- }
- if (!(toInsert === "")) {
- scope[0].Object.showShareUrl = $externalize(false, $Bool);
- location[0].URLUtils.Object.hash = $externalize("", $String);
- start$1 = $parseInt(codeArea[0].Prop("selectionStart")) >> 0;
- end = $parseInt(codeArea[0].Prop("selectionEnd")) >> 0;
- code$1 = $internalize(scope[0].Object.code, $String);
- scope[0].Apply((function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function() {
- var $ptr;
- scope[0].Object.code = $externalize(code$1.substring(0, start$1) + toInsert + code$1.substring(end), $String);
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- codeArea[0].SetProp(new $String("selectionStart"), new $Int((start$1 + toInsert.length >> 0)));
- codeArea[0].SetProp(new $String("selectionEnd"), new $Int((start$1 + toInsert.length >> 0)));
- e.PreventDefault();
- }
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- run[0] = $throwNilPointerError;
- run[0] = (function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function $b(loadOnly) {
- var $ptr, _entry, _i, _i$1, _i$2, _key, _key$1, _key$2, _key$3, _key$4, _keys, _map, _map$1, _map$2, _map$3, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _ref$2, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, allPkgs, entry, entry$1, err, file, jsCode, list, list$1, loadOnly, mainPkg, ok, ok$1, output$1, path, req$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _i = $f._i; _i$1 = $f._i$1; _i$2 = $f._i$2; _key = $f._key; _key$1 = $f._key$1; _key$2 = $f._key$2; _key$3 = $f._key$3; _key$4 = $f._key$4; _keys = $f._keys; _map = $f._map; _map$1 = $f._map$1; _map$2 = $f._map$2; _map$3 = $f._map$3; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _r$6 = $f._r$6; _r$7 = $f._r$7; _r$8 = $f._r$8; _r$9 = $f._r$9; _ref = $f._ref; _ref$1 = $f._ref$1; _ref$2 = $f._ref$2; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; allPkgs = $f.allPkgs; entry = $f.entry; entry$1 = $f.entry$1; err = $f.err; file = $f.file; jsCode = $f.jsCode; list = $f.list; list$1 = $f.list$1; loadOnly = $f.loadOnly; mainPkg = $f.mainPkg; ok = $f.ok; ok$1 = $f.ok$1; output$1 = $f.output$1; path = $f.path; req$1 = $f.req$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- loadOnly = [loadOnly];
- output = sliceType.nil;
- scope[0].Object.output = $externalize(output, sliceType);
- pkgsToLoad[0] = new $Map();
- _r$2 = parser.ParseFile(fileSet[0], "prog.go", new sliceType$2($stringToBytes($internalize(scope[0].Object.code, $String))), 4); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; file = _tuple[0]; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- _tuple$1 = $assertType(err, scanner.ErrorList, true); list = _tuple$1[0]; ok = _tuple$1[1];
- /* */ if (ok) { $s = 4; continue; }
- /* */ $s = 5; continue;
- /* if (ok) { */ case 4:
- _ref = list;
- _i = 0;
- /* while (true) { */ case 6:
- /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 7; continue; }
- entry = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]);
- _r$3 = entry.Error(); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- output = $append(output, (_map = new $Map(), _key = "type", _map[$String.keyFor(_key)] = { k: _key, v: "err" }, _key = "content", _map[$String.keyFor(_key)] = { k: _key, v: _r$3 }, _map));
- _i++;
- /* } */ $s = 6; continue; case 7:
- scope[0].Object.output = $externalize(output, sliceType);
- return;
- /* } */ case 5:
- _r$4 = err.Error(); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- scope[0].Object.output = $externalize(new sliceType([(_map$1 = new $Map(), _key$1 = "type", _map$1[$String.keyFor(_key$1)] = { k: _key$1, v: "err" }, _key$1 = "content", _map$1[$String.keyFor(_key$1)] = { k: _key$1, v: _r$4 }, _map$1)]), sliceType);
- return;
- /* } */ case 3:
- _r$5 = compiler.Compile("main", new sliceType$4([file]), fileSet[0], importContext[0], false); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; }
- _tuple$2 = _r$5; mainPkg = _tuple$2[0]; err = _tuple$2[1];
- _key$2 = "main"; (packages[0] || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$2)] = { k: _key$2, v: mainPkg };
- /* */ if (!($interfaceIsEqual(err, $ifaceNil)) && ($keys(pkgsToLoad[0]).length === 0)) { $s = 11; continue; }
- /* */ $s = 12; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil)) && ($keys(pkgsToLoad[0]).length === 0)) { */ case 11:
- _tuple$3 = $assertType(err, compiler.ErrorList, true); list$1 = _tuple$3[0]; ok$1 = _tuple$3[1];
- /* */ if (ok$1) { $s = 13; continue; }
- /* */ $s = 14; continue;
- /* if (ok$1) { */ case 13:
- output$1 = sliceType.nil;
- _ref$1 = list$1;
- _i$1 = 0;
- /* while (true) { */ case 15:
- /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 16; continue; }
- entry$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]);
- _r$6 = entry$1.Error(); /* */ $s = 17; case 17: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; }
- output$1 = $append(output$1, (_map$2 = new $Map(), _key$3 = "type", _map$2[$String.keyFor(_key$3)] = { k: _key$3, v: "err" }, _key$3 = "content", _map$2[$String.keyFor(_key$3)] = { k: _key$3, v: _r$6 }, _map$2));
- _i$1++;
- /* } */ $s = 15; continue; case 16:
- scope[0].Object.output = $externalize(output$1, sliceType);
- return;
- /* } */ case 14:
- _r$7 = err.Error(); /* */ $s = 18; case 18: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; }
- scope[0].Object.output = $externalize(new sliceType([(_map$3 = new $Map(), _key$4 = "type", _map$3[$String.keyFor(_key$4)] = { k: _key$4, v: "err" }, _key$4 = "content", _map$3[$String.keyFor(_key$4)] = { k: _key$4, v: _r$7 }, _map$3)]), sliceType);
- return;
- /* } */ case 12:
- allPkgs = sliceType$5.nil;
- /* */ if ($keys(pkgsToLoad[0]).length === 0) { $s = 19; continue; }
- /* */ $s = 20; continue;
- /* if ($keys(pkgsToLoad[0]).length === 0) { */ case 19:
- _r$8 = compiler.ImportDependencies(mainPkg, importContext[0].Import); /* */ $s = 21; case 21: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; }
- _tuple$4 = _r$8; allPkgs = _tuple$4[0];
- /* } */ case 20:
- /* */ if (!(($keys(pkgsToLoad[0]).length === 0))) { $s = 22; continue; }
- /* */ $s = 23; continue;
- /* if (!(($keys(pkgsToLoad[0]).length === 0))) { */ case 22:
- pkgsReceived[0] = 0;
- _ref$2 = pkgsToLoad[0];
- _i$2 = 0;
- _keys = $keys(_ref$2);
- while (true) {
- if (!(_i$2 < _keys.length)) { break; }
- req$1 = [req$1];
- _entry = _ref$2[_keys[_i$2]];
- if (_entry === undefined) {
- _i$2++;
- continue;
- }
- path = _entry.k;
- req$1[0] = xhr.NewRequest("GET", "pkg/" + path + ".a.js");
- req$1[0].Object.responseType = $externalize("arraybuffer", $String);
- $go((function(codeArea, codeReady, fileSet, id, importContext, loadOnly, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope) { return function $b(path$1) {
- var $ptr, _key$5, _r$10, _r$9, _tuple$5, data, err$1, path$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key$5 = $f._key$5; _r$10 = $f._r$10; _r$9 = $f._r$9; _tuple$5 = $f._tuple$5; data = $f.data; err$1 = $f.err$1; path$1 = $f.path$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- err$1 = [err$1];
- path$1 = [path$1];
- _r$9 = req$1[0].Send($ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- err$1[0] = _r$9;
- /* */ if (!($interfaceIsEqual(err$1[0], $ifaceNil)) || !((($parseInt(req$1[0].Object.status) >> 0) === 200))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err$1[0], $ifaceNil)) || !((($parseInt(req$1[0].Object.status) >> 0) === 200))) { */ case 2:
- scope[0].Apply((function(codeArea, codeReady, err$1, fileSet, id, importContext, loadOnly, location, packages, path$1, pkgsReceived, pkgsToLoad, req, req$1, run, scope) { return function() {
- var $ptr, _key$5, _map$4;
- scope[0].Object.output = $externalize(new sliceType([(_map$4 = new $Map(), _key$5 = "type", _map$4[$String.keyFor(_key$5)] = { k: _key$5, v: "err" }, _key$5 = "content", _map$4[$String.keyFor(_key$5)] = { k: _key$5, v: "failed to load package \"" + path$1[0] + "\"" }, _map$4)]), sliceType);
- }; })(codeArea, codeReady, err$1, fileSet, id, importContext, loadOnly, location, packages, path$1, pkgsReceived, pkgsToLoad, req, req$1, run, scope));
- return;
- /* } */ case 3:
- data = $assertType($internalize(new ($global.Uint8Array)(req$1[0].Object.response), $emptyInterface), sliceType$2);
- _r$10 = compiler.ReadArchive(path$1[0] + ".a", path$1[0], bytes.NewReader(data), importContext[0].Packages); /* */ $s = 4; case 4: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; }
- _tuple$5 = _r$10; _key$5 = path$1[0]; (packages[0] || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$5)] = { k: _key$5, v: _tuple$5[0] }; err$1[0] = _tuple$5[1];
- /* */ if (!($interfaceIsEqual(err$1[0], $ifaceNil))) { $s = 5; continue; }
- /* */ $s = 6; continue;
- /* if (!($interfaceIsEqual(err$1[0], $ifaceNil))) { */ case 5:
- scope[0].Apply((function(codeArea, codeReady, err$1, fileSet, id, importContext, loadOnly, location, packages, path$1, pkgsReceived, pkgsToLoad, req, req$1, run, scope) { return function $b() {
- var $ptr, _key$6, _map$4, _r$11, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key$6 = $f._key$6; _map$4 = $f._map$4; _r$11 = $f._r$11; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$11 = err$1[0].Error(); /* */ $s = 1; case 1: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; }
- scope[0].Object.output = $externalize(new sliceType([(_map$4 = new $Map(), _key$6 = "type", _map$4[$String.keyFor(_key$6)] = { k: _key$6, v: "err" }, _key$6 = "content", _map$4[$String.keyFor(_key$6)] = { k: _key$6, v: _r$11 }, _map$4)]), sliceType);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._key$6 = _key$6; $f._map$4 = _map$4; $f._r$11 = _r$11; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, err$1, fileSet, id, importContext, loadOnly, location, packages, path$1, pkgsReceived, pkgsToLoad, req, req$1, run, scope));
- return;
- /* } */ case 6:
- pkgsReceived[0] = pkgsReceived[0] + (1) >> 0;
- /* */ if (pkgsReceived[0] === $keys(pkgsToLoad[0]).length) { $s = 7; continue; }
- /* */ $s = 8; continue;
- /* if (pkgsReceived[0] === $keys(pkgsToLoad[0]).length) { */ case 7:
- $r = run[0](loadOnly[0]); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* } */ case 8:
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._key$5 = _key$5; $f._r$10 = _r$10; $f._r$9 = _r$9; $f._tuple$5 = _tuple$5; $f.data = data; $f.err$1 = err$1; $f.path$1 = path$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, importContext, loadOnly, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope), [path]);
- _i$2++;
- }
- return;
- /* } */ case 23:
- if (loadOnly[0]) {
- return;
- }
- jsCode = bytes.NewBuffer(sliceType$2.nil);
- jsCode.WriteString("try{\n");
- _r$9 = compiler.WriteProgramCode(allPkgs, new compiler.SourceMapFilter.ptr(jsCode, $throwNilPointerError, 0, 0, ptrType$4.nil)); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; }
- _r$9;
- jsCode.WriteString("} catch (err) {\ngoPanicHandler(err.message);\n}\n");
- $checkForDeadlock = $externalize(true, $Bool);
- $global.eval(jsCode.String());
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._entry = _entry; $f._i = _i; $f._i$1 = _i$1; $f._i$2 = _i$2; $f._key = _key; $f._key$1 = _key$1; $f._key$2 = _key$2; $f._key$3 = _key$3; $f._key$4 = _key$4; $f._keys = _keys; $f._map = _map; $f._map$1 = _map$1; $f._map$2 = _map$2; $f._map$3 = _map$3; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._r$6 = _r$6; $f._r$7 = _r$7; $f._r$8 = _r$8; $f._r$9 = _r$9; $f._ref = _ref; $f._ref$1 = _ref$1; $f._ref$2 = _ref$2; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $f.allPkgs = allPkgs; $f.entry = entry; $f.entry$1 = entry$1; $f.err = err; $f.file = file; $f.jsCode = jsCode; $f.list = list; $f.list$1 = list$1; $f.loadOnly = loadOnly; $f.mainPkg = mainPkg; $f.ok = ok; $f.ok$1 = ok$1; $f.output$1 = output$1; $f.path = path; $f.req$1 = req$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope);
- scope[0].Object.run = $externalize(run[0], funcType);
- $go((function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function $b() {
- var $ptr, _r$2, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = $recv(codeReady[0]); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$2[0];
- $r = run[0](true); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope), []);
- scope[0].Object.format = $externalize((function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function $b() {
- var $ptr, _key, _map, _r$2, _r$3, _tuple, err, out, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _key = $f._key; _map = $f._map; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; err = $f.err; out = $f.out; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- _r$2 = format.Source(new sliceType$2($stringToBytes($internalize(scope[0].Object.code, $String)))); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _tuple = _r$2; out = _tuple[0]; err = _tuple[1];
- /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 2; continue; }
- /* */ $s = 3; continue;
- /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 2:
- _r$3 = err.Error(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- scope[0].Object.output = $externalize(new sliceType([(_map = new $Map(), _key = "type", _map[$String.keyFor(_key)] = { k: _key, v: "err" }, _key = "content", _map[$String.keyFor(_key)] = { k: _key, v: _r$3 }, _map)]), sliceType);
- return;
- /* } */ case 3:
- scope[0].Object.code = $externalize($bytesToString(out), $String);
- scope[0].Object.output = $externalize(new sliceType([]), sliceType);
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._key = _key; $f._map = _map; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.err = err; $f.out = out; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope), funcType$1);
- scope[0].Object.share = $externalize((function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function() {
- var $ptr, req$1;
- req$1 = xhr.NewRequest("POST", "http://snippets.gopherjs.org/share");
- req$1.Object.responseType = $externalize("arraybuffer", $String);
- $go((function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function $b() {
- var $ptr, _r$2, data, err, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; data = $f.data; err = $f.err; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- data = [data];
- _r$2 = req$1.Send(new sliceType$2($stringToBytes($internalize(scope[0].Object.code, $String)))); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- err = _r$2;
- if (!($interfaceIsEqual(err, $ifaceNil)) || !((($parseInt(req$1.Object.status) >> 0) === 200))) {
- scope[0].Apply((function(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function() {
- var $ptr, _key, _map;
- scope[0].Object.output = $externalize(new sliceType([(_map = new $Map(), _key = "type", _map[$String.keyFor(_key)] = { k: _key, v: "err" }, _key = "content", _map[$String.keyFor(_key)] = { k: _key, v: "failed to share snippet" }, _map)]), sliceType);
- }; })(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- return;
- }
- data[0] = $assertType($internalize(new ($global.Uint8Array)(req$1.Object.response), $emptyInterface), sliceType$2);
- scope[0].Apply((function(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function() {
- var $ptr, id$1;
- id$1 = $bytesToString(data[0]);
- location[0].URLUtils.Object.hash = $externalize("#/" + id$1, $String);
- scope[0].Object.shareUrl = $externalize($internalize(location[0].Object, $String), $String);
- scope[0].Object.showShareUrl = $externalize(true, $Bool);
- $go((function(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function $b() {
- var $ptr, _r$3, _r$4, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$3 = $f._r$3; _r$4 = $f._r$4; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = time.Sleep(new time.Duration(0, 1000000)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- _r$3 = dom.GetWindow().Document(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$4 = _r$3.GetElementByID("share-url"); /* */ $s = 3; case 3: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; }
- $r = $assertType(_r$4, ptrType$5).Select(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope), []);
- }; })(codeArea, codeReady, data, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.data = data; $f.err = err; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope), []);
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope), funcType$1);
- _r$2 = dom.GetWindow().Top(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; }
- _r$3 = _r$2.AddEventListener("hashchange", false, (function(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope) { return function $b(event) {
- var $ptr, event, id$1, req$1, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; event = $f.event; id$1 = $f.id$1; req$1 = $f.req$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- id$1 = [id$1];
- req$1 = [req$1];
- $r = event.PreventDefault(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- if (strings.HasPrefix($internalize(location[0].URLUtils.Object.hash, $String), "#/")) {
- id$1[0] = $internalize(location[0].URLUtils.Object.hash, $String).substring(2);
- req$1[0] = xhr.NewRequest("GET", "http://snippets.gopherjs.org/p/" + id$1[0]);
- req$1[0].Object.responseType = $externalize("arraybuffer", $String);
- $go((function(codeArea, codeReady, fileSet, id, id$1, importContext, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope) { return function $b() {
- var $ptr, _r$3, data, err, $s, $r;
- /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$3 = $f._r$3; data = $f.data; err = $f.err; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- data = [data];
- _r$3 = req$1[0].Send($ifaceNil); /* */ $s = 1; case 1: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- err = _r$3;
- if (!($interfaceIsEqual(err, $ifaceNil)) || !((($parseInt(req$1[0].Object.status) >> 0) === 200))) {
- scope[0].Apply((function(codeArea, codeReady, data, fileSet, id, id$1, importContext, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope) { return function() {
- var $ptr, _key, _map;
- scope[0].Object.output = $externalize(new sliceType([(_map = new $Map(), _key = "type", _map[$String.keyFor(_key)] = { k: _key, v: "err" }, _key = "content", _map[$String.keyFor(_key)] = { k: _key, v: "failed to load snippet \"" + id$1[0] + "\"" }, _map)]), sliceType);
- }; })(codeArea, codeReady, data, fileSet, id, id$1, importContext, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope));
- return;
- }
- data[0] = $assertType($internalize(new ($global.Uint8Array)(req$1[0].Object.response), $emptyInterface), sliceType$2);
- scope[0].Apply((function(codeArea, codeReady, data, fileSet, id, id$1, importContext, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope) { return function() {
- var $ptr;
- scope[0].Object.code = $externalize($bytesToString(data[0]), $String);
- }; })(codeArea, codeReady, data, fileSet, id, id$1, importContext, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$3 = _r$3; $f.data = data; $f.err = err; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, id$1, importContext, location, packages, pkgsReceived, pkgsToLoad, req, req$1, run, scope), []);
- }
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.event = event; $f.id$1 = id$1; $f.req$1 = req$1; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeArea, codeReady, fileSet, id, importContext, location, packages, pkgsReceived, pkgsToLoad, req, run, scope)); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; }
- _r$3;
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.codeArea = codeArea; $f.fileSet = fileSet; $f.id = id; $f.importContext = importContext; $f.packages = packages; $f.pkgsReceived = pkgsReceived; $f.pkgsToLoad = pkgsToLoad; $f.req = req; $f.run = run; $f.scope = scope; $f.$s = $s; $f.$r = $r; return $f;
- }; })(codeReady, location));
- /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: main }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.app = app; $f.codeReady = codeReady; $f.location = location; $f.$s = $s; $f.$r = $r; return $f;
- };
- setupEnvironment = function(scope) {
- var $ptr, scope;
- $global.goPrintToConsole = (function(b) {
- var $ptr, _entry, _entry$1, _index, _key, _key$1, _key$2, _map, _map$1, b, i, lines, x;
- lines = strings.Split($bytesToString(b), "\n");
- if ((output.$length === 0) || !((_entry = (x = output.$length - 1 >> 0, ((x < 0 || x >= output.$length) ? $throwRuntimeError("index out of range") : output.$array[output.$offset + x]))[$String.keyFor("type")], _entry !== undefined ? _entry.v : "") === "out")) {
- output = $append(output, (_map = new $Map(), _key = "type", _map[$String.keyFor(_key)] = { k: _key, v: "out" }, _key = "content", _map[$String.keyFor(_key)] = { k: _key, v: "" }, _map));
- }
- _index = output.$length - 1 >> 0;
- _key$1 = "content"; (((_index < 0 || _index >= output.$length) ? $throwRuntimeError("index out of range") : output.$array[output.$offset + _index]) || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key$1)] = { k: _key$1, v: (_entry$1 = ((_index < 0 || _index >= output.$length) ? $throwRuntimeError("index out of range") : output.$array[output.$offset + _index])[$String.keyFor("content")], _entry$1 !== undefined ? _entry$1.v : "") + ((0 >= lines.$length ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + 0])) };
- i = 1;
- while (true) {
- if (!(i < lines.$length)) { break; }
- output = $append(output, (_map$1 = new $Map(), _key$2 = "type", _map$1[$String.keyFor(_key$2)] = { k: _key$2, v: "out" }, _key$2 = "content", _map$1[$String.keyFor(_key$2)] = { k: _key$2, v: ((i < 0 || i >= lines.$length) ? $throwRuntimeError("index out of range") : lines.$array[lines.$offset + i]) }, _map$1));
- i = i + (1) >> 0;
- }
- scope.Object.output = $externalize(output, sliceType);
- scope.EvalAsync((function() {
- var $ptr;
- time.AfterFunc(new time.Duration(0, 0), (function() {
- var $ptr, box;
- box = angularjs.ElementById("output");
- box.SetProp(new $String("scrollTop"), new $jsObjectPtr(box.Prop("scrollHeight")));
- }));
- }));
- });
- $global.goPanicHandler = (function(msg) {
- var $ptr, _key, _map, msg;
- output = $append(output, (_map = new $Map(), _key = "type", _map[$String.keyFor(_key)] = { k: _key, v: "err" }, _key = "content", _map[$String.keyFor(_key)] = { k: _key, v: "panic: " + msg }, _map));
- scope.Object.output = $externalize(output, sliceType);
- });
- };
- Line.init($String, $String);
- $init = function() {
- $pkg.$init = function() {};
- /* */ var $f, $c = false, $s = 0, $r; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0:
- $r = bytes.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = compiler.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = js.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = angularjs.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = ast.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = format.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = parser.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = scanner.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = token.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = dom.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = xhr.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = strings.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- $r = time.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- output = sliceType.nil;
- $r = main(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; }
- /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f;
- };
- $pkg.$init = $init;
- return $pkg;
-})();
+var $goVersion = "go1.18.6";
+Error.stackTraceLimit=1/0;var $global,$module,$NaN=NaN;if("undefined"!=typeof window?$global=window:"undefined"!=typeof self?$global=self:"undefined"!=typeof global?($global=global).require=require:$global=this,void 0===$global||void 0===$global.Array)throw new Error("no global object found");if("undefined"!=typeof module&&($module=module),!$global.fs&&$global.require)try{var fs=$global.require("fs");"object"==typeof fs&&null!==fs&&0!==Object.keys(fs).length&&($global.fs=fs)}catch(e){}if(!$global.fs){var outputBuf="",decoder=new TextDecoder("utf-8");$global.fs={constants:{O_WRONLY:-1,O_RDWR:-1,O_CREAT:-1,O_TRUNC:-1,O_APPEND:-1,O_EXCL:-1},writeSync:function(e,n){var r=(outputBuf+=decoder.decode(n)).lastIndexOf("\n");return-1!=r&&(console.log(outputBuf.substr(0,r)),outputBuf=outputBuf.substr(r+1)),n.length},write:function(e,n,r,t,i,a){0===r&&t===n.length&&null===i?a(null,this.writeSync(e,n)):a(enosys())}}}var $throwRuntimeError,$linknames={},$packages={},$idCounter=0,$keys=function(e){return e?Object.keys(e):[]},$flushConsole=function(){},$throwNilPointerError=function(){$throwRuntimeError("invalid memory address or nil pointer dereference")},$call=function(e,n,r){return e.apply(n,r)},$makeFunc=function(e){return function(){return $externalize(e(this,new($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments,[]))),$emptyInterface)}},$unused=function(e){},$print=console.log;if(void 0!==$global.process&&$global.require)try{var util=$global.require("util");$print=function(){$global.process.stderr.write(util.format.apply(this,arguments))}}catch(e){}var $println=console.log,$initAllLinknames=function(){for(var e=$keys($packages),n=0;ne.$capacity||t>e.$capacity)&&$throwRuntimeError("slice bounds out of range"),e===e.constructor.nil)return e;var i=new e.constructor(e.$array);return i.$offset=e.$offset+n,i.$length=r-n,i.$capacity=t-n,i},$substring=function(e,n,r){return(n<0||re.length)&&$throwRuntimeError("slice bounds out of range"),e.substring(n,r)},$sliceToNativeArray=function(e){return e.$array.constructor!==Array?e.$array.subarray(e.$offset,e.$offset+e.$length):e.$array.slice(e.$offset,e.$offset+e.$length)},$sliceToGoArray=function(e,n){var r=n.elem;return void 0!==r&&e.$length1114111||55296<=e&&e<=57343)&&(e=65533),e<=127?String.fromCharCode(e):e<=2047?String.fromCharCode(192|e>>6,128|63&e):e<=65535?String.fromCharCode(224|e>>12,128|e>>6&63,128|63&e):String.fromCharCode(240|e>>18,128|e>>12&63,128|e>>6&63,128|63&e)},$stringToBytes=function(e){for(var n=new Uint8Array(e.length),r=0;rt){for(var o=i-1;o>=0;o--)a.copy(e[r+o],n[t+o]);return}for(o=0;ot)for(o=i-1;o>=0;o--)e[r+o]=n[t+o];else for(o=0;oc)if(a=0,c=Math.max(o,e.$capacity<1024?2*e.$capacity:Math.floor(5*e.$capacity/4)),e.$array.constructor===Array){(i=e.$array.slice(e.$offset,e.$offset+e.$length)).length=c;for(var $=e.constructor.elem.zero,u=e.$length;u>>16&65535)*t+r*(n>>>16&65535)<<16>>>0)>>0},$floatKey=function(e){return e!=e?"NaN$"+ ++$idCounter:String(e)},$flatten64=function(e){return 4294967296*e.$high+e.$low},$shiftLeft64=function(e,n){return 0===n?e:n<32?new e.constructor(e.$high<>>32-n,e.$low<>>0):n<64?new e.constructor(e.$low<>n,(e.$low>>>n|e.$high<<32-n)>>>0):n<64?new e.constructor(e.$high>>31,e.$high>>n-32>>>0):e.$high<0?new e.constructor(-1,4294967295):new e.constructor(0,0)},$shiftRightUint64=function(e,n){return 0===n?e:n<32?new e.constructor(e.$high>>>n,(e.$low>>>n|e.$high<<32-n)>>>0):n<64?new e.constructor(0,e.$high>>>n-32):new e.constructor(0,0)},$mul64=function(e,n){var r=e.$high>>>16,t=65535&e.$high,i=e.$low>>>16,a=65535&e.$low,o=n.$high>>>16,c=65535&n.$high,$=n.$low>>>16,u=65535&n.$low,l=0,s=0,f=0,d=0;f+=(d+=a*u)>>>16,s+=(f+=i*u)>>>16,f&=65535,s+=(f+=a*$)>>>16,l+=(s+=t*u)>>>16,s&=65535,l+=(s+=i*$)>>>16,s&=65535,l+=(s+=a*c)>>>16,l+=r*u+t*$+i*c+a*o;var p=((l&=65535)<<16|(s&=65535))>>>0,h=((f&=65535)<<16|(d&=65535))>>>0;return new e.constructor(p,h)},$div64=function(e,n,r){0===n.$high&&0===n.$low&&$throwRuntimeError("integer divide by zero");var t=1,i=1,a=e.$high,o=e.$low;a<0&&(t=-1,i=-1,a=-a,0!==o&&(a--,o=4294967296-o));var c=n.$high,$=n.$low;n.$high<0&&(t*=-1,c=-c,0!==$&&(c--,$=4294967296-$));for(var u=0,l=0,s=0;c<2147483648&&(a>c||a===c&&o>$);)c=(c<<1|$>>>31)>>>0,$=$<<1>>>0,s++;for(var f=0;f<=s;f++)u=u<<1|l>>>31,l=l<<1>>>0,(a>c||a===c&&o>=$)&&(a-=c,(o-=$)<0&&(a--,o+=4294967296),4294967296===++l&&(u++,l=0)),$=($>>>1|c<<31)>>>0,c>>>=1;return r?new e.constructor(a*i,o*i):new e.constructor(u*t,l*t)},$divComplex=function(e,n){var r=e.$real===1/0||e.$real===-1/0||e.$imag===1/0||e.$imag===-1/0,t=n.$real===1/0||n.$real===-1/0||n.$imag===1/0||n.$imag===-1/0,i=!r&&(e.$real!=e.$real||e.$imag!=e.$imag),a=!t&&(n.$real!=n.$real||n.$imag!=n.$imag);if(i||a)return new e.constructor(NaN,NaN);if(r&&!t)return new e.constructor(1/0,1/0);if(!r&&t)return new e.constructor(0,0);if(0===n.$real&&0===n.$imag)return 0===e.$real&&0===e.$imag?new e.constructor(NaN,NaN):new e.constructor(1/0,1/0);if(Math.abs(n.$real)<=Math.abs(n.$imag)){var o=n.$real/n.$imag,c=n.$real*o+n.$imag;return new e.constructor((e.$real*o+e.$imag)/c,(e.$imag*o-e.$real)/c)}o=n.$imag/n.$real,c=n.$imag*o+n.$real;return new e.constructor((e.$imag*o+e.$real)/c,(e.$imag-e.$real*o)/c)},$kindBool=1,$kindInt=2,$kindInt8=3,$kindInt16=4,$kindInt32=5,$kindInt64=6,$kindUint=7,$kindUint8=8,$kindUint16=9,$kindUint32=10,$kindUint64=11,$kindUintptr=12,$kindFloat32=13,$kindFloat64=14,$kindComplex64=15,$kindComplex128=16,$kindArray=17,$kindChan=18,$kindFunc=19,$kindInterface=20,$kindMap=21,$kindPtr=22,$kindSlice=23,$kindString=24,$kindStruct=25,$kindUnsafePointer=26,$methodSynthesizers=[],$addMethodSynthesizer=function(e){null!==$methodSynthesizers?$methodSynthesizers.push(e):e()},$synthesizeMethods=function(){$methodSynthesizers.forEach(function(e){e()}),$methodSynthesizers=null},$ifaceKeyFor=function(e){if(e===$ifaceNil)return"nil";var n=e.constructor;return n.string+"$"+n.keyFor(e.$val)},$identity=function(e){return e},$typeIDCounter=0,$idKey=function(e){return void 0===e.$id&&($idCounter++,e.$id=$idCounter),String(e.$id)},$arrayPtrCtor=function(){return function(e){this.$get=function(){return e},this.$set=function(e){typ.copy(this,e)},this.$val=e}},$newType=function(e,n,r,t,i,a,o){var c;switch(n){case $kindBool:case $kindInt:case $kindInt8:case $kindInt16:case $kindInt32:case $kindUint:case $kindUint8:case $kindUint16:case $kindUint32:case $kindUintptr:case $kindUnsafePointer:(c=function(e){this.$val=e}).wrapped=!0,c.keyFor=$identity;break;case $kindString:(c=function(e){this.$val=e}).wrapped=!0,c.keyFor=function(e){return"$"+e};break;case $kindFloat32:case $kindFloat64:(c=function(e){this.$val=e}).wrapped=!0,c.keyFor=function(e){return $floatKey(e)};break;case $kindInt64:(c=function(e,n){this.$high=e+Math.floor(Math.ceil(n)/4294967296)>>0,this.$low=n>>>0,this.$val=this}).keyFor=function(e){return e.$high+"$"+e.$low};break;case $kindUint64:(c=function(e,n){this.$high=e+Math.floor(Math.ceil(n)/4294967296)>>>0,this.$low=n>>>0,this.$val=this}).keyFor=function(e){return e.$high+"$"+e.$low};break;case $kindComplex64:(c=function(e,n){this.$real=$fround(e),this.$imag=$fround(n),this.$val=this}).keyFor=function(e){return e.$real+"$"+e.$imag};break;case $kindComplex128:(c=function(e,n){this.$real=e,this.$imag=n,this.$val=this}).keyFor=function(e){return e.$real+"$"+e.$imag};break;case $kindArray:(c=function(e){this.$val=e}).wrapped=!0,c.ptr=$newType(4,$kindPtr,"*"+r,!1,"",!1,$arrayPtrCtor()),c.init=function(e,n){c.elem=e,c.len=n,c.comparable=e.comparable,c.keyFor=function(n){return Array.prototype.join.call($mapArray(n,function(n){return String(e.keyFor(n)).replace(/\\/g,"\\\\").replace(/\$/g,"\\$")}),"$")},c.copy=function(n,r){$copyArray(n,r,0,0,r.length,e)},c.ptr.init(c),Object.defineProperty(c.ptr.nil,"nilCheck",{get:$throwNilPointerError})};break;case $kindChan:(c=function(e){this.$val=e}).wrapped=!0,c.keyFor=$idKey,c.init=function(e,n,r){c.elem=e,c.sendOnly=n,c.recvOnly=r};break;case $kindFunc:(c=function(e){this.$val=e}).wrapped=!0,c.init=function(e,n,r){c.params=e,c.results=n,c.variadic=r,c.comparable=!1};break;case $kindInterface:(c={implementedBy:{},missingMethodFor:{}}).keyFor=$ifaceKeyFor,c.init=function(e){c.methods=e,e.forEach(function(e){$ifaceNil[e.prop]=$throwNilPointerError})};break;case $kindMap:(c=function(e){this.$val=e}).wrapped=!0,c.init=function(e,n){c.key=e,c.elem=n,c.comparable=!1};break;case $kindPtr:(c=o||function(e,n,r){this.$get=e,this.$set=n,this.$target=r,this.$val=this}).keyFor=$idKey,c.init=function(e){c.elem=e,c.wrapped=e.kind===$kindArray,c.nil=new c($throwNilPointerError,$throwNilPointerError)};break;case $kindSlice:(c=function(e){e.constructor!==c.nativeArray&&(e=new c.nativeArray(e)),this.$array=e,this.$offset=0,this.$length=e.length,this.$capacity=e.length,this.$val=this}).init=function(e){c.elem=e,c.comparable=!1,c.nativeArray=$nativeArray(e.kind),c.nil=new c([])};break;case $kindStruct:(c=function(e){this.$val=e}).wrapped=!0,c.ptr=$newType(4,$kindPtr,"*"+r,!1,i,a,o),c.ptr.elem=c,c.ptr.prototype.$get=function(){return this},c.ptr.prototype.$set=function(e){c.copy(this,e)},c.init=function(e,n){c.pkgPath=e,c.fields=n,n.forEach(function(e){e.typ.comparable||(c.comparable=!1)}),c.keyFor=function(e){var r=e.$val;return $mapArray(n,function(e){return String(e.typ.keyFor(r[e.prop])).replace(/\\/g,"\\\\").replace(/\$/g,"\\$")}).join("$")},c.copy=function(e,r){for(var t=0;t0;){var a=[],o=[];t.forEach(function(e){if(!i[e.typ.string])switch(i[e.typ.string]=!0,e.typ.named&&(o=o.concat(e.typ.methods),e.indirect&&(o=o.concat($ptrType(e.typ).methods))),e.typ.kind){case $kindStruct:e.typ.fields.forEach(function(n){if(n.embedded){var r=n.typ,t=r.kind===$kindPtr;a.push({typ:t?r.elem:r,indirect:e.indirect||t})}});break;case $kindInterface:o=o.concat(e.typ.methods)}}),o.forEach(function(e){void 0===n[e.name]&&(n[e.name]=e)}),t=a}return e.methodSetCache=[],Object.keys(n).sort().forEach(function(r){e.methodSetCache.push(n[r])}),e.methodSetCache},$Bool=$newType(1,$kindBool,"bool",!0,"",!1,null),$Int=$newType(4,$kindInt,"int",!0,"",!1,null),$Int8=$newType(1,$kindInt8,"int8",!0,"",!1,null),$Int16=$newType(2,$kindInt16,"int16",!0,"",!1,null),$Int32=$newType(4,$kindInt32,"int32",!0,"",!1,null),$Int64=$newType(8,$kindInt64,"int64",!0,"",!1,null),$Uint=$newType(4,$kindUint,"uint",!0,"",!1,null),$Uint8=$newType(1,$kindUint8,"uint8",!0,"",!1,null),$Uint16=$newType(2,$kindUint16,"uint16",!0,"",!1,null),$Uint32=$newType(4,$kindUint32,"uint32",!0,"",!1,null),$Uint64=$newType(8,$kindUint64,"uint64",!0,"",!1,null),$Uintptr=$newType(4,$kindUintptr,"uintptr",!0,"",!1,null),$Float32=$newType(4,$kindFloat32,"float32",!0,"",!1,null),$Float64=$newType(8,$kindFloat64,"float64",!0,"",!1,null),$Complex64=$newType(8,$kindComplex64,"complex64",!0,"",!1,null),$Complex128=$newType(16,$kindComplex128,"complex128",!0,"",!1,null),$String=$newType(8,$kindString,"string",!0,"",!1,null),$UnsafePointer=$newType(4,$kindUnsafePointer,"unsafe.Pointer",!0,"unsafe",!1,null),$nativeArray=function(e){switch(e){case $kindInt:return Int32Array;case $kindInt8:return Int8Array;case $kindInt16:return Int16Array;case $kindInt32:return Int32Array;case $kindUint:return Uint32Array;case $kindUint8:return Uint8Array;case $kindUint16:return Uint16Array;case $kindUint32:case $kindUintptr:return Uint32Array;case $kindFloat32:return Float32Array;case $kindFloat64:return Float64Array;default:return Array}},$toNativeArray=function(e,n){var r=$nativeArray(e);return r===Array?n:new r(n)},$arrayTypes={},$arrayType=function(e,n){var r=e.id+"$"+n,t=$arrayTypes[r];return void 0===t&&(t=$newType(12,$kindArray,"["+n+"]"+e.string,!1,"",!1,null),$arrayTypes[r]=t,t.init(e,n)),t},$chanType=function(e,n,r){var t=(r?"<-":"")+"chan"+(n?"<- ":" ");n||r||"<"!=e.string[0]?t+=e.string:t+="("+e.string+")";var i=n?"SendChan":r?"RecvChan":"Chan",a=e[i];return void 0===a&&(a=$newType(4,$kindChan,t,!1,"",!1,null),e[i]=a,a.init(e,n,r)),a},$Chan=function(e,n){(n<0||n>2147483647)&&$throwRuntimeError("makechan: size out of range"),this.$elem=e,this.$capacity=n,this.$buffer=[],this.$sendQueue=[],this.$recvQueue=[],this.$closed=!1},$chanNil=new $Chan(null,0);$chanNil.$sendQueue=$chanNil.$recvQueue={length:0,push:function(){},shift:function(){},indexOf:function(){return-1}};var $funcTypes={},$funcType=function(e,n,r){var t=$mapArray(e,function(e){return e.id}).join(",")+"$"+$mapArray(n,function(e){return e.id}).join(",")+"$"+r,i=$funcTypes[t];if(void 0===i){var a=$mapArray(e,function(e){return e.string});r&&(a[a.length-1]="..."+a[a.length-1].substr(2));var o="func("+a.join(", ")+")";1===n.length?o+=" "+n[0].string:n.length>1&&(o+=" ("+$mapArray(n,function(e){return e.string}).join(", ")+")"),i=$newType(4,$kindFunc,o,!1,"",!1,null),$funcTypes[t]=i,i.init(e,n,r)}return i},$interfaceTypes={},$interfaceType=function(e){var n=$mapArray(e,function(e){return e.pkg+","+e.name+","+e.typ.id}).join("$"),r=$interfaceTypes[n];if(void 0===r){var t="interface {}";0!==e.length&&(t="interface { "+$mapArray(e,function(e){return(""!==e.pkg?e.pkg+".":"")+e.name+e.typ.string.substr(4)}).join("; ")+" }"),r=$newType(8,$kindInterface,t,!1,"",!1,null),$interfaceTypes[n]=r,r.init(e)}return r},$emptyInterface=$interfaceType([]),$ifaceNil={},$error=$newType(8,$kindInterface,"error",!0,"",!1,null);$error.init([{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],!1)}]);var $panicValue,$jsObjectPtr,$jsErrorPtr,$mapTypes={},$mapType=function(e,n){var r=e.id+"$"+n.id,t=$mapTypes[r];return void 0===t&&(t=$newType(4,$kindMap,"map["+e.string+"]"+n.string,!1,"",!1,null),$mapTypes[r]=t,t.init(e,n)),t},$makeMap=function(e,n){for(var r=new Map,t=0;t2147483647)&&$throwRuntimeError("makeslice: len out of range"),(r<0||r2147483647)&&$throwRuntimeError("makeslice: cap out of range");var t=new e.nativeArray(r);if(e.nativeArray===Array)for(var i=0;i4||t<0)break}}finally{0==$scheduled.length&&clearTimeout(e)}},$schedule=function(e){e.asleep&&(e.asleep=!1,$awakeGoroutines++),$scheduled.push(e),$curGoroutine===$noGoroutine&&$runScheduled()},$setTimeout=function(e,n){return $awakeGoroutines++,setTimeout(function(){$awakeGoroutines--,e()},n)},$block=function(){$curGoroutine===$noGoroutine&&$throwRuntimeError("cannot block in JavaScript callback, fix by wrapping code in goroutine"),$curGoroutine.asleep=!0},$restore=function(e,n){return void 0!==e&&void 0!==e.$blk?e:n},$send=function(e,n){e.$closed&&$throwRuntimeError("send on closed channel");var r=e.$recvQueue.shift();if(void 0===r){if(!(e.$buffer.length65535){var l=Math.floor((u-65536)/1024)+55296,s=(u-65536)%1024+56320;$+=String.fromCharCode(l,s)}else $+=String.fromCharCode(u)}return $;case $kindStruct:var f=$packages.time;if(void 0!==f&&e.constructor===f.Time.ptr){var d=$div64(e.UnixNano(),new $Int64(0,1e6));return new Date($flatten64(d))}var p={},h=function(e,n){if(n===$jsObjectPtr)return e;switch(n.kind){case $kindPtr:return e===n.nil?p:h(e.$get(),n.elem);case $kindStruct:var r=n.fields[0];return h(e[r.prop],r.typ);case $kindInterface:return h(e.$val,e.constructor);default:return p}},k=h(e,n);if(k!==p)return k;if(void 0!==r)return r(e);k={};for(a=0;a>24;case $kindInt16:return parseInt(e)<<16>>16;case $kindInt32:return parseInt(e)>>0;case $kindUint:return parseInt(e);case $kindUint8:return parseInt(e)<<24>>>24;case $kindUint16:return parseInt(e)<<16>>>16;case $kindUint32:case $kindUintptr:return parseInt(e)>>>0;case $kindInt64:case $kindUint64:return new n(0,e);case $kindFloat32:case $kindFloat64:return parseFloat(e);case $kindArray:return e.length!==n.len&&$throwRuntimeError("got array with wrong size from JavaScript native"),$mapArray(e,function(e){return $internalize(e,n.elem,i)});case $kindFunc:return function(){for(var t=[],a=0;a=128)return!1;return!0};
+
+$packages["github.com/gopherjs/gopherjs/js"]=(function(){var $pkg={},$init,A,B,J,K,M,N,O,S,T,E,F,L;A=$pkg.Object=$newType(0,$kindStruct,"js.Object",true,"github.com/gopherjs/gopherjs/js",true,function(object_){this.$val=this;if(arguments.length===0){this.object=null;return;}this.object=object_;});B=$pkg.Error=$newType(0,$kindStruct,"js.Error",true,"github.com/gopherjs/gopherjs/js",true,function(Object_){this.$val=this;if(arguments.length===0){this.Object=null;return;}this.Object=Object_;});J=$pkg.M=$newType(4,$kindMap,"js.M",true,"github.com/gopherjs/gopherjs/js",true,null);K=$pkg.S=$newType(12,$kindSlice,"js.S",true,"github.com/gopherjs/gopherjs/js",true,null);M=$sliceType($emptyInterface);N=$sliceType($String);O=$ptrType(A);S=$funcType([O],[],false);T=$ptrType(B);A.ptr.prototype.Get=function(a){var a,b;b=this;return b.object[$externalize(a,$String)];};A.prototype.Get=function(a){return this.$val.Get(a);};A.ptr.prototype.Set=function(a,b){var a,b,c;c=this;c.object[$externalize(a,$String)]=$externalize(b,$emptyInterface);};A.prototype.Set=function(a,b){return this.$val.Set(a,b);};A.ptr.prototype.Delete=function(a){var a,b;b=this;delete b.object[$externalize(a,$String)];};A.prototype.Delete=function(a){return this.$val.Delete(a);};A.ptr.prototype.Length=function(){var a;a=this;return $parseInt(a.object.length);};A.prototype.Length=function(){return this.$val.Length();};A.ptr.prototype.Index=function(a){var a,b;b=this;return b.object[a];};A.prototype.Index=function(a){return this.$val.Index(a);};A.ptr.prototype.SetIndex=function(a,b){var a,b,c;c=this;c.object[a]=$externalize(b,$emptyInterface);};A.prototype.SetIndex=function(a,b){return this.$val.SetIndex(a,b);};A.ptr.prototype.Call=function(a,b){var a,b,c,d;c=this;return(d=c.object,d[$externalize(a,$String)].apply(d,$externalize(b,M)));};A.prototype.Call=function(a,b){return this.$val.Call(a,b);};A.ptr.prototype.Invoke=function(a){var a,b;b=this;return b.object.apply(undefined,$externalize(a,M));};A.prototype.Invoke=function(a){return this.$val.Invoke(a);};A.ptr.prototype.New=function(a){var a,b;b=this;return new($global.Function.prototype.bind.apply(b.object,[undefined].concat($externalize(a,M))));};A.prototype.New=function(a){return this.$val.New(a);};A.ptr.prototype.Bool=function(){var a;a=this;return!!(a.object);};A.prototype.Bool=function(){return this.$val.Bool();};A.ptr.prototype.String=function(){var a;a=this;return $internalize(a.object,$String);};A.prototype.String=function(){return this.$val.String();};A.ptr.prototype.Int=function(){var a;a=this;return $parseInt(a.object)>>0;};A.prototype.Int=function(){return this.$val.Int();};A.ptr.prototype.Int64=function(){var a;a=this;return $internalize(a.object,$Int64);};A.prototype.Int64=function(){return this.$val.Int64();};A.ptr.prototype.Uint64=function(){var a;a=this;return $internalize(a.object,$Uint64);};A.prototype.Uint64=function(){return this.$val.Uint64();};A.ptr.prototype.Float=function(){var a;a=this;return $parseFloat(a.object);};A.prototype.Float=function(){return this.$val.Float();};A.ptr.prototype.Interface=function(){var a;a=this;return $internalize(a.object,$emptyInterface);};A.prototype.Interface=function(){return this.$val.Interface();};A.ptr.prototype.Unsafe=function(){var a;a=this;return a.object;};A.prototype.Unsafe=function(){return this.$val.Unsafe();};B.ptr.prototype.Error=function(){var a;a=this;return"JavaScript error: "+$internalize(a.Object.message,$String);};B.prototype.Error=function(){return this.$val.Error();};B.ptr.prototype.Stack=function(){var a;a=this;return $internalize(a.Object.stack,$String);};B.prototype.Stack=function(){return this.$val.Stack();};E=function(a){var a;return $makeFunc(a);};$pkg.MakeFunc=E;F=function(a){var a,b,c,d;if(a===null||a===undefined){return N.nil;}b=$global.Object.keys(a);c=$makeSlice(N,$parseInt(b.length));d=0;while(true){if(!(d<$parseInt(b.length))){break;}((d<0||d>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]=$internalize(b[d],$String));d=d+(1)>>0;}return c;};$pkg.Keys=F;L=function(){var a;a=new B.ptr(null);$unused(a);};O.methods=[{prop:"Get",name:"Get",pkg:"",typ:$funcType([$String],[O],false)},{prop:"Set",name:"Set",pkg:"",typ:$funcType([$String,$emptyInterface],[],false)},{prop:"Delete",name:"Delete",pkg:"",typ:$funcType([$String],[],false)},{prop:"Length",name:"Length",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Index",name:"Index",pkg:"",typ:$funcType([$Int],[O],false)},{prop:"SetIndex",name:"SetIndex",pkg:"",typ:$funcType([$Int,$emptyInterface],[],false)},{prop:"Call",name:"Call",pkg:"",typ:$funcType([$String,M],[O],true)},{prop:"Invoke",name:"Invoke",pkg:"",typ:$funcType([M],[O],true)},{prop:"New",name:"New",pkg:"",typ:$funcType([M],[O],true)},{prop:"Bool",name:"Bool",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Int",name:"Int",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Int64",name:"Int64",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Uint64",name:"Uint64",pkg:"",typ:$funcType([],[$Uint64],false)},{prop:"Float",name:"Float",pkg:"",typ:$funcType([],[$Float64],false)},{prop:"Interface",name:"Interface",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"Unsafe",name:"Unsafe",pkg:"",typ:$funcType([],[$Uintptr],false)}];T.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)},{prop:"Stack",name:"Stack",pkg:"",typ:$funcType([],[$String],false)}];A.init("github.com/gopherjs/gopherjs/js",[{prop:"object",name:"object",embedded:false,exported:false,typ:O,tag:""}]);B.init("",[{prop:"Object",name:"Object",embedded:true,exported:true,typ:O,tag:""}]);J.init($String,$emptyInterface);K.init($emptyInterface);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:L();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["runtime"]=(function(){var $pkg={},$init,A,C,D,L,U,V,AF,AT,AX,AY,AZ,BA,BB,BC,BD,BE,H,I,N,O,AM,E,F,J,K,M,P,Q,R,S,T,AE,AG,AJ,AN,AS,AU,AV,AW;A=$packages["github.com/gopherjs/gopherjs/js"];C=$pkg._type=$newType(0,$kindStruct,"runtime._type",true,"runtime",false,function(str_){this.$val=this;if(arguments.length===0){this.str="";return;}this.str=str_;});D=$pkg.TypeAssertionError=$newType(0,$kindStruct,"runtime.TypeAssertionError",true,"runtime",true,function(_interface_,concrete_,asserted_,missingMethod_){this.$val=this;if(arguments.length===0){this._interface=AZ.nil;this.concrete=AZ.nil;this.asserted=AZ.nil;this.missingMethod="";return;}this._interface=_interface_;this.concrete=concrete_;this.asserted=asserted_;this.missingMethod=missingMethod_;});L=$pkg.basicFrame=$newType(0,$kindStruct,"runtime.basicFrame",true,"runtime",false,function(FuncName_,File_,Line_,Col_){this.$val=this;if(arguments.length===0){this.FuncName="";this.File="";this.Line=0;this.Col=0;return;}this.FuncName=FuncName_;this.File=File_;this.Line=Line_;this.Col=Col_;});U=$pkg.Frames=$newType(0,$kindStruct,"runtime.Frames",true,"runtime",true,function(frames_,current_){this.$val=this;if(arguments.length===0){this.frames=BC.nil;this.current=0;return;}this.frames=frames_;this.current=current_;});V=$pkg.Frame=$newType(0,$kindStruct,"runtime.Frame",true,"runtime",true,function(PC_,Func_,Function_,File_,Line_,Entry_){this.$val=this;if(arguments.length===0){this.PC=0;this.Func=AX.nil;this.Function="";this.File="";this.Line=0;this.Entry=0;return;}this.PC=PC_;this.Func=Func_;this.Function=Function_;this.File=File_;this.Line=Line_;this.Entry=Entry_;});AF=$pkg.Func=$newType(0,$kindStruct,"runtime.Func",true,"runtime",true,function(name_,file_,line_,opaque_){this.$val=this;if(arguments.length===0){this.name="";this.file="";this.line=0;this.opaque=new BA.ptr();return;}this.name=name_;this.file=file_;this.line=line_;this.opaque=opaque_;});AT=$pkg.errorString=$newType(8,$kindString,"runtime.errorString",true,"runtime",false,null);AX=$ptrType(AF);AY=$sliceType(AX);AZ=$ptrType(C);BA=$structType("",[]);BB=$sliceType(L);BC=$sliceType(V);BD=$ptrType(D);BE=$ptrType(U);C.ptr.prototype.string=function(){var a;a=this;return a.str;};C.prototype.string=function(){return this.$val.string();};C.ptr.prototype.pkgpath=function(){var a;a=this;return"";};C.prototype.pkgpath=function(){return this.$val.pkgpath();};D.ptr.prototype.RuntimeError=function(){};D.prototype.RuntimeError=function(){return this.$val.RuntimeError();};D.ptr.prototype.Error=function(){var a,b,c,d,e;a=this;b="interface";if(!(a._interface===AZ.nil)){b=a._interface.string();}c=a.asserted.string();if(a.concrete===AZ.nil){return"interface conversion: "+b+" is nil, not "+c;}d=a.concrete.string();if(a.missingMethod===""){e="interface conversion: "+b+" is "+d+", not "+c;if(d===c){if(!(a.concrete.pkgpath()===a.asserted.pkgpath())){e=e+(" (types from different packages)");}else{e=e+(" (types from different scopes)");}}return e;}return"interface conversion: "+d+" is not "+c+": missing method "+a.missingMethod;};D.prototype.Error=function(){return this.$val.Error();};E=function(){var a,b;a=$packages[$externalize("github.com/gopherjs/gopherjs/js",$String)];$jsObjectPtr=a.Object.ptr;$jsErrorPtr=a.Error.ptr;$throwRuntimeError=AU;AM=$internalize($goVersion,$String);b=$ifaceNil;b=new D.ptr(AZ.nil,AZ.nil,AZ.nil,"");$unused(b);};F=function(){var a,b,c;a=$global.process;if(a===undefined){return"/";}b=a.env.GOPHERJS_GOROOT;if(!(b===undefined)&&!($internalize(b,$String)==="")){return $internalize(b,$String);}else{c=a.env.GOROOT;if(!(c===undefined)&&!($internalize(c,$String)==="")){return $internalize(c,$String);}}return"/usr/local/go";};$pkg.GOROOT=F;J=function(a,b,c,d){var a,b,c,d,e,f,g,h,i,j,k,l;e=b+":"+K(c)+":"+K(d);f=(g=$mapIndex(H,$String.keyFor(e)),g!==undefined?[g.v,true]:[0,false]);h=f[0];i=f[1];if(i){return h;}j=new AF.ptr(a,b,c,new BA.ptr());k=((I.$length>>>0));I=$append(I,j);l=e;(H||$throwRuntimeError("assignment to entry in nil map")).set($String.keyFor(l),{k:l,v:k});return k;};K=function(a){var a;return $internalize(new($global.String)(a),$String);};M=function(a,b){var a,b,c;a=(a+1>>0)+1>>0;c=new($global.Error)().stack.split($externalize("\n",$String)).slice(a,a+b>>0);return P(c);};P=function(a){var a,b,c,d,e,f,g,h,i,j;b=new BB([]);c=$parseInt(a.length);d=0;while(true){if(!(d>0;continue;}g=(h=$mapIndex(O,$String.keyFor(e.FuncName)),h!==undefined?[h.v,true]:["",false]);i=g[0];j=g[1];if(j){e.FuncName=i;}b=$append(b,e);if(e.FuncName==="runtime.goexit"){break;}d=d+(1)>>0;}return b;};Q=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q;if(($parseInt(a.indexOf($externalize("@",$String)))>>0)>=0){b=new($global.RegExp)($externalize("[@:]",$String));c=a.split(b);return new L.ptr($internalize(c[0],$String),$internalize(c.slice(1,$parseInt(c.length)-2>>0).join($externalize(":",$String)),$String),$parseInt(c[($parseInt(c.length)-2>>0)])>>0,$parseInt(c[($parseInt(c.length)-1>>0)])>>0);}d=$parseInt(a.lastIndexOf($externalize("(",$String)))>>0;if(d===-1){e=a.split($externalize(":",$String));return new L.ptr("",$internalize(e.slice(0,$parseInt(e.length)-2>>0).join($externalize(":",$String)).replace(new($global.RegExp)($externalize("^\\s*at ",$String)),$externalize("",$String)),$String),$parseInt(e[($parseInt(e.length)-2>>0)])>>0,$parseInt(e[($parseInt(e.length)-1>>0)])>>0);}f="";g="";h=f;i=g;j=0;k=0;l=j;m=k;n=a.substring(d+1>>0,$parseInt(a.indexOf($externalize(")",$String)))>>0);o=n.split($externalize(":",$String));if($internalize(n,$String)===""){h="";}else{h=$internalize(o.slice(0,$parseInt(o.length)-2>>0).join($externalize(":",$String)),$String);l=$parseInt(o[($parseInt(o.length)-2>>0)])>>0;m=$parseInt(o[($parseInt(o.length)-1>>0)])>>0;}p=a.substring(($parseInt(a.indexOf($externalize("at ",$String)))>>0)+3>>0,$parseInt(a.indexOf($externalize(" (",$String)))>>0);q=$parseInt(p.indexOf($externalize("[as ",$String)))>>0;if(q>0){p=p.substring(q+4>>0,p.indexOf($externalize("]",$String)));}i=$internalize(p,$String);return new L.ptr(i,h,l,m);};$pkg.ParseCallFrame=Q;R=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n;b=0;c="";d=0;e=false;a=a+1>>0;f=M(a,1);if(!((f.$length===1))){g=0;h="";i=0;j=false;b=g;c=h;d=i;e=j;return[b,c,d,e];}b=J((0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).FuncName,(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).File,(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).Line,(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).Col);k=b;l=(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).File;m=(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).Line;n=true;b=k;c=l;d=m;e=n;return[b,c,d,e];};$pkg.Caller=R;S=function(a,b){var a,b,c,d,e,f,g;c=M(a,b.$length);d=c;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]),L);((f<0||f>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+f]=J(g.FuncName,g.File,g.Line,g.Col));e++;}return c.$length;};$pkg.Callers=S;T=function(a){var a,b,c,d,e,f;b=new U.ptr(BC.nil,0);c=a;d=0;while(true){if(!(d=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+d]);f=AG(e);b.frames=$append(b.frames,new V.ptr(e,f,f.name,f.file,f.line,f.Entry()));d++;}return b;};$pkg.CallersFrames=T;U.ptr.prototype.Next=function(){var a,b,c,d,e,f,g,h,i,j;a=new V.ptr(0,AX.nil,"","",0,0);b=false;c=this;if(c.current>=c.frames.$length){d=new V.ptr(0,AX.nil,"","",0,0);e=false;V.copy(a,d);b=e;return[a,b];}h=$clone((f=c.frames,g=c.current,((g<0||g>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g])),V);c.current=c.current+(1)>>0;i=$clone(h,V);j=c.current";}return a.name;};AF.prototype.Name=function(){return this.$val.Name();};AG=function(a){var a,b;b=((a>>0));if(b>=I.$length){$panic(new $String("GopherJS: pc="+K(b)+" is out of range of known position counters"));}return((b<0||b>=I.$length)?($throwRuntimeError("index out of range"),undefined):I.$array[I.$offset+b]);};$pkg.FuncForPC=AG;AJ=function(a,b){var a,b,c;c=new($global.Error)().stack;if(c===undefined){return 0;}return $copyString(a,$internalize(c.substr(($parseInt(c.indexOf($externalize("\n",$String)))>>0)+1>>0),$String));};$pkg.Stack=AJ;AN=function(){return AM;};$pkg.Version=AN;AS=function(a){var a;};$pkg.KeepAlive=AS;AT.prototype.RuntimeError=function(){var a;a=this.$val;};$ptrType(AT).prototype.RuntimeError=function(){return new AT(this.$get()).RuntimeError();};AT.prototype.Error=function(){var a;a=this.$val;return"runtime error: "+(a);};$ptrType(AT).prototype.Error=function(){return new AT(this.$get()).Error();};AU=function(a){var a;$panic(new AT((a)));};AV=function(){return $mul64($internalize(new($global.Date)().getTime(),$Int64),new $Int64(0,1000000));};$linknames["runtime.nanotime"]=AV;AW=function(){return(($parseFloat($global.Math.random())*4.294967295e+09>>0));};$linknames["runtime.fastrand"]=AW;AZ.methods=[{prop:"string",name:"string",pkg:"runtime",typ:$funcType([],[$String],false)},{prop:"pkgpath",name:"pkgpath",pkg:"runtime",typ:$funcType([],[$String],false)}];BD.methods=[{prop:"RuntimeError",name:"RuntimeError",pkg:"",typ:$funcType([],[],false)},{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];BE.methods=[{prop:"Next",name:"Next",pkg:"",typ:$funcType([],[V,$Bool],false)}];AX.methods=[{prop:"Entry",name:"Entry",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"FileLine",name:"FileLine",pkg:"",typ:$funcType([$Uintptr],[$String,$Int],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)}];AT.methods=[{prop:"RuntimeError",name:"RuntimeError",pkg:"",typ:$funcType([],[],false)},{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];C.init("runtime",[{prop:"str",name:"str",embedded:false,exported:false,typ:$String,tag:""}]);D.init("runtime",[{prop:"_interface",name:"_interface",embedded:false,exported:false,typ:AZ,tag:""},{prop:"concrete",name:"concrete",embedded:false,exported:false,typ:AZ,tag:""},{prop:"asserted",name:"asserted",embedded:false,exported:false,typ:AZ,tag:""},{prop:"missingMethod",name:"missingMethod",embedded:false,exported:false,typ:$String,tag:""}]);L.init("",[{prop:"FuncName",name:"FuncName",embedded:false,exported:true,typ:$String,tag:""},{prop:"File",name:"File",embedded:false,exported:true,typ:$String,tag:""},{prop:"Line",name:"Line",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Col",name:"Col",embedded:false,exported:true,typ:$Int,tag:""}]);U.init("runtime",[{prop:"frames",name:"frames",embedded:false,exported:false,typ:BC,tag:""},{prop:"current",name:"current",embedded:false,exported:false,typ:$Int,tag:""}]);V.init("",[{prop:"PC",name:"PC",embedded:false,exported:true,typ:$Uintptr,tag:""},{prop:"Func",name:"Func",embedded:false,exported:true,typ:AX,tag:""},{prop:"Function",name:"Function",embedded:false,exported:true,typ:$String,tag:""},{prop:"File",name:"File",embedded:false,exported:true,typ:$String,tag:""},{prop:"Line",name:"Line",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Entry",name:"Entry",embedded:false,exported:true,typ:$Uintptr,tag:""}]);AF.init("runtime",[{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"file",name:"file",embedded:false,exported:false,typ:$String,tag:""},{prop:"line",name:"line",embedded:false,exported:false,typ:$Int,tag:""},{prop:"opaque",name:"opaque",embedded:false,exported:false,typ:BA,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}AM="";H=$makeMap($String.keyFor,[]);I=new AY([]);N=$makeMap($String.keyFor,[{k:"$callDeferred",v:true}]);O=$makeMap($String.keyFor,[{k:"$panic",v:"runtime.gopanic"},{k:"$goroutine",v:"runtime.goexit"}]);E();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/goarch"]=(function(){var $pkg={},$init;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/unsafeheader"]=(function(){var $pkg={},$init,A;A=$pkg.Slice=$newType(0,$kindStruct,"unsafeheader.Slice",true,"internal/unsafeheader",true,function(Data_,Len_,Cap_){this.$val=this;if(arguments.length===0){this.Data=0;this.Len=0;this.Cap=0;return;}this.Data=Data_;this.Len=Len_;this.Cap=Cap_;});A.init("",[{prop:"Data",name:"Data",embedded:false,exported:true,typ:$UnsafePointer,tag:""},{prop:"Len",name:"Len",embedded:false,exported:true,typ:$Int,tag:""},{prop:"Cap",name:"Cap",embedded:false,exported:true,typ:$Int,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/reflectlite"]=(function(){var $pkg={},$init,D,A,B,C,E,F,I,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,AB,AC,AG,AH,AI,AT,AV,BL,BN,BO,BP,CU,CW,DU,DV,DW,DX,DY,DZ,EA,EC,ED,EE,EF,EG,EH,EI,EJ,EK,EL,EM,EN,EO,ES,ET,EU,EV,EW,EX,EY,EZ,AD,AR,BB,BD,BE,BF,BG,BH,BM,BQ,BS,BU,DH,DN,AK,AL,AM,AN,AP,AQ,AU,BA,BC,BI,BJ,BK,BR,BT,BV,BW,BX,BY,BZ,CB,CC,CF,CH,CJ,CM,CQ,CR,CV,CX,CY,CZ,DC,DD,DE,DF,DG,DI,DJ,DK,DL,DM;D=$packages["github.com/gopherjs/gopherjs/js"];A=$packages["internal/goarch"];B=$packages["internal/unsafeheader"];C=$packages["runtime"];E=$pkg.Value=$newType(0,$kindStruct,"reflectlite.Value",true,"internal/reflectlite",true,function(typ_,ptr_,flag_){this.$val=this;if(arguments.length===0){this.typ=DU.nil;this.ptr=0;this.flag=0;return;}this.typ=typ_;this.ptr=ptr_;this.flag=flag_;});F=$pkg.flag=$newType(4,$kindUintptr,"reflectlite.flag",true,"internal/reflectlite",false,null);I=$pkg.ValueError=$newType(0,$kindStruct,"reflectlite.ValueError",true,"internal/reflectlite",true,function(Method_,Kind_){this.$val=this;if(arguments.length===0){this.Method="";this.Kind=0;return;}this.Method=Method_;this.Kind=Kind_;});O=$pkg.Type=$newType(8,$kindInterface,"reflectlite.Type",true,"internal/reflectlite",true,null);P=$pkg.Kind=$newType(4,$kindUint,"reflectlite.Kind",true,"internal/reflectlite",true,null);Q=$pkg.tflag=$newType(1,$kindUint8,"reflectlite.tflag",true,"internal/reflectlite",false,null);R=$pkg.rtype=$newType(0,$kindStruct,"reflectlite.rtype",true,"internal/reflectlite",false,function(size_,ptrdata_,hash_,tflag_,align_,fieldAlign_,kind_,equal_,gcdata_,str_,ptrToThis_){this.$val=this;if(arguments.length===0){this.size=0;this.ptrdata=0;this.hash=0;this.tflag=0;this.align=0;this.fieldAlign=0;this.kind=0;this.equal=$throwNilPointerError;this.gcdata=EG.nil;this.str=0;this.ptrToThis=0;return;}this.size=size_;this.ptrdata=ptrdata_;this.hash=hash_;this.tflag=tflag_;this.align=align_;this.fieldAlign=fieldAlign_;this.kind=kind_;this.equal=equal_;this.gcdata=gcdata_;this.str=str_;this.ptrToThis=ptrToThis_;});S=$pkg.method=$newType(0,$kindStruct,"reflectlite.method",true,"internal/reflectlite",false,function(name_,mtyp_,ifn_,tfn_){this.$val=this;if(arguments.length===0){this.name=0;this.mtyp=0;this.ifn=0;this.tfn=0;return;}this.name=name_;this.mtyp=mtyp_;this.ifn=ifn_;this.tfn=tfn_;});T=$pkg.chanDir=$newType(4,$kindInt,"reflectlite.chanDir",true,"internal/reflectlite",false,null);U=$pkg.arrayType=$newType(0,$kindStruct,"reflectlite.arrayType",true,"internal/reflectlite",false,function(rtype_,elem_,slice_,len_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.elem=DU.nil;this.slice=DU.nil;this.len=0;return;}this.rtype=rtype_;this.elem=elem_;this.slice=slice_;this.len=len_;});V=$pkg.chanType=$newType(0,$kindStruct,"reflectlite.chanType",true,"internal/reflectlite",false,function(rtype_,elem_,dir_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.elem=DU.nil;this.dir=0;return;}this.rtype=rtype_;this.elem=elem_;this.dir=dir_;});W=$pkg.imethod=$newType(0,$kindStruct,"reflectlite.imethod",true,"internal/reflectlite",false,function(name_,typ_){this.$val=this;if(arguments.length===0){this.name=0;this.typ=0;return;}this.name=name_;this.typ=typ_;});X=$pkg.interfaceType=$newType(0,$kindStruct,"reflectlite.interfaceType",true,"internal/reflectlite",false,function(rtype_,pkgPath_,methods_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.pkgPath=new BO.ptr(EG.nil);this.methods=EK.nil;return;}this.rtype=rtype_;this.pkgPath=pkgPath_;this.methods=methods_;});Y=$pkg.mapType=$newType(0,$kindStruct,"reflectlite.mapType",true,"internal/reflectlite",false,function(rtype_,key_,elem_,bucket_,hasher_,keysize_,valuesize_,bucketsize_,flags_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.key=DU.nil;this.elem=DU.nil;this.bucket=DU.nil;this.hasher=$throwNilPointerError;this.keysize=0;this.valuesize=0;this.bucketsize=0;this.flags=0;return;}this.rtype=rtype_;this.key=key_;this.elem=elem_;this.bucket=bucket_;this.hasher=hasher_;this.keysize=keysize_;this.valuesize=valuesize_;this.bucketsize=bucketsize_;this.flags=flags_;});Z=$pkg.ptrType=$newType(0,$kindStruct,"reflectlite.ptrType",true,"internal/reflectlite",false,function(rtype_,elem_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.elem=DU.nil;return;}this.rtype=rtype_;this.elem=elem_;});AA=$pkg.sliceType=$newType(0,$kindStruct,"reflectlite.sliceType",true,"internal/reflectlite",false,function(rtype_,elem_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.elem=DU.nil;return;}this.rtype=rtype_;this.elem=elem_;});AB=$pkg.structField=$newType(0,$kindStruct,"reflectlite.structField",true,"internal/reflectlite",false,function(name_,typ_,offsetEmbed_){this.$val=this;if(arguments.length===0){this.name=new BO.ptr(EG.nil);this.typ=DU.nil;this.offsetEmbed=0;return;}this.name=name_;this.typ=typ_;this.offsetEmbed=offsetEmbed_;});AC=$pkg.structType=$newType(0,$kindStruct,"reflectlite.structType",true,"internal/reflectlite",false,function(rtype_,pkgPath_,fields_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.pkgPath=new BO.ptr(EG.nil);this.fields=EL.nil;return;}this.rtype=rtype_;this.pkgPath=pkgPath_;this.fields=fields_;});AG=$pkg.nameOff=$newType(4,$kindInt32,"reflectlite.nameOff",true,"internal/reflectlite",false,null);AH=$pkg.typeOff=$newType(4,$kindInt32,"reflectlite.typeOff",true,"internal/reflectlite",false,null);AI=$pkg.textOff=$newType(4,$kindInt32,"reflectlite.textOff",true,"internal/reflectlite",false,null);AT=$pkg.errorString=$newType(0,$kindStruct,"reflectlite.errorString",true,"internal/reflectlite",false,function(s_){this.$val=this;if(arguments.length===0){this.s="";return;}this.s=s_;});AV=$pkg.Method=$newType(0,$kindStruct,"reflectlite.Method",true,"internal/reflectlite",true,function(Name_,PkgPath_,Type_,Func_,Index_){this.$val=this;if(arguments.length===0){this.Name="";this.PkgPath="";this.Type=$ifaceNil;this.Func=new E.ptr(DU.nil,0,0);this.Index=0;return;}this.Name=Name_;this.PkgPath=PkgPath_;this.Type=Type_;this.Func=Func_;this.Index=Index_;});BL=$pkg.uncommonType=$newType(0,$kindStruct,"reflectlite.uncommonType",true,"internal/reflectlite",false,function(pkgPath_,mcount_,xcount_,moff_,_methods_){this.$val=this;if(arguments.length===0){this.pkgPath=0;this.mcount=0;this.xcount=0;this.moff=0;this._methods=ED.nil;return;}this.pkgPath=pkgPath_;this.mcount=mcount_;this.xcount=xcount_;this.moff=moff_;this._methods=_methods_;});BN=$pkg.funcType=$newType(0,$kindStruct,"reflectlite.funcType",true,"internal/reflectlite",false,function(rtype_,inCount_,outCount_,_in_,_out_){this.$val=this;if(arguments.length===0){this.rtype=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);this.inCount=0;this.outCount=0;this._in=DW.nil;this._out=DW.nil;return;}this.rtype=rtype_;this.inCount=inCount_;this.outCount=outCount_;this._in=_in_;this._out=_out_;});BO=$pkg.name=$newType(0,$kindStruct,"reflectlite.name",true,"internal/reflectlite",false,function(bytes_){this.$val=this;if(arguments.length===0){this.bytes=EG.nil;return;}this.bytes=bytes_;});BP=$pkg.nameData=$newType(0,$kindStruct,"reflectlite.nameData",true,"internal/reflectlite",false,function(name_,tag_,exported_){this.$val=this;if(arguments.length===0){this.name="";this.tag="";this.exported=false;return;}this.name=name_;this.tag=tag_;this.exported=exported_;});CU=$pkg.mapIter=$newType(0,$kindStruct,"reflectlite.mapIter",true,"internal/reflectlite",false,function(t_,m_,keys_,i_,last_){this.$val=this;if(arguments.length===0){this.t=$ifaceNil;this.m=null;this.keys=null;this.i=0;this.last=null;return;}this.t=t_;this.m=m_;this.keys=keys_;this.i=i_;this.last=last_;});CW=$pkg.TypeEx=$newType(8,$kindInterface,"reflectlite.TypeEx",true,"internal/reflectlite",true,null);DU=$ptrType(R);DV=$sliceType(BO);DW=$sliceType(DU);DX=$sliceType($String);DY=$sliceType($emptyInterface);DZ=$ptrType(D.Object);EA=$funcType([DY],[DZ],true);EC=$ptrType(BL);ED=$sliceType(S);EE=$ptrType(BN);EF=$sliceType(E);EG=$ptrType($Uint8);EH=$ptrType($UnsafePointer);EI=$sliceType(O);EJ=$sliceType(DZ);EK=$sliceType(W);EL=$sliceType(AB);EM=$ptrType(BP);EN=$structType("internal/reflectlite",[{prop:"str",name:"str",embedded:false,exported:false,typ:$String,tag:""}]);EO=$ptrType(CU);ES=$arrayType($Uintptr,2);ET=$sliceType($Uint8);EU=$ptrType(I);EV=$funcType([$UnsafePointer,$UnsafePointer],[$Bool],false);EW=$ptrType(X);EX=$funcType([$UnsafePointer,$Uintptr],[$Uintptr],false);EY=$ptrType(AB);EZ=$ptrType(AT);F.prototype.kind=function(){var m;m=this.$val;return((((m&31)>>>0)>>>0));};$ptrType(F).prototype.kind=function(){return new F(this.$get()).kind();};F.prototype.ro=function(){var m;m=this.$val;if(!((((m&96)>>>0)===0))){return 32;}return 0;};$ptrType(F).prototype.ro=function(){return new F(this.$get()).ro();};E.ptr.prototype.pointer=function(){var m;m=this;if(!((m.typ.size===4))||!m.typ.pointers()){$panic(new $String("can't call pointer on a non-pointer Value"));}if(!((((m.flag&128)>>>0)===0))){return(m.ptr).$get();}return m.ptr;};E.prototype.pointer=function(){return this.$val.pointer();};I.ptr.prototype.Error=function(){var m;m=this;if(m.Kind===0){return"reflect: call of "+m.Method+" on zero Value";}return"reflect: call of "+m.Method+" on "+new P(m.Kind).String()+" Value";};I.prototype.Error=function(){return this.$val.Error();};F.prototype.mustBeExported=function(){var m;m=this.$val;if(m===0){$panic(new I.ptr(DF(),0));}if(!((((m&96)>>>0)===0))){$panic(new $String("reflect: "+DF()+" using value obtained using unexported field"));}};$ptrType(F).prototype.mustBeExported=function(){return new F(this.$get()).mustBeExported();};F.prototype.mustBeAssignable=function(){var m;m=this.$val;if(m===0){$panic(new I.ptr(DF(),0));}if(!((((m&96)>>>0)===0))){$panic(new $String("reflect: "+DF()+" using value obtained using unexported field"));}if(((m&256)>>>0)===0){$panic(new $String("reflect: "+DF()+" using unaddressable value"));}};$ptrType(F).prototype.mustBeAssignable=function(){return new F(this.$get()).mustBeAssignable();};E.ptr.prototype.CanSet=function(){var m;m=this;return((m.flag&352)>>>0)===256;};E.prototype.CanSet=function(){return this.$val.CanSet();};E.ptr.prototype.IsValid=function(){var m;m=this;return!((m.flag===0));};E.prototype.IsValid=function(){return this.$val.IsValid();};E.ptr.prototype.Kind=function(){var m;m=this;return new F(m.flag).kind();};E.prototype.Kind=function(){return this.$val.Kind();};E.ptr.prototype.Type=function(){var m,n;m=this;n=m.flag;if(n===0){$panic(new I.ptr("reflectlite.Value.Type",0));}return m.typ;};E.prototype.Type=function(){return this.$val.Type();};AB.ptr.prototype.embedded=function(){var m;m=this;return!((((m.offsetEmbed&1)>>>0)===0));};AB.prototype.embedded=function(){return this.$val.embedded();};P.prototype.String=function(){var m;m=this.$val;if(((m>>0))=AD.$length)?($throwRuntimeError("index out of range"),undefined):AD.$array[AD.$offset+m]);}return(0>=AD.$length?($throwRuntimeError("index out of range"),undefined):AD.$array[AD.$offset+0]);};$ptrType(P).prototype.String=function(){return new P(this.$get()).String();};R.ptr.prototype.String=function(){var m,n;m=this;n=$clone(m.nameOff(m.str),BO).name();if(!((((m.tflag&2)>>>0)===0))){return $substring(n,1);}return n;};R.prototype.String=function(){return this.$val.String();};R.ptr.prototype.Size=function(){var m;m=this;return m.size;};R.prototype.Size=function(){return this.$val.Size();};R.ptr.prototype.Kind=function(){var m;m=this;return((((m.kind&31)>>>0)>>>0));};R.prototype.Kind=function(){return this.$val.Kind();};R.ptr.prototype.pointers=function(){var m;m=this;return!((m.ptrdata===0));};R.prototype.pointers=function(){return this.$val.pointers();};R.ptr.prototype.common=function(){var m;m=this;return m;};R.prototype.common=function(){return this.$val.common();};R.ptr.prototype.exportedMethods=function(){var m,n;m=this;n=m.uncommon();if(n===EC.nil){return ED.nil;}return n.exportedMethods();};R.prototype.exportedMethods=function(){return this.$val.exportedMethods();};R.ptr.prototype.NumMethod=function(){var m,n;m=this;if(m.Kind()===20){n=(m.kindType);return n.NumMethod();}return m.exportedMethods().$length;};R.prototype.NumMethod=function(){return this.$val.NumMethod();};R.ptr.prototype.PkgPath=function(){var m,n;m=this;if(((m.tflag&4)>>>0)===0){return"";}n=m.uncommon();if(n===EC.nil){return"";}return $clone(m.nameOff(n.pkgPath),BO).name();};R.prototype.PkgPath=function(){return this.$val.PkgPath();};R.ptr.prototype.hasName=function(){var m;m=this;return!((((m.tflag&4)>>>0)===0));};R.prototype.hasName=function(){return this.$val.hasName();};R.ptr.prototype.Name=function(){var m,n,o;m=this;if(!m.hasName()){return"";}n=m.String();o=n.length-1>>0;while(true){if(!(o>=0&&!((n.charCodeAt(o)===46)))){break;}o=o-(1)>>0;}return $substring(n,(o+1>>0));};R.prototype.Name=function(){return this.$val.Name();};R.ptr.prototype.chanDir=function(){var m,n;m=this;if(!((m.Kind()===18))){$panic(new $String("reflect: chanDir of non-chan type"));}n=(m.kindType);return((n.dir>>0));};R.prototype.chanDir=function(){return this.$val.chanDir();};R.ptr.prototype.Elem=function(){var m,n,o,p,q,r,s;m=this;n=m.Kind();if(n===(17)){o=(m.kindType);return AP(o.elem);}else if(n===(18)){p=(m.kindType);return AP(p.elem);}else if(n===(21)){q=(m.kindType);return AP(q.elem);}else if(n===(22)){r=(m.kindType);return AP(r.elem);}else if(n===(23)){s=(m.kindType);return AP(s.elem);}$panic(new $String("reflect: Elem of invalid type"));};R.prototype.Elem=function(){return this.$val.Elem();};R.ptr.prototype.In=function(m){var m,n,o,p;n=this;if(!((n.Kind()===19))){$panic(new $String("reflect: In of non-func type"));}o=(n.kindType);return AP((p=o.in$(),((m<0||m>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+m])));};R.prototype.In=function(m){return this.$val.In(m);};R.ptr.prototype.Len=function(){var m,n;m=this;if(!((m.Kind()===17))){$panic(new $String("reflect: Len of non-array type"));}n=(m.kindType);return((n.len>>0));};R.prototype.Len=function(){return this.$val.Len();};R.ptr.prototype.NumIn=function(){var m,n;m=this;if(!((m.Kind()===19))){$panic(new $String("reflect: NumIn of non-func type"));}n=(m.kindType);return((n.inCount>>0));};R.prototype.NumIn=function(){return this.$val.NumIn();};R.ptr.prototype.NumOut=function(){var m,n;m=this;if(!((m.Kind()===19))){$panic(new $String("reflect: NumOut of non-func type"));}n=(m.kindType);return n.out().$length;};R.prototype.NumOut=function(){return this.$val.NumOut();};R.ptr.prototype.Out=function(m){var m,n,o,p;n=this;if(!((n.Kind()===19))){$panic(new $String("reflect: Out of non-func type"));}o=(n.kindType);return AP((p=o.out(),((m<0||m>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+m])));};R.prototype.Out=function(m){return this.$val.Out(m);};X.ptr.prototype.NumMethod=function(){var m;m=this;return m.methods.$length;};X.prototype.NumMethod=function(){return this.$val.NumMethod();};R.ptr.prototype.Implements=function(m){var{m,n,o,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=this;if($interfaceIsEqual(m,$ifaceNil)){$panic(new $String("reflect: nil type passed to Type.Implements"));}o=m.Kind();$s=3;case 3:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}if(!((o===20))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect: non-interface type passed to Type.Implements"));case 2:$s=-1;return AK($assertType(m,DU),n);}return;}var $f={$blk:R.ptr.prototype.Implements,$c:true,$r,m,n,o,$s};return $f;};R.prototype.Implements=function(m){return this.$val.Implements(m);};R.ptr.prototype.AssignableTo=function(m){var{m,n,o,p,q,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=this;if($interfaceIsEqual(m,$ifaceNil)){$panic(new $String("reflect: nil type passed to Type.AssignableTo"));}o=$assertType(m,DU);p=AL(o,n);$s=1;case 1:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}q=p||AK(o,n);$s=2;case 2:return q;}return;}var $f={$blk:R.ptr.prototype.AssignableTo,$c:true,$r,m,n,o,p,q,$s};return $f;};R.prototype.AssignableTo=function(m){return this.$val.AssignableTo(m);};AK=function(m,n){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if(!((m.Kind()===20))){return false;}o=(m.kindType);if(o.methods.$length===0){return true;}if(n.Kind()===20){p=(n.kindType);q=0;r=0;while(true){if(!(r=s.$length)?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+q]));u=$clone(o.rtype.nameOff(t.name),BO);w=(v=p.methods,((r<0||r>=v.$length)?($throwRuntimeError("index out of range"),undefined):v.$array[v.$offset+r]));x=$clone(n.nameOff(w.name),BO);if($clone(x,BO).name()===$clone(u,BO).name()&&n.typeOff(w.typ)===o.rtype.typeOff(t.typ)){if(!$clone(u,BO).isExported()){y=$clone(u,BO).pkgPath();if(y===""){y=$clone(o.pkgPath,BO).name();}z=$clone(x,BO).pkgPath();if(z===""){z=$clone(p.pkgPath,BO).name();}if(!(y===z)){r=r+(1)>>0;continue;}}q=q+(1)>>0;if(q>=o.methods.$length){return true;}}r=r+(1)>>0;}return false;}aa=n.uncommon();if(aa===EC.nil){return false;}ab=0;ac=aa.methods();ad=0;while(true){if(!(ad<((aa.mcount>>0)))){break;}af=(ae=o.methods,((ab<0||ab>=ae.$length)?($throwRuntimeError("index out of range"),undefined):ae.$array[ae.$offset+ab]));ag=$clone(o.rtype.nameOff(af.name),BO);ah=$clone(((ad<0||ad>=ac.$length)?($throwRuntimeError("index out of range"),undefined):ac.$array[ac.$offset+ad]),S);ai=$clone(n.nameOff(ah.name),BO);if($clone(ai,BO).name()===$clone(ag,BO).name()&&n.typeOff(ah.mtyp)===o.rtype.typeOff(af.typ)){if(!$clone(ag,BO).isExported()){aj=$clone(ag,BO).pkgPath();if(aj===""){aj=$clone(o.pkgPath,BO).name();}ak=$clone(ai,BO).pkgPath();if(ak===""){ak=$clone(n.nameOff(aa.pkgPath),BO).name();}if(!(aj===ak)){ad=ad+(1)>>0;continue;}}ab=ab+(1)>>0;if(ab>=o.methods.$length){return true;}}ad=ad+(1)>>0;}return false;};AL=function(m,n){var{m,n,o,p,$s,$r,$c}=$restore(this,{m,n});$s=$s||0;s:while(true){switch($s){case 0:if(m===n){$s=-1;return true;}if(m.hasName()&&n.hasName()||!((m.Kind()===n.Kind()))){$s=-1;return false;}o=AN(m,n,true);$s=1;case 1:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}p=o;$s=2;case 2:return p;}return;}var $f={$blk:AL,$c:true,$r,m,n,o,p,$s};return $f;};AM=function(m,n,o){var{m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m,n,o});$s=$s||0;s:while(true){switch($s){case 0:if(o){$s=-1;return $interfaceIsEqual(m,n);}q=m.Name();$s=4;case 4:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}r=n.Name();$s=5;case 5:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}if(!(q===r)){p=true;$s=3;continue s;}s=m.Kind();$s=6;case 6:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}t=n.Kind();$s=7;case 7:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}p=!((s===t));case 3:if(p){$s=1;continue;}$s=2;continue;case 1:$s=-1;return false;case 2:u=m.common();$s=8;case 8:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}v=u;w=n.common();$s=9;case 9:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}x=w;y=AN(v,x,false);$s=10;case 10:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}z=y;$s=11;case 11:return z;}return;}var $f={$blk:AM,$c:true,$r,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};AN=function(m,n,o){var{aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m,n,o});$s=$s||0;s:while(true){switch($s){case 0:if(m===n){$s=-1;return true;}p=m.Kind();if(!((p===n.Kind()))){$s=-1;return false;}if(1<=p&&p<=16||(p===24)||(p===26)){$s=-1;return true;}q=p;if(q===(17)){$s=2;continue;}if(q===(18)){$s=3;continue;}if(q===(19)){$s=4;continue;}if(q===(20)){$s=5;continue;}if(q===(21)){$s=6;continue;}if((q===(22))||(q===(23))){$s=7;continue;}if(q===(25)){$s=8;continue;}$s=9;continue;case 2:if(!(m.Len()===n.Len())){r=false;$s=10;continue s;}s=AM(m.Elem(),n.Elem(),o);$s=11;case 11:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}r=s;case 10:t=r;$s=12;case 12:return t;case 3:if(!(n.chanDir()===3)){u=false;$s=15;continue s;}v=AM(m.Elem(),n.Elem(),o);$s=16;case 16:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}u=v;case 15:if(u){$s=13;continue;}$s=14;continue;case 13:$s=-1;return true;case 14:if(!(n.chanDir()===m.chanDir())){w=false;$s=17;continue s;}x=AM(m.Elem(),n.Elem(),o);$s=18;case 18:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}w=x;case 17:y=w;$s=19;case 19:return y;case 4:z=(m.kindType);aa=(n.kindType);if(!((z.outCount===aa.outCount))||!((z.inCount===aa.inCount))){$s=-1;return false;}ab=0;case 20:if(!(ab>0;$s=20;continue;case 21:ad=0;case 25:if(!(ad>0;$s=25;continue;case 26:$s=-1;return true;case 5:af=(m.kindType);ag=(n.kindType);if((af.methods.$length===0)&&(ag.methods.$length===0)){$s=-1;return true;}$s=-1;return false;case 6:ai=AM(m.Key(),n.Key(),o);$s=31;case 31:if($c){$c=false;ai=ai.$blk();}if(ai&&ai.$blk!==undefined){break s;}if(!(ai)){ah=false;$s=30;continue s;}aj=AM(m.Elem(),n.Elem(),o);$s=32;case 32:if($c){$c=false;aj=aj.$blk();}if(aj&&aj.$blk!==undefined){break s;}ah=aj;case 30:ak=ah;$s=33;case 33:return ak;case 7:al=AM(m.Elem(),n.Elem(),o);$s=34;case 34:if($c){$c=false;al=al.$blk();}if(al&&al.$blk!==undefined){break s;}am=al;$s=35;case 35:return am;case 8:an=(m.kindType);ao=(n.kindType);if(!((an.fields.$length===ao.fields.$length))){$s=-1;return false;}if(!($clone(an.pkgPath,BO).name()===$clone(ao.pkgPath,BO).name())){$s=-1;return false;}ap=an.fields;aq=0;case 36:if(!(aq=as.$length)?($throwRuntimeError("index out of range"),undefined):as.$array[as.$offset+ar]));av=(au=ao.fields,((ar<0||ar>=au.$length)?($throwRuntimeError("index out of range"),undefined):au.$array[au.$offset+ar]));if(!($clone(at.name,BO).name()===$clone(av.name,BO).name())){$s=-1;return false;}aw=AM(at.typ,av.typ,o);$s=40;case 40:if($c){$c=false;aw=aw.$blk();}if(aw&&aw.$blk!==undefined){break s;}if(!aw){$s=38;continue;}$s=39;continue;case 38:$s=-1;return false;case 39:if(o&&!($clone(at.name,BO).tag()===$clone(av.name,BO).tag())){$s=-1;return false;}if(!((at.offsetEmbed===av.offsetEmbed))){$s=-1;return false;}aq++;$s=36;continue;case 37:$s=-1;return true;case 9:case 1:$s=-1;return false;}return;}var $f={$blk:AN,$c:true,$r,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};AP=function(m){var m;if(m===DU.nil){return $ifaceNil;}return m;};AQ=function(m){var m;return((m.kind&32)>>>0)===0;};E.ptr.prototype.object=function(){var m,n,o,p;m=this;if((m.typ.Kind()===17)||(m.typ.Kind()===25)){return m.ptr;}if(!((((m.flag&128)>>>0)===0))){n=m.ptr.$get();if(!(n===$ifaceNil)&&!(n.constructor===BI(m.typ))){switch(0){default:o=m.typ.Kind();if((o===(11))||(o===(6))){n=new(BI(m.typ))(n.$high,n.$low);}else if((o===(15))||(o===(16))){n=new(BI(m.typ))(n.$real,n.$imag);}else if(o===(23)){if(n===n.constructor.nil){n=BI(m.typ).nil;break;}p=new(BI(m.typ))(n.$array);p.$offset=n.$offset;p.$length=n.$length;p.$capacity=n.$capacity;n=p;}}}return n;}return m.ptr;};E.prototype.object=function(){return this.$val.object();};E.ptr.prototype.assignTo=function(m,n,o){var{m,n,o,p,q,r,s,t,u,$s,$r,$c}=$restore(this,{m,n,o});$s=$s||0;s:while(true){switch($s){case 0:p=this;if(!((((p.flag&512)>>>0)===0))){$s=1;continue;}$s=2;continue;case 1:q=DG(m,$clone(p,E));$s=3;case 3:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}E.copy(p,q);case 2:r=AL(n,p.typ);$s=8;case 8:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}if(r){$s=5;continue;}if(AK(n,p.typ)){$s=6;continue;}$s=7;continue;case 5:s=(((p.flag&384)>>>0)|new F(p.flag).ro())>>>0;s=(s|(((n.Kind()>>>0))))>>>0;$s=-1;return new E.ptr(n,p.ptr,s);case 6:if(o===0){o=CJ(n);}t=DD($clone(p,E));$s=9;case 9:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}u=t;if(n.NumMethod()===0){(o).$set(u);}else{DE(n,u,o);}$s=-1;return new E.ptr(n,o,148);case 7:case 4:$panic(new $String(m+": value of type "+p.typ.String()+" is not assignable to type "+n.String()));$s=-1;return new E.ptr(DU.nil,0,0);}return;}var $f={$blk:E.ptr.prototype.assignTo,$c:true,$r,m,n,o,p,q,r,s,t,u,$s};return $f;};E.prototype.assignTo=function(m,n,o){return this.$val.assignTo(m,n,o);};E.ptr.prototype.Cap=function(){var m,n,o;m=this;n=new F(m.flag).kind();o=n;if(o===(17)){return m.typ.Len();}else if((o===(18))||(o===(23))){return $parseInt($clone(m,E).object().$capacity)>>0;}$panic(new I.ptr("reflect.Value.Cap",n));};E.prototype.Cap=function(){return this.$val.Cap();};E.ptr.prototype.Index=function(m){var{aa,ab,ac,ad,ae,af,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:m=[m];n=[n];o=[o];p=[p];q=[q];r=[r];s=this;t=new F(s.flag).kind();u=t;if(u===(17)){$s=2;continue;}if(u===(23)){$s=3;continue;}if(u===(24)){$s=4;continue;}$s=5;continue;case 2:v=(s.typ.kindType);if(m[0]<0||m[0]>((v.len>>0))){$panic(new $String("reflect: array index out of range"));}q[0]=v.elem;w=(((((s.flag&384)>>>0)|new F(s.flag).ro())>>>0)|((q[0].Kind()>>>0)))>>>0;n[0]=s.ptr;if(!((((w&128)>>>0)===0))&&!((q[0].Kind()===17))&&!((q[0].Kind()===25))){$s=7;continue;}$s=8;continue;case 7:$s=-1;return new E.ptr(q[0],(new(BI(DL(q[0])))((function(m,n,o,p,q,r){return function(){return DI(q[0],n[0][m[0]]);};})(m,n,o,p,q,r),(function(m,n,o,p,q,r){return function(x){var x;n[0][m[0]]=DJ(q[0],x);};})(m,n,o,p,q,r))),w);case 8:x=BZ(q[0],DI(q[0],n[0][m[0]]),w);$s=9;case 9:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}y=x;$s=10;case 10:return y;case 3:z=$clone(s,E).object();if(m[0]<0||m[0]>=($parseInt(z.$length)>>0)){$panic(new $String("reflect: slice index out of range"));}aa=(s.typ.kindType);r[0]=aa.elem;ab=(((384|new F(s.flag).ro())>>>0)|((r[0].Kind()>>>0)))>>>0;m[0]=m[0]+(($parseInt(z.$offset)>>0))>>0;o[0]=z.$array;if(!((((ab&128)>>>0)===0))&&!((r[0].Kind()===17))&&!((r[0].Kind()===25))){$s=11;continue;}$s=12;continue;case 11:$s=-1;return new E.ptr(r[0],(new(BI(DL(r[0])))((function(m,n,o,p,q,r){return function(){return DI(r[0],o[0][m[0]]);};})(m,n,o,p,q,r),(function(m,n,o,p,q,r){return function(ac){var ac;o[0][m[0]]=DJ(r[0],ac);};})(m,n,o,p,q,r))),ab);case 12:ac=BZ(r[0],DI(r[0],o[0][m[0]]),ab);$s=13;case 13:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}ad=ac;$s=14;case 14:return ad;case 4:ae=(s.ptr).$get();if(m[0]<0||m[0]>=ae.length){$panic(new $String("reflect: string index out of range"));}af=(((new F(s.flag).ro()|8)>>>0)|128)>>>0;p[0]=ae.charCodeAt(m[0]);$s=-1;return new E.ptr(BD,((p.$ptr||(p.$ptr=new EG(function(){return this.$target[0];},function($v){this.$target[0]=$v;},p)))),af);case 5:$panic(new I.ptr("reflect.Value.Index",t));case 6:case 1:$s=-1;return new E.ptr(DU.nil,0,0);}return;}var $f={$blk:E.ptr.prototype.Index,$c:true,$r,aa,ab,ac,ad,ae,af,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};E.prototype.Index=function(m){return this.$val.Index(m);};E.ptr.prototype.InterfaceData=function(){var m;m=this;$panic(new $String("InterfaceData is not supported by GopherJS"));};E.prototype.InterfaceData=function(){return this.$val.InterfaceData();};E.ptr.prototype.IsNil=function(){var m,n,o;m=this;n=new F(m.flag).kind();o=n;if((o===(22))||(o===(23))){return $clone(m,E).object()===BI(m.typ).nil;}else if(o===(18)){return $clone(m,E).object()===$chanNil;}else if(o===(19)){return $clone(m,E).object()===$throwNilPointerError;}else if(o===(21)){return $clone(m,E).object()===false;}else if(o===(20)){return $clone(m,E).object()===$ifaceNil;}else if(o===(26)){return $clone(m,E).object()===0;}else{$panic(new I.ptr("reflect.Value.IsNil",n));}};E.prototype.IsNil=function(){return this.$val.IsNil();};E.ptr.prototype.Len=function(){var m,n,o;m=this;n=new F(m.flag).kind();o=n;if((o===(17))||(o===(24))){return $parseInt($clone(m,E).object().length);}else if(o===(23)){return $parseInt($clone(m,E).object().$length)>>0;}else if(o===(18)){return $parseInt($clone(m,E).object().$buffer.length)>>0;}else if(o===(21)){return $parseInt($clone(m,E).object().size)>>0;}else{$panic(new I.ptr("reflect.Value.Len",n));}};E.prototype.Len=function(){return this.$val.Len();};E.ptr.prototype.Pointer=function(){var m,n,o;m=this;n=new F(m.flag).kind();o=n;if((o===(18))||(o===(21))||(o===(22))||(o===(26))){if($clone(m,E).IsNil()){return 0;}return $clone(m,E).object();}else if(o===(19)){if($clone(m,E).IsNil()){return 0;}return 1;}else if(o===(23)){if($clone(m,E).IsNil()){return 0;}return $clone(m,E).object().$array;}else{$panic(new I.ptr("reflect.Value.Pointer",n));}};E.prototype.Pointer=function(){return this.$val.Pointer();};E.ptr.prototype.Set=function(m){var{m,n,o,p,q,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=this;new F(n.flag).mustBeAssignable();new F(m.flag).mustBeExported();o=$clone(m,E).assignTo("reflect.Set",n.typ,0);$s=1;case 1:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}E.copy(m,o);if(!((((n.flag&128)>>>0)===0))){$s=2;continue;}$s=3;continue;case 2:p=n.typ.Kind();if(p===(17)){$s=5;continue;}if(p===(20)){$s=6;continue;}if(p===(25)){$s=7;continue;}$s=8;continue;case 5:BI(n.typ).copy(n.ptr,m.ptr);$s=9;continue;case 6:q=DD($clone(m,E));$s=10;case 10:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}n.ptr.$set(q);$s=9;continue;case 7:BY(n.ptr,m.ptr,n.typ);$s=9;continue;case 8:n.ptr.$set($clone(m,E).object());case 9:case 4:$s=-1;return;case 3:n.ptr=m.ptr;$s=-1;return;}return;}var $f={$blk:E.ptr.prototype.Set,$c:true,$r,m,n,o,p,q,$s};return $f;};E.prototype.Set=function(m){return this.$val.Set(m);};E.ptr.prototype.SetBytes=function(m){var{m,n,o,p,q,r,s,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=this;new F(n.flag).mustBeAssignable();new F(n.flag).mustBe(23);o=n.typ.Elem().Kind();$s=3;case 3:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}if(!((o===8))){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.Value.SetBytes of non-byte slice"));case 2:p=m;if(!(n.typ.Name()==="")){q=true;$s=6;continue s;}r=n.typ.Elem().Name();$s=7;case 7:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}q=!(r==="");case 6:if(q){$s=4;continue;}$s=5;continue;case 4:s=new(BI(n.typ))(p.$array);s.$offset=p.$offset;s.$length=p.$length;s.$capacity=p.$capacity;p=s;case 5:n.ptr.$set(p);$s=-1;return;}return;}var $f={$blk:E.ptr.prototype.SetBytes,$c:true,$r,m,n,o,p,q,r,s,$s};return $f;};E.prototype.SetBytes=function(m){return this.$val.SetBytes(m);};E.ptr.prototype.SetCap=function(m){var m,n,o,p;n=this;new F(n.flag).mustBeAssignable();new F(n.flag).mustBe(23);o=n.ptr.$get();if(m<($parseInt(o.$length)>>0)||m>($parseInt(o.$capacity)>>0)){$panic(new $String("reflect: slice capacity out of range in SetCap"));}p=new(BI(n.typ))(o.$array);p.$offset=o.$offset;p.$length=o.$length;p.$capacity=m;n.ptr.$set(p);};E.prototype.SetCap=function(m){return this.$val.SetCap(m);};E.ptr.prototype.SetLen=function(m){var m,n,o,p;n=this;new F(n.flag).mustBeAssignable();new F(n.flag).mustBe(23);o=n.ptr.$get();if(m<0||m>($parseInt(o.$capacity)>>0)){$panic(new $String("reflect: slice length out of range in SetLen"));}p=new(BI(n.typ))(o.$array);p.$offset=o.$offset;p.$length=m;p.$capacity=o.$capacity;n.ptr.$set(p);};E.prototype.SetLen=function(m){return this.$val.SetLen(m);};E.ptr.prototype.Slice=function(m,n){var{m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m,n});$s=$s||0;s:while(true){switch($s){case 0:o=this;p=0;q=$ifaceNil;r=null;s=new F(o.flag).kind();t=s;if(t===(17)){$s=2;continue;}if(t===(23)){$s=3;continue;}if(t===(24)){$s=4;continue;}$s=5;continue;case 2:if(((o.flag&256)>>>0)===0){$panic(new $String("reflect.Value.Slice: slice of unaddressable array"));}u=(o.typ.kindType);p=((u.len>>0));q=CH(u.elem);r=new(BI(q))($clone(o,E).object());$s=6;continue;case 3:q=o.typ;r=$clone(o,E).object();p=$parseInt(r.$capacity)>>0;$s=6;continue;case 4:v=(o.ptr).$get();if(m<0||nv.length){$panic(new $String("reflect.Value.Slice: string slice index out of bounds"));}w=CC(new $String($substring(v,m,n)));$s=7;case 7:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}x=w;$s=8;case 8:return x;case 5:$panic(new I.ptr("reflect.Value.Slice",s));case 6:case 1:if(m<0||np){$panic(new $String("reflect.Value.Slice: slice index out of bounds"));}y=BZ(q,$subslice(r,m,n),new F(o.flag).ro());$s=9;case 9:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}z=y;$s=10;case 10:return z;}return;}var $f={$blk:E.ptr.prototype.Slice,$c:true,$r,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};E.prototype.Slice=function(m,n){return this.$val.Slice(m,n);};E.ptr.prototype.Slice3=function(m,n,o){var{m,n,o,p,q,r,s,t,u,v,w,x,$s,$r,$c}=$restore(this,{m,n,o});$s=$s||0;s:while(true){switch($s){case 0:p=this;q=0;r=$ifaceNil;s=null;t=new F(p.flag).kind();u=t;if(u===(17)){if(((p.flag&256)>>>0)===0){$panic(new $String("reflect.Value.Slice: slice of unaddressable array"));}v=(p.typ.kindType);q=((v.len>>0));r=CH(v.elem);s=new(BI(r))($clone(p,E).object());}else if(u===(23)){r=p.typ;s=$clone(p,E).object();q=$parseInt(s.$capacity)>>0;}else{$panic(new I.ptr("reflect.Value.Slice3",t));}if(m<0||nq){$panic(new $String("reflect.Value.Slice3: slice index out of bounds"));}w=BZ(r,$subslice(s,m,n,o),new F(p.flag).ro());$s=1;case 1:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}x=w;$s=2;case 2:return x;}return;}var $f={$blk:E.ptr.prototype.Slice3,$c:true,$r,m,n,o,p,q,r,s,t,u,v,w,x,$s};return $f;};E.prototype.Slice3=function(m,n,o){return this.$val.Slice3(m,n,o);};E.ptr.prototype.Close=function(){var m;m=this;new F(m.flag).mustBe(18);new F(m.flag).mustBeExported();$close($clone(m,E).object());};E.prototype.Close=function(){return this.$val.Close();};E.ptr.prototype.Elem=function(){var{m,n,o,p,q,r,s,t,u,v,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:m=this;n=new F(m.flag).kind();o=n;if(o===(20)){$s=2;continue;}if(o===(22)){$s=3;continue;}$s=4;continue;case 2:p=$clone(m,E).object();if(p===$ifaceNil){$s=-1;return new E.ptr(DU.nil,0,0);}q=BJ(p.constructor);r=BZ(q,p.$val,new F(m.flag).ro());$s=6;case 6:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}s=r;$s=7;case 7:return s;case 3:if($clone(m,E).IsNil()){$s=-1;return new E.ptr(DU.nil,0,0);}t=$clone(m,E).object();u=(m.typ.kindType);v=(((((m.flag&96)>>>0)|128)>>>0)|256)>>>0;v=(v|(((u.elem.Kind()>>>0))))>>>0;$s=-1;return new E.ptr(u.elem,(DI(u.elem,t)),v);case 4:$panic(new I.ptr("reflect.Value.Elem",n));case 5:case 1:$s=-1;return new E.ptr(DU.nil,0,0);}return;}var $f={$blk:E.ptr.prototype.Elem,$c:true,$r,m,n,o,p,q,r,s,t,u,v,$s};return $f;};E.prototype.Elem=function(){return this.$val.Elem();};E.ptr.prototype.NumField=function(){var m,n;m=this;new F(m.flag).mustBe(25);n=(m.typ.kindType);return n.fields.$length;};E.prototype.NumField=function(){return this.$val.NumField();};E.ptr.prototype.MapKeys=function(){var{m,n,o,p,q,r,s,t,u,v,w,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:m=this;new F(m.flag).mustBe(21);n=(m.typ.kindType);o=n.key;p=(new F(m.flag).ro()|((o.Kind()>>>0)))>>>0;q=$clone(m,E).pointer();r=0;if(!(q===0)){r=CZ(q);}s=CV(m.typ,q);t=$makeSlice(EF,r);u=0;u=0;case 1:if(!(u=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+u]),DM(o,p,w));CY(s);u=u+(1)>>0;$s=1;continue;case 2:$s=-1;return $subslice(t,0,u);}return;}var $f={$blk:E.ptr.prototype.MapKeys,$c:true,$r,m,n,o,p,q,r,s,t,u,v,w,$s};return $f;};E.prototype.MapKeys=function(){return this.$val.MapKeys();};E.ptr.prototype.MapIndex=function(m){var{m,n,o,p,q,r,s,t,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=this;new F(n.flag).mustBe(21);o=(n.typ.kindType);p=$clone(m,E).assignTo("reflect.Value.MapIndex",o.key,0);$s=1;case 1:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}E.copy(m,p);q=0;if(!((((m.flag&128)>>>0)===0))){q=m.ptr;}else{q=((m.$ptr_ptr||(m.$ptr_ptr=new EH(function(){return this.$target.ptr;},function($v){this.$target.ptr=$v;},m))));}r=CR(n.typ,$clone(n,E).pointer(),q);if(r===0){$s=-1;return new E.ptr(DU.nil,0,0);}s=o.elem;t=new F((((n.flag|m.flag)>>>0))).ro();t=(t|(((s.Kind()>>>0))))>>>0;$s=-1;return DM(s,t,r);}return;}var $f={$blk:E.ptr.prototype.MapIndex,$c:true,$r,m,n,o,p,q,r,s,t,$s};return $f;};E.prototype.MapIndex=function(m){return this.$val.MapIndex(m);};E.ptr.prototype.Field=function(m){var{aa,ab,ac,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=[n];o=[o];p=[p];q=[q];r=this;if(!((new F(r.flag).kind()===25))){$panic(new I.ptr("reflect.Value.Field",new F(r.flag).kind()));}s=(r.typ.kindType);if(((m>>>0))>=((s.fields.$length>>>0))){$panic(new $String("reflect: Field index out of range"));}o[0]=$internalize(BI(r.typ).fields[m].prop,$String);u=(t=s.fields,((m<0||m>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+m]));q[0]=u.typ;v=(((r.flag&416)>>>0)|((q[0].Kind()>>>0)))>>>0;if(!$clone(u.name,BO).isExported()){if(u.embedded()){v=(v|(64))>>>0;}else{v=(v|(32))>>>0;}}x=$clone((w=s.fields,((m<0||m>=w.$length)?($throwRuntimeError("index out of range"),undefined):w.$array[w.$offset+m])).name,BO).tag();if(!(x==="")&&!((m===0))){$s=1;continue;}$s=2;continue;case 1:n[0]=DK(x);if(!(n[0]==="")){$s=3;continue;}$s=4;continue;case 3:case 5:y=[y];z=$clone(r,E).Field(0);$s=7;case 7:if($c){$c=false;z=z.$blk();}if(z&&z.$blk!==undefined){break s;}E.copy(r,z);if(r.typ===DH){$s=8;continue;}$s=9;continue;case 8:y[0]=$clone(r,E).object().object;$s=-1;return new E.ptr(q[0],(new(BI(DL(q[0])))((function(n,o,p,q,y){return function(){return $internalize(y[0][$externalize(n[0],$String)],BI(q[0]));};})(n,o,p,q,y),(function(n,o,p,q,y){return function(aa){var aa;y[0][$externalize(n[0],$String)]=$externalize(aa,BI(q[0]));};})(n,o,p,q,y))),v);case 9:if(r.typ.Kind()===22){$s=10;continue;}$s=11;continue;case 10:aa=$clone(r,E).Elem();$s=12;case 12:if($c){$c=false;aa=aa.$blk();}if(aa&&aa.$blk!==undefined){break s;}E.copy(r,aa);case 11:$s=5;continue;case 6:case 4:case 2:p[0]=r.ptr;if(!((((v&128)>>>0)===0))&&!((q[0].Kind()===17))&&!((q[0].Kind()===25))){$s=13;continue;}$s=14;continue;case 13:$s=-1;return new E.ptr(q[0],(new(BI(DL(q[0])))((function(n,o,p,q){return function(){return DI(q[0],p[0][$externalize(o[0],$String)]);};})(n,o,p,q),(function(n,o,p,q){return function(ab){var ab;p[0][$externalize(o[0],$String)]=DJ(q[0],ab);};})(n,o,p,q))),v);case 14:ab=BZ(q[0],DI(q[0],p[0][$externalize(o[0],$String)]),v);$s=15;case 15:if($c){$c=false;ab=ab.$blk();}if(ab&&ab.$blk!==undefined){break s;}ac=ab;$s=16;case 16:return ac;}return;}var $f={$blk:E.ptr.prototype.Field,$c:true,$r,aa,ab,ac,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};E.prototype.Field=function(m){return this.$val.Field(m);};AT.ptr.prototype.Error=function(){var m;m=this;return m.s;};AT.prototype.Error=function(){return this.$val.Error();};AU=function(m){var m;if(m.length<2){return[m,$ifaceNil];}if((m.charCodeAt(0)===39)||(m.charCodeAt(0)===34)){if(m.charCodeAt((m.length-1>>0))===m.charCodeAt(0)){return[$substring(m,1,(m.length-1>>0)),$ifaceNil];}return["",$pkg.ErrSyntax];}return[m,$ifaceNil];};F.prototype.mustBe=function(m){var m,n;n=this.$val;if(!((((((n&31)>>>0)>>>0))===m))){$panic(new I.ptr(DF(),new F(n).kind()));}};$ptrType(F).prototype.mustBe=function(m){return new F(this.$get()).mustBe(m);};R.ptr.prototype.Comparable=function(){var{m,n,o,p,q,r,s,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:m=this;n=m.Kind();if((n===(19))||(n===(23))||(n===(21))){$s=2;continue;}if(n===(17)){$s=3;continue;}if(n===(25)){$s=4;continue;}$s=5;continue;case 2:$s=-1;return false;case 3:o=m.Elem().Comparable();$s=6;case 6:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}p=o;$s=7;case 7:return p;case 4:q=0;case 8:if(!(q>0;$s=8;continue;case 9:case 5:case 1:$s=-1;return true;}return;}var $f={$blk:R.ptr.prototype.Comparable,$c:true,$r,m,n,o,p,q,r,s,$s};return $f;};R.prototype.Comparable=function(){return this.$val.Comparable();};R.ptr.prototype.IsVariadic=function(){var m,n;m=this;if(!((m.Kind()===19))){$panic(new $String("reflect: IsVariadic of non-func type"));}n=(m.kindType);return!((((n.outCount&32768)>>>0)===0));};R.prototype.IsVariadic=function(){return this.$val.IsVariadic();};R.ptr.prototype.Field=function(m){var m,n,o,p;n=this;if(!((n.Kind()===25))){$panic(new $String("reflect: Field of non-struct type"));}o=(n.kindType);if(m<0||m>=o.fields.$length){$panic(new $String("reflect: Field index out of bounds"));}return(p=o.fields,((m<0||m>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+m]));};R.prototype.Field=function(m){return this.$val.Field(m);};R.ptr.prototype.Key=function(){var m,n;m=this;if(!((m.Kind()===21))){$panic(new $String("reflect: Key of non-map type"));}n=(m.kindType);return AP(n.key);};R.prototype.Key=function(){return this.$val.Key();};R.ptr.prototype.NumField=function(){var m,n;m=this;if(!((m.Kind()===25))){$panic(new $String("reflect: NumField of non-struct type"));}n=(m.kindType);return n.fields.$length;};R.prototype.NumField=function(){return this.$val.NumField();};R.ptr.prototype.Method=function(m){var{aa,ab,ac,ad,ae,af,ag,ah,ai,aj,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=[n];o=new AV.ptr("","",$ifaceNil,new E.ptr(DU.nil,0,0),0);p=this;if(p.Kind()===20){$s=1;continue;}$s=2;continue;case 1:q=(p.kindType);r=q.rtype.Method(m);$s=3;case 3:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}AV.copy(o,r);s=o;$s=4;case 4:return s;case 2:t=p.exportedMethods();if(m<0||m>=t.$length){$panic(new $String("reflect: Method index out of range"));}u=$clone(((m<0||m>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+m]),S);v=$clone(p.nameOff(u.name),BO);o.Name=$clone(v,BO).name();w=19;x=p.typeOff(u.mtyp);y=(x.kindType);z=$makeSlice(EI,0,(1+y.in$().$length>>0));z=$append(z,p);aa=y.in$();ab=0;while(true){if(!(ab=aa.$length)?($throwRuntimeError("index out of range"),undefined):aa.$array[aa.$offset+ab]);z=$append(z,ac);ab++;}ad=$makeSlice(EI,0,y.out().$length);ae=y.out();af=0;while(true){if(!(af=ae.$length)?($throwRuntimeError("index out of range"),undefined):ae.$array[ae.$offset+af]);ad=$append(ad,ag);af++;}ah=CF(z,ad,y.rtype.IsVariadic());$s=5;case 5:if($c){$c=false;ah=ah.$blk();}if(ah&&ah.$blk!==undefined){break s;}ai=ah;o.Type=ai;n[0]=$internalize($methodSet(p[$externalize(BE,$String)])[m].prop,$String);aj=D.MakeFunc((function(n){return function(aj,ak){var aj,ak,al;al=(0>=ak.$length?($throwRuntimeError("index out of range"),undefined):ak.$array[ak.$offset+0]);return new $jsObjectPtr(al[$externalize(n[0],$String)].apply(al,$externalize($subslice(ak,1),EJ)));};})(n));E.copy(o.Func,new E.ptr($assertType(ai,DU),(aj),w));o.Index=m;AV.copy(o,o);$s=-1;return o;}return;}var $f={$blk:R.ptr.prototype.Method,$c:true,$r,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};R.prototype.Method=function(m){return this.$val.Method(m);};BA=function(m){var{m,n,o,p,q,r,s,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=[n];o=[o];p=[p];q=CC(m);$s=1;case 1:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}r=$clone(q,E);if(!(($clone(r,E).Kind()===23))){$panic(new I.ptr("Swapper",$clone(r,E).Kind()));}p[0]=(($clone(r,E).Len()>>>0));s=p[0];if(s===(0)){$s=-1;return(function(n,o,p){return function(t,u){var t,u;$panic(new $String("reflect: slice index out of range"));};})(n,o,p);}else if(s===(1)){$s=-1;return(function(n,o,p){return function(t,u){var t,u;if(!((t===0))||!((u===0))){$panic(new $String("reflect: slice index out of range"));}};})(n,o,p);}n[0]=m.$array;o[0]=$parseInt(m.$offset)>>0;$s=-1;return(function(n,o,p){return function(t,u){var t,u,v;if(((t>>>0))>=p[0]||((u>>>0))>=p[0]){$panic(new $String("reflect: slice index out of range"));}t=t+(o[0])>>0;u=u+(o[0])>>0;v=n[0][t];n[0][t]=n[0][u];n[0][u]=v;};})(n,o,p);}return;}var $f={$blk:BA,$c:true,$r,m,n,o,p,q,r,s,$s};return $f;};$pkg.Swapper=BA;BC=function(){var{m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:m=(function(m){var m;});$r=m((n=new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),new n.constructor.elem(n)));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((o=new BL.ptr(0,0,0,0,ED.nil),new o.constructor.elem(o)));$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((p=new S.ptr(0,0,0,0),new p.constructor.elem(p)));$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((q=new U.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),DU.nil,DU.nil,0),new q.constructor.elem(q)));$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((r=new V.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),DU.nil,0),new r.constructor.elem(r)));$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((s=new BN.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),0,0,DW.nil,DW.nil),new s.constructor.elem(s)));$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((t=new X.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),new BO.ptr(EG.nil),EK.nil),new t.constructor.elem(t)));$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((u=new Y.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),DU.nil,DU.nil,DU.nil,$throwNilPointerError,0,0,0,0),new u.constructor.elem(u)));$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((v=new Z.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),DU.nil),new v.constructor.elem(v)));$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((w=new AA.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),DU.nil),new w.constructor.elem(w)));$s=10;case 10:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((x=new AC.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),new BO.ptr(EG.nil),EL.nil),new x.constructor.elem(x)));$s=11;case 11:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((y=new W.ptr(0,0),new y.constructor.elem(y)));$s=12;case 12:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=m((z=new AB.ptr(new BO.ptr(EG.nil),DU.nil,0),new z.constructor.elem(z)));$s=13;case 13:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}BB=true;BD=$assertType(CB(new $Uint8(0)),DU);$s=-1;return;}return;}var $f={$blk:BC,$c:true,$r,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};BI=function(m){var m;return m[$externalize(BE,$String)];};BJ=function(m){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if(m[$externalize(BF,$String)]===undefined){n=new R.ptr(((($parseInt(m.size)>>0)>>>0)),0,0,0,0,0,((($parseInt(m.kind)>>0)<<24>>>24)),$throwNilPointerError,EG.nil,BT($clone(BR(BW(m.string),"",!!(m.exported)),BO)),0);n[$externalize(BE,$String)]=m;m[$externalize(BF,$String)]=n;o=$methodSet(m);if(!(($parseInt(o.length)===0))||!!(m.named)){n.tflag=(n.tflag|(1))>>>0;if(!!(m.named)){n.tflag=(n.tflag|(4))>>>0;}p=ED.nil;q=0;while(true){if(!(q<$parseInt(o.length))){break;}r=o[q];s=BW(r.pkg)==="";if(!s){q=q+(1)>>0;continue;}p=$append(p,new S.ptr(BT($clone(BR(BW(r.name),"",s),BO)),BV(BJ(r.typ)),0,0));q=q+(1)>>0;}t=((p.$length<<16>>>16));u=0;while(true){if(!(u<$parseInt(o.length))){break;}v=o[u];w=BW(v.pkg)==="";if(w){u=u+(1)>>0;continue;}p=$append(p,new S.ptr(BT($clone(BR(BW(v.name),"",w),BO)),BV(BJ(v.typ)),0,0));u=u+(1)>>0;}x=new BL.ptr(BT($clone(BR(BW(m.pkg),"",false),BO)),(($parseInt(o.length)<<16>>>16)),t,0,p);y=n;(BM||$throwRuntimeError("assignment to entry in nil map")).set(DU.keyFor(y),{k:y,v:x});x[$externalize(BE,$String)]=m;}z=n.Kind();if(z===(17)){BK(n,new U.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),BJ(m.elem),DU.nil,((($parseInt(m.len)>>0)>>>0))));}else if(z===(18)){aa=3;if(!!(m.sendOnly)){aa=2;}if(!!(m.recvOnly)){aa=1;}BK(n,new V.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),BJ(m.elem),((aa>>>0))));}else if(z===(19)){ab=m.params;ac=$makeSlice(DW,$parseInt(ab.length));ad=ac;ae=0;while(true){if(!(ae=ac.$length)?($throwRuntimeError("index out of range"),undefined):ac.$array[ac.$offset+af]=BJ(ab[af]));ae++;}ag=m.results;ah=$makeSlice(DW,$parseInt(ag.length));ai=ah;aj=0;while(true){if(!(aj=ah.$length)?($throwRuntimeError("index out of range"),undefined):ah.$array[ah.$offset+ak]=BJ(ag[ak]));aj++;}al=(($parseInt(ag.length)<<16>>>16));if(!!(m.variadic)){al=(al|(32768))>>>0;}BK(n,new BN.ptr($clone(n,R),(($parseInt(ab.length)<<16>>>16)),al,ac,ah));}else if(z===(20)){am=m.methods;an=$makeSlice(EK,$parseInt(am.length));ao=an;ap=0;while(true){if(!(ap=an.$length)?($throwRuntimeError("index out of range"),undefined):an.$array[an.$offset+aq]),new W.ptr(BT($clone(BR(BW(ar.name),"",BW(ar.pkg)===""),BO)),BV(BJ(ar.typ))));ap++;}BK(n,new X.ptr($clone(n,R),$clone(BR(BW(m.pkg),"",false),BO),an));}else if(z===(21)){BK(n,new Y.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),BJ(m.key),BJ(m.elem),DU.nil,$throwNilPointerError,0,0,0,0));}else if(z===(22)){BK(n,new Z.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),BJ(m.elem)));}else if(z===(23)){BK(n,new AA.ptr(new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0),BJ(m.elem)));}else if(z===(25)){as=m.fields;at=$makeSlice(EL,$parseInt(as.length));au=at;av=0;while(true){if(!(av>>0))<<1>>>0;if(!!(ax.embedded)){ay=(ay|(1))>>>0;}AB.copy(((aw<0||aw>=at.$length)?($throwRuntimeError("index out of range"),undefined):at.$array[at.$offset+aw]),new AB.ptr($clone(BR(BW(ax.name),BW(ax.tag),!!(ax.exported)),BO),BJ(ax.typ),ay));av++;}BK(n,new AC.ptr($clone(n,R),$clone(BR(BW(m.pkgPath),"",false),BO),at));}}return((m[$externalize(BF,$String)]));};BK=function(m,n){var m,n;m[$externalize(BG,$String)]=n;n[$externalize(BH,$String)]=m;};BL.ptr.prototype.methods=function(){var m;m=this;return m._methods;};BL.prototype.methods=function(){return this.$val.methods();};BL.ptr.prototype.exportedMethods=function(){var m;m=this;return $subslice(m._methods,0,m.xcount,m.xcount);};BL.prototype.exportedMethods=function(){return this.$val.exportedMethods();};R.ptr.prototype.uncommon=function(){var m,n;m=this;return(n=$mapIndex(BM,DU.keyFor(m)),n!==undefined?n.v:EC.nil);};R.prototype.uncommon=function(){return this.$val.uncommon();};BN.ptr.prototype.in$=function(){var m;m=this;return m._in;};BN.prototype.in$=function(){return this.$val.in$();};BN.ptr.prototype.out=function(){var m;m=this;return m._out;};BN.prototype.out=function(){return this.$val.out();};BO.ptr.prototype.name=function(){var m,n,o;m="";n=this;m=(o=$mapIndex(BQ,EG.keyFor(n.bytes)),o!==undefined?o.v:EM.nil).name;return m;};BO.prototype.name=function(){return this.$val.name();};BO.ptr.prototype.tag=function(){var m,n,o;m="";n=this;m=(o=$mapIndex(BQ,EG.keyFor(n.bytes)),o!==undefined?o.v:EM.nil).tag;return m;};BO.prototype.tag=function(){return this.$val.tag();};BO.ptr.prototype.pkgPath=function(){var m;m=this;return"";};BO.prototype.pkgPath=function(){return this.$val.pkgPath();};BO.ptr.prototype.isExported=function(){var m,n;m=this;return(n=$mapIndex(BQ,EG.keyFor(m.bytes)),n!==undefined?n.v:EM.nil).exported;};BO.prototype.isExported=function(){return this.$val.isExported();};BR=function(m,n,o){var m,n,o,p,q;p=$newDataPointer(0,EG);q=p;(BQ||$throwRuntimeError("assignment to entry in nil map")).set(EG.keyFor(q),{k:q,v:new BP.ptr(m,n,o)});return new BO.ptr(p);};R.ptr.prototype.nameOff=function(m){var m,n,o;n=this;return(o=((m>>0)),((o<0||o>=BS.$length)?($throwRuntimeError("index out of range"),undefined):BS.$array[BS.$offset+o]));};R.prototype.nameOff=function(m){return this.$val.nameOff(m);};BT=function(m){var m,n;n=BS.$length;BS=$append(BS,m);return((n>>0));};R.ptr.prototype.typeOff=function(m){var m,n,o;n=this;return(o=((m>>0)),((o<0||o>=BU.$length)?($throwRuntimeError("index out of range"),undefined):BU.$array[BU.$offset+o]));};R.prototype.typeOff=function(m){return this.$val.typeOff(m);};BV=function(m){var m,n;n=BU.$length;BU=$append(BU,m);return((n>>0));};BW=function(m){var m,n;n=new EN.ptr("");n.str=m;return n.str;};BX=function(m){var m;return!!(BI(m).wrapped);};BY=function(m,n,o){var m,n,o,p,q,r;p=BI(o).fields;q=0;while(true){if(!(q<$parseInt(p.length))){break;}r=$internalize(p[q].prop,$String);m[$externalize(r,$String)]=n[$externalize(r,$String)];q=q+(1)>>0;}};BZ=function(m,n,o){var{m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m,n,o});$s=$s||0;s:while(true){switch($s){case 0:p=m.common();$s=1;case 1:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}q=p;t=m.Kind();$s=6;case 6:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}if(t===17){s=true;$s=5;continue s;}u=m.Kind();$s=7;case 7:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}s=u===25;case 5:if(s){r=true;$s=4;continue s;}v=m.Kind();$s=8;case 8:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}r=v===22;case 4:if(r){$s=2;continue;}$s=3;continue;case 2:w=m.Kind();$s=9;case 9:if($c){$c=false;w=w.$blk();}if(w&&w.$blk!==undefined){break s;}x=new E.ptr(q,(n),(o|((w>>>0)))>>>0);$s=10;case 10:return x;case 3:y=m.Kind();$s=11;case 11:if($c){$c=false;y=y.$blk();}if(y&&y.$blk!==undefined){break s;}z=new E.ptr(q,($newDataPointer(n,BI(q.ptrTo()))),(((o|((y>>>0)))>>>0)|128)>>>0);$s=12;case 12:return z;}return;}var $f={$blk:BZ,$c:true,$r,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};CB=function(m){var m;if(!BB){return new R.ptr(0,0,0,0,0,0,0,$throwNilPointerError,EG.nil,0,0);}if($interfaceIsEqual(m,$ifaceNil)){return $ifaceNil;}return BJ(m.constructor);};$pkg.TypeOf=CB;CC=function(m){var{m,n,o,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:if($interfaceIsEqual(m,$ifaceNil)){$s=-1;return new E.ptr(DU.nil,0,0);}n=BZ(BJ(m.constructor),m.$val,0);$s=1;case 1:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}o=n;$s=2;case 2:return o;}return;}var $f={$blk:CC,$c:true,$r,m,n,o,$s};return $f;};$pkg.ValueOf=CC;CF=function(m,n,o){var{aa,ab,ac,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{m,n,o});$s=$s||0;s:while(true){switch($s){case 0:if(!(o)){p=false;$s=3;continue s;}if(m.$length===0){q=true;$s=4;continue s;}s=(r=m.$length-1>>0,((r<0||r>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+r])).Kind();$s=5;case 5:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}q=!((s===23));case 4:p=q;case 3:if(p){$s=1;continue;}$s=2;continue;case 1:$panic(new $String("reflect.FuncOf: last arg of variadic func must be slice"));case 2:t=$makeSlice(EJ,m.$length);u=m;v=0;while(true){if(!(v=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+v]);((w<0||w>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+w]=BI(x));v++;}y=$makeSlice(EJ,n.$length);z=n;aa=0;while(true){if(!(aa=z.$length)?($throwRuntimeError("index out of range"),undefined):z.$array[z.$offset+aa]);((ab<0||ab>=y.$length)?($throwRuntimeError("index out of range"),undefined):y.$array[y.$offset+ab]=BI(ac));aa++;}$s=-1;return BJ($funcType($externalize(t,EJ),$externalize(y,EJ),$externalize(o,$Bool)));}return;}var $f={$blk:CF,$c:true,$r,aa,ab,ac,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};$pkg.FuncOf=CF;R.ptr.prototype.ptrTo=function(){var m;m=this;return BJ($ptrType(BI(m)));};R.prototype.ptrTo=function(){return this.$val.ptrTo();};CH=function(m){var m;return BJ($sliceType(BI(m)));};$pkg.SliceOf=CH;CJ=function(m){var m,n;n=m.Kind();if(n===(25)){return(new(BI(m).ptr)());}else if(n===(17)){return(BI(m).zero());}else{return($newDataPointer(BI(m).zero(),BI(m.ptrTo())));}};CM=function(m,n,o){var m,n,o;n.$set(o.$get());};CQ=function(m,n){var m,n,o,p;o=n;if(!(o.$get===undefined)){o=o.$get();}p=$internalize(BI(m.Key()).keyFor(o),$String);return[o,p];};CR=function(m,n,o){var m,n,o,p,q,r;p=CQ(m,o);q=p[1];r=n.get($externalize(q,$String));if(r===undefined){return 0;}return($newDataPointer(r.v,BI(DL(m.Elem()))));};CU.ptr.prototype.skipUntilValidKey=function(){var m,n;m=this;while(true){if(!(m.i<$parseInt(m.keys.length))){break;}n=m.keys[m.i];if(!(m.m.get(n)===undefined)){break;}m.i=m.i+(1)>>0;}};CU.prototype.skipUntilValidKey=function(){return this.$val.skipUntilValidKey();};CV=function(m,n){var m,n;return(new CU.ptr(m,n,$global.Array.from(n.keys()),0,null));};CX=function(m){var{m,n,o,p,q,r,s,t,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:n=($pointerOfStructConversion(m,EO));o=null;if(!(n.last===null)){o=n.last;}else{n.skipUntilValidKey();if(n.i===$parseInt(n.keys.length)){$s=-1;return 0;}p=n.keys[n.i];o=n.m.get(p);n.last=o;}q=$assertType(n.t,CW).Key();$s=1;case 1:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}r=DL(q);$s=2;case 2:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}s=BI(r);$s=3;case 3:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}t=($newDataPointer(o.k,s));$s=4;case 4:return t;}return;}var $f={$blk:CX,$c:true,$r,m,n,o,p,q,r,s,t,$s};return $f;};CY=function(m){var m,n;n=($pointerOfStructConversion(m,EO));n.last=null;n.i=n.i+(1)>>0;};CZ=function(m){var m;return $parseInt(m.size)>>0;};DC=function(m,n,o){var m,n,o,p,q,r,s,t,u,v,w,x,y;p=DU.nil;q=EE.nil;r=0;s="";if(n.typ.Kind()===20){t=(n.typ.kindType);if(o<0||o>=t.methods.$length){$panic(new $String("reflect: internal error: invalid method index"));}v=(u=t.methods,((o<0||o>=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+o]));if(!$clone(t.rtype.nameOff(v.name),BO).isExported()){$panic(new $String("reflect: "+m+" of unexported method"));}q=(t.rtype.typeOff(v.typ).kindType);s=$clone(t.rtype.nameOff(v.name),BO).name();}else{w=n.typ.exportedMethods();if(((o>>>0))>=((w.$length>>>0))){$panic(new $String("reflect: internal error: invalid method index"));}x=$clone(((o<0||o>=w.$length)?($throwRuntimeError("index out of range"),undefined):w.$array[w.$offset+o]),S);if(!$clone(n.typ.nameOff(x.name),BO).isExported()){$panic(new $String("reflect: "+m+" of unexported method"));}q=(n.typ.typeOff(x.mtyp).kindType);s=$internalize($methodSet(BI(n.typ))[o].prop,$String);}y=$clone(n,E).object();if(BX(n.typ)){y=new(BI(n.typ))(y);}r=(y[$externalize(s,$String)]);return[p,q,r];};DD=function(m){var{m,n,$s,$r,$c}=$restore(this,{m});$s=$s||0;s:while(true){switch($s){case 0:if(m.flag===0){$panic(new I.ptr("reflect.Value.Interface",0));}if(!((((m.flag&512)>>>0)===0))){$s=1;continue;}$s=2;continue;case 1:n=DG("Interface",$clone(m,E));$s=3;case 3:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}E.copy(m,n);case 2:if(BX(m.typ)){$s=-1;return((new(BI(m.typ))($clone(m,E).object())));}$s=-1;return(($clone(m,E).object()));}return;}var $f={$blk:DD,$c:true,$r,m,n,$s};return $f;};DE=function(m,n,o){var m,n,o;o.$set(n);};DF=function(){return"?FIXME?";};DG=function(m,n){var{m,n,o,p,q,r,s,t,$s,$r,$c}=$restore(this,{m,n});$s=$s||0;s:while(true){switch($s){case 0:o=[o];p=[p];if(((n.flag&512)>>>0)===0){$panic(new $String("reflect: internal error: invalid use of makePartialFunc"));}q=DC(m,$clone(n,E),((n.flag>>0))>>10>>0);o[0]=q[2];p[0]=$clone(n,E).object();if(BX(n.typ)){p[0]=new(BI(n.typ))(p[0]);}r=D.MakeFunc((function(o,p){return function(r,s){var r,s;return new $jsObjectPtr(o[0].apply(p[0],$externalize(s,EJ)));};})(o,p));s=$clone(n,E).Type().common();$s=1;case 1:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}t=new E.ptr(s,(r),(new F(n.flag).ro()|19)>>>0);$s=2;case 2:return t;}return;}var $f={$blk:DG,$c:true,$r,m,n,o,p,q,r,s,t,$s};return $f;};DI=function(m,n){var m,n;if($interfaceIsEqual(m,DH)){return new(BI(DH))(n);}return n;};DJ=function(m,n){var m,n;if($interfaceIsEqual(m,DH)){return n.object;}return n;};DK=function(m){var m,n,o,p,q,r;while(true){if(!(!(m===""))){break;}n=0;while(true){if(!(n>0;}m=$substring(m,n);if(m===""){break;}n=0;while(true){if(!(n>0;}if((n+1>>0)>=m.length||!((m.charCodeAt(n)===58))||!((m.charCodeAt((n+1>>0))===34))){break;}o=($substring(m,0,n));m=$substring(m,(n+1>>0));n=1;while(true){if(!(n>0;}n=n+(1)>>0;}if(n>=m.length){break;}p=($substring(m,0,(n+1>>0)));m=$substring(m,(n+1>>0));if(o==="js"){q=AU(p);r=q[0];return r;}}return"";};DL=function(m){var m;return $assertType(m,DU).ptrTo();};$pkg.PtrTo=DL;DM=function(m,n,o){var m,n,o,p;if(AQ(m)){p=CJ(m);CM(m,p,o);return new E.ptr(m,p,(n|128)>>>0);}return new E.ptr(m,(o).$get(),n);};E.methods=[{prop:"pointer",name:"pointer",pkg:"internal/reflectlite",typ:$funcType([],[$UnsafePointer],false)},{prop:"CanSet",name:"CanSet",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"IsValid",name:"IsValid",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Kind",name:"Kind",pkg:"",typ:$funcType([],[P],false)},{prop:"numMethod",name:"numMethod",pkg:"internal/reflectlite",typ:$funcType([],[$Int],false)},{prop:"Type",name:"Type",pkg:"",typ:$funcType([],[O],false)},{prop:"object",name:"object",pkg:"internal/reflectlite",typ:$funcType([],[DZ],false)},{prop:"assignTo",name:"assignTo",pkg:"internal/reflectlite",typ:$funcType([$String,DU,$UnsafePointer],[E],false)},{prop:"call",name:"call",pkg:"internal/reflectlite",typ:$funcType([$String,EF],[EF],false)},{prop:"Cap",name:"Cap",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Index",name:"Index",pkg:"",typ:$funcType([$Int],[E],false)},{prop:"InterfaceData",name:"InterfaceData",pkg:"",typ:$funcType([],[ES],false)},{prop:"IsNil",name:"IsNil",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Pointer",name:"Pointer",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"Set",name:"Set",pkg:"",typ:$funcType([E],[],false)},{prop:"SetBytes",name:"SetBytes",pkg:"",typ:$funcType([ET],[],false)},{prop:"SetCap",name:"SetCap",pkg:"",typ:$funcType([$Int],[],false)},{prop:"SetLen",name:"SetLen",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Slice",name:"Slice",pkg:"",typ:$funcType([$Int,$Int],[E],false)},{prop:"Slice3",name:"Slice3",pkg:"",typ:$funcType([$Int,$Int,$Int],[E],false)},{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[],false)},{prop:"Elem",name:"Elem",pkg:"",typ:$funcType([],[E],false)},{prop:"NumField",name:"NumField",pkg:"",typ:$funcType([],[$Int],false)},{prop:"MapKeys",name:"MapKeys",pkg:"",typ:$funcType([],[EF],false)},{prop:"MapIndex",name:"MapIndex",pkg:"",typ:$funcType([E],[E],false)},{prop:"Field",name:"Field",pkg:"",typ:$funcType([$Int],[E],false)}];F.methods=[{prop:"kind",name:"kind",pkg:"internal/reflectlite",typ:$funcType([],[P],false)},{prop:"ro",name:"ro",pkg:"internal/reflectlite",typ:$funcType([],[F],false)},{prop:"mustBeExported",name:"mustBeExported",pkg:"internal/reflectlite",typ:$funcType([],[],false)},{prop:"mustBeAssignable",name:"mustBeAssignable",pkg:"internal/reflectlite",typ:$funcType([],[],false)},{prop:"mustBe",name:"mustBe",pkg:"internal/reflectlite",typ:$funcType([P],[],false)}];EU.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];P.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)}];DU.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"Kind",name:"Kind",pkg:"",typ:$funcType([],[P],false)},{prop:"pointers",name:"pointers",pkg:"internal/reflectlite",typ:$funcType([],[$Bool],false)},{prop:"common",name:"common",pkg:"internal/reflectlite",typ:$funcType([],[DU],false)},{prop:"exportedMethods",name:"exportedMethods",pkg:"internal/reflectlite",typ:$funcType([],[ED],false)},{prop:"NumMethod",name:"NumMethod",pkg:"",typ:$funcType([],[$Int],false)},{prop:"PkgPath",name:"PkgPath",pkg:"",typ:$funcType([],[$String],false)},{prop:"hasName",name:"hasName",pkg:"internal/reflectlite",typ:$funcType([],[$Bool],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"chanDir",name:"chanDir",pkg:"internal/reflectlite",typ:$funcType([],[T],false)},{prop:"Elem",name:"Elem",pkg:"",typ:$funcType([],[O],false)},{prop:"In",name:"In",pkg:"",typ:$funcType([$Int],[O],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumIn",name:"NumIn",pkg:"",typ:$funcType([],[$Int],false)},{prop:"NumOut",name:"NumOut",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Out",name:"Out",pkg:"",typ:$funcType([$Int],[O],false)},{prop:"Implements",name:"Implements",pkg:"",typ:$funcType([O],[$Bool],false)},{prop:"AssignableTo",name:"AssignableTo",pkg:"",typ:$funcType([O],[$Bool],false)},{prop:"Comparable",name:"Comparable",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"IsVariadic",name:"IsVariadic",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"kindType",name:"kindType",pkg:"internal/reflectlite",typ:$funcType([],[DU],false)},{prop:"Field",name:"Field",pkg:"",typ:$funcType([$Int],[AB],false)},{prop:"Key",name:"Key",pkg:"",typ:$funcType([],[O],false)},{prop:"NumField",name:"NumField",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Method",name:"Method",pkg:"",typ:$funcType([$Int],[AV],false)},{prop:"uncommon",name:"uncommon",pkg:"internal/reflectlite",typ:$funcType([],[EC],false)},{prop:"nameOff",name:"nameOff",pkg:"internal/reflectlite",typ:$funcType([AG],[BO],false)},{prop:"typeOff",name:"typeOff",pkg:"internal/reflectlite",typ:$funcType([AH],[DU],false)},{prop:"ptrTo",name:"ptrTo",pkg:"internal/reflectlite",typ:$funcType([],[DU],false)}];EW.methods=[{prop:"NumMethod",name:"NumMethod",pkg:"",typ:$funcType([],[$Int],false)}];EY.methods=[{prop:"offset",name:"offset",pkg:"internal/reflectlite",typ:$funcType([],[$Uintptr],false)},{prop:"embedded",name:"embedded",pkg:"internal/reflectlite",typ:$funcType([],[$Bool],false)}];EZ.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];EC.methods=[{prop:"methods",name:"methods",pkg:"internal/reflectlite",typ:$funcType([],[ED],false)},{prop:"exportedMethods",name:"exportedMethods",pkg:"internal/reflectlite",typ:$funcType([],[ED],false)}];EE.methods=[{prop:"in$",name:"in",pkg:"internal/reflectlite",typ:$funcType([],[DW],false)},{prop:"out",name:"out",pkg:"internal/reflectlite",typ:$funcType([],[DW],false)}];BO.methods=[{prop:"data",name:"data",pkg:"internal/reflectlite",typ:$funcType([$Int,$String],[EG],false)},{prop:"hasTag",name:"hasTag",pkg:"internal/reflectlite",typ:$funcType([],[$Bool],false)},{prop:"readVarint",name:"readVarint",pkg:"internal/reflectlite",typ:$funcType([$Int],[$Int,$Int],false)},{prop:"name",name:"name",pkg:"internal/reflectlite",typ:$funcType([],[$String],false)},{prop:"tag",name:"tag",pkg:"internal/reflectlite",typ:$funcType([],[$String],false)},{prop:"pkgPath",name:"pkgPath",pkg:"internal/reflectlite",typ:$funcType([],[$String],false)},{prop:"isExported",name:"isExported",pkg:"internal/reflectlite",typ:$funcType([],[$Bool],false)}];EO.methods=[{prop:"skipUntilValidKey",name:"skipUntilValidKey",pkg:"internal/reflectlite",typ:$funcType([],[],false)}];E.init("internal/reflectlite",[{prop:"typ",name:"typ",embedded:false,exported:false,typ:DU,tag:""},{prop:"ptr",name:"ptr",embedded:false,exported:false,typ:$UnsafePointer,tag:""},{prop:"flag",name:"flag",embedded:true,exported:false,typ:F,tag:""}]);I.init("",[{prop:"Method",name:"Method",embedded:false,exported:true,typ:$String,tag:""},{prop:"Kind",name:"Kind",embedded:false,exported:true,typ:P,tag:""}]);O.init([{prop:"AssignableTo",name:"AssignableTo",pkg:"",typ:$funcType([O],[$Bool],false)},{prop:"Comparable",name:"Comparable",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Elem",name:"Elem",pkg:"",typ:$funcType([],[O],false)},{prop:"Implements",name:"Implements",pkg:"",typ:$funcType([O],[$Bool],false)},{prop:"Kind",name:"Kind",pkg:"",typ:$funcType([],[P],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"PkgPath",name:"PkgPath",pkg:"",typ:$funcType([],[$String],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"common",name:"common",pkg:"internal/reflectlite",typ:$funcType([],[DU],false)},{prop:"uncommon",name:"uncommon",pkg:"internal/reflectlite",typ:$funcType([],[EC],false)}]);R.init("internal/reflectlite",[{prop:"size",name:"size",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"ptrdata",name:"ptrdata",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"hash",name:"hash",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"tflag",name:"tflag",embedded:false,exported:false,typ:Q,tag:""},{prop:"align",name:"align",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"fieldAlign",name:"fieldAlign",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"kind",name:"kind",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"equal",name:"equal",embedded:false,exported:false,typ:EV,tag:""},{prop:"gcdata",name:"gcdata",embedded:false,exported:false,typ:EG,tag:""},{prop:"str",name:"str",embedded:false,exported:false,typ:AG,tag:""},{prop:"ptrToThis",name:"ptrToThis",embedded:false,exported:false,typ:AH,tag:""}]);S.init("internal/reflectlite",[{prop:"name",name:"name",embedded:false,exported:false,typ:AG,tag:""},{prop:"mtyp",name:"mtyp",embedded:false,exported:false,typ:AH,tag:""},{prop:"ifn",name:"ifn",embedded:false,exported:false,typ:AI,tag:""},{prop:"tfn",name:"tfn",embedded:false,exported:false,typ:AI,tag:""}]);U.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:DU,tag:""},{prop:"slice",name:"slice",embedded:false,exported:false,typ:DU,tag:""},{prop:"len",name:"len",embedded:false,exported:false,typ:$Uintptr,tag:""}]);V.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:DU,tag:""},{prop:"dir",name:"dir",embedded:false,exported:false,typ:$Uintptr,tag:""}]);W.init("internal/reflectlite",[{prop:"name",name:"name",embedded:false,exported:false,typ:AG,tag:""},{prop:"typ",name:"typ",embedded:false,exported:false,typ:AH,tag:""}]);X.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:""},{prop:"pkgPath",name:"pkgPath",embedded:false,exported:false,typ:BO,tag:""},{prop:"methods",name:"methods",embedded:false,exported:false,typ:EK,tag:""}]);Y.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:""},{prop:"key",name:"key",embedded:false,exported:false,typ:DU,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:DU,tag:""},{prop:"bucket",name:"bucket",embedded:false,exported:false,typ:DU,tag:""},{prop:"hasher",name:"hasher",embedded:false,exported:false,typ:EX,tag:""},{prop:"keysize",name:"keysize",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"valuesize",name:"valuesize",embedded:false,exported:false,typ:$Uint8,tag:""},{prop:"bucketsize",name:"bucketsize",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"flags",name:"flags",embedded:false,exported:false,typ:$Uint32,tag:""}]);Z.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:DU,tag:""}]);AA.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:""},{prop:"elem",name:"elem",embedded:false,exported:false,typ:DU,tag:""}]);AB.init("internal/reflectlite",[{prop:"name",name:"name",embedded:false,exported:false,typ:BO,tag:""},{prop:"typ",name:"typ",embedded:false,exported:false,typ:DU,tag:""},{prop:"offsetEmbed",name:"offsetEmbed",embedded:false,exported:false,typ:$Uintptr,tag:""}]);AC.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:""},{prop:"pkgPath",name:"pkgPath",embedded:false,exported:false,typ:BO,tag:""},{prop:"fields",name:"fields",embedded:false,exported:false,typ:EL,tag:""}]);AT.init("internal/reflectlite",[{prop:"s",name:"s",embedded:false,exported:false,typ:$String,tag:""}]);AV.init("",[{prop:"Name",name:"Name",embedded:false,exported:true,typ:$String,tag:""},{prop:"PkgPath",name:"PkgPath",embedded:false,exported:true,typ:$String,tag:""},{prop:"Type",name:"Type",embedded:false,exported:true,typ:O,tag:""},{prop:"Func",name:"Func",embedded:false,exported:true,typ:E,tag:""},{prop:"Index",name:"Index",embedded:false,exported:true,typ:$Int,tag:""}]);BL.init("internal/reflectlite",[{prop:"pkgPath",name:"pkgPath",embedded:false,exported:false,typ:AG,tag:""},{prop:"mcount",name:"mcount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"xcount",name:"xcount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"moff",name:"moff",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"_methods",name:"_methods",embedded:false,exported:false,typ:ED,tag:""}]);BN.init("internal/reflectlite",[{prop:"rtype",name:"rtype",embedded:true,exported:false,typ:R,tag:"reflect:\"func\""},{prop:"inCount",name:"inCount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"outCount",name:"outCount",embedded:false,exported:false,typ:$Uint16,tag:""},{prop:"_in",name:"_in",embedded:false,exported:false,typ:DW,tag:""},{prop:"_out",name:"_out",embedded:false,exported:false,typ:DW,tag:""}]);BO.init("internal/reflectlite",[{prop:"bytes",name:"bytes",embedded:false,exported:false,typ:EG,tag:""}]);BP.init("internal/reflectlite",[{prop:"name",name:"name",embedded:false,exported:false,typ:$String,tag:""},{prop:"tag",name:"tag",embedded:false,exported:false,typ:$String,tag:""},{prop:"exported",name:"exported",embedded:false,exported:false,typ:$Bool,tag:""}]);CU.init("internal/reflectlite",[{prop:"t",name:"t",embedded:false,exported:false,typ:O,tag:""},{prop:"m",name:"m",embedded:false,exported:false,typ:DZ,tag:""},{prop:"keys",name:"keys",embedded:false,exported:false,typ:DZ,tag:""},{prop:"i",name:"i",embedded:false,exported:false,typ:$Int,tag:""},{prop:"last",name:"last",embedded:false,exported:false,typ:DZ,tag:""}]);CW.init([{prop:"AssignableTo",name:"AssignableTo",pkg:"",typ:$funcType([O],[$Bool],false)},{prop:"Comparable",name:"Comparable",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Elem",name:"Elem",pkg:"",typ:$funcType([],[O],false)},{prop:"Implements",name:"Implements",pkg:"",typ:$funcType([O],[$Bool],false)},{prop:"Key",name:"Key",pkg:"",typ:$funcType([],[O],false)},{prop:"Kind",name:"Kind",pkg:"",typ:$funcType([],[P],false)},{prop:"Name",name:"Name",pkg:"",typ:$funcType([],[$String],false)},{prop:"PkgPath",name:"PkgPath",pkg:"",typ:$funcType([],[$String],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Uintptr],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"common",name:"common",pkg:"internal/reflectlite",typ:$funcType([],[DU],false)},{prop:"uncommon",name:"uncommon",pkg:"internal/reflectlite",typ:$funcType([],[EC],false)}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=D.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}BD=DU.nil;BS=DV.nil;BU=DW.nil;AD=new DX(["invalid","bool","int","int8","int16","int32","int64","uint","uint8","uint16","uint32","uint64","uintptr","float32","float64","complex64","complex128","array","chan","func","interface","map","ptr","slice","string","struct","unsafe.Pointer"]);AR=$assertType($internalize($call,$emptyInterface),EA);$pkg.ErrSyntax=new AT.ptr("invalid syntax");BB=false;BE="_jsType";BF="_reflectType";BG="kindType";BH="_rtype";BM=new $global.Map();BQ=new $global.Map();DH=BJ($jsObjectPtr);DN=$assertType($internalize($select,$emptyInterface),EA);$r=BC();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["errors"]=(function(){var $pkg={},$init,A,G,H,I,K,L,E,a,B,D,F;A=$packages["internal/reflectlite"];G=$pkg.errorString=$newType(0,$kindStruct,"errors.errorString",true,"errors",false,function(s_){this.$val=this;if(arguments.length===0){this.s="";return;}this.s=s_;});H=$ptrType($error);I=$interfaceType([{prop:"Unwrap",name:"Unwrap",pkg:"",typ:$funcType([],[$error],false)}]);K=$interfaceType([{prop:"As",name:"As",pkg:"",typ:$funcType([$emptyInterface],[$Bool],false)}]);L=$ptrType(G);B=function(b){var{b,c,d,e,f,g,$s,$r,$c}=$restore(this,{b});$s=$s||0;s:while(true){switch($s){case 0:c=$assertType(b,I,true);d=c[0];e=c[1];if(!e){$s=-1;return $ifaceNil;}f=d.Unwrap();$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;$s=2;case 2:return g;}return;}var $f={$blk:B,$c:true,$r,b,c,d,e,f,g,$s};return $f;};$pkg.Unwrap=B;D=function(b,c){var{b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,$s,$r,$c}=$restore(this,{b,c});$s=$s||0;s:while(true){switch($s){case 0:if($interfaceIsEqual(c,$ifaceNil)){$panic(new $String("errors: target cannot be nil"));}d=A.ValueOf(c);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}e=$clone(d,A.Value);f=$clone(e,A.Value).Type();g=f.Kind();$s=4;case 4:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}if(!((g===22))||$clone(e,A.Value).IsNil()){$s=2;continue;}$s=3;continue;case 2:$panic(new $String("errors: target must be a non-nil pointer"));case 3:h=f.Elem();$s=5;case 5:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;k=i.Kind();$s=9;case 9:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}if(!(!((k===20)))){j=false;$s=8;continue s;}l=i.Implements(E);$s=10;case 10:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}j=!l;case 8:if(j){$s=6;continue;}$s=7;continue;case 6:$panic(new $String("errors: *target must be interface or implement error"));case 7:case 11:if(!(!($interfaceIsEqual(b,$ifaceNil)))){$s=12;continue;}m=A.TypeOf(b).AssignableTo(i);$s=15;case 15:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}if(m){$s=13;continue;}$s=14;continue;case 13:n=$clone(e,A.Value).Elem();$s=16;case 16:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}o=A.ValueOf(b);$s=17;case 17:if($c){$c=false;o=o.$blk();}if(o&&o.$blk!==undefined){break s;}$r=$clone(n,A.Value).Set($clone(o,A.Value));$s=18;case 18:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return true;case 14:p=$assertType(b,K,true);q=p[0];r=p[1];if(!(r)){s=false;$s=21;continue s;}t=q.As(c);$s=22;case 22:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}s=t;case 21:if(s){$s=19;continue;}$s=20;continue;case 19:$s=-1;return true;case 20:u=B(b);$s=23;case 23:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}b=u;$s=11;continue;case 12:$s=-1;return false;}return;}var $f={$blk:D,$c:true,$r,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,$s};return $f;};$pkg.As=D;F=function(b){var b;return new G.ptr(b);};$pkg.New=F;G.ptr.prototype.Error=function(){var b;b=this;return b.s;};G.prototype.Error=function(){return this.$val.Error();};L.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)}];G.init("errors",[{prop:"s",name:"s",embedded:false,exported:false,typ:$String,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}a=A.TypeOf((H.nil)).Elem();$s=2;case 2:if($c){$c=false;a=a.$blk();}if(a&&a.$blk!==undefined){break s;}E=a;}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/cpu"]=(function(){var $pkg={},$init;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/bytealg"]=(function(){var $pkg={},$init,A,B,C,D,E,G,J,N,P,R;A=$packages["internal/cpu"];B=function(d,e){var d,e;$panic(new $String("unimplemented"));};$pkg.Index=B;C=function(d,e){var d,e;$panic(new $String("unimplemented"));};$pkg.IndexString=C;D=function(d){var d;$panic(new $String("unimplemented"));};$pkg.Cutover=D;E=function(d,e){var d,e,f,g,h,i;if(!((d.$length===e.$length))){return false;}f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(!((i===((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])))){return false;}g++;}return true;};$pkg.Equal=E;G=function(d,e){var d,e,f;f=0;while(true){if(!(f>0;}return-1;};$pkg.IndexByteString=G;J=function(d,e){var d,e,f,g,h,i;f=0;g=d;h=0;while(true){if(!(h=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+h]);if(i===e){f=f+(1)>>0;}h++;}return f;};$pkg.Count=J;N=function(d){var d,e,f,g,h,i,j,k;e=0;f=0;while(true){if(!(f>>0)+((((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])>>>0))>>>0;f=f+(1)>>0;}g=1;h=16777619;i=g;j=h;k=d.$length;while(true){if(!(k>0)){break;}if(!(((k&1)===0))){i=$imul(i,(j))>>>0;}j=$imul(j,(j))>>>0;k=(k>>$min((1),31))>>0;}return[e,i];};$pkg.HashStrBytes=N;P=function(d){var d,e,f,g,h,i,j,k;e=0;f=d.$length-1>>0;while(true){if(!(f>=0)){break;}e=($imul(e,16777619)>>>0)+((((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])>>>0))>>>0;f=f-(1)>>0;}g=1;h=16777619;i=g;j=h;k=d.$length;while(true){if(!(k>0)){break;}if(!(((k&1)===0))){i=$imul(i,(j))>>>0;}j=$imul(j,(j))>>>0;k=(k>>$min((1),31))>>0;}return[e,i];};$pkg.HashStrRevBytes=P;R=function(d,e){var d,e,f,g,h,i,j,k,l,m;f=N(e);g=f[0];h=f[1];i=e.$length;j=0;k=0;while(true){if(!(k>>0)+((((k<0||k>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+k])>>>0))>>>0;k=k+(1)>>0;}if((j===g)&&E($subslice(d,0,i),e)){return 0;}l=i;while(true){if(!(l>>0;j=j+(((((l<0||l>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+l])>>>0)))>>>0;j=j-(($imul(h,(((m=l-i>>0,((m<0||m>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+m]))>>>0)))>>>0))>>>0;l=l+(1)>>0;if((j===g)&&E($subslice(d,(l-i>>0),l),e)){return l-i>>0;}}return-1;};$pkg.IndexRabinKarpBytes=R;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.MaxLen=0;}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/race"]=(function(){var $pkg={},$init,A,B,C,D,E;A=function(a){var a;};$pkg.Acquire=A;B=function(a){var a;};$pkg.Release=B;C=function(a){var a;};$pkg.ReleaseMerge=C;D=function(){};$pkg.Disable=D;E=function(){};$pkg.Enable=E;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["sync/atomic"]=(function(){var $pkg={},$init,A,B,AL,M,P,R,S,T,X,Z,AA,AC,AD,AF,AI,AJ;A=$packages["github.com/gopherjs/gopherjs/js"];B=$pkg.Value=$newType(0,$kindStruct,"atomic.Value",true,"sync/atomic",true,function(v_){this.$val=this;if(arguments.length===0){this.v=$ifaceNil;return;}this.v=v_;});AL=$ptrType(B);M=function(ad,ae,af){var ad,ae,af;if(ad.$get()===ae){ad.$set(af);return true;}return false;};$pkg.CompareAndSwapInt32=M;P=function(ad,ae,af){var ad,ae,af,ag;if((ag=ad.$get(),(ag.$high===ae.$high&&ag.$low===ae.$low))){ad.$set(af);return true;}return false;};$pkg.CompareAndSwapUint64=P;R=function(ad,ae,af){var ad,ae,af;if(ad.$get()===ae){ad.$set(af);return true;}return false;};$pkg.CompareAndSwapPointer=R;S=function(ad,ae){var ad,ae,af;af=ad.$get()+ae>>0;ad.$set(af);return af;};$pkg.AddInt32=S;T=function(ad,ae){var ad,ae,af;af=ad.$get()+ae>>>0;ad.$set(af);return af;};$pkg.AddUint32=T;X=function(ad){var ad;return ad.$get();};$pkg.LoadInt32=X;Z=function(ad){var ad;return ad.$get();};$pkg.LoadUint32=Z;AA=function(ad){var ad;return ad.$get();};$pkg.LoadUint64=AA;AC=function(ad){var ad;return ad.$get();};$pkg.LoadPointer=AC;AD=function(ad,ae){var ad,ae;ad.$set(ae);};$pkg.StoreInt32=AD;AF=function(ad,ae){var ad,ae;ad.$set(ae);};$pkg.StoreUint32=AF;AI=function(ad,ae){var ad,ae;ad.$set(ae);};$pkg.StorePointer=AI;B.ptr.prototype.Load=function(){var ad,ae;ad=$ifaceNil;ae=this;ad=ae.v;return ad;};B.prototype.Load=function(){return this.$val.Load();};B.ptr.prototype.Store=function(ad){var ad,ae;ae=this;ae.checkNew("store",ad);ae.v=ad;};B.prototype.Store=function(ad){return this.$val.Store(ad);};B.ptr.prototype.Swap=function(ad){var ad,ae,af,ag,ah;ae=$ifaceNil;af=this;af.checkNew("swap",ad);ag=af.v;ah=ad;ae=ag;af.v=ah;ae=ae;return ae;};B.prototype.Swap=function(ad){return this.$val.Swap(ad);};B.ptr.prototype.CompareAndSwap=function(ad,ae){var ad,ae,af,ag;af=false;ag=this;ag.checkNew("compare and swap",ae);if(!($interfaceIsEqual(ag.v,$ifaceNil)&&$interfaceIsEqual(ad,$ifaceNil))&&!AJ(ad,ae)){$panic(new $String("sync/atomic: compare and swap of inconsistently typed values into Value"));}if(!($interfaceIsEqual(ag.v,ad))){af=false;return af;}ag.v=ae;af=true;return af;};B.prototype.CompareAndSwap=function(ad,ae){return this.$val.CompareAndSwap(ad,ae);};B.ptr.prototype.checkNew=function(ad,ae){var ad,ae,af;af=this;if($interfaceIsEqual(ae,$ifaceNil)){$panic(new $String("sync/atomic: "+ad+" of nil value into Value"));}if(!($interfaceIsEqual(af.v,$ifaceNil))&&!AJ(ae,af.v)){$panic(new $String("sync/atomic: "+ad+" of inconsistently typed value into Value"));}};B.prototype.checkNew=function(ad,ae){return this.$val.checkNew(ad,ae);};AJ=function(ad,ae){var ad,ae;return ad.constructor===ae.constructor;};AL.methods=[{prop:"Load",name:"Load",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"Store",name:"Store",pkg:"",typ:$funcType([$emptyInterface],[],false)},{prop:"Swap",name:"Swap",pkg:"",typ:$funcType([$emptyInterface],[$emptyInterface],false)},{prop:"CompareAndSwap",name:"CompareAndSwap",pkg:"",typ:$funcType([$emptyInterface,$emptyInterface],[$Bool],false)},{prop:"checkNew",name:"checkNew",pkg:"sync/atomic",typ:$funcType([$String,$emptyInterface],[],false)}];B.init("sync/atomic",[{prop:"v",name:"v",embedded:false,exported:false,typ:$emptyInterface,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["sync"]=(function(){var $pkg={},$init,C,A,B,D,E,F,T,U,V,W,X,Z,AL,AT,AV,AW,AX,AY,BD,BE,BG,BH,BL,BM,BN,BO,BP,BQ,BT,BU,BV,Y,AC,AD,K,L,AA,AE,AF,AG,AH,AI,AJ,AK;C=$packages["github.com/gopherjs/gopherjs/js"];A=$packages["internal/race"];B=$packages["sync/atomic"];D=$pkg.RWMutex=$newType(0,$kindStruct,"sync.RWMutex",true,"sync",true,function(w_,writerSem_,readerSem_,readerCount_,readerWait_){this.$val=this;if(arguments.length===0){this.w=new U.ptr(0,0);this.writerSem=0;this.readerSem=0;this.readerCount=0;this.readerWait=0;return;}this.w=w_;this.writerSem=writerSem_;this.readerSem=readerSem_;this.readerCount=readerCount_;this.readerWait=readerWait_;});E=$pkg.rlocker=$newType(0,$kindStruct,"sync.rlocker",true,"sync",false,function(w_,writerSem_,readerSem_,readerCount_,readerWait_){this.$val=this;if(arguments.length===0){this.w=new U.ptr(0,0);this.writerSem=0;this.readerSem=0;this.readerCount=0;this.readerWait=0;return;}this.w=w_;this.writerSem=writerSem_;this.readerSem=readerSem_;this.readerCount=readerCount_;this.readerWait=readerWait_;});F=$pkg.notifyList=$newType(0,$kindStruct,"sync.notifyList",true,"sync",false,function(wait_,notify_,lock_,head_,tail_){this.$val=this;if(arguments.length===0){this.wait=0;this.notify=0;this.lock=0;this.head=0;this.tail=0;return;}this.wait=wait_;this.notify=notify_;this.lock=lock_;this.head=head_;this.tail=tail_;});T=$pkg.Once=$newType(0,$kindStruct,"sync.Once",true,"sync",true,function(done_,m_){this.$val=this;if(arguments.length===0){this.done=0;this.m=new U.ptr(0,0);return;}this.done=done_;this.m=m_;});U=$pkg.Mutex=$newType(0,$kindStruct,"sync.Mutex",true,"sync",true,function(state_,sema_){this.$val=this;if(arguments.length===0){this.state=0;this.sema=0;return;}this.state=state_;this.sema=sema_;});V=$pkg.Locker=$newType(8,$kindInterface,"sync.Locker",true,"sync",true,null);W=$pkg.Map=$newType(0,$kindStruct,"sync.Map",true,"sync",true,function(mu_,read_,dirty_,misses_){this.$val=this;if(arguments.length===0){this.mu=new U.ptr(0,0);this.read=new B.Value.ptr($ifaceNil);this.dirty=false;this.misses=0;return;}this.mu=mu_;this.read=read_;this.dirty=dirty_;this.misses=misses_;});X=$pkg.readOnly=$newType(0,$kindStruct,"sync.readOnly",true,"sync",false,function(m_,amended_){this.$val=this;if(arguments.length===0){this.m=false;this.amended=false;return;}this.m=m_;this.amended=amended_;});Z=$pkg.entry=$newType(0,$kindStruct,"sync.entry",true,"sync",false,function(p_){this.$val=this;if(arguments.length===0){this.p=0;return;}this.p=p_;});AL=$pkg.Pool=$newType(0,$kindStruct,"sync.Pool",true,"sync",true,function(store_,New_){this.$val=this;if(arguments.length===0){this.store=BT.nil;this.New=$throwNilPointerError;return;}this.store=store_;this.New=New_;});AT=$ptrType($Uint32);AV=$ptrType($Int32);AW=$ptrType(E);AX=$ptrType(D);AY=$ptrType($UnsafePointer);BD=$ptrType($emptyInterface);BE=$ptrType(Z);BG=$chanType($Bool,false,false);BH=$sliceType(BG);BL=$funcType([],[],false);BM=$ptrType(T);BN=$ptrType(U);BO=$funcType([$emptyInterface,$emptyInterface],[$Bool],false);BP=$ptrType(W);BQ=$mapType($emptyInterface,BE);BT=$sliceType($emptyInterface);BU=$ptrType(AL);BV=$funcType([],[$emptyInterface],false);D.ptr.prototype.RLock=function(){var{j,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(false){$unused(j.w.state);A.Disable();}if(B.AddInt32((j.$ptr_readerCount||(j.$ptr_readerCount=new AV(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},j))),1)<0){$s=1;continue;}$s=2;continue;case 1:$r=AF((j.$ptr_readerSem||(j.$ptr_readerSem=new AT(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},j))),false,0);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(false){A.Enable();A.Acquire(((j.$ptr_readerSem||(j.$ptr_readerSem=new AT(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},j)))));}$s=-1;return;}return;}var $f={$blk:D.ptr.prototype.RLock,$c:true,$r,j,$s};return $f;};D.prototype.RLock=function(){return this.$val.RLock();};D.ptr.prototype.TryRLock=function(){var j,k;j=this;if(false){$unused(j.w.state);A.Disable();}while(true){k=B.LoadInt32((j.$ptr_readerCount||(j.$ptr_readerCount=new AV(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},j))));if(k<0){if(false){A.Enable();}return false;}if(B.CompareAndSwapInt32((j.$ptr_readerCount||(j.$ptr_readerCount=new AV(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},j))),k,k+1>>0)){if(false){A.Enable();A.Acquire(((j.$ptr_readerSem||(j.$ptr_readerSem=new AT(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},j)))));}return true;}}};D.prototype.TryRLock=function(){return this.$val.TryRLock();};D.ptr.prototype.RUnlock=function(){var{j,k,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(false){$unused(j.w.state);A.ReleaseMerge(((j.$ptr_writerSem||(j.$ptr_writerSem=new AT(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},j)))));A.Disable();}k=B.AddInt32((j.$ptr_readerCount||(j.$ptr_readerCount=new AV(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},j))),-1);if(k<0){$s=1;continue;}$s=2;continue;case 1:$r=j.rUnlockSlow(k);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(false){A.Enable();}$s=-1;return;}return;}var $f={$blk:D.ptr.prototype.RUnlock,$c:true,$r,j,k,$s};return $f;};D.prototype.RUnlock=function(){return this.$val.RUnlock();};D.ptr.prototype.rUnlockSlow=function(j){var{j,k,$s,$r,$c}=$restore(this,{j});$s=$s||0;s:while(true){switch($s){case 0:k=this;if(((j+1>>0)===0)||((j+1>>0)===-1073741824)){A.Enable();AK("sync: RUnlock of unlocked RWMutex");}if(B.AddInt32((k.$ptr_readerWait||(k.$ptr_readerWait=new AV(function(){return this.$target.readerWait;},function($v){this.$target.readerWait=$v;},k))),-1)===0){$s=1;continue;}$s=2;continue;case 1:$r=AG((k.$ptr_writerSem||(k.$ptr_writerSem=new AT(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},k))),false,1);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$s=-1;return;}return;}var $f={$blk:D.ptr.prototype.rUnlockSlow,$c:true,$r,j,k,$s};return $f;};D.prototype.rUnlockSlow=function(j){return this.$val.rUnlockSlow(j);};D.ptr.prototype.Lock=function(){var{j,k,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(false){$unused(j.w.state);A.Disable();}$r=j.w.Lock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}k=B.AddInt32((j.$ptr_readerCount||(j.$ptr_readerCount=new AV(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},j))),-1073741824)+1073741824>>0;if(!((k===0))&&!((B.AddInt32((j.$ptr_readerWait||(j.$ptr_readerWait=new AV(function(){return this.$target.readerWait;},function($v){this.$target.readerWait=$v;},j))),k)===0))){$s=2;continue;}$s=3;continue;case 2:$r=AF((j.$ptr_writerSem||(j.$ptr_writerSem=new AT(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},j))),false,0);$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 3:if(false){A.Enable();A.Acquire(((j.$ptr_readerSem||(j.$ptr_readerSem=new AT(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},j)))));A.Acquire(((j.$ptr_writerSem||(j.$ptr_writerSem=new AT(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},j)))));}$s=-1;return;}return;}var $f={$blk:D.ptr.prototype.Lock,$c:true,$r,j,k,$s};return $f;};D.prototype.Lock=function(){return this.$val.Lock();};D.ptr.prototype.TryLock=function(){var{j,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(false){$unused(j.w.state);A.Disable();}if(!j.w.TryLock()){if(false){A.Enable();}$s=-1;return false;}if(!B.CompareAndSwapInt32((j.$ptr_readerCount||(j.$ptr_readerCount=new AV(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},j))),0,-1073741824)){$s=1;continue;}$s=2;continue;case 1:$r=j.w.Unlock();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if(false){A.Enable();}$s=-1;return false;case 2:if(false){A.Enable();A.Acquire(((j.$ptr_readerSem||(j.$ptr_readerSem=new AT(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},j)))));A.Acquire(((j.$ptr_writerSem||(j.$ptr_writerSem=new AT(function(){return this.$target.writerSem;},function($v){this.$target.writerSem=$v;},j)))));}$s=-1;return true;}return;}var $f={$blk:D.ptr.prototype.TryLock,$c:true,$r,j,$s};return $f;};D.prototype.TryLock=function(){return this.$val.TryLock();};D.ptr.prototype.Unlock=function(){var{j,k,l,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(false){$unused(j.w.state);A.Release(((j.$ptr_readerSem||(j.$ptr_readerSem=new AT(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},j)))));A.Disable();}k=B.AddInt32((j.$ptr_readerCount||(j.$ptr_readerCount=new AV(function(){return this.$target.readerCount;},function($v){this.$target.readerCount=$v;},j))),1073741824);if(k>=1073741824){A.Enable();AK("sync: Unlock of unlocked RWMutex");}l=0;case 1:if(!(l<((k>>0)))){$s=2;continue;}$r=AG((j.$ptr_readerSem||(j.$ptr_readerSem=new AT(function(){return this.$target.readerSem;},function($v){this.$target.readerSem=$v;},j))),false,0);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}l=l+(1)>>0;$s=1;continue;case 2:$r=j.w.Unlock();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}if(false){A.Enable();}$s=-1;return;}return;}var $f={$blk:D.ptr.prototype.Unlock,$c:true,$r,j,k,l,$s};return $f;};D.prototype.Unlock=function(){return this.$val.Unlock();};D.ptr.prototype.RLocker=function(){var j;j=this;return($pointerOfStructConversion(j,AW));};D.prototype.RLocker=function(){return this.$val.RLocker();};E.ptr.prototype.Lock=function(){var{j,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;$r=($pointerOfStructConversion(j,AX)).RLock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}var $f={$blk:E.ptr.prototype.Lock,$c:true,$r,j,$s};return $f;};E.prototype.Lock=function(){return this.$val.Lock();};E.ptr.prototype.Unlock=function(){var{j,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;$r=($pointerOfStructConversion(j,AX)).RUnlock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}var $f={$blk:E.ptr.prototype.Unlock,$c:true,$r,j,$s};return $f;};E.prototype.Unlock=function(){return this.$val.Unlock();};K=function(){var j;j=new F.ptr(0,0,0,0,0);AH(20);};L=function(){$throwRuntimeError("native function not implemented: sync.runtime_doSpin");};T.ptr.prototype.Do=function(j){var{j,k,$s,$r,$c}=$restore(this,{j});$s=$s||0;s:while(true){switch($s){case 0:k=this;if(B.LoadUint32((k.$ptr_done||(k.$ptr_done=new AT(function(){return this.$target.done;},function($v){this.$target.done=$v;},k))))===0){$s=1;continue;}$s=2;continue;case 1:$r=k.doSlow(j);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$s=-1;return;}return;}var $f={$blk:T.ptr.prototype.Do,$c:true,$r,j,k,$s};return $f;};T.prototype.Do=function(j){return this.$val.Do(j);};T.ptr.prototype.doSlow=function(j){var{j,k,$s,$deferred,$r,$c}=$restore(this,{j});$s=$s||0;var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$curGoroutine.deferStack.push($deferred);k=this;$r=k.m.Lock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$deferred.push([$methodVal(k.m,"Unlock"),[]]);if(k.done===0){$s=2;continue;}$s=3;continue;case 2:$deferred.push([B.StoreUint32,[(k.$ptr_done||(k.$ptr_done=new AT(function(){return this.$target.done;},function($v){this.$target.done=$v;},k))),1]]);$r=j();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 3:$s=-1;return;}return;}}catch(err){$err=err;$s=-1;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){var $f={$blk:T.ptr.prototype.doSlow,$c:true,$r,j,k,$s,$deferred};return $f;}}};T.prototype.doSlow=function(j){return this.$val.doSlow(j);};U.ptr.prototype.Lock=function(){var{j,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(B.CompareAndSwapInt32((j.$ptr_state||(j.$ptr_state=new AV(function(){return this.$target.state;},function($v){this.$target.state=$v;},j))),0,1)){if(false){A.Acquire((j));}$s=-1;return;}$r=j.lockSlow();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}var $f={$blk:U.ptr.prototype.Lock,$c:true,$r,j,$s};return $f;};U.prototype.Lock=function(){return this.$val.Lock();};U.ptr.prototype.TryLock=function(){var j,k;j=this;k=j.state;if(!(((k&5)===0))){return false;}if(!B.CompareAndSwapInt32((j.$ptr_state||(j.$ptr_state=new AV(function(){return this.$target.state;},function($v){this.$target.state=$v;},j))),k,k|1)){return false;}if(false){A.Acquire((j));}return true;};U.prototype.TryLock=function(){return this.$val.TryLock();};U.ptr.prototype.lockSlow=function(){var{j,k,l,m,n,o,p,q,r,s,t,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;k=new $Int64(0,0);l=false;m=false;n=0;o=j.state;case 1:if(((o&5)===1)&&AI(n)){$s=3;continue;}$s=4;continue;case 3:if(!m&&((o&2)===0)&&!(((o>>3>>0)===0))&&B.CompareAndSwapInt32((j.$ptr_state||(j.$ptr_state=new AV(function(){return this.$target.state;},function($v){this.$target.state=$v;},j))),o,o|2)){m=true;}$r=L();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}n=n+(1)>>0;o=j.state;$s=1;continue;case 4:p=o;if((o&4)===0){p=p|(1);}if(!(((o&5)===0))){p=p+(8)>>0;}if(l&&!(((o&1)===0))){p=p|(4);}if(m){if((p&2)===0){AK("sync: inconsistent mutex state");}p=(p&~(2))>>0;}if(B.CompareAndSwapInt32((j.$ptr_state||(j.$ptr_state=new AV(function(){return this.$target.state;},function($v){this.$target.state=$v;},j))),o,p)){$s=6;continue;}$s=7;continue;case 6:if((o&5)===0){$s=2;continue;}q=!((k.$high===0&&k.$low===0));if((k.$high===0&&k.$low===0)){k=AJ();}$r=AF((j.$ptr_sema||(j.$ptr_sema=new AT(function(){return this.$target.sema;},function($v){this.$target.sema=$v;},j))),q,1);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}l=l||(r=(s=AJ(),new $Int64(s.$high-k.$high,s.$low-k.$low)),(r.$high>0||(r.$high===0&&r.$low>1000000)));o=j.state;if(!(((o&4)===0))){if(!(((o&3)===0))||((o>>3>>0)===0)){AK("sync: inconsistent mutex state");}t=-7;if(!l||((o>>3>>0)===1)){t=t-(4)>>0;}B.AddInt32((j.$ptr_state||(j.$ptr_state=new AV(function(){return this.$target.state;},function($v){this.$target.state=$v;},j))),t);$s=2;continue;}m=true;n=0;$s=8;continue;case 7:o=j.state;case 8:$s=1;continue;case 2:if(false){A.Acquire((j));}$s=-1;return;}return;}var $f={$blk:U.ptr.prototype.lockSlow,$c:true,$r,j,k,l,m,n,o,p,q,r,s,t,$s};return $f;};U.prototype.lockSlow=function(){return this.$val.lockSlow();};U.ptr.prototype.Unlock=function(){var{j,k,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(false){$unused(j.state);A.Release((j));}k=B.AddInt32((j.$ptr_state||(j.$ptr_state=new AV(function(){return this.$target.state;},function($v){this.$target.state=$v;},j))),-1);if(!((k===0))){$s=1;continue;}$s=2;continue;case 1:$r=j.unlockSlow(k);$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:$s=-1;return;}return;}var $f={$blk:U.ptr.prototype.Unlock,$c:true,$r,j,k,$s};return $f;};U.prototype.Unlock=function(){return this.$val.Unlock();};U.ptr.prototype.unlockSlow=function(j){var{j,k,l,$s,$r,$c}=$restore(this,{j});$s=$s||0;s:while(true){switch($s){case 0:k=this;if((((j+1>>0))&1)===0){AK("sync: unlock of unlocked mutex");}if((j&4)===0){$s=1;continue;}$s=2;continue;case 1:l=j;case 4:if(((l>>3>>0)===0)||!(((l&7)===0))){$s=-1;return;}j=((l-8>>0))|2;if(B.CompareAndSwapInt32((k.$ptr_state||(k.$ptr_state=new AV(function(){return this.$target.state;},function($v){this.$target.state=$v;},k))),l,j)){$s=6;continue;}$s=7;continue;case 6:$r=AG((k.$ptr_sema||(k.$ptr_sema=new AT(function(){return this.$target.sema;},function($v){this.$target.sema=$v;},k))),false,1);$s=8;case 8:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;case 7:l=k.state;$s=4;continue;case 5:$s=3;continue;case 2:$r=AG((k.$ptr_sema||(k.$ptr_sema=new AT(function(){return this.$target.sema;},function($v){this.$target.sema=$v;},k))),true,1);$s=9;case 9:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 3:$s=-1;return;}return;}var $f={$blk:U.ptr.prototype.unlockSlow,$c:true,$r,j,k,l,$s};return $f;};U.prototype.unlockSlow=function(j){return this.$val.unlockSlow(j);};AA=function(j){var j,k;return new Z.ptr(((k||(k=new BD(function(){return j;},function($v){j=$v;})))));};W.ptr.prototype.Load=function(j){var{j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{j});$s=$s||0;s:while(true){switch($s){case 0:k=$ifaceNil;l=false;m=this;n=$assertType(m.read.Load(),X,true);o=$clone(n[0],X);p=(q=$mapIndex(o.m,$emptyInterface.keyFor(j)),q!==undefined?[q.v,true]:[BE.nil,false]);r=p[0];l=p[1];if(!l&&o.amended){$s=1;continue;}$s=2;continue;case 1:$r=m.mu.Lock();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}s=$assertType(m.read.Load(),X,true);X.copy(o,s[0]);t=(u=$mapIndex(o.m,$emptyInterface.keyFor(j)),u!==undefined?[u.v,true]:[BE.nil,false]);r=t[0];l=t[1];if(!l&&o.amended){v=(w=$mapIndex(m.dirty,$emptyInterface.keyFor(j)),w!==undefined?[w.v,true]:[BE.nil,false]);r=v[0];l=v[1];m.missLocked();}$r=m.mu.Unlock();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(!l){x=$ifaceNil;y=false;k=x;l=y;$s=-1;return[k,l];}z=r.load();k=z[0];l=z[1];$s=-1;return[k,l];}return;}var $f={$blk:W.ptr.prototype.Load,$c:true,$r,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};W.prototype.Load=function(j){return this.$val.Load(j);};Z.ptr.prototype.load=function(){var j,k,l,m,n,o,p,q;j=$ifaceNil;k=false;l=this;m=B.LoadPointer((l.$ptr_p||(l.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},l))));if(m===0||m===Y){n=$ifaceNil;o=false;j=n;k=o;return[j,k];}p=(m).$get();q=true;j=p;k=q;return[j,k];};Z.prototype.load=function(){return this.$val.load();};W.ptr.prototype.Store=function(j,k){var{aa,ab,ac,ad,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{j,k});$s=$s||0;s:while(true){switch($s){case 0:k=[k];l=this;m=$assertType(l.read.Load(),X,true);n=$clone(m[0],X);o=(p=$mapIndex(n.m,$emptyInterface.keyFor(j)),p!==undefined?[p.v,true]:[BE.nil,false]);q=o[0];r=o[1];if(r&&q.tryStore((k.$ptr||(k.$ptr=new BD(function(){return this.$target[0];},function($v){this.$target[0]=$v;},k))))){$s=-1;return;}$r=l.mu.Lock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}s=$assertType(l.read.Load(),X,true);X.copy(n,s[0]);t=(u=$mapIndex(n.m,$emptyInterface.keyFor(j)),u!==undefined?[u.v,true]:[BE.nil,false]);v=t[0];w=t[1];if(w){if(v.unexpungeLocked()){x=j;(l.dirty||$throwRuntimeError("assignment to entry in nil map")).set($emptyInterface.keyFor(x),{k:x,v:v});}v.storeLocked((k.$ptr||(k.$ptr=new BD(function(){return this.$target[0];},function($v){this.$target[0]=$v;},k))));}else{y=(z=$mapIndex(l.dirty,$emptyInterface.keyFor(j)),z!==undefined?[z.v,true]:[BE.nil,false]);aa=y[0];ab=y[1];if(ab){aa.storeLocked((k.$ptr||(k.$ptr=new BD(function(){return this.$target[0];},function($v){this.$target[0]=$v;},k))));}else{if(!n.amended){l.dirtyLocked();l.read.Store((ac=new X.ptr(n.m,true),new ac.constructor.elem(ac)));}ad=j;(l.dirty||$throwRuntimeError("assignment to entry in nil map")).set($emptyInterface.keyFor(ad),{k:ad,v:AA(k[0])});}}$r=l.mu.Unlock();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}var $f={$blk:W.ptr.prototype.Store,$c:true,$r,aa,ab,ac,ad,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};W.prototype.Store=function(j,k){return this.$val.Store(j,k);};Z.ptr.prototype.tryStore=function(j){var j,k,l;k=this;while(true){l=B.LoadPointer((k.$ptr_p||(k.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},k))));if(l===Y){return false;}if(B.CompareAndSwapPointer((k.$ptr_p||(k.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},k))),l,(j))){return true;}}};Z.prototype.tryStore=function(j){return this.$val.tryStore(j);};Z.ptr.prototype.unexpungeLocked=function(){var j,k;j=false;k=this;j=B.CompareAndSwapPointer((k.$ptr_p||(k.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},k))),Y,0);return j;};Z.prototype.unexpungeLocked=function(){return this.$val.unexpungeLocked();};Z.ptr.prototype.storeLocked=function(j){var j,k;k=this;B.StorePointer((k.$ptr_p||(k.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},k))),(j));};Z.prototype.storeLocked=function(j){return this.$val.storeLocked(j);};W.ptr.prototype.LoadOrStore=function(j,k){var{aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{j,k});$s=$s||0;s:while(true){switch($s){case 0:l=$ifaceNil;m=false;n=this;o=$assertType(n.read.Load(),X,true);p=$clone(o[0],X);q=(r=$mapIndex(p.m,$emptyInterface.keyFor(j)),r!==undefined?[r.v,true]:[BE.nil,false]);s=q[0];t=q[1];if(t){u=s.tryLoadOrStore(k);v=u[0];w=u[1];x=u[2];if(x){y=v;z=w;l=y;m=z;$s=-1;return[l,m];}}$r=n.mu.Lock();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}aa=$assertType(n.read.Load(),X,true);X.copy(p,aa[0]);ab=(ac=$mapIndex(p.m,$emptyInterface.keyFor(j)),ac!==undefined?[ac.v,true]:[BE.nil,false]);ad=ab[0];ae=ab[1];if(ae){if(ad.unexpungeLocked()){af=j;(n.dirty||$throwRuntimeError("assignment to entry in nil map")).set($emptyInterface.keyFor(af),{k:af,v:ad});}ag=ad.tryLoadOrStore(k);l=ag[0];m=ag[1];}else{ah=(ai=$mapIndex(n.dirty,$emptyInterface.keyFor(j)),ai!==undefined?[ai.v,true]:[BE.nil,false]);aj=ah[0];ak=ah[1];if(ak){al=aj.tryLoadOrStore(k);l=al[0];m=al[1];n.missLocked();}else{if(!p.amended){n.dirtyLocked();n.read.Store((am=new X.ptr(p.m,true),new am.constructor.elem(am)));}an=j;(n.dirty||$throwRuntimeError("assignment to entry in nil map")).set($emptyInterface.keyFor(an),{k:an,v:AA(k)});ao=k;ap=false;l=ao;m=ap;}}$r=n.mu.Unlock();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}aq=l;ar=m;l=aq;m=ar;$s=-1;return[l,m];}return;}var $f={$blk:W.ptr.prototype.LoadOrStore,$c:true,$r,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};W.prototype.LoadOrStore=function(j,k){return this.$val.LoadOrStore(j,k);};Z.ptr.prototype.tryLoadOrStore=function(j){var aa,ab,ac,ad,ae,af,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;k=$ifaceNil;l=false;m=false;n=this;o=B.LoadPointer((n.$ptr_p||(n.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},n))));if(o===Y){p=$ifaceNil;q=false;r=false;k=p;l=q;m=r;return[k,l,m];}if(!(o===0)){s=(o).$get();t=true;u=true;k=s;l=t;m=u;return[k,l,m];}v=j;while(true){if(B.CompareAndSwapPointer((n.$ptr_p||(n.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},n))),0,((w||(w=new BD(function(){return v;},function($v){v=$v;})))))){x=j;y=false;z=true;k=x;l=y;m=z;return[k,l,m];}o=B.LoadPointer((n.$ptr_p||(n.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},n))));if(o===Y){aa=$ifaceNil;ab=false;ac=false;k=aa;l=ab;m=ac;return[k,l,m];}if(!(o===0)){ad=(o).$get();ae=true;af=true;k=ad;l=ae;m=af;return[k,l,m];}}};Z.prototype.tryLoadOrStore=function(j){return this.$val.tryLoadOrStore(j);};W.ptr.prototype.LoadAndDelete=function(j){var{aa,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{j});$s=$s||0;s:while(true){switch($s){case 0:k=$ifaceNil;l=false;m=this;n=$assertType(m.read.Load(),X,true);o=$clone(n[0],X);p=(q=$mapIndex(o.m,$emptyInterface.keyFor(j)),q!==undefined?[q.v,true]:[BE.nil,false]);r=p[0];s=p[1];if(!s&&o.amended){$s=1;continue;}$s=2;continue;case 1:$r=m.mu.Lock();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}t=$assertType(m.read.Load(),X,true);X.copy(o,t[0]);u=(v=$mapIndex(o.m,$emptyInterface.keyFor(j)),v!==undefined?[v.v,true]:[BE.nil,false]);r=u[0];s=u[1];if(!s&&o.amended){w=(x=$mapIndex(m.dirty,$emptyInterface.keyFor(j)),x!==undefined?[x.v,true]:[BE.nil,false]);r=w[0];s=w[1];$mapDelete(m.dirty,$emptyInterface.keyFor(j));m.missLocked();}$r=m.mu.Unlock();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:if(s){y=r.delete$();k=y[0];l=y[1];$s=-1;return[k,l];}z=$ifaceNil;aa=false;k=z;l=aa;$s=-1;return[k,l];}return;}var $f={$blk:W.ptr.prototype.LoadAndDelete,$c:true,$r,aa,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};W.prototype.LoadAndDelete=function(j){return this.$val.LoadAndDelete(j);};W.ptr.prototype.Delete=function(j){var{j,k,l,$s,$r,$c}=$restore(this,{j});$s=$s||0;s:while(true){switch($s){case 0:k=this;l=k.LoadAndDelete(j);$s=1;case 1:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}l;$s=-1;return;}return;}var $f={$blk:W.ptr.prototype.Delete,$c:true,$r,j,k,l,$s};return $f;};W.prototype.Delete=function(j){return this.$val.Delete(j);};Z.ptr.prototype.delete$=function(){var j,k,l,m,n,o,p,q;j=$ifaceNil;k=false;l=this;while(true){m=B.LoadPointer((l.$ptr_p||(l.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},l))));if(m===0||m===Y){n=$ifaceNil;o=false;j=n;k=o;return[j,k];}if(B.CompareAndSwapPointer((l.$ptr_p||(l.$ptr_p=new AY(function(){return this.$target.p;},function($v){this.$target.p=$v;},l))),m,0)){p=(m).$get();q=true;j=p;k=q;return[j,k];}}};Z.prototype.delete$=function(){return this.$val.delete$();};W.ptr.prototype.Range=function(j){var{j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{j});$s=$s||0;s:while(true){switch($s){case 0:k=this;l=$assertType(k.read.Load(),X,true);m=$clone(l[0],X);if(m.amended){$s=1;continue;}$s=2;continue;case 1:$r=k.mu.Lock();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}n=$assertType(k.read.Load(),X,true);X.copy(m,n[0]);if(m.amended){X.copy(m,new X.ptr(k.dirty,false));k.read.Store(new m.constructor.elem(m));k.dirty=false;k.misses=0;}$r=k.mu.Unlock();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}case 2:o=m.m;p=0;q=o?o.keys():undefined;r=o?o.size:0;case 5:if(!(p>0;if(j.misses<(j.dirty?j.dirty.size:0)){return;}j.read.Store((k=new X.ptr(j.dirty,false),new k.constructor.elem(k)));j.dirty=false;j.misses=0;};W.prototype.missLocked=function(){return this.$val.missLocked();};W.ptr.prototype.dirtyLocked=function(){var j,k,l,m,n,o,p,q,r,s,t,u,v;j=this;if(!(j.dirty===false)){return;}k=$assertType(j.read.Load(),X,true);l=$clone(k[0],X);j.dirty=(m=(l.m?l.m.size:0),((m<0||m>2147483647)?$throwRuntimeError("makemap: size out of range"):new $global.Map()));n=l.m;o=0;p=n?n.keys():undefined;q=n?n.size:0;while(true){if(!(o>>0))===0){$s=1;continue;}$s=2;continue;case 1:n=new $Chan($Bool,0);if(k){o=j;(AC||$throwRuntimeError("assignment to entry in nil map")).set(AT.keyFor(o),{k:o,v:$appendSlice(new BH([n]),(p=$mapIndex(AC,AT.keyFor(j)),p!==undefined?p.v:BH.nil))});}else{q=j;(AC||$throwRuntimeError("assignment to entry in nil map")).set(AT.keyFor(q),{k:q,v:$append((r=$mapIndex(AC,AT.keyFor(j)),r!==undefined?r.v:BH.nil),n)});}s=$recv(n);$s=3;case 3:if($c){$c=false;s=s.$blk();}if(s&&s.$blk!==undefined){break s;}s[0];t=j;(AD||$throwRuntimeError("assignment to entry in nil map")).set(AT.keyFor(t),{k:t,v:(u=$mapIndex(AD,AT.keyFor(j)),u!==undefined?u.v:0)-(1)>>>0});if((v=$mapIndex(AD,AT.keyFor(j)),v!==undefined?v.v:0)===0){$mapDelete(AD,AT.keyFor(j));}case 2:j.$set(j.$get()-(1)>>>0);$s=-1;return;}return;}var $f={$blk:AF,$c:true,$r,j,k,l,m,n,o,p,q,r,s,t,u,v,$s};return $f;};AG=function(j,k,l){var{j,k,l,m,n,o,p,q,r,$s,$r,$c}=$restore(this,{j,k,l});$s=$s||0;s:while(true){switch($s){case 0:j.$set(j.$get()+(1)>>>0);n=(m=$mapIndex(AC,AT.keyFor(j)),m!==undefined?m.v:BH.nil);if(n.$length===0){$s=-1;return;}o=(0>=n.$length?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+0]);n=$subslice(n,1);p=j;(AC||$throwRuntimeError("assignment to entry in nil map")).set(AT.keyFor(p),{k:p,v:n});if(n.$length===0){$mapDelete(AC,AT.keyFor(j));}q=j;(AD||$throwRuntimeError("assignment to entry in nil map")).set(AT.keyFor(q),{k:q,v:(r=$mapIndex(AD,AT.keyFor(j)),r!==undefined?r.v:0)+(1)>>>0});$r=$send(o,true);$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=-1;return;}return;}var $f={$blk:AG,$c:true,$r,j,k,l,m,n,o,p,q,r,$s};return $f;};$linknames["sync.runtime_Semrelease"]=AG;AH=function(j){var j;};AI=function(j){var j;return false;};AJ=function(){return $mul64($internalize(new($global.Date)().getTime(),$Int64),new $Int64(0,1000000));};AK=function(j){var j;$throwRuntimeError($externalize(j,$String));};AL.ptr.prototype.Get=function(){var{j,k,l,m,n,o,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:j=this;if(j.store.$length===0){$s=1;continue;}$s=2;continue;case 1:if(!(j.New===$throwNilPointerError)){$s=3;continue;}$s=4;continue;case 3:k=j.New();$s=5;case 5:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}l=k;$s=6;case 6:return l;case 4:$s=-1;return $ifaceNil;case 2:o=(m=j.store,n=j.store.$length-1>>0,((n<0||n>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+n]));j.store=$subslice(j.store,0,(j.store.$length-1>>0));$s=-1;return o;}return;}var $f={$blk:AL.ptr.prototype.Get,$c:true,$r,j,k,l,m,n,o,$s};return $f;};AL.prototype.Get=function(){return this.$val.Get();};AL.ptr.prototype.Put=function(j){var j,k;k=this;if($interfaceIsEqual(j,$ifaceNil)){return;}k.store=$append(k.store,j);};AL.prototype.Put=function(j){return this.$val.Put(j);};AX.methods=[{prop:"RLock",name:"RLock",pkg:"",typ:$funcType([],[],false)},{prop:"TryRLock",name:"TryRLock",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"RUnlock",name:"RUnlock",pkg:"",typ:$funcType([],[],false)},{prop:"rUnlockSlow",name:"rUnlockSlow",pkg:"sync",typ:$funcType([$Int32],[],false)},{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"TryLock",name:"TryLock",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)},{prop:"RLocker",name:"RLocker",pkg:"",typ:$funcType([],[V],false)}];AW.methods=[{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)}];BM.methods=[{prop:"Do",name:"Do",pkg:"",typ:$funcType([BL],[],false)},{prop:"doSlow",name:"doSlow",pkg:"sync",typ:$funcType([BL],[],false)}];BN.methods=[{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"TryLock",name:"TryLock",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"lockSlow",name:"lockSlow",pkg:"sync",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)},{prop:"unlockSlow",name:"unlockSlow",pkg:"sync",typ:$funcType([$Int32],[],false)}];BP.methods=[{prop:"Load",name:"Load",pkg:"",typ:$funcType([$emptyInterface],[$emptyInterface,$Bool],false)},{prop:"Store",name:"Store",pkg:"",typ:$funcType([$emptyInterface,$emptyInterface],[],false)},{prop:"LoadOrStore",name:"LoadOrStore",pkg:"",typ:$funcType([$emptyInterface,$emptyInterface],[$emptyInterface,$Bool],false)},{prop:"LoadAndDelete",name:"LoadAndDelete",pkg:"",typ:$funcType([$emptyInterface],[$emptyInterface,$Bool],false)},{prop:"Delete",name:"Delete",pkg:"",typ:$funcType([$emptyInterface],[],false)},{prop:"Range",name:"Range",pkg:"",typ:$funcType([BO],[],false)},{prop:"missLocked",name:"missLocked",pkg:"sync",typ:$funcType([],[],false)},{prop:"dirtyLocked",name:"dirtyLocked",pkg:"sync",typ:$funcType([],[],false)}];BE.methods=[{prop:"load",name:"load",pkg:"sync",typ:$funcType([],[$emptyInterface,$Bool],false)},{prop:"tryStore",name:"tryStore",pkg:"sync",typ:$funcType([BD],[$Bool],false)},{prop:"unexpungeLocked",name:"unexpungeLocked",pkg:"sync",typ:$funcType([],[$Bool],false)},{prop:"storeLocked",name:"storeLocked",pkg:"sync",typ:$funcType([BD],[],false)},{prop:"tryLoadOrStore",name:"tryLoadOrStore",pkg:"sync",typ:$funcType([$emptyInterface],[$emptyInterface,$Bool,$Bool],false)},{prop:"delete$",name:"delete",pkg:"sync",typ:$funcType([],[$emptyInterface,$Bool],false)},{prop:"tryExpungeLocked",name:"tryExpungeLocked",pkg:"sync",typ:$funcType([],[$Bool],false)}];BU.methods=[{prop:"Get",name:"Get",pkg:"",typ:$funcType([],[$emptyInterface],false)},{prop:"Put",name:"Put",pkg:"",typ:$funcType([$emptyInterface],[],false)}];D.init("sync",[{prop:"w",name:"w",embedded:false,exported:false,typ:U,tag:""},{prop:"writerSem",name:"writerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerSem",name:"readerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerCount",name:"readerCount",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"readerWait",name:"readerWait",embedded:false,exported:false,typ:$Int32,tag:""}]);E.init("sync",[{prop:"w",name:"w",embedded:false,exported:false,typ:U,tag:""},{prop:"writerSem",name:"writerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerSem",name:"readerSem",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"readerCount",name:"readerCount",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"readerWait",name:"readerWait",embedded:false,exported:false,typ:$Int32,tag:""}]);F.init("sync",[{prop:"wait",name:"wait",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"notify",name:"notify",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"lock",name:"lock",embedded:false,exported:false,typ:$Uintptr,tag:""},{prop:"head",name:"head",embedded:false,exported:false,typ:$UnsafePointer,tag:""},{prop:"tail",name:"tail",embedded:false,exported:false,typ:$UnsafePointer,tag:""}]);T.init("sync",[{prop:"done",name:"done",embedded:false,exported:false,typ:$Uint32,tag:""},{prop:"m",name:"m",embedded:false,exported:false,typ:U,tag:""}]);U.init("sync",[{prop:"state",name:"state",embedded:false,exported:false,typ:$Int32,tag:""},{prop:"sema",name:"sema",embedded:false,exported:false,typ:$Uint32,tag:""}]);V.init([{prop:"Lock",name:"Lock",pkg:"",typ:$funcType([],[],false)},{prop:"Unlock",name:"Unlock",pkg:"",typ:$funcType([],[],false)}]);W.init("sync",[{prop:"mu",name:"mu",embedded:false,exported:false,typ:U,tag:""},{prop:"read",name:"read",embedded:false,exported:false,typ:B.Value,tag:""},{prop:"dirty",name:"dirty",embedded:false,exported:false,typ:BQ,tag:""},{prop:"misses",name:"misses",embedded:false,exported:false,typ:$Int,tag:""}]);X.init("sync",[{prop:"m",name:"m",embedded:false,exported:false,typ:BQ,tag:""},{prop:"amended",name:"amended",embedded:false,exported:false,typ:$Bool,tag:""}]);Z.init("sync",[{prop:"p",name:"p",embedded:false,exported:false,typ:$UnsafePointer,tag:""}]);AL.init("sync",[{prop:"store",name:"store",embedded:false,exported:false,typ:BT,tag:""},{prop:"New",name:"New",embedded:false,exported:true,typ:BV,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=C.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}Y=(new Uint8Array(8));AC=new $global.Map();AD=new $global.Map();K();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["io"]=(function(){var $pkg={},$init,A,B,N,O,P,S,T,Z,AA,AD,AE,AG,AH,AI,AR,BE,BF,BG,BL,M,AU,AV,AZ,AJ,AK,AL,AN,AP,BC;A=$packages["errors"];B=$packages["sync"];N=$pkg.Reader=$newType(8,$kindInterface,"io.Reader",true,"io",true,null);O=$pkg.Writer=$newType(8,$kindInterface,"io.Writer",true,"io",true,null);P=$pkg.Closer=$newType(8,$kindInterface,"io.Closer",true,"io",true,null);S=$pkg.ReadCloser=$newType(8,$kindInterface,"io.ReadCloser",true,"io",true,null);T=$pkg.WriteCloser=$newType(8,$kindInterface,"io.WriteCloser",true,"io",true,null);Z=$pkg.ReaderFrom=$newType(8,$kindInterface,"io.ReaderFrom",true,"io",true,null);AA=$pkg.WriterTo=$newType(8,$kindInterface,"io.WriterTo",true,"io",true,null);AD=$pkg.ByteReader=$newType(8,$kindInterface,"io.ByteReader",true,"io",true,null);AE=$pkg.ByteScanner=$newType(8,$kindInterface,"io.ByteScanner",true,"io",true,null);AG=$pkg.RuneReader=$newType(8,$kindInterface,"io.RuneReader",true,"io",true,null);AH=$pkg.RuneScanner=$newType(8,$kindInterface,"io.RuneScanner",true,"io",true,null);AI=$pkg.StringWriter=$newType(8,$kindInterface,"io.StringWriter",true,"io",true,null);AR=$pkg.LimitedReader=$newType(0,$kindStruct,"io.LimitedReader",true,"io",true,function(R_,N_){this.$val=this;if(arguments.length===0){this.R=$ifaceNil;this.N=new $Int64(0,0);return;}this.R=R_;this.N=N_;});BE=$sliceType($emptyInterface);BF=$sliceType($Uint8);BG=$ptrType(BF);BL=$ptrType(AR);AJ=function(c,d){var{c,d,e,f,g,h,i,j,k,l,m,n,o,$s,$r,$c}=$restore(this,{c,d});$s=$s||0;s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=$assertType(c,AI,true);h=g[0];i=g[1];if(i){$s=1;continue;}$s=2;continue;case 1:k=h.WriteString(d);$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;e=j[0];f=j[1];l=[e,f];$s=4;case 4:return l;case 2:n=c.Write((new BF($stringToBytes(d))));$s=5;case 5:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;e=m[0];f=m[1];o=[e,f];$s=6;case 6:return o;}return;}var $f={$blk:AJ,$c:true,$r,c,d,e,f,g,h,i,j,k,l,m,n,o,$s};return $f;};$pkg.WriteString=AJ;AK=function(c,d,e){var{c,d,e,f,g,h,i,j,k,l,$s,$r,$c}=$restore(this,{c,d,e});$s=$s||0;s:while(true){switch($s){case 0:f=0;g=$ifaceNil;if(d.$length>0;$s=1;continue;case 2:if(f>=e){g=$ifaceNil;}else if(f>0&&$interfaceIsEqual(g,$pkg.EOF)){g=$pkg.ErrUnexpectedEOF;}$s=-1;return[f,g];}return;}var $f={$blk:AK,$c:true,$r,c,d,e,f,g,h,i,j,k,l,$s};return $f;};$pkg.ReadAtLeast=AK;AL=function(c,d){var{c,d,e,f,g,h,i,$s,$r,$c}=$restore(this,{c,d});$s=$s||0;s:while(true){switch($s){case 0:e=0;f=$ifaceNil;h=AK(c,d,d.$length);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;e=g[0];f=g[1];i=[e,f];$s=2;case 2:return i;}return;}var $f={$blk:AL,$c:true,$r,c,d,e,f,g,h,i,$s};return $f;};$pkg.ReadFull=AL;AN=function(c,d){var{c,d,e,f,g,h,i,$s,$r,$c}=$restore(this,{c,d});$s=$s||0;s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;h=AP(c,d,BF.nil);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}g=h;e=g[0];f=g[1];i=[e,f];$s=2;case 2:return i;}return;}var $f={$blk:AN,$c:true,$r,c,d,e,f,g,h,i,$s};return $f;};$pkg.Copy=AN;AP=function(c,d,e){var{aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{c,d,e});$s=$s||0;s:while(true){switch($s){case 0:f=new $Int64(0,0);g=$ifaceNil;h=$assertType(d,AA,true);i=h[0];j=h[1];if(j){$s=1;continue;}$s=2;continue;case 1:l=i.WriteTo(c);$s=3;case 3:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;f=k[0];g=k[1];m=[f,g];$s=4;case 4:return m;case 2:n=$assertType(c,Z,true);o=n[0];p=n[1];if(p){$s=5;continue;}$s=6;continue;case 5:r=o.ReadFrom(d);$s=7;case 7:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}q=r;f=q[0];g=q[1];s=[f,g];$s=8;case 8:return s;case 6:if(e===BF.nil){t=32768;u=$assertType(d,BL,true);v=u[0];w=u[1];if(w&&(x=(new $Int64(0,t)),y=v.N,(x.$high>y.$high||(x.$high===y.$high&&x.$low>y.$low)))){if((z=v.N,(z.$high<0||(z.$high===0&&z.$low<1)))){t=1;}else{t=(((aa=v.N,aa.$low+((aa.$high>>31)*4294967296))>>0));}}e=$makeSlice(BF,t);}case 9:ac=d.Read(e);$s=11;case 11:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}ab=ac;ad=ab[0];ae=ab[1];if(ad>0){$s=12;continue;}$s=13;continue;case 12:ag=c.Write($subslice(e,0,ad));$s=14;case 14:if($c){$c=false;ag=ag.$blk();}if(ag&&ag.$blk!==undefined){break s;}af=ag;ah=af[0];ai=af[1];if(ah<0||adk.$high||(j.$high===k.$high&&j.$low>k.$low)))){c=$subslice(c,0,$flatten64(f.N));}m=f.R.Read(c);$s=1;case 1:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}l=m;d=l[0];e=l[1];f.N=(n=f.N,o=(new $Int64(0,d)),new $Int64(n.$high-o.$high,n.$low-o.$low));$s=-1;return[d,e];}return;}var $f={$blk:AR.ptr.prototype.Read,$c:true,$r,c,d,e,f,g,h,i,j,k,l,m,n,o,$s};return $f;};AR.prototype.Read=function(c){return this.$val.Read(c);};BC=function(c){var{c,d,e,f,g,h,$s,$r,$c}=$restore(this,{c});$s=$s||0;s:while(true){switch($s){case 0:d=$makeSlice(BF,0,512);case 1:if(d.$length===d.$capacity){d=$subslice($append(d,0),0,d.$length);}f=c.Read($subslice(d,d.$length,d.$capacity));$s=3;case 3:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;g=e[0];h=e[1];d=$subslice(d,0,(d.$length+g>>0));if(!($interfaceIsEqual(h,$ifaceNil))){if($interfaceIsEqual(h,$pkg.EOF)){h=$ifaceNil;}$s=-1;return[d,h];}$s=1;continue;case 2:$s=-1;return[BF.nil,$ifaceNil];}return;}var $f={$blk:BC,$c:true,$r,c,d,e,f,g,h,$s};return $f;};$pkg.ReadAll=BC;BL.methods=[{prop:"Read",name:"Read",pkg:"",typ:$funcType([BF],[$Int,$error],false)}];N.init([{prop:"Read",name:"Read",pkg:"",typ:$funcType([BF],[$Int,$error],false)}]);O.init([{prop:"Write",name:"Write",pkg:"",typ:$funcType([BF],[$Int,$error],false)}]);P.init([{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[$error],false)}]);S.init([{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[$error],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([BF],[$Int,$error],false)}]);T.init([{prop:"Close",name:"Close",pkg:"",typ:$funcType([],[$error],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([BF],[$Int,$error],false)}]);Z.init([{prop:"ReadFrom",name:"ReadFrom",pkg:"",typ:$funcType([N],[$Int64,$error],false)}]);AA.init([{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([O],[$Int64,$error],false)}]);AD.init([{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)}]);AE.init([{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)}]);AG.init([{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)}]);AH.init([{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)}]);AI.init([{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)}]);AR.init("",[{prop:"R",name:"R",embedded:false,exported:true,typ:N,tag:""},{prop:"N",name:"N",embedded:false,exported:true,typ:$Int64,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.ErrClosedPipe=A.New("io: read/write on closed pipe");$pkg.ErrShortWrite=A.New("short write");M=A.New("invalid write result");$pkg.ErrShortBuffer=A.New("short buffer");$pkg.EOF=A.New("EOF");$pkg.ErrUnexpectedEOF=A.New("unexpected EOF");$pkg.ErrNoProgress=A.New("multiple Read calls return no data or error");AU=A.New("Seek: invalid whence");AV=A.New("Seek: invalid offset");AZ=new B.Pool.ptr(BE.nil,(function(){var c,d;c=$makeSlice(BF,8192);return(d||(d=new BG(function(){return c;},function($v){c=$convertSliceType($v,BF);})));}));}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["unicode"]=(function(){var $pkg={},$init,IF,IG,IH,II,IK,IW,JM,JN,JO,JP,JQ,JR,JS,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,AA,AB,AC,AD,AE,AF,AG,AH,AI,AJ,AK,AL,AM,AN,AO,AP,AQ,AR,AS,AT,AU,AV,AW,AX,AY,AZ,BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BK,BL,BM,BN,BO,BP,BQ,BR,BS,BT,BU,BV,BW,BX,BY,BZ,CA,CB,CC,CD,CE,CF,CG,CH,CI,CJ,CK,CL,CM,CN,CO,CP,CQ,CR,CS,CT,CU,CV,CW,CX,CY,CZ,DA,DB,DC,DD,DE,DF,DG,DH,DI,DJ,DK,DL,DM,DN,DO,DP,DQ,DR,DS,DT,DU,DV,DW,DX,DY,DZ,EA,EB,EC,ED,EE,EF,EG,EH,EI,EJ,EK,EL,EM,EN,EO,EP,EQ,ER,ES,ET,EU,EV,EW,EX,EY,EZ,FA,FB,FC,FD,FE,FF,FG,FH,FI,FJ,FK,FL,FM,FN,FO,FP,FQ,FR,FS,FT,FU,FV,FW,FX,FY,FZ,GA,GB,GC,GD,GE,GF,GG,GH,GI,GJ,HR,HS,HT,HU,HV,HW,HX,HY,HZ,IA,IB,IC,ID,IE,IL,IM,IN,IO,IP,IS,IT,IU,IX,IY,IZ,JB,JD,JF,JH,JJ,JK;IF=$pkg.RangeTable=$newType(0,$kindStruct,"unicode.RangeTable",true,"unicode",true,function(R16_,R32_,LatinOffset_){this.$val=this;if(arguments.length===0){this.R16=JM.nil;this.R32=JN.nil;this.LatinOffset=0;return;}this.R16=R16_;this.R32=R32_;this.LatinOffset=LatinOffset_;});IG=$pkg.Range16=$newType(0,$kindStruct,"unicode.Range16",true,"unicode",true,function(Lo_,Hi_,Stride_){this.$val=this;if(arguments.length===0){this.Lo=0;this.Hi=0;this.Stride=0;return;}this.Lo=Lo_;this.Hi=Hi_;this.Stride=Stride_;});IH=$pkg.Range32=$newType(0,$kindStruct,"unicode.Range32",true,"unicode",true,function(Lo_,Hi_,Stride_){this.$val=this;if(arguments.length===0){this.Lo=0;this.Hi=0;this.Stride=0;return;}this.Lo=Lo_;this.Hi=Hi_;this.Stride=Stride_;});II=$pkg.CaseRange=$newType(0,$kindStruct,"unicode.CaseRange",true,"unicode",true,function(Lo_,Hi_,Delta_){this.$val=this;if(arguments.length===0){this.Lo=0;this.Hi=0;this.Delta=JQ.zero();return;}this.Lo=Lo_;this.Hi=Hi_;this.Delta=Delta_;});IK=$pkg.d=$newType(12,$kindArray,"unicode.d",true,"unicode",false,null);IW=$pkg.foldPair=$newType(0,$kindStruct,"unicode.foldPair",true,"unicode",false,function(From_,To_){this.$val=this;if(arguments.length===0){this.From=0;this.To=0;return;}this.From=From_;this.To=To_;});JM=$sliceType(IG);JN=$sliceType(IH);JO=$sliceType(IW);JP=$sliceType(II);JQ=$arrayType($Int32,3);JR=$ptrType(IF);JS=$sliceType(JR);IL=function(b,c){var b,c,d,e,f,g,h,i,j,k,l,m,n;if(b.$length<=18||c<=255){d=b;e=0;while(true){if(!(e=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+f]);if(c>>16))%g.Stride,h===h?h:$throwRuntimeError("integer divide by zero"))===0);}e++;}return false;}i=0;j=b.$length;while(true){if(!(i>0))/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))>>0;m=((l<0||l>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+l]);if(m.Lo<=c&&c<=m.Hi){return(m.Stride===1)||((n=((c-m.Lo<<16>>>16))%m.Stride,n===n?n:$throwRuntimeError("integer divide by zero"))===0);}if(c>0;}}return false;};IM=function(b,c){var b,c,d,e,f,g,h,i,j,k,l,m,n;if(b.$length<=18){d=b;e=0;while(true){if(!(e=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+f]);if(c>>0))%g.Stride,h===h?h:$throwRuntimeError("integer divide by zero"))===0);}e++;}return false;}i=0;j=b.$length;while(true){if(!(i>0))/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))>>0;m=$clone(((l<0||l>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+l]),IH);if(m.Lo<=c&&c<=m.Hi){return(m.Stride===1)||((n=((c-m.Lo>>>0))%m.Stride,n===n?n:$throwRuntimeError("integer divide by zero"))===0);}if(c>0;}}return false;};IN=function(b,c){var b,c,d,e,f;d=b.R16;if(d.$length>0&&((c>>>0))<=(((e=d.$length-1>>0,((e<0||e>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e])).Hi>>>0))){return IL(d,((c<<16>>>16)));}f=b.R32;if(f.$length>0&&c>=(((0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]).Lo>>0))){return IM(f,((c>>>0)));}return false;};$pkg.Is=IN;IO=function(b,c){var b,c,d,e,f,g;d=b.R16;e=b.LatinOffset;if(d.$length>e&&((c>>>0))<=(((f=d.$length-1>>0,((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])).Hi>>>0))){return IL($subslice(d,e),((c<<16>>>16)));}g=b.R32;if(g.$length>0&&c>=(((0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]).Lo>>0))){return IM(g,((c>>>0)));}return false;};IP=function(b){var b,c;if(((b>>>0))<=255){return(((c=((b<<24>>>24)),((c<0||c>=HT.length)?($throwRuntimeError("index out of range"),undefined):HT[c]))&96)>>>0)===32;}return IO($pkg.Upper,b);};$pkg.IsUpper=IP;IS=function(b,c){var b,c,d;d=JJ(b,c,$pkg.CaseRanges);c=d[0];return c;};$pkg.To=IS;IT=function(b){var b;if(b<=127){if(97<=b&&b<=122){b=b-(32)>>0;}return b;}return IS(0,b);};$pkg.ToUpper=IT;IU=function(b){var b;if(b<=127){if(65<=b&&b<=90){b=b+(32)>>0;}return b;}return IS(1,b);};$pkg.ToLower=IU;IX=function(b){var b,c,d,e,f,g;if(b<0||b>1114111){return b;}if(((b>>0))<128){return((((b<0||b>=HU.length)?($throwRuntimeError("index out of range"),undefined):HU[b])>>0));}c=0;d=HV.$length;while(true){if(!(c>0))/2,(e===e&&e!==1/0&&e!==-1/0)?e>>0:$throwRuntimeError("integer divide by zero"))>>0;if(((((f<0||f>=HV.$length)?($throwRuntimeError("index out of range"),undefined):HV.$array[HV.$offset+f]).From>>0))>0;}else{d=f;}}if(c=HV.$length)?($throwRuntimeError("index out of range"),undefined):HV.$array[HV.$offset+c]).From>>0))===b)){return((((c<0||c>=HV.$length)?($throwRuntimeError("index out of range"),undefined):HV.$array[HV.$offset+c]).To>>0));}g=IU(b);if(!((g===b))){return g;}return IT(b);};$pkg.SimpleFold=IX;IY=function(b){var b,c;if(((b>>>0))<=255){return!(((((c=((b<<24>>>24)),((c<0||c>=HT.length)?($throwRuntimeError("index out of range"),undefined):HT[c]))&144)>>>0)===0));}return JB(b,$pkg.GraphicRanges);};$pkg.IsGraphic=IY;IZ=function(b){var b,c;if(((b>>>0))<=255){return!(((((c=((b<<24>>>24)),((c<0||c>=HT.length)?($throwRuntimeError("index out of range"),undefined):HT[c]))&128)>>>0)===0));}return JB(b,$pkg.PrintRanges);};$pkg.IsPrint=IZ;JB=function(b,c){var b,c,d,e,f;d=c;e=0;while(true){if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);if(IN(f,b)){return true;}e++;}return false;};$pkg.In=JB;JD=function(b){var b,c;if(((b>>>0))<=255){return!(((((c=((b<<24>>>24)),((c<0||c>=HT.length)?($throwRuntimeError("index out of range"),undefined):HT[c]))&96)>>>0)===0));}return IO($pkg.Letter,b);};$pkg.IsLetter=JD;JF=function(b){var b,c;if(((b>>>0))<=255){return!(((((c=((b<<24>>>24)),((c<0||c>=HT.length)?($throwRuntimeError("index out of range"),undefined):HT[c]))&4)>>>0)===0));}return IO($pkg.Number,b);};$pkg.IsNumber=JF;JH=function(b){var b,c;if(((b>>>0))<=255){c=b;if((c===(9))||(c===(10))||(c===(11))||(c===(12))||(c===(13))||(c===(32))||(c===(133))||(c===(160))){return true;}return false;}return IO($pkg.White_Space,b);};$pkg.IsSpace=JH;JJ=function(b,c,d){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;e=0;f=false;if(b<0||3<=b){g=65533;h=false;e=g;f=h;return[e,f];}i=0;j=d.$length;while(true){if(!(i>0))/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))>>0;m=((l<0||l>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+l]);if(((m.Lo>>0))<=c&&c<=((m.Hi>>0))){o=((n=m.Delta,((b<0||b>=n.length)?($throwRuntimeError("index out of range"),undefined):n[b])));if(o>1114111){p=((m.Lo>>0))+((((((c-((m.Lo>>0))>>0))&~1)>>0)|(((b&1)>>0))))>>0;q=true;e=p;f=q;return[e,f];}r=c+o>>0;s=true;e=r;f=s;return[e,f];}if(c<((m.Lo>>0))){j=l;}else{i=l+1>>0;}}t=c;u=false;e=t;f=u;return[e,f];};JK=function(b){var b;if(b<=255){return 48<=b&&b<=57;}return IO($pkg.Digit,b);};$pkg.IsDigit=JK;IF.init("",[{prop:"R16",name:"R16",embedded:false,exported:true,typ:JM,tag:""},{prop:"R32",name:"R32",embedded:false,exported:true,typ:JN,tag:""},{prop:"LatinOffset",name:"LatinOffset",embedded:false,exported:true,typ:$Int,tag:""}]);IG.init("",[{prop:"Lo",name:"Lo",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Hi",name:"Hi",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"Stride",name:"Stride",embedded:false,exported:true,typ:$Uint16,tag:""}]);IH.init("",[{prop:"Lo",name:"Lo",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Hi",name:"Hi",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Stride",name:"Stride",embedded:false,exported:true,typ:$Uint32,tag:""}]);II.init("",[{prop:"Lo",name:"Lo",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Hi",name:"Hi",embedded:false,exported:true,typ:$Uint32,tag:""},{prop:"Delta",name:"Delta",embedded:false,exported:true,typ:IK,tag:""}]);IK.init($Int32,3);IW.init("",[{prop:"From",name:"From",embedded:false,exported:true,typ:$Uint16,tag:""},{prop:"To",name:"To",embedded:false,exported:true,typ:$Uint16,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:A=new IF.ptr(new JM([new IG.ptr(0,31,1),new IG.ptr(127,159,1),new IG.ptr(173,1536,1363),new IG.ptr(1537,1541,1),new IG.ptr(1564,1757,193),new IG.ptr(1807,2274,467),new IG.ptr(6158,8203,2045),new IG.ptr(8204,8207,1),new IG.ptr(8234,8238,1),new IG.ptr(8288,8292,1),new IG.ptr(8294,8303,1),new IG.ptr(55296,63743,1),new IG.ptr(65279,65529,250),new IG.ptr(65530,65531,1)]),new JN([new IH.ptr(69821,69837,16),new IH.ptr(78896,78904,1),new IH.ptr(113824,113827,1),new IH.ptr(119155,119162,1),new IH.ptr(917505,917536,31),new IH.ptr(917537,917631,1),new IH.ptr(983040,1048573,1),new IH.ptr(1048576,1114109,1)]),2);B=new IF.ptr(new JM([new IG.ptr(0,31,1),new IG.ptr(127,159,1)]),JN.nil,2);C=new IF.ptr(new JM([new IG.ptr(173,1536,1363),new IG.ptr(1537,1541,1),new IG.ptr(1564,1757,193),new IG.ptr(1807,2274,467),new IG.ptr(6158,8203,2045),new IG.ptr(8204,8207,1),new IG.ptr(8234,8238,1),new IG.ptr(8288,8292,1),new IG.ptr(8294,8303,1),new IG.ptr(65279,65529,250),new IG.ptr(65530,65531,1)]),new JN([new IH.ptr(69821,69837,16),new IH.ptr(78896,78904,1),new IH.ptr(113824,113827,1),new IH.ptr(119155,119162,1),new IH.ptr(917505,917536,31),new IH.ptr(917537,917631,1)]),0);D=new IF.ptr(new JM([new IG.ptr(57344,63743,1)]),new JN([new IH.ptr(983040,1048573,1),new IH.ptr(1048576,1114109,1)]),0);E=new IF.ptr(new JM([new IG.ptr(55296,57343,1)]),JN.nil,0);F=new IF.ptr(new JM([new IG.ptr(65,90,1),new IG.ptr(97,122,1),new IG.ptr(170,181,11),new IG.ptr(186,192,6),new IG.ptr(193,214,1),new IG.ptr(216,246,1),new IG.ptr(248,705,1),new IG.ptr(710,721,1),new IG.ptr(736,740,1),new IG.ptr(748,750,2),new IG.ptr(880,884,1),new IG.ptr(886,887,1),new IG.ptr(890,893,1),new IG.ptr(895,902,7),new IG.ptr(904,906,1),new IG.ptr(908,910,2),new IG.ptr(911,929,1),new IG.ptr(931,1013,1),new IG.ptr(1015,1153,1),new IG.ptr(1162,1327,1),new IG.ptr(1329,1366,1),new IG.ptr(1369,1376,7),new IG.ptr(1377,1416,1),new IG.ptr(1488,1514,1),new IG.ptr(1519,1522,1),new IG.ptr(1568,1610,1),new IG.ptr(1646,1647,1),new IG.ptr(1649,1747,1),new IG.ptr(1749,1765,16),new IG.ptr(1766,1774,8),new IG.ptr(1775,1786,11),new IG.ptr(1787,1788,1),new IG.ptr(1791,1808,17),new IG.ptr(1810,1839,1),new IG.ptr(1869,1957,1),new IG.ptr(1969,1994,25),new IG.ptr(1995,2026,1),new IG.ptr(2036,2037,1),new IG.ptr(2042,2048,6),new IG.ptr(2049,2069,1),new IG.ptr(2074,2084,10),new IG.ptr(2088,2112,24),new IG.ptr(2113,2136,1),new IG.ptr(2144,2154,1),new IG.ptr(2208,2228,1),new IG.ptr(2230,2247,1),new IG.ptr(2308,2361,1),new IG.ptr(2365,2384,19),new IG.ptr(2392,2401,1),new IG.ptr(2417,2432,1),new IG.ptr(2437,2444,1),new IG.ptr(2447,2448,1),new IG.ptr(2451,2472,1),new IG.ptr(2474,2480,1),new IG.ptr(2482,2486,4),new IG.ptr(2487,2489,1),new IG.ptr(2493,2510,17),new IG.ptr(2524,2525,1),new IG.ptr(2527,2529,1),new IG.ptr(2544,2545,1),new IG.ptr(2556,2565,9),new IG.ptr(2566,2570,1),new IG.ptr(2575,2576,1),new IG.ptr(2579,2600,1),new IG.ptr(2602,2608,1),new IG.ptr(2610,2611,1),new IG.ptr(2613,2614,1),new IG.ptr(2616,2617,1),new IG.ptr(2649,2652,1),new IG.ptr(2654,2674,20),new IG.ptr(2675,2676,1),new IG.ptr(2693,2701,1),new IG.ptr(2703,2705,1),new IG.ptr(2707,2728,1),new IG.ptr(2730,2736,1),new IG.ptr(2738,2739,1),new IG.ptr(2741,2745,1),new IG.ptr(2749,2768,19),new IG.ptr(2784,2785,1),new IG.ptr(2809,2821,12),new IG.ptr(2822,2828,1),new IG.ptr(2831,2832,1),new IG.ptr(2835,2856,1),new IG.ptr(2858,2864,1),new IG.ptr(2866,2867,1),new IG.ptr(2869,2873,1),new IG.ptr(2877,2908,31),new IG.ptr(2909,2911,2),new IG.ptr(2912,2913,1),new IG.ptr(2929,2947,18),new IG.ptr(2949,2954,1),new IG.ptr(2958,2960,1),new IG.ptr(2962,2965,1),new IG.ptr(2969,2970,1),new IG.ptr(2972,2974,2),new IG.ptr(2975,2979,4),new IG.ptr(2980,2984,4),new IG.ptr(2985,2986,1),new IG.ptr(2990,3001,1),new IG.ptr(3024,3077,53),new IG.ptr(3078,3084,1),new IG.ptr(3086,3088,1),new IG.ptr(3090,3112,1),new IG.ptr(3114,3129,1),new IG.ptr(3133,3160,27),new IG.ptr(3161,3162,1),new IG.ptr(3168,3169,1),new IG.ptr(3200,3205,5),new IG.ptr(3206,3212,1),new IG.ptr(3214,3216,1),new IG.ptr(3218,3240,1),new IG.ptr(3242,3251,1),new IG.ptr(3253,3257,1),new IG.ptr(3261,3294,33),new IG.ptr(3296,3297,1),new IG.ptr(3313,3314,1),new IG.ptr(3332,3340,1),new IG.ptr(3342,3344,1),new IG.ptr(3346,3386,1),new IG.ptr(3389,3406,17),new IG.ptr(3412,3414,1),new IG.ptr(3423,3425,1),new IG.ptr(3450,3455,1),new IG.ptr(3461,3478,1),new IG.ptr(3482,3505,1),new IG.ptr(3507,3515,1),new IG.ptr(3517,3520,3),new IG.ptr(3521,3526,1),new IG.ptr(3585,3632,1),new IG.ptr(3634,3635,1),new IG.ptr(3648,3654,1),new IG.ptr(3713,3714,1),new IG.ptr(3716,3718,2),new IG.ptr(3719,3722,1),new IG.ptr(3724,3747,1),new IG.ptr(3749,3751,2),new IG.ptr(3752,3760,1),new IG.ptr(3762,3763,1),new IG.ptr(3773,3776,3),new IG.ptr(3777,3780,1),new IG.ptr(3782,3804,22),new IG.ptr(3805,3807,1),new IG.ptr(3840,3904,64),new IG.ptr(3905,3911,1),new IG.ptr(3913,3948,1),new IG.ptr(3976,3980,1),new IG.ptr(4096,4138,1),new IG.ptr(4159,4176,17),new IG.ptr(4177,4181,1),new IG.ptr(4186,4189,1),new IG.ptr(4193,4197,4),new IG.ptr(4198,4206,8),new IG.ptr(4207,4208,1),new IG.ptr(4213,4225,1),new IG.ptr(4238,4256,18),new IG.ptr(4257,4293,1),new IG.ptr(4295,4301,6),new IG.ptr(4304,4346,1),new IG.ptr(4348,4680,1),new IG.ptr(4682,4685,1),new IG.ptr(4688,4694,1),new IG.ptr(4696,4698,2),new IG.ptr(4699,4701,1),new IG.ptr(4704,4744,1),new IG.ptr(4746,4749,1),new IG.ptr(4752,4784,1),new IG.ptr(4786,4789,1),new IG.ptr(4792,4798,1),new IG.ptr(4800,4802,2),new IG.ptr(4803,4805,1),new IG.ptr(4808,4822,1),new IG.ptr(4824,4880,1),new IG.ptr(4882,4885,1),new IG.ptr(4888,4954,1),new IG.ptr(4992,5007,1),new IG.ptr(5024,5109,1),new IG.ptr(5112,5117,1),new IG.ptr(5121,5740,1),new IG.ptr(5743,5759,1),new IG.ptr(5761,5786,1),new IG.ptr(5792,5866,1),new IG.ptr(5873,5880,1),new IG.ptr(5888,5900,1),new IG.ptr(5902,5905,1),new IG.ptr(5920,5937,1),new IG.ptr(5952,5969,1),new IG.ptr(5984,5996,1),new IG.ptr(5998,6000,1),new IG.ptr(6016,6067,1),new IG.ptr(6103,6108,5),new IG.ptr(6176,6264,1),new IG.ptr(6272,6276,1),new IG.ptr(6279,6312,1),new IG.ptr(6314,6320,6),new IG.ptr(6321,6389,1),new IG.ptr(6400,6430,1),new IG.ptr(6480,6509,1),new IG.ptr(6512,6516,1),new IG.ptr(6528,6571,1),new IG.ptr(6576,6601,1),new IG.ptr(6656,6678,1),new IG.ptr(6688,6740,1),new IG.ptr(6823,6917,94),new IG.ptr(6918,6963,1),new IG.ptr(6981,6987,1),new IG.ptr(7043,7072,1),new IG.ptr(7086,7087,1),new IG.ptr(7098,7141,1),new IG.ptr(7168,7203,1),new IG.ptr(7245,7247,1),new IG.ptr(7258,7293,1),new IG.ptr(7296,7304,1),new IG.ptr(7312,7354,1),new IG.ptr(7357,7359,1),new IG.ptr(7401,7404,1),new IG.ptr(7406,7411,1),new IG.ptr(7413,7414,1),new IG.ptr(7418,7424,6),new IG.ptr(7425,7615,1),new IG.ptr(7680,7957,1),new IG.ptr(7960,7965,1),new IG.ptr(7968,8005,1),new IG.ptr(8008,8013,1),new IG.ptr(8016,8023,1),new IG.ptr(8025,8031,2),new IG.ptr(8032,8061,1),new IG.ptr(8064,8116,1),new IG.ptr(8118,8124,1),new IG.ptr(8126,8130,4),new IG.ptr(8131,8132,1),new IG.ptr(8134,8140,1),new IG.ptr(8144,8147,1),new IG.ptr(8150,8155,1),new IG.ptr(8160,8172,1),new IG.ptr(8178,8180,1),new IG.ptr(8182,8188,1),new IG.ptr(8305,8319,14),new IG.ptr(8336,8348,1),new IG.ptr(8450,8455,5),new IG.ptr(8458,8467,1),new IG.ptr(8469,8473,4),new IG.ptr(8474,8477,1),new IG.ptr(8484,8490,2),new IG.ptr(8491,8493,1),new IG.ptr(8495,8505,1),new IG.ptr(8508,8511,1),new IG.ptr(8517,8521,1),new IG.ptr(8526,8579,53),new IG.ptr(8580,11264,2684),new IG.ptr(11265,11310,1),new IG.ptr(11312,11358,1),new IG.ptr(11360,11492,1),new IG.ptr(11499,11502,1),new IG.ptr(11506,11507,1),new IG.ptr(11520,11557,1),new IG.ptr(11559,11565,6),new IG.ptr(11568,11623,1),new IG.ptr(11631,11648,17),new IG.ptr(11649,11670,1),new IG.ptr(11680,11686,1),new IG.ptr(11688,11694,1),new IG.ptr(11696,11702,1),new IG.ptr(11704,11710,1),new IG.ptr(11712,11718,1),new IG.ptr(11720,11726,1),new IG.ptr(11728,11734,1),new IG.ptr(11736,11742,1),new IG.ptr(11823,12293,470),new IG.ptr(12294,12337,43),new IG.ptr(12338,12341,1),new IG.ptr(12347,12348,1),new IG.ptr(12353,12438,1),new IG.ptr(12445,12447,1),new IG.ptr(12449,12538,1),new IG.ptr(12540,12543,1),new IG.ptr(12549,12591,1),new IG.ptr(12593,12686,1),new IG.ptr(12704,12735,1),new IG.ptr(12784,12799,1),new IG.ptr(13312,19903,1),new IG.ptr(19968,40956,1),new IG.ptr(40960,42124,1),new IG.ptr(42192,42237,1),new IG.ptr(42240,42508,1),new IG.ptr(42512,42527,1),new IG.ptr(42538,42539,1),new IG.ptr(42560,42606,1),new IG.ptr(42623,42653,1),new IG.ptr(42656,42725,1),new IG.ptr(42775,42783,1),new IG.ptr(42786,42888,1),new IG.ptr(42891,42943,1),new IG.ptr(42946,42954,1),new IG.ptr(42997,43009,1),new IG.ptr(43011,43013,1),new IG.ptr(43015,43018,1),new IG.ptr(43020,43042,1),new IG.ptr(43072,43123,1),new IG.ptr(43138,43187,1),new IG.ptr(43250,43255,1),new IG.ptr(43259,43261,2),new IG.ptr(43262,43274,12),new IG.ptr(43275,43301,1),new IG.ptr(43312,43334,1),new IG.ptr(43360,43388,1),new IG.ptr(43396,43442,1),new IG.ptr(43471,43488,17),new IG.ptr(43489,43492,1),new IG.ptr(43494,43503,1),new IG.ptr(43514,43518,1),new IG.ptr(43520,43560,1),new IG.ptr(43584,43586,1),new IG.ptr(43588,43595,1),new IG.ptr(43616,43638,1),new IG.ptr(43642,43646,4),new IG.ptr(43647,43695,1),new IG.ptr(43697,43701,4),new IG.ptr(43702,43705,3),new IG.ptr(43706,43709,1),new IG.ptr(43712,43714,2),new IG.ptr(43739,43741,1),new IG.ptr(43744,43754,1),new IG.ptr(43762,43764,1),new IG.ptr(43777,43782,1),new IG.ptr(43785,43790,1),new IG.ptr(43793,43798,1),new IG.ptr(43808,43814,1),new IG.ptr(43816,43822,1),new IG.ptr(43824,43866,1),new IG.ptr(43868,43881,1),new IG.ptr(43888,44002,1),new IG.ptr(44032,55203,1),new IG.ptr(55216,55238,1),new IG.ptr(55243,55291,1),new IG.ptr(63744,64109,1),new IG.ptr(64112,64217,1),new IG.ptr(64256,64262,1),new IG.ptr(64275,64279,1),new IG.ptr(64285,64287,2),new IG.ptr(64288,64296,1),new IG.ptr(64298,64310,1),new IG.ptr(64312,64316,1),new IG.ptr(64318,64320,2),new IG.ptr(64321,64323,2),new IG.ptr(64324,64326,2),new IG.ptr(64327,64433,1),new IG.ptr(64467,64829,1),new IG.ptr(64848,64911,1),new IG.ptr(64914,64967,1),new IG.ptr(65008,65019,1),new IG.ptr(65136,65140,1),new IG.ptr(65142,65276,1),new IG.ptr(65313,65338,1),new IG.ptr(65345,65370,1),new IG.ptr(65382,65470,1),new IG.ptr(65474,65479,1),new IG.ptr(65482,65487,1),new IG.ptr(65490,65495,1),new IG.ptr(65498,65500,1)]),new JN([new IH.ptr(65536,65547,1),new IH.ptr(65549,65574,1),new IH.ptr(65576,65594,1),new IH.ptr(65596,65597,1),new IH.ptr(65599,65613,1),new IH.ptr(65616,65629,1),new IH.ptr(65664,65786,1),new IH.ptr(66176,66204,1),new IH.ptr(66208,66256,1),new IH.ptr(66304,66335,1),new IH.ptr(66349,66368,1),new IH.ptr(66370,66377,1),new IH.ptr(66384,66421,1),new IH.ptr(66432,66461,1),new IH.ptr(66464,66499,1),new IH.ptr(66504,66511,1),new IH.ptr(66560,66717,1),new IH.ptr(66736,66771,1),new IH.ptr(66776,66811,1),new IH.ptr(66816,66855,1),new IH.ptr(66864,66915,1),new IH.ptr(67072,67382,1),new IH.ptr(67392,67413,1),new IH.ptr(67424,67431,1),new IH.ptr(67584,67589,1),new IH.ptr(67592,67594,2),new IH.ptr(67595,67637,1),new IH.ptr(67639,67640,1),new IH.ptr(67644,67647,3),new IH.ptr(67648,67669,1),new IH.ptr(67680,67702,1),new IH.ptr(67712,67742,1),new IH.ptr(67808,67826,1),new IH.ptr(67828,67829,1),new IH.ptr(67840,67861,1),new IH.ptr(67872,67897,1),new IH.ptr(67968,68023,1),new IH.ptr(68030,68031,1),new IH.ptr(68096,68112,16),new IH.ptr(68113,68115,1),new IH.ptr(68117,68119,1),new IH.ptr(68121,68149,1),new IH.ptr(68192,68220,1),new IH.ptr(68224,68252,1),new IH.ptr(68288,68295,1),new IH.ptr(68297,68324,1),new IH.ptr(68352,68405,1),new IH.ptr(68416,68437,1),new IH.ptr(68448,68466,1),new IH.ptr(68480,68497,1),new IH.ptr(68608,68680,1),new IH.ptr(68736,68786,1),new IH.ptr(68800,68850,1),new IH.ptr(68864,68899,1),new IH.ptr(69248,69289,1),new IH.ptr(69296,69297,1),new IH.ptr(69376,69404,1),new IH.ptr(69415,69424,9),new IH.ptr(69425,69445,1),new IH.ptr(69552,69572,1),new IH.ptr(69600,69622,1),new IH.ptr(69635,69687,1),new IH.ptr(69763,69807,1),new IH.ptr(69840,69864,1),new IH.ptr(69891,69926,1),new IH.ptr(69956,69959,3),new IH.ptr(69968,70002,1),new IH.ptr(70006,70019,13),new IH.ptr(70020,70066,1),new IH.ptr(70081,70084,1),new IH.ptr(70106,70108,2),new IH.ptr(70144,70161,1),new IH.ptr(70163,70187,1),new IH.ptr(70272,70278,1),new IH.ptr(70280,70282,2),new IH.ptr(70283,70285,1),new IH.ptr(70287,70301,1),new IH.ptr(70303,70312,1),new IH.ptr(70320,70366,1),new IH.ptr(70405,70412,1),new IH.ptr(70415,70416,1),new IH.ptr(70419,70440,1),new IH.ptr(70442,70448,1),new IH.ptr(70450,70451,1),new IH.ptr(70453,70457,1),new IH.ptr(70461,70480,19),new IH.ptr(70493,70497,1),new IH.ptr(70656,70708,1),new IH.ptr(70727,70730,1),new IH.ptr(70751,70753,1),new IH.ptr(70784,70831,1),new IH.ptr(70852,70853,1),new IH.ptr(70855,71040,185),new IH.ptr(71041,71086,1),new IH.ptr(71128,71131,1),new IH.ptr(71168,71215,1),new IH.ptr(71236,71296,60),new IH.ptr(71297,71338,1),new IH.ptr(71352,71424,72),new IH.ptr(71425,71450,1),new IH.ptr(71680,71723,1),new IH.ptr(71840,71903,1),new IH.ptr(71935,71942,1),new IH.ptr(71945,71948,3),new IH.ptr(71949,71955,1),new IH.ptr(71957,71958,1),new IH.ptr(71960,71983,1),new IH.ptr(71999,72001,2),new IH.ptr(72096,72103,1),new IH.ptr(72106,72144,1),new IH.ptr(72161,72163,2),new IH.ptr(72192,72203,11),new IH.ptr(72204,72242,1),new IH.ptr(72250,72272,22),new IH.ptr(72284,72329,1),new IH.ptr(72349,72384,35),new IH.ptr(72385,72440,1),new IH.ptr(72704,72712,1),new IH.ptr(72714,72750,1),new IH.ptr(72768,72818,50),new IH.ptr(72819,72847,1),new IH.ptr(72960,72966,1),new IH.ptr(72968,72969,1),new IH.ptr(72971,73008,1),new IH.ptr(73030,73056,26),new IH.ptr(73057,73061,1),new IH.ptr(73063,73064,1),new IH.ptr(73066,73097,1),new IH.ptr(73112,73440,328),new IH.ptr(73441,73458,1),new IH.ptr(73648,73728,80),new IH.ptr(73729,74649,1),new IH.ptr(74880,75075,1),new IH.ptr(77824,78894,1),new IH.ptr(82944,83526,1),new IH.ptr(92160,92728,1),new IH.ptr(92736,92766,1),new IH.ptr(92880,92909,1),new IH.ptr(92928,92975,1),new IH.ptr(92992,92995,1),new IH.ptr(93027,93047,1),new IH.ptr(93053,93071,1),new IH.ptr(93760,93823,1),new IH.ptr(93952,94026,1),new IH.ptr(94032,94099,67),new IH.ptr(94100,94111,1),new IH.ptr(94176,94177,1),new IH.ptr(94179,94208,29),new IH.ptr(94209,100343,1),new IH.ptr(100352,101589,1),new IH.ptr(101632,101640,1),new IH.ptr(110592,110878,1),new IH.ptr(110928,110930,1),new IH.ptr(110948,110951,1),new IH.ptr(110960,111355,1),new IH.ptr(113664,113770,1),new IH.ptr(113776,113788,1),new IH.ptr(113792,113800,1),new IH.ptr(113808,113817,1),new IH.ptr(119808,119892,1),new IH.ptr(119894,119964,1),new IH.ptr(119966,119967,1),new IH.ptr(119970,119973,3),new IH.ptr(119974,119977,3),new IH.ptr(119978,119980,1),new IH.ptr(119982,119993,1),new IH.ptr(119995,119997,2),new IH.ptr(119998,120003,1),new IH.ptr(120005,120069,1),new IH.ptr(120071,120074,1),new IH.ptr(120077,120084,1),new IH.ptr(120086,120092,1),new IH.ptr(120094,120121,1),new IH.ptr(120123,120126,1),new IH.ptr(120128,120132,1),new IH.ptr(120134,120138,4),new IH.ptr(120139,120144,1),new IH.ptr(120146,120485,1),new IH.ptr(120488,120512,1),new IH.ptr(120514,120538,1),new IH.ptr(120540,120570,1),new IH.ptr(120572,120596,1),new IH.ptr(120598,120628,1),new IH.ptr(120630,120654,1),new IH.ptr(120656,120686,1),new IH.ptr(120688,120712,1),new IH.ptr(120714,120744,1),new IH.ptr(120746,120770,1),new IH.ptr(120772,120779,1),new IH.ptr(123136,123180,1),new IH.ptr(123191,123197,1),new IH.ptr(123214,123584,370),new IH.ptr(123585,123627,1),new IH.ptr(124928,125124,1),new IH.ptr(125184,125251,1),new IH.ptr(125259,126464,1205),new IH.ptr(126465,126467,1),new IH.ptr(126469,126495,1),new IH.ptr(126497,126498,1),new IH.ptr(126500,126503,3),new IH.ptr(126505,126514,1),new IH.ptr(126516,126519,1),new IH.ptr(126521,126523,2),new IH.ptr(126530,126535,5),new IH.ptr(126537,126541,2),new IH.ptr(126542,126543,1),new IH.ptr(126545,126546,1),new IH.ptr(126548,126551,3),new IH.ptr(126553,126561,2),new IH.ptr(126562,126564,2),new IH.ptr(126567,126570,1),new IH.ptr(126572,126578,1),new IH.ptr(126580,126583,1),new IH.ptr(126585,126588,1),new IH.ptr(126590,126592,2),new IH.ptr(126593,126601,1),new IH.ptr(126603,126619,1),new IH.ptr(126625,126627,1),new IH.ptr(126629,126633,1),new IH.ptr(126635,126651,1),new IH.ptr(131072,173789,1),new IH.ptr(173824,177972,1),new IH.ptr(177984,178205,1),new IH.ptr(178208,183969,1),new IH.ptr(183984,191456,1),new IH.ptr(194560,195101,1),new IH.ptr(196608,201546,1)]),6);G=new IF.ptr(new JM([new IG.ptr(97,122,1),new IG.ptr(181,223,42),new IG.ptr(224,246,1),new IG.ptr(248,255,1),new IG.ptr(257,311,2),new IG.ptr(312,328,2),new IG.ptr(329,375,2),new IG.ptr(378,382,2),new IG.ptr(383,384,1),new IG.ptr(387,389,2),new IG.ptr(392,396,4),new IG.ptr(397,402,5),new IG.ptr(405,409,4),new IG.ptr(410,411,1),new IG.ptr(414,417,3),new IG.ptr(419,421,2),new IG.ptr(424,426,2),new IG.ptr(427,429,2),new IG.ptr(432,436,4),new IG.ptr(438,441,3),new IG.ptr(442,445,3),new IG.ptr(446,447,1),new IG.ptr(454,460,3),new IG.ptr(462,476,2),new IG.ptr(477,495,2),new IG.ptr(496,499,3),new IG.ptr(501,505,4),new IG.ptr(507,563,2),new IG.ptr(564,569,1),new IG.ptr(572,575,3),new IG.ptr(576,578,2),new IG.ptr(583,591,2),new IG.ptr(592,659,1),new IG.ptr(661,687,1),new IG.ptr(881,883,2),new IG.ptr(887,891,4),new IG.ptr(892,893,1),new IG.ptr(912,940,28),new IG.ptr(941,974,1),new IG.ptr(976,977,1),new IG.ptr(981,983,1),new IG.ptr(985,1007,2),new IG.ptr(1008,1011,1),new IG.ptr(1013,1019,3),new IG.ptr(1020,1072,52),new IG.ptr(1073,1119,1),new IG.ptr(1121,1153,2),new IG.ptr(1163,1215,2),new IG.ptr(1218,1230,2),new IG.ptr(1231,1327,2),new IG.ptr(1376,1416,1),new IG.ptr(4304,4346,1),new IG.ptr(4349,4351,1),new IG.ptr(5112,5117,1),new IG.ptr(7296,7304,1),new IG.ptr(7424,7467,1),new IG.ptr(7531,7543,1),new IG.ptr(7545,7578,1),new IG.ptr(7681,7829,2),new IG.ptr(7830,7837,1),new IG.ptr(7839,7935,2),new IG.ptr(7936,7943,1),new IG.ptr(7952,7957,1),new IG.ptr(7968,7975,1),new IG.ptr(7984,7991,1),new IG.ptr(8000,8005,1),new IG.ptr(8016,8023,1),new IG.ptr(8032,8039,1),new IG.ptr(8048,8061,1),new IG.ptr(8064,8071,1),new IG.ptr(8080,8087,1),new IG.ptr(8096,8103,1),new IG.ptr(8112,8116,1),new IG.ptr(8118,8119,1),new IG.ptr(8126,8130,4),new IG.ptr(8131,8132,1),new IG.ptr(8134,8135,1),new IG.ptr(8144,8147,1),new IG.ptr(8150,8151,1),new IG.ptr(8160,8167,1),new IG.ptr(8178,8180,1),new IG.ptr(8182,8183,1),new IG.ptr(8458,8462,4),new IG.ptr(8463,8467,4),new IG.ptr(8495,8505,5),new IG.ptr(8508,8509,1),new IG.ptr(8518,8521,1),new IG.ptr(8526,8580,54),new IG.ptr(11312,11358,1),new IG.ptr(11361,11365,4),new IG.ptr(11366,11372,2),new IG.ptr(11377,11379,2),new IG.ptr(11380,11382,2),new IG.ptr(11383,11387,1),new IG.ptr(11393,11491,2),new IG.ptr(11492,11500,8),new IG.ptr(11502,11507,5),new IG.ptr(11520,11557,1),new IG.ptr(11559,11565,6),new IG.ptr(42561,42605,2),new IG.ptr(42625,42651,2),new IG.ptr(42787,42799,2),new IG.ptr(42800,42801,1),new IG.ptr(42803,42865,2),new IG.ptr(42866,42872,1),new IG.ptr(42874,42876,2),new IG.ptr(42879,42887,2),new IG.ptr(42892,42894,2),new IG.ptr(42897,42899,2),new IG.ptr(42900,42901,1),new IG.ptr(42903,42921,2),new IG.ptr(42927,42933,6),new IG.ptr(42935,42943,2),new IG.ptr(42947,42952,5),new IG.ptr(42954,42998,44),new IG.ptr(43002,43824,822),new IG.ptr(43825,43866,1),new IG.ptr(43872,43880,1),new IG.ptr(43888,43967,1),new IG.ptr(64256,64262,1),new IG.ptr(64275,64279,1),new IG.ptr(65345,65370,1)]),new JN([new IH.ptr(66600,66639,1),new IH.ptr(66776,66811,1),new IH.ptr(68800,68850,1),new IH.ptr(71872,71903,1),new IH.ptr(93792,93823,1),new IH.ptr(119834,119859,1),new IH.ptr(119886,119892,1),new IH.ptr(119894,119911,1),new IH.ptr(119938,119963,1),new IH.ptr(119990,119993,1),new IH.ptr(119995,119997,2),new IH.ptr(119998,120003,1),new IH.ptr(120005,120015,1),new IH.ptr(120042,120067,1),new IH.ptr(120094,120119,1),new IH.ptr(120146,120171,1),new IH.ptr(120198,120223,1),new IH.ptr(120250,120275,1),new IH.ptr(120302,120327,1),new IH.ptr(120354,120379,1),new IH.ptr(120406,120431,1),new IH.ptr(120458,120485,1),new IH.ptr(120514,120538,1),new IH.ptr(120540,120545,1),new IH.ptr(120572,120596,1),new IH.ptr(120598,120603,1),new IH.ptr(120630,120654,1),new IH.ptr(120656,120661,1),new IH.ptr(120688,120712,1),new IH.ptr(120714,120719,1),new IH.ptr(120746,120770,1),new IH.ptr(120772,120777,1),new IH.ptr(120779,125218,4439),new IH.ptr(125219,125251,1)]),4);H=new IF.ptr(new JM([new IG.ptr(688,705,1),new IG.ptr(710,721,1),new IG.ptr(736,740,1),new IG.ptr(748,750,2),new IG.ptr(884,890,6),new IG.ptr(1369,1600,231),new IG.ptr(1765,1766,1),new IG.ptr(2036,2037,1),new IG.ptr(2042,2074,32),new IG.ptr(2084,2088,4),new IG.ptr(2417,3654,1237),new IG.ptr(3782,4348,566),new IG.ptr(6103,6211,108),new IG.ptr(6823,7288,465),new IG.ptr(7289,7293,1),new IG.ptr(7468,7530,1),new IG.ptr(7544,7579,35),new IG.ptr(7580,7615,1),new IG.ptr(8305,8319,14),new IG.ptr(8336,8348,1),new IG.ptr(11388,11389,1),new IG.ptr(11631,11823,192),new IG.ptr(12293,12337,44),new IG.ptr(12338,12341,1),new IG.ptr(12347,12445,98),new IG.ptr(12446,12540,94),new IG.ptr(12541,12542,1),new IG.ptr(40981,42232,1251),new IG.ptr(42233,42237,1),new IG.ptr(42508,42623,115),new IG.ptr(42652,42653,1),new IG.ptr(42775,42783,1),new IG.ptr(42864,42888,24),new IG.ptr(43000,43001,1),new IG.ptr(43471,43494,23),new IG.ptr(43632,43741,109),new IG.ptr(43763,43764,1),new IG.ptr(43868,43871,1),new IG.ptr(43881,65392,21511),new IG.ptr(65438,65439,1)]),new JN([new IH.ptr(92992,92995,1),new IH.ptr(94099,94111,1),new IH.ptr(94176,94177,1),new IH.ptr(94179,123191,29012),new IH.ptr(123192,123197,1),new IH.ptr(125259,125259,1)]),0);I=new IF.ptr(new JM([new IG.ptr(170,186,16),new IG.ptr(443,448,5),new IG.ptr(449,451,1),new IG.ptr(660,1488,828),new IG.ptr(1489,1514,1),new IG.ptr(1519,1522,1),new IG.ptr(1568,1599,1),new IG.ptr(1601,1610,1),new IG.ptr(1646,1647,1),new IG.ptr(1649,1747,1),new IG.ptr(1749,1774,25),new IG.ptr(1775,1786,11),new IG.ptr(1787,1788,1),new IG.ptr(1791,1808,17),new IG.ptr(1810,1839,1),new IG.ptr(1869,1957,1),new IG.ptr(1969,1994,25),new IG.ptr(1995,2026,1),new IG.ptr(2048,2069,1),new IG.ptr(2112,2136,1),new IG.ptr(2144,2154,1),new IG.ptr(2208,2228,1),new IG.ptr(2230,2247,1),new IG.ptr(2308,2361,1),new IG.ptr(2365,2384,19),new IG.ptr(2392,2401,1),new IG.ptr(2418,2432,1),new IG.ptr(2437,2444,1),new IG.ptr(2447,2448,1),new IG.ptr(2451,2472,1),new IG.ptr(2474,2480,1),new IG.ptr(2482,2486,4),new IG.ptr(2487,2489,1),new IG.ptr(2493,2510,17),new IG.ptr(2524,2525,1),new IG.ptr(2527,2529,1),new IG.ptr(2544,2545,1),new IG.ptr(2556,2565,9),new IG.ptr(2566,2570,1),new IG.ptr(2575,2576,1),new IG.ptr(2579,2600,1),new IG.ptr(2602,2608,1),new IG.ptr(2610,2611,1),new IG.ptr(2613,2614,1),new IG.ptr(2616,2617,1),new IG.ptr(2649,2652,1),new IG.ptr(2654,2674,20),new IG.ptr(2675,2676,1),new IG.ptr(2693,2701,1),new IG.ptr(2703,2705,1),new IG.ptr(2707,2728,1),new IG.ptr(2730,2736,1),new IG.ptr(2738,2739,1),new IG.ptr(2741,2745,1),new IG.ptr(2749,2768,19),new IG.ptr(2784,2785,1),new IG.ptr(2809,2821,12),new IG.ptr(2822,2828,1),new IG.ptr(2831,2832,1),new IG.ptr(2835,2856,1),new IG.ptr(2858,2864,1),new IG.ptr(2866,2867,1),new IG.ptr(2869,2873,1),new IG.ptr(2877,2908,31),new IG.ptr(2909,2911,2),new IG.ptr(2912,2913,1),new IG.ptr(2929,2947,18),new IG.ptr(2949,2954,1),new IG.ptr(2958,2960,1),new IG.ptr(2962,2965,1),new IG.ptr(2969,2970,1),new IG.ptr(2972,2974,2),new IG.ptr(2975,2979,4),new IG.ptr(2980,2984,4),new IG.ptr(2985,2986,1),new IG.ptr(2990,3001,1),new IG.ptr(3024,3077,53),new IG.ptr(3078,3084,1),new IG.ptr(3086,3088,1),new IG.ptr(3090,3112,1),new IG.ptr(3114,3129,1),new IG.ptr(3133,3160,27),new IG.ptr(3161,3162,1),new IG.ptr(3168,3169,1),new IG.ptr(3200,3205,5),new IG.ptr(3206,3212,1),new IG.ptr(3214,3216,1),new IG.ptr(3218,3240,1),new IG.ptr(3242,3251,1),new IG.ptr(3253,3257,1),new IG.ptr(3261,3294,33),new IG.ptr(3296,3297,1),new IG.ptr(3313,3314,1),new IG.ptr(3332,3340,1),new IG.ptr(3342,3344,1),new IG.ptr(3346,3386,1),new IG.ptr(3389,3406,17),new IG.ptr(3412,3414,1),new IG.ptr(3423,3425,1),new IG.ptr(3450,3455,1),new IG.ptr(3461,3478,1),new IG.ptr(3482,3505,1),new IG.ptr(3507,3515,1),new IG.ptr(3517,3520,3),new IG.ptr(3521,3526,1),new IG.ptr(3585,3632,1),new IG.ptr(3634,3635,1),new IG.ptr(3648,3653,1),new IG.ptr(3713,3714,1),new IG.ptr(3716,3718,2),new IG.ptr(3719,3722,1),new IG.ptr(3724,3747,1),new IG.ptr(3749,3751,2),new IG.ptr(3752,3760,1),new IG.ptr(3762,3763,1),new IG.ptr(3773,3776,3),new IG.ptr(3777,3780,1),new IG.ptr(3804,3807,1),new IG.ptr(3840,3904,64),new IG.ptr(3905,3911,1),new IG.ptr(3913,3948,1),new IG.ptr(3976,3980,1),new IG.ptr(4096,4138,1),new IG.ptr(4159,4176,17),new IG.ptr(4177,4181,1),new IG.ptr(4186,4189,1),new IG.ptr(4193,4197,4),new IG.ptr(4198,4206,8),new IG.ptr(4207,4208,1),new IG.ptr(4213,4225,1),new IG.ptr(4238,4352,114),new IG.ptr(4353,4680,1),new IG.ptr(4682,4685,1),new IG.ptr(4688,4694,1),new IG.ptr(4696,4698,2),new IG.ptr(4699,4701,1),new IG.ptr(4704,4744,1),new IG.ptr(4746,4749,1),new IG.ptr(4752,4784,1),new IG.ptr(4786,4789,1),new IG.ptr(4792,4798,1),new IG.ptr(4800,4802,2),new IG.ptr(4803,4805,1),new IG.ptr(4808,4822,1),new IG.ptr(4824,4880,1),new IG.ptr(4882,4885,1),new IG.ptr(4888,4954,1),new IG.ptr(4992,5007,1),new IG.ptr(5121,5740,1),new IG.ptr(5743,5759,1),new IG.ptr(5761,5786,1),new IG.ptr(5792,5866,1),new IG.ptr(5873,5880,1),new IG.ptr(5888,5900,1),new IG.ptr(5902,5905,1),new IG.ptr(5920,5937,1),new IG.ptr(5952,5969,1),new IG.ptr(5984,5996,1),new IG.ptr(5998,6000,1),new IG.ptr(6016,6067,1),new IG.ptr(6108,6176,68),new IG.ptr(6177,6210,1),new IG.ptr(6212,6264,1),new IG.ptr(6272,6276,1),new IG.ptr(6279,6312,1),new IG.ptr(6314,6320,6),new IG.ptr(6321,6389,1),new IG.ptr(6400,6430,1),new IG.ptr(6480,6509,1),new IG.ptr(6512,6516,1),new IG.ptr(6528,6571,1),new IG.ptr(6576,6601,1),new IG.ptr(6656,6678,1),new IG.ptr(6688,6740,1),new IG.ptr(6917,6963,1),new IG.ptr(6981,6987,1),new IG.ptr(7043,7072,1),new IG.ptr(7086,7087,1),new IG.ptr(7098,7141,1),new IG.ptr(7168,7203,1),new IG.ptr(7245,7247,1),new IG.ptr(7258,7287,1),new IG.ptr(7401,7404,1),new IG.ptr(7406,7411,1),new IG.ptr(7413,7414,1),new IG.ptr(7418,8501,1083),new IG.ptr(8502,8504,1),new IG.ptr(11568,11623,1),new IG.ptr(11648,11670,1),new IG.ptr(11680,11686,1),new IG.ptr(11688,11694,1),new IG.ptr(11696,11702,1),new IG.ptr(11704,11710,1),new IG.ptr(11712,11718,1),new IG.ptr(11720,11726,1),new IG.ptr(11728,11734,1),new IG.ptr(11736,11742,1),new IG.ptr(12294,12348,54),new IG.ptr(12353,12438,1),new IG.ptr(12447,12449,2),new IG.ptr(12450,12538,1),new IG.ptr(12543,12549,6),new IG.ptr(12550,12591,1),new IG.ptr(12593,12686,1),new IG.ptr(12704,12735,1),new IG.ptr(12784,12799,1),new IG.ptr(13312,19903,1),new IG.ptr(19968,40956,1),new IG.ptr(40960,40980,1),new IG.ptr(40982,42124,1),new IG.ptr(42192,42231,1),new IG.ptr(42240,42507,1),new IG.ptr(42512,42527,1),new IG.ptr(42538,42539,1),new IG.ptr(42606,42656,50),new IG.ptr(42657,42725,1),new IG.ptr(42895,42999,104),new IG.ptr(43003,43009,1),new IG.ptr(43011,43013,1),new IG.ptr(43015,43018,1),new IG.ptr(43020,43042,1),new IG.ptr(43072,43123,1),new IG.ptr(43138,43187,1),new IG.ptr(43250,43255,1),new IG.ptr(43259,43261,2),new IG.ptr(43262,43274,12),new IG.ptr(43275,43301,1),new IG.ptr(43312,43334,1),new IG.ptr(43360,43388,1),new IG.ptr(43396,43442,1),new IG.ptr(43488,43492,1),new IG.ptr(43495,43503,1),new IG.ptr(43514,43518,1),new IG.ptr(43520,43560,1),new IG.ptr(43584,43586,1),new IG.ptr(43588,43595,1),new IG.ptr(43616,43631,1),new IG.ptr(43633,43638,1),new IG.ptr(43642,43646,4),new IG.ptr(43647,43695,1),new IG.ptr(43697,43701,4),new IG.ptr(43702,43705,3),new IG.ptr(43706,43709,1),new IG.ptr(43712,43714,2),new IG.ptr(43739,43740,1),new IG.ptr(43744,43754,1),new IG.ptr(43762,43777,15),new IG.ptr(43778,43782,1),new IG.ptr(43785,43790,1),new IG.ptr(43793,43798,1),new IG.ptr(43808,43814,1),new IG.ptr(43816,43822,1),new IG.ptr(43968,44002,1),new IG.ptr(44032,55203,1),new IG.ptr(55216,55238,1),new IG.ptr(55243,55291,1),new IG.ptr(63744,64109,1),new IG.ptr(64112,64217,1),new IG.ptr(64285,64287,2),new IG.ptr(64288,64296,1),new IG.ptr(64298,64310,1),new IG.ptr(64312,64316,1),new IG.ptr(64318,64320,2),new IG.ptr(64321,64323,2),new IG.ptr(64324,64326,2),new IG.ptr(64327,64433,1),new IG.ptr(64467,64829,1),new IG.ptr(64848,64911,1),new IG.ptr(64914,64967,1),new IG.ptr(65008,65019,1),new IG.ptr(65136,65140,1),new IG.ptr(65142,65276,1),new IG.ptr(65382,65391,1),new IG.ptr(65393,65437,1),new IG.ptr(65440,65470,1),new IG.ptr(65474,65479,1),new IG.ptr(65482,65487,1),new IG.ptr(65490,65495,1),new IG.ptr(65498,65500,1)]),new JN([new IH.ptr(65536,65547,1),new IH.ptr(65549,65574,1),new IH.ptr(65576,65594,1),new IH.ptr(65596,65597,1),new IH.ptr(65599,65613,1),new IH.ptr(65616,65629,1),new IH.ptr(65664,65786,1),new IH.ptr(66176,66204,1),new IH.ptr(66208,66256,1),new IH.ptr(66304,66335,1),new IH.ptr(66349,66368,1),new IH.ptr(66370,66377,1),new IH.ptr(66384,66421,1),new IH.ptr(66432,66461,1),new IH.ptr(66464,66499,1),new IH.ptr(66504,66511,1),new IH.ptr(66640,66717,1),new IH.ptr(66816,66855,1),new IH.ptr(66864,66915,1),new IH.ptr(67072,67382,1),new IH.ptr(67392,67413,1),new IH.ptr(67424,67431,1),new IH.ptr(67584,67589,1),new IH.ptr(67592,67594,2),new IH.ptr(67595,67637,1),new IH.ptr(67639,67640,1),new IH.ptr(67644,67647,3),new IH.ptr(67648,67669,1),new IH.ptr(67680,67702,1),new IH.ptr(67712,67742,1),new IH.ptr(67808,67826,1),new IH.ptr(67828,67829,1),new IH.ptr(67840,67861,1),new IH.ptr(67872,67897,1),new IH.ptr(67968,68023,1),new IH.ptr(68030,68031,1),new IH.ptr(68096,68112,16),new IH.ptr(68113,68115,1),new IH.ptr(68117,68119,1),new IH.ptr(68121,68149,1),new IH.ptr(68192,68220,1),new IH.ptr(68224,68252,1),new IH.ptr(68288,68295,1),new IH.ptr(68297,68324,1),new IH.ptr(68352,68405,1),new IH.ptr(68416,68437,1),new IH.ptr(68448,68466,1),new IH.ptr(68480,68497,1),new IH.ptr(68608,68680,1),new IH.ptr(68864,68899,1),new IH.ptr(69248,69289,1),new IH.ptr(69296,69297,1),new IH.ptr(69376,69404,1),new IH.ptr(69415,69424,9),new IH.ptr(69425,69445,1),new IH.ptr(69552,69572,1),new IH.ptr(69600,69622,1),new IH.ptr(69635,69687,1),new IH.ptr(69763,69807,1),new IH.ptr(69840,69864,1),new IH.ptr(69891,69926,1),new IH.ptr(69956,69959,3),new IH.ptr(69968,70002,1),new IH.ptr(70006,70019,13),new IH.ptr(70020,70066,1),new IH.ptr(70081,70084,1),new IH.ptr(70106,70108,2),new IH.ptr(70144,70161,1),new IH.ptr(70163,70187,1),new IH.ptr(70272,70278,1),new IH.ptr(70280,70282,2),new IH.ptr(70283,70285,1),new IH.ptr(70287,70301,1),new IH.ptr(70303,70312,1),new IH.ptr(70320,70366,1),new IH.ptr(70405,70412,1),new IH.ptr(70415,70416,1),new IH.ptr(70419,70440,1),new IH.ptr(70442,70448,1),new IH.ptr(70450,70451,1),new IH.ptr(70453,70457,1),new IH.ptr(70461,70480,19),new IH.ptr(70493,70497,1),new IH.ptr(70656,70708,1),new IH.ptr(70727,70730,1),new IH.ptr(70751,70753,1),new IH.ptr(70784,70831,1),new IH.ptr(70852,70853,1),new IH.ptr(70855,71040,185),new IH.ptr(71041,71086,1),new IH.ptr(71128,71131,1),new IH.ptr(71168,71215,1),new IH.ptr(71236,71296,60),new IH.ptr(71297,71338,1),new IH.ptr(71352,71424,72),new IH.ptr(71425,71450,1),new IH.ptr(71680,71723,1),new IH.ptr(71935,71942,1),new IH.ptr(71945,71948,3),new IH.ptr(71949,71955,1),new IH.ptr(71957,71958,1),new IH.ptr(71960,71983,1),new IH.ptr(71999,72001,2),new IH.ptr(72096,72103,1),new IH.ptr(72106,72144,1),new IH.ptr(72161,72163,2),new IH.ptr(72192,72203,11),new IH.ptr(72204,72242,1),new IH.ptr(72250,72272,22),new IH.ptr(72284,72329,1),new IH.ptr(72349,72384,35),new IH.ptr(72385,72440,1),new IH.ptr(72704,72712,1),new IH.ptr(72714,72750,1),new IH.ptr(72768,72818,50),new IH.ptr(72819,72847,1),new IH.ptr(72960,72966,1),new IH.ptr(72968,72969,1),new IH.ptr(72971,73008,1),new IH.ptr(73030,73056,26),new IH.ptr(73057,73061,1),new IH.ptr(73063,73064,1),new IH.ptr(73066,73097,1),new IH.ptr(73112,73440,328),new IH.ptr(73441,73458,1),new IH.ptr(73648,73728,80),new IH.ptr(73729,74649,1),new IH.ptr(74880,75075,1),new IH.ptr(77824,78894,1),new IH.ptr(82944,83526,1),new IH.ptr(92160,92728,1),new IH.ptr(92736,92766,1),new IH.ptr(92880,92909,1),new IH.ptr(92928,92975,1),new IH.ptr(93027,93047,1),new IH.ptr(93053,93071,1),new IH.ptr(93952,94026,1),new IH.ptr(94032,94208,176),new IH.ptr(94209,100343,1),new IH.ptr(100352,101589,1),new IH.ptr(101632,101640,1),new IH.ptr(110592,110878,1),new IH.ptr(110928,110930,1),new IH.ptr(110948,110951,1),new IH.ptr(110960,111355,1),new IH.ptr(113664,113770,1),new IH.ptr(113776,113788,1),new IH.ptr(113792,113800,1),new IH.ptr(113808,113817,1),new IH.ptr(123136,123180,1),new IH.ptr(123214,123584,370),new IH.ptr(123585,123627,1),new IH.ptr(124928,125124,1),new IH.ptr(126464,126467,1),new IH.ptr(126469,126495,1),new IH.ptr(126497,126498,1),new IH.ptr(126500,126503,3),new IH.ptr(126505,126514,1),new IH.ptr(126516,126519,1),new IH.ptr(126521,126523,2),new IH.ptr(126530,126535,5),new IH.ptr(126537,126541,2),new IH.ptr(126542,126543,1),new IH.ptr(126545,126546,1),new IH.ptr(126548,126551,3),new IH.ptr(126553,126561,2),new IH.ptr(126562,126564,2),new IH.ptr(126567,126570,1),new IH.ptr(126572,126578,1),new IH.ptr(126580,126583,1),new IH.ptr(126585,126588,1),new IH.ptr(126590,126592,2),new IH.ptr(126593,126601,1),new IH.ptr(126603,126619,1),new IH.ptr(126625,126627,1),new IH.ptr(126629,126633,1),new IH.ptr(126635,126651,1),new IH.ptr(131072,173789,1),new IH.ptr(173824,177972,1),new IH.ptr(177984,178205,1),new IH.ptr(178208,183969,1),new IH.ptr(183984,191456,1),new IH.ptr(194560,195101,1),new IH.ptr(196608,201546,1)]),1);J=new IF.ptr(new JM([new IG.ptr(453,459,3),new IG.ptr(498,8072,7574),new IG.ptr(8073,8079,1),new IG.ptr(8088,8095,1),new IG.ptr(8104,8111,1),new IG.ptr(8124,8140,16),new IG.ptr(8188,8188,1)]),JN.nil,0);K=new IF.ptr(new JM([new IG.ptr(65,90,1),new IG.ptr(192,214,1),new IG.ptr(216,222,1),new IG.ptr(256,310,2),new IG.ptr(313,327,2),new IG.ptr(330,376,2),new IG.ptr(377,381,2),new IG.ptr(385,386,1),new IG.ptr(388,390,2),new IG.ptr(391,393,2),new IG.ptr(394,395,1),new IG.ptr(398,401,1),new IG.ptr(403,404,1),new IG.ptr(406,408,1),new IG.ptr(412,413,1),new IG.ptr(415,416,1),new IG.ptr(418,422,2),new IG.ptr(423,425,2),new IG.ptr(428,430,2),new IG.ptr(431,433,2),new IG.ptr(434,435,1),new IG.ptr(437,439,2),new IG.ptr(440,444,4),new IG.ptr(452,461,3),new IG.ptr(463,475,2),new IG.ptr(478,494,2),new IG.ptr(497,500,3),new IG.ptr(502,504,1),new IG.ptr(506,562,2),new IG.ptr(570,571,1),new IG.ptr(573,574,1),new IG.ptr(577,579,2),new IG.ptr(580,582,1),new IG.ptr(584,590,2),new IG.ptr(880,882,2),new IG.ptr(886,895,9),new IG.ptr(902,904,2),new IG.ptr(905,906,1),new IG.ptr(908,910,2),new IG.ptr(911,913,2),new IG.ptr(914,929,1),new IG.ptr(931,939,1),new IG.ptr(975,978,3),new IG.ptr(979,980,1),new IG.ptr(984,1006,2),new IG.ptr(1012,1015,3),new IG.ptr(1017,1018,1),new IG.ptr(1021,1071,1),new IG.ptr(1120,1152,2),new IG.ptr(1162,1216,2),new IG.ptr(1217,1229,2),new IG.ptr(1232,1326,2),new IG.ptr(1329,1366,1),new IG.ptr(4256,4293,1),new IG.ptr(4295,4301,6),new IG.ptr(5024,5109,1),new IG.ptr(7312,7354,1),new IG.ptr(7357,7359,1),new IG.ptr(7680,7828,2),new IG.ptr(7838,7934,2),new IG.ptr(7944,7951,1),new IG.ptr(7960,7965,1),new IG.ptr(7976,7983,1),new IG.ptr(7992,7999,1),new IG.ptr(8008,8013,1),new IG.ptr(8025,8031,2),new IG.ptr(8040,8047,1),new IG.ptr(8120,8123,1),new IG.ptr(8136,8139,1),new IG.ptr(8152,8155,1),new IG.ptr(8168,8172,1),new IG.ptr(8184,8187,1),new IG.ptr(8450,8455,5),new IG.ptr(8459,8461,1),new IG.ptr(8464,8466,1),new IG.ptr(8469,8473,4),new IG.ptr(8474,8477,1),new IG.ptr(8484,8490,2),new IG.ptr(8491,8493,1),new IG.ptr(8496,8499,1),new IG.ptr(8510,8511,1),new IG.ptr(8517,8579,62),new IG.ptr(11264,11310,1),new IG.ptr(11360,11362,2),new IG.ptr(11363,11364,1),new IG.ptr(11367,11373,2),new IG.ptr(11374,11376,1),new IG.ptr(11378,11381,3),new IG.ptr(11390,11392,1),new IG.ptr(11394,11490,2),new IG.ptr(11499,11501,2),new IG.ptr(11506,42560,31054),new IG.ptr(42562,42604,2),new IG.ptr(42624,42650,2),new IG.ptr(42786,42798,2),new IG.ptr(42802,42862,2),new IG.ptr(42873,42877,2),new IG.ptr(42878,42886,2),new IG.ptr(42891,42893,2),new IG.ptr(42896,42898,2),new IG.ptr(42902,42922,2),new IG.ptr(42923,42926,1),new IG.ptr(42928,42932,1),new IG.ptr(42934,42942,2),new IG.ptr(42946,42948,2),new IG.ptr(42949,42951,1),new IG.ptr(42953,42997,44),new IG.ptr(65313,65338,1)]),new JN([new IH.ptr(66560,66599,1),new IH.ptr(66736,66771,1),new IH.ptr(68736,68786,1),new IH.ptr(71840,71871,1),new IH.ptr(93760,93791,1),new IH.ptr(119808,119833,1),new IH.ptr(119860,119885,1),new IH.ptr(119912,119937,1),new IH.ptr(119964,119966,2),new IH.ptr(119967,119973,3),new IH.ptr(119974,119977,3),new IH.ptr(119978,119980,1),new IH.ptr(119982,119989,1),new IH.ptr(120016,120041,1),new IH.ptr(120068,120069,1),new IH.ptr(120071,120074,1),new IH.ptr(120077,120084,1),new IH.ptr(120086,120092,1),new IH.ptr(120120,120121,1),new IH.ptr(120123,120126,1),new IH.ptr(120128,120132,1),new IH.ptr(120134,120138,4),new IH.ptr(120139,120144,1),new IH.ptr(120172,120197,1),new IH.ptr(120224,120249,1),new IH.ptr(120276,120301,1),new IH.ptr(120328,120353,1),new IH.ptr(120380,120405,1),new IH.ptr(120432,120457,1),new IH.ptr(120488,120512,1),new IH.ptr(120546,120570,1),new IH.ptr(120604,120628,1),new IH.ptr(120662,120686,1),new IH.ptr(120720,120744,1),new IH.ptr(120778,125184,4406),new IH.ptr(125185,125217,1)]),3);L=new IF.ptr(new JM([new IG.ptr(768,879,1),new IG.ptr(1155,1161,1),new IG.ptr(1425,1469,1),new IG.ptr(1471,1473,2),new IG.ptr(1474,1476,2),new IG.ptr(1477,1479,2),new IG.ptr(1552,1562,1),new IG.ptr(1611,1631,1),new IG.ptr(1648,1750,102),new IG.ptr(1751,1756,1),new IG.ptr(1759,1764,1),new IG.ptr(1767,1768,1),new IG.ptr(1770,1773,1),new IG.ptr(1809,1840,31),new IG.ptr(1841,1866,1),new IG.ptr(1958,1968,1),new IG.ptr(2027,2035,1),new IG.ptr(2045,2070,25),new IG.ptr(2071,2073,1),new IG.ptr(2075,2083,1),new IG.ptr(2085,2087,1),new IG.ptr(2089,2093,1),new IG.ptr(2137,2139,1),new IG.ptr(2259,2273,1),new IG.ptr(2275,2307,1),new IG.ptr(2362,2364,1),new IG.ptr(2366,2383,1),new IG.ptr(2385,2391,1),new IG.ptr(2402,2403,1),new IG.ptr(2433,2435,1),new IG.ptr(2492,2494,2),new IG.ptr(2495,2500,1),new IG.ptr(2503,2504,1),new IG.ptr(2507,2509,1),new IG.ptr(2519,2530,11),new IG.ptr(2531,2558,27),new IG.ptr(2561,2563,1),new IG.ptr(2620,2622,2),new IG.ptr(2623,2626,1),new IG.ptr(2631,2632,1),new IG.ptr(2635,2637,1),new IG.ptr(2641,2672,31),new IG.ptr(2673,2677,4),new IG.ptr(2689,2691,1),new IG.ptr(2748,2750,2),new IG.ptr(2751,2757,1),new IG.ptr(2759,2761,1),new IG.ptr(2763,2765,1),new IG.ptr(2786,2787,1),new IG.ptr(2810,2815,1),new IG.ptr(2817,2819,1),new IG.ptr(2876,2878,2),new IG.ptr(2879,2884,1),new IG.ptr(2887,2888,1),new IG.ptr(2891,2893,1),new IG.ptr(2901,2903,1),new IG.ptr(2914,2915,1),new IG.ptr(2946,3006,60),new IG.ptr(3007,3010,1),new IG.ptr(3014,3016,1),new IG.ptr(3018,3021,1),new IG.ptr(3031,3072,41),new IG.ptr(3073,3076,1),new IG.ptr(3134,3140,1),new IG.ptr(3142,3144,1),new IG.ptr(3146,3149,1),new IG.ptr(3157,3158,1),new IG.ptr(3170,3171,1),new IG.ptr(3201,3203,1),new IG.ptr(3260,3262,2),new IG.ptr(3263,3268,1),new IG.ptr(3270,3272,1),new IG.ptr(3274,3277,1),new IG.ptr(3285,3286,1),new IG.ptr(3298,3299,1),new IG.ptr(3328,3331,1),new IG.ptr(3387,3388,1),new IG.ptr(3390,3396,1),new IG.ptr(3398,3400,1),new IG.ptr(3402,3405,1),new IG.ptr(3415,3426,11),new IG.ptr(3427,3457,30),new IG.ptr(3458,3459,1),new IG.ptr(3530,3535,5),new IG.ptr(3536,3540,1),new IG.ptr(3542,3544,2),new IG.ptr(3545,3551,1),new IG.ptr(3570,3571,1),new IG.ptr(3633,3636,3),new IG.ptr(3637,3642,1),new IG.ptr(3655,3662,1),new IG.ptr(3761,3764,3),new IG.ptr(3765,3772,1),new IG.ptr(3784,3789,1),new IG.ptr(3864,3865,1),new IG.ptr(3893,3897,2),new IG.ptr(3902,3903,1),new IG.ptr(3953,3972,1),new IG.ptr(3974,3975,1),new IG.ptr(3981,3991,1),new IG.ptr(3993,4028,1),new IG.ptr(4038,4139,101),new IG.ptr(4140,4158,1),new IG.ptr(4182,4185,1),new IG.ptr(4190,4192,1),new IG.ptr(4194,4196,1),new IG.ptr(4199,4205,1),new IG.ptr(4209,4212,1),new IG.ptr(4226,4237,1),new IG.ptr(4239,4250,11),new IG.ptr(4251,4253,1),new IG.ptr(4957,4959,1),new IG.ptr(5906,5908,1),new IG.ptr(5938,5940,1),new IG.ptr(5970,5971,1),new IG.ptr(6002,6003,1),new IG.ptr(6068,6099,1),new IG.ptr(6109,6155,46),new IG.ptr(6156,6157,1),new IG.ptr(6277,6278,1),new IG.ptr(6313,6432,119),new IG.ptr(6433,6443,1),new IG.ptr(6448,6459,1),new IG.ptr(6679,6683,1),new IG.ptr(6741,6750,1),new IG.ptr(6752,6780,1),new IG.ptr(6783,6832,49),new IG.ptr(6833,6848,1),new IG.ptr(6912,6916,1),new IG.ptr(6964,6980,1),new IG.ptr(7019,7027,1),new IG.ptr(7040,7042,1),new IG.ptr(7073,7085,1),new IG.ptr(7142,7155,1),new IG.ptr(7204,7223,1),new IG.ptr(7376,7378,1),new IG.ptr(7380,7400,1),new IG.ptr(7405,7412,7),new IG.ptr(7415,7417,1),new IG.ptr(7616,7673,1),new IG.ptr(7675,7679,1),new IG.ptr(8400,8432,1),new IG.ptr(11503,11505,1),new IG.ptr(11647,11744,97),new IG.ptr(11745,11775,1),new IG.ptr(12330,12335,1),new IG.ptr(12441,12442,1),new IG.ptr(42607,42610,1),new IG.ptr(42612,42621,1),new IG.ptr(42654,42655,1),new IG.ptr(42736,42737,1),new IG.ptr(43010,43014,4),new IG.ptr(43019,43043,24),new IG.ptr(43044,43047,1),new IG.ptr(43052,43136,84),new IG.ptr(43137,43188,51),new IG.ptr(43189,43205,1),new IG.ptr(43232,43249,1),new IG.ptr(43263,43302,39),new IG.ptr(43303,43309,1),new IG.ptr(43335,43347,1),new IG.ptr(43392,43395,1),new IG.ptr(43443,43456,1),new IG.ptr(43493,43561,68),new IG.ptr(43562,43574,1),new IG.ptr(43587,43596,9),new IG.ptr(43597,43643,46),new IG.ptr(43644,43645,1),new IG.ptr(43696,43698,2),new IG.ptr(43699,43700,1),new IG.ptr(43703,43704,1),new IG.ptr(43710,43711,1),new IG.ptr(43713,43755,42),new IG.ptr(43756,43759,1),new IG.ptr(43765,43766,1),new IG.ptr(44003,44010,1),new IG.ptr(44012,44013,1),new IG.ptr(64286,65024,738),new IG.ptr(65025,65039,1),new IG.ptr(65056,65071,1)]),new JN([new IH.ptr(66045,66272,227),new IH.ptr(66422,66426,1),new IH.ptr(68097,68099,1),new IH.ptr(68101,68102,1),new IH.ptr(68108,68111,1),new IH.ptr(68152,68154,1),new IH.ptr(68159,68325,166),new IH.ptr(68326,68900,574),new IH.ptr(68901,68903,1),new IH.ptr(69291,69292,1),new IH.ptr(69446,69456,1),new IH.ptr(69632,69634,1),new IH.ptr(69688,69702,1),new IH.ptr(69759,69762,1),new IH.ptr(69808,69818,1),new IH.ptr(69888,69890,1),new IH.ptr(69927,69940,1),new IH.ptr(69957,69958,1),new IH.ptr(70003,70016,13),new IH.ptr(70017,70018,1),new IH.ptr(70067,70080,1),new IH.ptr(70089,70092,1),new IH.ptr(70094,70095,1),new IH.ptr(70188,70199,1),new IH.ptr(70206,70367,161),new IH.ptr(70368,70378,1),new IH.ptr(70400,70403,1),new IH.ptr(70459,70460,1),new IH.ptr(70462,70468,1),new IH.ptr(70471,70472,1),new IH.ptr(70475,70477,1),new IH.ptr(70487,70498,11),new IH.ptr(70499,70502,3),new IH.ptr(70503,70508,1),new IH.ptr(70512,70516,1),new IH.ptr(70709,70726,1),new IH.ptr(70750,70832,82),new IH.ptr(70833,70851,1),new IH.ptr(71087,71093,1),new IH.ptr(71096,71104,1),new IH.ptr(71132,71133,1),new IH.ptr(71216,71232,1),new IH.ptr(71339,71351,1),new IH.ptr(71453,71467,1),new IH.ptr(71724,71738,1),new IH.ptr(71984,71989,1),new IH.ptr(71991,71992,1),new IH.ptr(71995,71998,1),new IH.ptr(72000,72002,2),new IH.ptr(72003,72145,142),new IH.ptr(72146,72151,1),new IH.ptr(72154,72160,1),new IH.ptr(72164,72193,29),new IH.ptr(72194,72202,1),new IH.ptr(72243,72249,1),new IH.ptr(72251,72254,1),new IH.ptr(72263,72273,10),new IH.ptr(72274,72283,1),new IH.ptr(72330,72345,1),new IH.ptr(72751,72758,1),new IH.ptr(72760,72767,1),new IH.ptr(72850,72871,1),new IH.ptr(72873,72886,1),new IH.ptr(73009,73014,1),new IH.ptr(73018,73020,2),new IH.ptr(73021,73023,2),new IH.ptr(73024,73029,1),new IH.ptr(73031,73098,67),new IH.ptr(73099,73102,1),new IH.ptr(73104,73105,1),new IH.ptr(73107,73111,1),new IH.ptr(73459,73462,1),new IH.ptr(92912,92916,1),new IH.ptr(92976,92982,1),new IH.ptr(94031,94033,2),new IH.ptr(94034,94087,1),new IH.ptr(94095,94098,1),new IH.ptr(94180,94192,12),new IH.ptr(94193,113821,19628),new IH.ptr(113822,119141,5319),new IH.ptr(119142,119145,1),new IH.ptr(119149,119154,1),new IH.ptr(119163,119170,1),new IH.ptr(119173,119179,1),new IH.ptr(119210,119213,1),new IH.ptr(119362,119364,1),new IH.ptr(121344,121398,1),new IH.ptr(121403,121452,1),new IH.ptr(121461,121476,15),new IH.ptr(121499,121503,1),new IH.ptr(121505,121519,1),new IH.ptr(122880,122886,1),new IH.ptr(122888,122904,1),new IH.ptr(122907,122913,1),new IH.ptr(122915,122916,1),new IH.ptr(122918,122922,1),new IH.ptr(123184,123190,1),new IH.ptr(123628,123631,1),new IH.ptr(125136,125142,1),new IH.ptr(125252,125258,1),new IH.ptr(917760,917999,1)]),0);M=new IF.ptr(new JM([new IG.ptr(2307,2363,56),new IG.ptr(2366,2368,1),new IG.ptr(2377,2380,1),new IG.ptr(2382,2383,1),new IG.ptr(2434,2435,1),new IG.ptr(2494,2496,1),new IG.ptr(2503,2504,1),new IG.ptr(2507,2508,1),new IG.ptr(2519,2563,44),new IG.ptr(2622,2624,1),new IG.ptr(2691,2750,59),new IG.ptr(2751,2752,1),new IG.ptr(2761,2763,2),new IG.ptr(2764,2818,54),new IG.ptr(2819,2878,59),new IG.ptr(2880,2887,7),new IG.ptr(2888,2891,3),new IG.ptr(2892,2903,11),new IG.ptr(3006,3007,1),new IG.ptr(3009,3010,1),new IG.ptr(3014,3016,1),new IG.ptr(3018,3020,1),new IG.ptr(3031,3073,42),new IG.ptr(3074,3075,1),new IG.ptr(3137,3140,1),new IG.ptr(3202,3203,1),new IG.ptr(3262,3264,2),new IG.ptr(3265,3268,1),new IG.ptr(3271,3272,1),new IG.ptr(3274,3275,1),new IG.ptr(3285,3286,1),new IG.ptr(3330,3331,1),new IG.ptr(3390,3392,1),new IG.ptr(3398,3400,1),new IG.ptr(3402,3404,1),new IG.ptr(3415,3458,43),new IG.ptr(3459,3535,76),new IG.ptr(3536,3537,1),new IG.ptr(3544,3551,1),new IG.ptr(3570,3571,1),new IG.ptr(3902,3903,1),new IG.ptr(3967,4139,172),new IG.ptr(4140,4145,5),new IG.ptr(4152,4155,3),new IG.ptr(4156,4182,26),new IG.ptr(4183,4194,11),new IG.ptr(4195,4196,1),new IG.ptr(4199,4205,1),new IG.ptr(4227,4228,1),new IG.ptr(4231,4236,1),new IG.ptr(4239,4250,11),new IG.ptr(4251,4252,1),new IG.ptr(6070,6078,8),new IG.ptr(6079,6085,1),new IG.ptr(6087,6088,1),new IG.ptr(6435,6438,1),new IG.ptr(6441,6443,1),new IG.ptr(6448,6449,1),new IG.ptr(6451,6456,1),new IG.ptr(6681,6682,1),new IG.ptr(6741,6743,2),new IG.ptr(6753,6755,2),new IG.ptr(6756,6765,9),new IG.ptr(6766,6770,1),new IG.ptr(6916,6965,49),new IG.ptr(6971,6973,2),new IG.ptr(6974,6977,1),new IG.ptr(6979,6980,1),new IG.ptr(7042,7073,31),new IG.ptr(7078,7079,1),new IG.ptr(7082,7143,61),new IG.ptr(7146,7148,1),new IG.ptr(7150,7154,4),new IG.ptr(7155,7204,49),new IG.ptr(7205,7211,1),new IG.ptr(7220,7221,1),new IG.ptr(7393,7415,22),new IG.ptr(12334,12335,1),new IG.ptr(43043,43044,1),new IG.ptr(43047,43136,89),new IG.ptr(43137,43188,51),new IG.ptr(43189,43203,1),new IG.ptr(43346,43347,1),new IG.ptr(43395,43444,49),new IG.ptr(43445,43450,5),new IG.ptr(43451,43454,3),new IG.ptr(43455,43456,1),new IG.ptr(43567,43568,1),new IG.ptr(43571,43572,1),new IG.ptr(43597,43643,46),new IG.ptr(43645,43755,110),new IG.ptr(43758,43759,1),new IG.ptr(43765,44003,238),new IG.ptr(44004,44006,2),new IG.ptr(44007,44009,2),new IG.ptr(44010,44012,2)]),new JN([new IH.ptr(69632,69634,2),new IH.ptr(69762,69808,46),new IH.ptr(69809,69810,1),new IH.ptr(69815,69816,1),new IH.ptr(69932,69957,25),new IH.ptr(69958,70018,60),new IH.ptr(70067,70069,1),new IH.ptr(70079,70080,1),new IH.ptr(70094,70188,94),new IH.ptr(70189,70190,1),new IH.ptr(70194,70195,1),new IH.ptr(70197,70368,171),new IH.ptr(70369,70370,1),new IH.ptr(70402,70403,1),new IH.ptr(70462,70463,1),new IH.ptr(70465,70468,1),new IH.ptr(70471,70472,1),new IH.ptr(70475,70477,1),new IH.ptr(70487,70498,11),new IH.ptr(70499,70709,210),new IH.ptr(70710,70711,1),new IH.ptr(70720,70721,1),new IH.ptr(70725,70832,107),new IH.ptr(70833,70834,1),new IH.ptr(70841,70843,2),new IH.ptr(70844,70846,1),new IH.ptr(70849,71087,238),new IH.ptr(71088,71089,1),new IH.ptr(71096,71099,1),new IH.ptr(71102,71216,114),new IH.ptr(71217,71218,1),new IH.ptr(71227,71228,1),new IH.ptr(71230,71340,110),new IH.ptr(71342,71343,1),new IH.ptr(71350,71456,106),new IH.ptr(71457,71462,5),new IH.ptr(71724,71726,1),new IH.ptr(71736,71984,248),new IH.ptr(71985,71989,1),new IH.ptr(71991,71992,1),new IH.ptr(71997,72000,3),new IH.ptr(72002,72145,143),new IH.ptr(72146,72147,1),new IH.ptr(72156,72159,1),new IH.ptr(72164,72249,85),new IH.ptr(72279,72280,1),new IH.ptr(72343,72751,408),new IH.ptr(72766,72873,107),new IH.ptr(72881,72884,3),new IH.ptr(73098,73102,1),new IH.ptr(73107,73108,1),new IH.ptr(73110,73461,351),new IH.ptr(73462,94033,20571),new IH.ptr(94034,94087,1),new IH.ptr(94192,94193,1),new IH.ptr(119141,119142,1),new IH.ptr(119149,119154,1)]),0);N=new IF.ptr(new JM([new IG.ptr(1160,1161,1),new IG.ptr(6846,8413,1567),new IG.ptr(8414,8416,1),new IG.ptr(8418,8420,1),new IG.ptr(42608,42610,1)]),JN.nil,0);O=new IF.ptr(new JM([new IG.ptr(768,879,1),new IG.ptr(1155,1159,1),new IG.ptr(1425,1469,1),new IG.ptr(1471,1473,2),new IG.ptr(1474,1476,2),new IG.ptr(1477,1479,2),new IG.ptr(1552,1562,1),new IG.ptr(1611,1631,1),new IG.ptr(1648,1750,102),new IG.ptr(1751,1756,1),new IG.ptr(1759,1764,1),new IG.ptr(1767,1768,1),new IG.ptr(1770,1773,1),new IG.ptr(1809,1840,31),new IG.ptr(1841,1866,1),new IG.ptr(1958,1968,1),new IG.ptr(2027,2035,1),new IG.ptr(2045,2070,25),new IG.ptr(2071,2073,1),new IG.ptr(2075,2083,1),new IG.ptr(2085,2087,1),new IG.ptr(2089,2093,1),new IG.ptr(2137,2139,1),new IG.ptr(2259,2273,1),new IG.ptr(2275,2306,1),new IG.ptr(2362,2364,2),new IG.ptr(2369,2376,1),new IG.ptr(2381,2385,4),new IG.ptr(2386,2391,1),new IG.ptr(2402,2403,1),new IG.ptr(2433,2492,59),new IG.ptr(2497,2500,1),new IG.ptr(2509,2530,21),new IG.ptr(2531,2558,27),new IG.ptr(2561,2562,1),new IG.ptr(2620,2625,5),new IG.ptr(2626,2631,5),new IG.ptr(2632,2635,3),new IG.ptr(2636,2637,1),new IG.ptr(2641,2672,31),new IG.ptr(2673,2677,4),new IG.ptr(2689,2690,1),new IG.ptr(2748,2753,5),new IG.ptr(2754,2757,1),new IG.ptr(2759,2760,1),new IG.ptr(2765,2786,21),new IG.ptr(2787,2810,23),new IG.ptr(2811,2815,1),new IG.ptr(2817,2876,59),new IG.ptr(2879,2881,2),new IG.ptr(2882,2884,1),new IG.ptr(2893,2901,8),new IG.ptr(2902,2914,12),new IG.ptr(2915,2946,31),new IG.ptr(3008,3021,13),new IG.ptr(3072,3076,4),new IG.ptr(3134,3136,1),new IG.ptr(3142,3144,1),new IG.ptr(3146,3149,1),new IG.ptr(3157,3158,1),new IG.ptr(3170,3171,1),new IG.ptr(3201,3260,59),new IG.ptr(3263,3270,7),new IG.ptr(3276,3277,1),new IG.ptr(3298,3299,1),new IG.ptr(3328,3329,1),new IG.ptr(3387,3388,1),new IG.ptr(3393,3396,1),new IG.ptr(3405,3426,21),new IG.ptr(3427,3457,30),new IG.ptr(3530,3538,8),new IG.ptr(3539,3540,1),new IG.ptr(3542,3633,91),new IG.ptr(3636,3642,1),new IG.ptr(3655,3662,1),new IG.ptr(3761,3764,3),new IG.ptr(3765,3772,1),new IG.ptr(3784,3789,1),new IG.ptr(3864,3865,1),new IG.ptr(3893,3897,2),new IG.ptr(3953,3966,1),new IG.ptr(3968,3972,1),new IG.ptr(3974,3975,1),new IG.ptr(3981,3991,1),new IG.ptr(3993,4028,1),new IG.ptr(4038,4141,103),new IG.ptr(4142,4144,1),new IG.ptr(4146,4151,1),new IG.ptr(4153,4154,1),new IG.ptr(4157,4158,1),new IG.ptr(4184,4185,1),new IG.ptr(4190,4192,1),new IG.ptr(4209,4212,1),new IG.ptr(4226,4229,3),new IG.ptr(4230,4237,7),new IG.ptr(4253,4957,704),new IG.ptr(4958,4959,1),new IG.ptr(5906,5908,1),new IG.ptr(5938,5940,1),new IG.ptr(5970,5971,1),new IG.ptr(6002,6003,1),new IG.ptr(6068,6069,1),new IG.ptr(6071,6077,1),new IG.ptr(6086,6089,3),new IG.ptr(6090,6099,1),new IG.ptr(6109,6155,46),new IG.ptr(6156,6157,1),new IG.ptr(6277,6278,1),new IG.ptr(6313,6432,119),new IG.ptr(6433,6434,1),new IG.ptr(6439,6440,1),new IG.ptr(6450,6457,7),new IG.ptr(6458,6459,1),new IG.ptr(6679,6680,1),new IG.ptr(6683,6742,59),new IG.ptr(6744,6750,1),new IG.ptr(6752,6754,2),new IG.ptr(6757,6764,1),new IG.ptr(6771,6780,1),new IG.ptr(6783,6832,49),new IG.ptr(6833,6845,1),new IG.ptr(6847,6848,1),new IG.ptr(6912,6915,1),new IG.ptr(6964,6966,2),new IG.ptr(6967,6970,1),new IG.ptr(6972,6978,6),new IG.ptr(7019,7027,1),new IG.ptr(7040,7041,1),new IG.ptr(7074,7077,1),new IG.ptr(7080,7081,1),new IG.ptr(7083,7085,1),new IG.ptr(7142,7144,2),new IG.ptr(7145,7149,4),new IG.ptr(7151,7153,1),new IG.ptr(7212,7219,1),new IG.ptr(7222,7223,1),new IG.ptr(7376,7378,1),new IG.ptr(7380,7392,1),new IG.ptr(7394,7400,1),new IG.ptr(7405,7412,7),new IG.ptr(7416,7417,1),new IG.ptr(7616,7673,1),new IG.ptr(7675,7679,1),new IG.ptr(8400,8412,1),new IG.ptr(8417,8421,4),new IG.ptr(8422,8432,1),new IG.ptr(11503,11505,1),new IG.ptr(11647,11744,97),new IG.ptr(11745,11775,1),new IG.ptr(12330,12333,1),new IG.ptr(12441,12442,1),new IG.ptr(42607,42612,5),new IG.ptr(42613,42621,1),new IG.ptr(42654,42655,1),new IG.ptr(42736,42737,1),new IG.ptr(43010,43014,4),new IG.ptr(43019,43045,26),new IG.ptr(43046,43052,6),new IG.ptr(43204,43205,1),new IG.ptr(43232,43249,1),new IG.ptr(43263,43302,39),new IG.ptr(43303,43309,1),new IG.ptr(43335,43345,1),new IG.ptr(43392,43394,1),new IG.ptr(43443,43446,3),new IG.ptr(43447,43449,1),new IG.ptr(43452,43453,1),new IG.ptr(43493,43561,68),new IG.ptr(43562,43566,1),new IG.ptr(43569,43570,1),new IG.ptr(43573,43574,1),new IG.ptr(43587,43596,9),new IG.ptr(43644,43696,52),new IG.ptr(43698,43700,1),new IG.ptr(43703,43704,1),new IG.ptr(43710,43711,1),new IG.ptr(43713,43756,43),new IG.ptr(43757,43766,9),new IG.ptr(44005,44008,3),new IG.ptr(44013,64286,20273),new IG.ptr(65024,65039,1),new IG.ptr(65056,65071,1)]),new JN([new IH.ptr(66045,66272,227),new IH.ptr(66422,66426,1),new IH.ptr(68097,68099,1),new IH.ptr(68101,68102,1),new IH.ptr(68108,68111,1),new IH.ptr(68152,68154,1),new IH.ptr(68159,68325,166),new IH.ptr(68326,68900,574),new IH.ptr(68901,68903,1),new IH.ptr(69291,69292,1),new IH.ptr(69446,69456,1),new IH.ptr(69633,69688,55),new IH.ptr(69689,69702,1),new IH.ptr(69759,69761,1),new IH.ptr(69811,69814,1),new IH.ptr(69817,69818,1),new IH.ptr(69888,69890,1),new IH.ptr(69927,69931,1),new IH.ptr(69933,69940,1),new IH.ptr(70003,70016,13),new IH.ptr(70017,70070,53),new IH.ptr(70071,70078,1),new IH.ptr(70089,70092,1),new IH.ptr(70095,70191,96),new IH.ptr(70192,70193,1),new IH.ptr(70196,70198,2),new IH.ptr(70199,70206,7),new IH.ptr(70367,70371,4),new IH.ptr(70372,70378,1),new IH.ptr(70400,70401,1),new IH.ptr(70459,70460,1),new IH.ptr(70464,70502,38),new IH.ptr(70503,70508,1),new IH.ptr(70512,70516,1),new IH.ptr(70712,70719,1),new IH.ptr(70722,70724,1),new IH.ptr(70726,70750,24),new IH.ptr(70835,70840,1),new IH.ptr(70842,70847,5),new IH.ptr(70848,70850,2),new IH.ptr(70851,71090,239),new IH.ptr(71091,71093,1),new IH.ptr(71100,71101,1),new IH.ptr(71103,71104,1),new IH.ptr(71132,71133,1),new IH.ptr(71219,71226,1),new IH.ptr(71229,71231,2),new IH.ptr(71232,71339,107),new IH.ptr(71341,71344,3),new IH.ptr(71345,71349,1),new IH.ptr(71351,71453,102),new IH.ptr(71454,71455,1),new IH.ptr(71458,71461,1),new IH.ptr(71463,71467,1),new IH.ptr(71727,71735,1),new IH.ptr(71737,71738,1),new IH.ptr(71995,71996,1),new IH.ptr(71998,72003,5),new IH.ptr(72148,72151,1),new IH.ptr(72154,72155,1),new IH.ptr(72160,72193,33),new IH.ptr(72194,72202,1),new IH.ptr(72243,72248,1),new IH.ptr(72251,72254,1),new IH.ptr(72263,72273,10),new IH.ptr(72274,72278,1),new IH.ptr(72281,72283,1),new IH.ptr(72330,72342,1),new IH.ptr(72344,72345,1),new IH.ptr(72752,72758,1),new IH.ptr(72760,72765,1),new IH.ptr(72767,72850,83),new IH.ptr(72851,72871,1),new IH.ptr(72874,72880,1),new IH.ptr(72882,72883,1),new IH.ptr(72885,72886,1),new IH.ptr(73009,73014,1),new IH.ptr(73018,73020,2),new IH.ptr(73021,73023,2),new IH.ptr(73024,73029,1),new IH.ptr(73031,73104,73),new IH.ptr(73105,73109,4),new IH.ptr(73111,73459,348),new IH.ptr(73460,92912,19452),new IH.ptr(92913,92916,1),new IH.ptr(92976,92982,1),new IH.ptr(94031,94095,64),new IH.ptr(94096,94098,1),new IH.ptr(94180,113821,19641),new IH.ptr(113822,119143,5321),new IH.ptr(119144,119145,1),new IH.ptr(119163,119170,1),new IH.ptr(119173,119179,1),new IH.ptr(119210,119213,1),new IH.ptr(119362,119364,1),new IH.ptr(121344,121398,1),new IH.ptr(121403,121452,1),new IH.ptr(121461,121476,15),new IH.ptr(121499,121503,1),new IH.ptr(121505,121519,1),new IH.ptr(122880,122886,1),new IH.ptr(122888,122904,1),new IH.ptr(122907,122913,1),new IH.ptr(122915,122916,1),new IH.ptr(122918,122922,1),new IH.ptr(123184,123190,1),new IH.ptr(123628,123631,1),new IH.ptr(125136,125142,1),new IH.ptr(125252,125258,1),new IH.ptr(917760,917999,1)]),0);P=new IF.ptr(new JM([new IG.ptr(48,57,1),new IG.ptr(178,179,1),new IG.ptr(185,188,3),new IG.ptr(189,190,1),new IG.ptr(1632,1641,1),new IG.ptr(1776,1785,1),new IG.ptr(1984,1993,1),new IG.ptr(2406,2415,1),new IG.ptr(2534,2543,1),new IG.ptr(2548,2553,1),new IG.ptr(2662,2671,1),new IG.ptr(2790,2799,1),new IG.ptr(2918,2927,1),new IG.ptr(2930,2935,1),new IG.ptr(3046,3058,1),new IG.ptr(3174,3183,1),new IG.ptr(3192,3198,1),new IG.ptr(3302,3311,1),new IG.ptr(3416,3422,1),new IG.ptr(3430,3448,1),new IG.ptr(3558,3567,1),new IG.ptr(3664,3673,1),new IG.ptr(3792,3801,1),new IG.ptr(3872,3891,1),new IG.ptr(4160,4169,1),new IG.ptr(4240,4249,1),new IG.ptr(4969,4988,1),new IG.ptr(5870,5872,1),new IG.ptr(6112,6121,1),new IG.ptr(6128,6137,1),new IG.ptr(6160,6169,1),new IG.ptr(6470,6479,1),new IG.ptr(6608,6618,1),new IG.ptr(6784,6793,1),new IG.ptr(6800,6809,1),new IG.ptr(6992,7001,1),new IG.ptr(7088,7097,1),new IG.ptr(7232,7241,1),new IG.ptr(7248,7257,1),new IG.ptr(8304,8308,4),new IG.ptr(8309,8313,1),new IG.ptr(8320,8329,1),new IG.ptr(8528,8578,1),new IG.ptr(8581,8585,1),new IG.ptr(9312,9371,1),new IG.ptr(9450,9471,1),new IG.ptr(10102,10131,1),new IG.ptr(11517,12295,778),new IG.ptr(12321,12329,1),new IG.ptr(12344,12346,1),new IG.ptr(12690,12693,1),new IG.ptr(12832,12841,1),new IG.ptr(12872,12879,1),new IG.ptr(12881,12895,1),new IG.ptr(12928,12937,1),new IG.ptr(12977,12991,1),new IG.ptr(42528,42537,1),new IG.ptr(42726,42735,1),new IG.ptr(43056,43061,1),new IG.ptr(43216,43225,1),new IG.ptr(43264,43273,1),new IG.ptr(43472,43481,1),new IG.ptr(43504,43513,1),new IG.ptr(43600,43609,1),new IG.ptr(44016,44025,1),new IG.ptr(65296,65305,1)]),new JN([new IH.ptr(65799,65843,1),new IH.ptr(65856,65912,1),new IH.ptr(65930,65931,1),new IH.ptr(66273,66299,1),new IH.ptr(66336,66339,1),new IH.ptr(66369,66378,9),new IH.ptr(66513,66517,1),new IH.ptr(66720,66729,1),new IH.ptr(67672,67679,1),new IH.ptr(67705,67711,1),new IH.ptr(67751,67759,1),new IH.ptr(67835,67839,1),new IH.ptr(67862,67867,1),new IH.ptr(68028,68029,1),new IH.ptr(68032,68047,1),new IH.ptr(68050,68095,1),new IH.ptr(68160,68168,1),new IH.ptr(68221,68222,1),new IH.ptr(68253,68255,1),new IH.ptr(68331,68335,1),new IH.ptr(68440,68447,1),new IH.ptr(68472,68479,1),new IH.ptr(68521,68527,1),new IH.ptr(68858,68863,1),new IH.ptr(68912,68921,1),new IH.ptr(69216,69246,1),new IH.ptr(69405,69414,1),new IH.ptr(69457,69460,1),new IH.ptr(69573,69579,1),new IH.ptr(69714,69743,1),new IH.ptr(69872,69881,1),new IH.ptr(69942,69951,1),new IH.ptr(70096,70105,1),new IH.ptr(70113,70132,1),new IH.ptr(70384,70393,1),new IH.ptr(70736,70745,1),new IH.ptr(70864,70873,1),new IH.ptr(71248,71257,1),new IH.ptr(71360,71369,1),new IH.ptr(71472,71483,1),new IH.ptr(71904,71922,1),new IH.ptr(72016,72025,1),new IH.ptr(72784,72812,1),new IH.ptr(73040,73049,1),new IH.ptr(73120,73129,1),new IH.ptr(73664,73684,1),new IH.ptr(74752,74862,1),new IH.ptr(92768,92777,1),new IH.ptr(93008,93017,1),new IH.ptr(93019,93025,1),new IH.ptr(93824,93846,1),new IH.ptr(119520,119539,1),new IH.ptr(119648,119672,1),new IH.ptr(120782,120831,1),new IH.ptr(123200,123209,1),new IH.ptr(123632,123641,1),new IH.ptr(125127,125135,1),new IH.ptr(125264,125273,1),new IH.ptr(126065,126123,1),new IH.ptr(126125,126127,1),new IH.ptr(126129,126132,1),new IH.ptr(126209,126253,1),new IH.ptr(126255,126269,1),new IH.ptr(127232,127244,1),new IH.ptr(130032,130041,1)]),4);Q=new IF.ptr(new JM([new IG.ptr(48,57,1),new IG.ptr(1632,1641,1),new IG.ptr(1776,1785,1),new IG.ptr(1984,1993,1),new IG.ptr(2406,2415,1),new IG.ptr(2534,2543,1),new IG.ptr(2662,2671,1),new IG.ptr(2790,2799,1),new IG.ptr(2918,2927,1),new IG.ptr(3046,3055,1),new IG.ptr(3174,3183,1),new IG.ptr(3302,3311,1),new IG.ptr(3430,3439,1),new IG.ptr(3558,3567,1),new IG.ptr(3664,3673,1),new IG.ptr(3792,3801,1),new IG.ptr(3872,3881,1),new IG.ptr(4160,4169,1),new IG.ptr(4240,4249,1),new IG.ptr(6112,6121,1),new IG.ptr(6160,6169,1),new IG.ptr(6470,6479,1),new IG.ptr(6608,6617,1),new IG.ptr(6784,6793,1),new IG.ptr(6800,6809,1),new IG.ptr(6992,7001,1),new IG.ptr(7088,7097,1),new IG.ptr(7232,7241,1),new IG.ptr(7248,7257,1),new IG.ptr(42528,42537,1),new IG.ptr(43216,43225,1),new IG.ptr(43264,43273,1),new IG.ptr(43472,43481,1),new IG.ptr(43504,43513,1),new IG.ptr(43600,43609,1),new IG.ptr(44016,44025,1),new IG.ptr(65296,65305,1)]),new JN([new IH.ptr(66720,66729,1),new IH.ptr(68912,68921,1),new IH.ptr(69734,69743,1),new IH.ptr(69872,69881,1),new IH.ptr(69942,69951,1),new IH.ptr(70096,70105,1),new IH.ptr(70384,70393,1),new IH.ptr(70736,70745,1),new IH.ptr(70864,70873,1),new IH.ptr(71248,71257,1),new IH.ptr(71360,71369,1),new IH.ptr(71472,71481,1),new IH.ptr(71904,71913,1),new IH.ptr(72016,72025,1),new IH.ptr(72784,72793,1),new IH.ptr(73040,73049,1),new IH.ptr(73120,73129,1),new IH.ptr(92768,92777,1),new IH.ptr(93008,93017,1),new IH.ptr(120782,120831,1),new IH.ptr(123200,123209,1),new IH.ptr(123632,123641,1),new IH.ptr(125264,125273,1),new IH.ptr(130032,130041,1)]),1);R=new IF.ptr(new JM([new IG.ptr(5870,5872,1),new IG.ptr(8544,8578,1),new IG.ptr(8581,8584,1),new IG.ptr(12295,12321,26),new IG.ptr(12322,12329,1),new IG.ptr(12344,12346,1),new IG.ptr(42726,42735,1)]),new JN([new IH.ptr(65856,65908,1),new IH.ptr(66369,66378,9),new IH.ptr(66513,66517,1),new IH.ptr(74752,74862,1)]),0);S=new IF.ptr(new JM([new IG.ptr(178,179,1),new IG.ptr(185,188,3),new IG.ptr(189,190,1),new IG.ptr(2548,2553,1),new IG.ptr(2930,2935,1),new IG.ptr(3056,3058,1),new IG.ptr(3192,3198,1),new IG.ptr(3416,3422,1),new IG.ptr(3440,3448,1),new IG.ptr(3882,3891,1),new IG.ptr(4969,4988,1),new IG.ptr(6128,6137,1),new IG.ptr(6618,8304,1686),new IG.ptr(8308,8313,1),new IG.ptr(8320,8329,1),new IG.ptr(8528,8543,1),new IG.ptr(8585,9312,727),new IG.ptr(9313,9371,1),new IG.ptr(9450,9471,1),new IG.ptr(10102,10131,1),new IG.ptr(11517,12690,1173),new IG.ptr(12691,12693,1),new IG.ptr(12832,12841,1),new IG.ptr(12872,12879,1),new IG.ptr(12881,12895,1),new IG.ptr(12928,12937,1),new IG.ptr(12977,12991,1),new IG.ptr(43056,43061,1)]),new JN([new IH.ptr(65799,65843,1),new IH.ptr(65909,65912,1),new IH.ptr(65930,65931,1),new IH.ptr(66273,66299,1),new IH.ptr(66336,66339,1),new IH.ptr(67672,67679,1),new IH.ptr(67705,67711,1),new IH.ptr(67751,67759,1),new IH.ptr(67835,67839,1),new IH.ptr(67862,67867,1),new IH.ptr(68028,68029,1),new IH.ptr(68032,68047,1),new IH.ptr(68050,68095,1),new IH.ptr(68160,68168,1),new IH.ptr(68221,68222,1),new IH.ptr(68253,68255,1),new IH.ptr(68331,68335,1),new IH.ptr(68440,68447,1),new IH.ptr(68472,68479,1),new IH.ptr(68521,68527,1),new IH.ptr(68858,68863,1),new IH.ptr(69216,69246,1),new IH.ptr(69405,69414,1),new IH.ptr(69457,69460,1),new IH.ptr(69573,69579,1),new IH.ptr(69714,69733,1),new IH.ptr(70113,70132,1),new IH.ptr(71482,71483,1),new IH.ptr(71914,71922,1),new IH.ptr(72794,72812,1),new IH.ptr(73664,73684,1),new IH.ptr(93019,93025,1),new IH.ptr(93824,93846,1),new IH.ptr(119520,119539,1),new IH.ptr(119648,119672,1),new IH.ptr(125127,125135,1),new IH.ptr(126065,126123,1),new IH.ptr(126125,126127,1),new IH.ptr(126129,126132,1),new IH.ptr(126209,126253,1),new IH.ptr(126255,126269,1),new IH.ptr(127232,127244,1)]),3);T=new IF.ptr(new JM([new IG.ptr(33,35,1),new IG.ptr(37,42,1),new IG.ptr(44,47,1),new IG.ptr(58,59,1),new IG.ptr(63,64,1),new IG.ptr(91,93,1),new IG.ptr(95,123,28),new IG.ptr(125,161,36),new IG.ptr(167,171,4),new IG.ptr(182,183,1),new IG.ptr(187,191,4),new IG.ptr(894,903,9),new IG.ptr(1370,1375,1),new IG.ptr(1417,1418,1),new IG.ptr(1470,1472,2),new IG.ptr(1475,1478,3),new IG.ptr(1523,1524,1),new IG.ptr(1545,1546,1),new IG.ptr(1548,1549,1),new IG.ptr(1563,1566,3),new IG.ptr(1567,1642,75),new IG.ptr(1643,1645,1),new IG.ptr(1748,1792,44),new IG.ptr(1793,1805,1),new IG.ptr(2039,2041,1),new IG.ptr(2096,2110,1),new IG.ptr(2142,2404,262),new IG.ptr(2405,2416,11),new IG.ptr(2557,2678,121),new IG.ptr(2800,3191,391),new IG.ptr(3204,3572,368),new IG.ptr(3663,3674,11),new IG.ptr(3675,3844,169),new IG.ptr(3845,3858,1),new IG.ptr(3860,3898,38),new IG.ptr(3899,3901,1),new IG.ptr(3973,4048,75),new IG.ptr(4049,4052,1),new IG.ptr(4057,4058,1),new IG.ptr(4170,4175,1),new IG.ptr(4347,4960,613),new IG.ptr(4961,4968,1),new IG.ptr(5120,5742,622),new IG.ptr(5787,5788,1),new IG.ptr(5867,5869,1),new IG.ptr(5941,5942,1),new IG.ptr(6100,6102,1),new IG.ptr(6104,6106,1),new IG.ptr(6144,6154,1),new IG.ptr(6468,6469,1),new IG.ptr(6686,6687,1),new IG.ptr(6816,6822,1),new IG.ptr(6824,6829,1),new IG.ptr(7002,7008,1),new IG.ptr(7164,7167,1),new IG.ptr(7227,7231,1),new IG.ptr(7294,7295,1),new IG.ptr(7360,7367,1),new IG.ptr(7379,8208,829),new IG.ptr(8209,8231,1),new IG.ptr(8240,8259,1),new IG.ptr(8261,8273,1),new IG.ptr(8275,8286,1),new IG.ptr(8317,8318,1),new IG.ptr(8333,8334,1),new IG.ptr(8968,8971,1),new IG.ptr(9001,9002,1),new IG.ptr(10088,10101,1),new IG.ptr(10181,10182,1),new IG.ptr(10214,10223,1),new IG.ptr(10627,10648,1),new IG.ptr(10712,10715,1),new IG.ptr(10748,10749,1),new IG.ptr(11513,11516,1),new IG.ptr(11518,11519,1),new IG.ptr(11632,11776,144),new IG.ptr(11777,11822,1),new IG.ptr(11824,11855,1),new IG.ptr(11858,12289,431),new IG.ptr(12290,12291,1),new IG.ptr(12296,12305,1),new IG.ptr(12308,12319,1),new IG.ptr(12336,12349,13),new IG.ptr(12448,12539,91),new IG.ptr(42238,42239,1),new IG.ptr(42509,42511,1),new IG.ptr(42611,42622,11),new IG.ptr(42738,42743,1),new IG.ptr(43124,43127,1),new IG.ptr(43214,43215,1),new IG.ptr(43256,43258,1),new IG.ptr(43260,43310,50),new IG.ptr(43311,43359,48),new IG.ptr(43457,43469,1),new IG.ptr(43486,43487,1),new IG.ptr(43612,43615,1),new IG.ptr(43742,43743,1),new IG.ptr(43760,43761,1),new IG.ptr(44011,64830,20819),new IG.ptr(64831,65040,209),new IG.ptr(65041,65049,1),new IG.ptr(65072,65106,1),new IG.ptr(65108,65121,1),new IG.ptr(65123,65128,5),new IG.ptr(65130,65131,1),new IG.ptr(65281,65283,1),new IG.ptr(65285,65290,1),new IG.ptr(65292,65295,1),new IG.ptr(65306,65307,1),new IG.ptr(65311,65312,1),new IG.ptr(65339,65341,1),new IG.ptr(65343,65371,28),new IG.ptr(65373,65375,2),new IG.ptr(65376,65381,1)]),new JN([new IH.ptr(65792,65794,1),new IH.ptr(66463,66512,49),new IH.ptr(66927,67671,744),new IH.ptr(67871,67903,32),new IH.ptr(68176,68184,1),new IH.ptr(68223,68336,113),new IH.ptr(68337,68342,1),new IH.ptr(68409,68415,1),new IH.ptr(68505,68508,1),new IH.ptr(69293,69461,168),new IH.ptr(69462,69465,1),new IH.ptr(69703,69709,1),new IH.ptr(69819,69820,1),new IH.ptr(69822,69825,1),new IH.ptr(69952,69955,1),new IH.ptr(70004,70005,1),new IH.ptr(70085,70088,1),new IH.ptr(70093,70107,14),new IH.ptr(70109,70111,1),new IH.ptr(70200,70205,1),new IH.ptr(70313,70731,418),new IH.ptr(70732,70735,1),new IH.ptr(70746,70747,1),new IH.ptr(70749,70854,105),new IH.ptr(71105,71127,1),new IH.ptr(71233,71235,1),new IH.ptr(71264,71276,1),new IH.ptr(71484,71486,1),new IH.ptr(71739,72004,265),new IH.ptr(72005,72006,1),new IH.ptr(72162,72255,93),new IH.ptr(72256,72262,1),new IH.ptr(72346,72348,1),new IH.ptr(72350,72354,1),new IH.ptr(72769,72773,1),new IH.ptr(72816,72817,1),new IH.ptr(73463,73464,1),new IH.ptr(73727,74864,1137),new IH.ptr(74865,74868,1),new IH.ptr(92782,92783,1),new IH.ptr(92917,92983,66),new IH.ptr(92984,92987,1),new IH.ptr(92996,93847,851),new IH.ptr(93848,93850,1),new IH.ptr(94178,113823,19645),new IH.ptr(121479,121483,1),new IH.ptr(125278,125279,1)]),11);U=new IF.ptr(new JM([new IG.ptr(95,8255,8160),new IG.ptr(8256,8276,20),new IG.ptr(65075,65076,1),new IG.ptr(65101,65103,1),new IG.ptr(65343,65343,1)]),JN.nil,0);V=new IF.ptr(new JM([new IG.ptr(45,1418,1373),new IG.ptr(1470,5120,3650),new IG.ptr(6150,8208,2058),new IG.ptr(8209,8213,1),new IG.ptr(11799,11802,3),new IG.ptr(11834,11835,1),new IG.ptr(11840,12316,476),new IG.ptr(12336,12448,112),new IG.ptr(65073,65074,1),new IG.ptr(65112,65123,11),new IG.ptr(65293,65293,1)]),new JN([new IH.ptr(69293,69293,1)]),0);W=new IF.ptr(new JM([new IG.ptr(41,93,52),new IG.ptr(125,3899,3774),new IG.ptr(3901,5788,1887),new IG.ptr(8262,8318,56),new IG.ptr(8334,8969,635),new IG.ptr(8971,9002,31),new IG.ptr(10089,10101,2),new IG.ptr(10182,10215,33),new IG.ptr(10217,10223,2),new IG.ptr(10628,10648,2),new IG.ptr(10713,10715,2),new IG.ptr(10749,11811,1062),new IG.ptr(11813,11817,2),new IG.ptr(12297,12305,2),new IG.ptr(12309,12315,2),new IG.ptr(12318,12319,1),new IG.ptr(64830,65048,218),new IG.ptr(65078,65092,2),new IG.ptr(65096,65114,18),new IG.ptr(65116,65118,2),new IG.ptr(65289,65341,52),new IG.ptr(65373,65379,3)]),JN.nil,1);X=new IF.ptr(new JM([new IG.ptr(187,8217,8030),new IG.ptr(8221,8250,29),new IG.ptr(11779,11781,2),new IG.ptr(11786,11789,3),new IG.ptr(11805,11809,4)]),JN.nil,0);Y=new IF.ptr(new JM([new IG.ptr(171,8216,8045),new IG.ptr(8219,8220,1),new IG.ptr(8223,8249,26),new IG.ptr(11778,11780,2),new IG.ptr(11785,11788,3),new IG.ptr(11804,11808,4)]),JN.nil,0);Z=new IF.ptr(new JM([new IG.ptr(33,35,1),new IG.ptr(37,39,1),new IG.ptr(42,46,2),new IG.ptr(47,58,11),new IG.ptr(59,63,4),new IG.ptr(64,92,28),new IG.ptr(161,167,6),new IG.ptr(182,183,1),new IG.ptr(191,894,703),new IG.ptr(903,1370,467),new IG.ptr(1371,1375,1),new IG.ptr(1417,1472,55),new IG.ptr(1475,1478,3),new IG.ptr(1523,1524,1),new IG.ptr(1545,1546,1),new IG.ptr(1548,1549,1),new IG.ptr(1563,1566,3),new IG.ptr(1567,1642,75),new IG.ptr(1643,1645,1),new IG.ptr(1748,1792,44),new IG.ptr(1793,1805,1),new IG.ptr(2039,2041,1),new IG.ptr(2096,2110,1),new IG.ptr(2142,2404,262),new IG.ptr(2405,2416,11),new IG.ptr(2557,2678,121),new IG.ptr(2800,3191,391),new IG.ptr(3204,3572,368),new IG.ptr(3663,3674,11),new IG.ptr(3675,3844,169),new IG.ptr(3845,3858,1),new IG.ptr(3860,3973,113),new IG.ptr(4048,4052,1),new IG.ptr(4057,4058,1),new IG.ptr(4170,4175,1),new IG.ptr(4347,4960,613),new IG.ptr(4961,4968,1),new IG.ptr(5742,5867,125),new IG.ptr(5868,5869,1),new IG.ptr(5941,5942,1),new IG.ptr(6100,6102,1),new IG.ptr(6104,6106,1),new IG.ptr(6144,6149,1),new IG.ptr(6151,6154,1),new IG.ptr(6468,6469,1),new IG.ptr(6686,6687,1),new IG.ptr(6816,6822,1),new IG.ptr(6824,6829,1),new IG.ptr(7002,7008,1),new IG.ptr(7164,7167,1),new IG.ptr(7227,7231,1),new IG.ptr(7294,7295,1),new IG.ptr(7360,7367,1),new IG.ptr(7379,8214,835),new IG.ptr(8215,8224,9),new IG.ptr(8225,8231,1),new IG.ptr(8240,8248,1),new IG.ptr(8251,8254,1),new IG.ptr(8257,8259,1),new IG.ptr(8263,8273,1),new IG.ptr(8275,8277,2),new IG.ptr(8278,8286,1),new IG.ptr(11513,11516,1),new IG.ptr(11518,11519,1),new IG.ptr(11632,11776,144),new IG.ptr(11777,11782,5),new IG.ptr(11783,11784,1),new IG.ptr(11787,11790,3),new IG.ptr(11791,11798,1),new IG.ptr(11800,11801,1),new IG.ptr(11803,11806,3),new IG.ptr(11807,11818,11),new IG.ptr(11819,11822,1),new IG.ptr(11824,11833,1),new IG.ptr(11836,11839,1),new IG.ptr(11841,11843,2),new IG.ptr(11844,11855,1),new IG.ptr(11858,12289,431),new IG.ptr(12290,12291,1),new IG.ptr(12349,12539,190),new IG.ptr(42238,42239,1),new IG.ptr(42509,42511,1),new IG.ptr(42611,42622,11),new IG.ptr(42738,42743,1),new IG.ptr(43124,43127,1),new IG.ptr(43214,43215,1),new IG.ptr(43256,43258,1),new IG.ptr(43260,43310,50),new IG.ptr(43311,43359,48),new IG.ptr(43457,43469,1),new IG.ptr(43486,43487,1),new IG.ptr(43612,43615,1),new IG.ptr(43742,43743,1),new IG.ptr(43760,43761,1),new IG.ptr(44011,65040,21029),new IG.ptr(65041,65046,1),new IG.ptr(65049,65072,23),new IG.ptr(65093,65094,1),new IG.ptr(65097,65100,1),new IG.ptr(65104,65106,1),new IG.ptr(65108,65111,1),new IG.ptr(65119,65121,1),new IG.ptr(65128,65130,2),new IG.ptr(65131,65281,150),new IG.ptr(65282,65283,1),new IG.ptr(65285,65287,1),new IG.ptr(65290,65294,2),new IG.ptr(65295,65306,11),new IG.ptr(65307,65311,4),new IG.ptr(65312,65340,28),new IG.ptr(65377,65380,3),new IG.ptr(65381,65381,1)]),new JN([new IH.ptr(65792,65794,1),new IH.ptr(66463,66512,49),new IH.ptr(66927,67671,744),new IH.ptr(67871,67903,32),new IH.ptr(68176,68184,1),new IH.ptr(68223,68336,113),new IH.ptr(68337,68342,1),new IH.ptr(68409,68415,1),new IH.ptr(68505,68508,1),new IH.ptr(69461,69465,1),new IH.ptr(69703,69709,1),new IH.ptr(69819,69820,1),new IH.ptr(69822,69825,1),new IH.ptr(69952,69955,1),new IH.ptr(70004,70005,1),new IH.ptr(70085,70088,1),new IH.ptr(70093,70107,14),new IH.ptr(70109,70111,1),new IH.ptr(70200,70205,1),new IH.ptr(70313,70731,418),new IH.ptr(70732,70735,1),new IH.ptr(70746,70747,1),new IH.ptr(70749,70854,105),new IH.ptr(71105,71127,1),new IH.ptr(71233,71235,1),new IH.ptr(71264,71276,1),new IH.ptr(71484,71486,1),new IH.ptr(71739,72004,265),new IH.ptr(72005,72006,1),new IH.ptr(72162,72255,93),new IH.ptr(72256,72262,1),new IH.ptr(72346,72348,1),new IH.ptr(72350,72354,1),new IH.ptr(72769,72773,1),new IH.ptr(72816,72817,1),new IH.ptr(73463,73464,1),new IH.ptr(73727,74864,1137),new IH.ptr(74865,74868,1),new IH.ptr(92782,92783,1),new IH.ptr(92917,92983,66),new IH.ptr(92984,92987,1),new IH.ptr(92996,93847,851),new IH.ptr(93848,93850,1),new IH.ptr(94178,113823,19645),new IH.ptr(121479,121483,1),new IH.ptr(125278,125279,1)]),8);AA=new IF.ptr(new JM([new IG.ptr(40,91,51),new IG.ptr(123,3898,3775),new IG.ptr(3900,5787,1887),new IG.ptr(8218,8222,4),new IG.ptr(8261,8317,56),new IG.ptr(8333,8968,635),new IG.ptr(8970,9001,31),new IG.ptr(10088,10100,2),new IG.ptr(10181,10214,33),new IG.ptr(10216,10222,2),new IG.ptr(10627,10647,2),new IG.ptr(10712,10714,2),new IG.ptr(10748,11810,1062),new IG.ptr(11812,11816,2),new IG.ptr(11842,12296,454),new IG.ptr(12298,12304,2),new IG.ptr(12308,12314,2),new IG.ptr(12317,64831,52514),new IG.ptr(65047,65077,30),new IG.ptr(65079,65091,2),new IG.ptr(65095,65113,18),new IG.ptr(65115,65117,2),new IG.ptr(65288,65339,51),new IG.ptr(65371,65375,4),new IG.ptr(65378,65378,1)]),JN.nil,1);AB=new IF.ptr(new JM([new IG.ptr(36,43,7),new IG.ptr(60,62,1),new IG.ptr(94,96,2),new IG.ptr(124,126,2),new IG.ptr(162,166,1),new IG.ptr(168,169,1),new IG.ptr(172,174,2),new IG.ptr(175,177,1),new IG.ptr(180,184,4),new IG.ptr(215,247,32),new IG.ptr(706,709,1),new IG.ptr(722,735,1),new IG.ptr(741,747,1),new IG.ptr(749,751,2),new IG.ptr(752,767,1),new IG.ptr(885,900,15),new IG.ptr(901,1014,113),new IG.ptr(1154,1421,267),new IG.ptr(1422,1423,1),new IG.ptr(1542,1544,1),new IG.ptr(1547,1550,3),new IG.ptr(1551,1758,207),new IG.ptr(1769,1789,20),new IG.ptr(1790,2038,248),new IG.ptr(2046,2047,1),new IG.ptr(2546,2547,1),new IG.ptr(2554,2555,1),new IG.ptr(2801,2928,127),new IG.ptr(3059,3066,1),new IG.ptr(3199,3407,208),new IG.ptr(3449,3647,198),new IG.ptr(3841,3843,1),new IG.ptr(3859,3861,2),new IG.ptr(3862,3863,1),new IG.ptr(3866,3871,1),new IG.ptr(3892,3896,2),new IG.ptr(4030,4037,1),new IG.ptr(4039,4044,1),new IG.ptr(4046,4047,1),new IG.ptr(4053,4056,1),new IG.ptr(4254,4255,1),new IG.ptr(5008,5017,1),new IG.ptr(5741,6107,366),new IG.ptr(6464,6622,158),new IG.ptr(6623,6655,1),new IG.ptr(7009,7018,1),new IG.ptr(7028,7036,1),new IG.ptr(8125,8127,2),new IG.ptr(8128,8129,1),new IG.ptr(8141,8143,1),new IG.ptr(8157,8159,1),new IG.ptr(8173,8175,1),new IG.ptr(8189,8190,1),new IG.ptr(8260,8274,14),new IG.ptr(8314,8316,1),new IG.ptr(8330,8332,1),new IG.ptr(8352,8383,1),new IG.ptr(8448,8449,1),new IG.ptr(8451,8454,1),new IG.ptr(8456,8457,1),new IG.ptr(8468,8470,2),new IG.ptr(8471,8472,1),new IG.ptr(8478,8483,1),new IG.ptr(8485,8489,2),new IG.ptr(8494,8506,12),new IG.ptr(8507,8512,5),new IG.ptr(8513,8516,1),new IG.ptr(8522,8525,1),new IG.ptr(8527,8586,59),new IG.ptr(8587,8592,5),new IG.ptr(8593,8967,1),new IG.ptr(8972,9000,1),new IG.ptr(9003,9254,1),new IG.ptr(9280,9290,1),new IG.ptr(9372,9449,1),new IG.ptr(9472,10087,1),new IG.ptr(10132,10180,1),new IG.ptr(10183,10213,1),new IG.ptr(10224,10626,1),new IG.ptr(10649,10711,1),new IG.ptr(10716,10747,1),new IG.ptr(10750,11123,1),new IG.ptr(11126,11157,1),new IG.ptr(11159,11263,1),new IG.ptr(11493,11498,1),new IG.ptr(11856,11857,1),new IG.ptr(11904,11929,1),new IG.ptr(11931,12019,1),new IG.ptr(12032,12245,1),new IG.ptr(12272,12283,1),new IG.ptr(12292,12306,14),new IG.ptr(12307,12320,13),new IG.ptr(12342,12343,1),new IG.ptr(12350,12351,1),new IG.ptr(12443,12444,1),new IG.ptr(12688,12689,1),new IG.ptr(12694,12703,1),new IG.ptr(12736,12771,1),new IG.ptr(12800,12830,1),new IG.ptr(12842,12871,1),new IG.ptr(12880,12896,16),new IG.ptr(12897,12927,1),new IG.ptr(12938,12976,1),new IG.ptr(12992,13311,1),new IG.ptr(19904,19967,1),new IG.ptr(42128,42182,1),new IG.ptr(42752,42774,1),new IG.ptr(42784,42785,1),new IG.ptr(42889,42890,1),new IG.ptr(43048,43051,1),new IG.ptr(43062,43065,1),new IG.ptr(43639,43641,1),new IG.ptr(43867,43882,15),new IG.ptr(43883,64297,20414),new IG.ptr(64434,64449,1),new IG.ptr(65020,65021,1),new IG.ptr(65122,65124,2),new IG.ptr(65125,65126,1),new IG.ptr(65129,65284,155),new IG.ptr(65291,65308,17),new IG.ptr(65309,65310,1),new IG.ptr(65342,65344,2),new IG.ptr(65372,65374,2),new IG.ptr(65504,65510,1),new IG.ptr(65512,65518,1),new IG.ptr(65532,65533,1)]),new JN([new IH.ptr(65847,65855,1),new IH.ptr(65913,65929,1),new IH.ptr(65932,65934,1),new IH.ptr(65936,65948,1),new IH.ptr(65952,66000,48),new IH.ptr(66001,66044,1),new IH.ptr(67703,67704,1),new IH.ptr(68296,71487,3191),new IH.ptr(73685,73713,1),new IH.ptr(92988,92991,1),new IH.ptr(92997,113820,20823),new IH.ptr(118784,119029,1),new IH.ptr(119040,119078,1),new IH.ptr(119081,119140,1),new IH.ptr(119146,119148,1),new IH.ptr(119171,119172,1),new IH.ptr(119180,119209,1),new IH.ptr(119214,119272,1),new IH.ptr(119296,119361,1),new IH.ptr(119365,119552,187),new IH.ptr(119553,119638,1),new IH.ptr(120513,120539,26),new IH.ptr(120571,120597,26),new IH.ptr(120629,120655,26),new IH.ptr(120687,120713,26),new IH.ptr(120745,120771,26),new IH.ptr(120832,121343,1),new IH.ptr(121399,121402,1),new IH.ptr(121453,121460,1),new IH.ptr(121462,121475,1),new IH.ptr(121477,121478,1),new IH.ptr(123215,123647,432),new IH.ptr(126124,126128,4),new IH.ptr(126254,126704,450),new IH.ptr(126705,126976,271),new IH.ptr(126977,127019,1),new IH.ptr(127024,127123,1),new IH.ptr(127136,127150,1),new IH.ptr(127153,127167,1),new IH.ptr(127169,127183,1),new IH.ptr(127185,127221,1),new IH.ptr(127245,127405,1),new IH.ptr(127462,127490,1),new IH.ptr(127504,127547,1),new IH.ptr(127552,127560,1),new IH.ptr(127568,127569,1),new IH.ptr(127584,127589,1),new IH.ptr(127744,128727,1),new IH.ptr(128736,128748,1),new IH.ptr(128752,128764,1),new IH.ptr(128768,128883,1),new IH.ptr(128896,128984,1),new IH.ptr(128992,129003,1),new IH.ptr(129024,129035,1),new IH.ptr(129040,129095,1),new IH.ptr(129104,129113,1),new IH.ptr(129120,129159,1),new IH.ptr(129168,129197,1),new IH.ptr(129200,129201,1),new IH.ptr(129280,129400,1),new IH.ptr(129402,129483,1),new IH.ptr(129485,129619,1),new IH.ptr(129632,129645,1),new IH.ptr(129648,129652,1),new IH.ptr(129656,129658,1),new IH.ptr(129664,129670,1),new IH.ptr(129680,129704,1),new IH.ptr(129712,129718,1),new IH.ptr(129728,129730,1),new IH.ptr(129744,129750,1),new IH.ptr(129792,129938,1),new IH.ptr(129940,129994,1)]),10);AC=new IF.ptr(new JM([new IG.ptr(36,162,126),new IG.ptr(163,165,1),new IG.ptr(1423,1547,124),new IG.ptr(2046,2047,1),new IG.ptr(2546,2547,1),new IG.ptr(2555,2801,246),new IG.ptr(3065,3647,582),new IG.ptr(6107,8352,2245),new IG.ptr(8353,8383,1),new IG.ptr(43064,65020,21956),new IG.ptr(65129,65284,155),new IG.ptr(65504,65505,1),new IG.ptr(65509,65510,1)]),new JN([new IH.ptr(73693,73696,1),new IH.ptr(123647,126128,2481)]),2);AD=new IF.ptr(new JM([new IG.ptr(94,96,2),new IG.ptr(168,175,7),new IG.ptr(180,184,4),new IG.ptr(706,709,1),new IG.ptr(722,735,1),new IG.ptr(741,747,1),new IG.ptr(749,751,2),new IG.ptr(752,767,1),new IG.ptr(885,900,15),new IG.ptr(901,8125,7224),new IG.ptr(8127,8129,1),new IG.ptr(8141,8143,1),new IG.ptr(8157,8159,1),new IG.ptr(8173,8175,1),new IG.ptr(8189,8190,1),new IG.ptr(12443,12444,1),new IG.ptr(42752,42774,1),new IG.ptr(42784,42785,1),new IG.ptr(42889,42890,1),new IG.ptr(43867,43882,15),new IG.ptr(43883,64434,20551),new IG.ptr(64435,64449,1),new IG.ptr(65342,65344,2),new IG.ptr(65507,65507,1)]),new JN([new IH.ptr(127995,127999,1)]),3);AE=new IF.ptr(new JM([new IG.ptr(43,60,17),new IG.ptr(61,62,1),new IG.ptr(124,126,2),new IG.ptr(172,177,5),new IG.ptr(215,247,32),new IG.ptr(1014,1542,528),new IG.ptr(1543,1544,1),new IG.ptr(8260,8274,14),new IG.ptr(8314,8316,1),new IG.ptr(8330,8332,1),new IG.ptr(8472,8512,40),new IG.ptr(8513,8516,1),new IG.ptr(8523,8592,69),new IG.ptr(8593,8596,1),new IG.ptr(8602,8603,1),new IG.ptr(8608,8614,3),new IG.ptr(8622,8654,32),new IG.ptr(8655,8658,3),new IG.ptr(8660,8692,32),new IG.ptr(8693,8959,1),new IG.ptr(8992,8993,1),new IG.ptr(9084,9115,31),new IG.ptr(9116,9139,1),new IG.ptr(9180,9185,1),new IG.ptr(9655,9665,10),new IG.ptr(9720,9727,1),new IG.ptr(9839,10176,337),new IG.ptr(10177,10180,1),new IG.ptr(10183,10213,1),new IG.ptr(10224,10239,1),new IG.ptr(10496,10626,1),new IG.ptr(10649,10711,1),new IG.ptr(10716,10747,1),new IG.ptr(10750,11007,1),new IG.ptr(11056,11076,1),new IG.ptr(11079,11084,1),new IG.ptr(64297,65122,825),new IG.ptr(65124,65126,1),new IG.ptr(65291,65308,17),new IG.ptr(65309,65310,1),new IG.ptr(65372,65374,2),new IG.ptr(65506,65513,7),new IG.ptr(65514,65516,1)]),new JN([new IH.ptr(120513,120539,26),new IH.ptr(120571,120597,26),new IH.ptr(120629,120655,26),new IH.ptr(120687,120713,26),new IH.ptr(120745,120771,26),new IH.ptr(126704,126705,1)]),5);AF=new IF.ptr(new JM([new IG.ptr(166,169,3),new IG.ptr(174,176,2),new IG.ptr(1154,1421,267),new IG.ptr(1422,1550,128),new IG.ptr(1551,1758,207),new IG.ptr(1769,1789,20),new IG.ptr(1790,2038,248),new IG.ptr(2554,2928,374),new IG.ptr(3059,3064,1),new IG.ptr(3066,3199,133),new IG.ptr(3407,3449,42),new IG.ptr(3841,3843,1),new IG.ptr(3859,3861,2),new IG.ptr(3862,3863,1),new IG.ptr(3866,3871,1),new IG.ptr(3892,3896,2),new IG.ptr(4030,4037,1),new IG.ptr(4039,4044,1),new IG.ptr(4046,4047,1),new IG.ptr(4053,4056,1),new IG.ptr(4254,4255,1),new IG.ptr(5008,5017,1),new IG.ptr(5741,6464,723),new IG.ptr(6622,6655,1),new IG.ptr(7009,7018,1),new IG.ptr(7028,7036,1),new IG.ptr(8448,8449,1),new IG.ptr(8451,8454,1),new IG.ptr(8456,8457,1),new IG.ptr(8468,8470,2),new IG.ptr(8471,8478,7),new IG.ptr(8479,8483,1),new IG.ptr(8485,8489,2),new IG.ptr(8494,8506,12),new IG.ptr(8507,8522,15),new IG.ptr(8524,8525,1),new IG.ptr(8527,8586,59),new IG.ptr(8587,8597,10),new IG.ptr(8598,8601,1),new IG.ptr(8604,8607,1),new IG.ptr(8609,8610,1),new IG.ptr(8612,8613,1),new IG.ptr(8615,8621,1),new IG.ptr(8623,8653,1),new IG.ptr(8656,8657,1),new IG.ptr(8659,8661,2),new IG.ptr(8662,8691,1),new IG.ptr(8960,8967,1),new IG.ptr(8972,8991,1),new IG.ptr(8994,9000,1),new IG.ptr(9003,9083,1),new IG.ptr(9085,9114,1),new IG.ptr(9140,9179,1),new IG.ptr(9186,9254,1),new IG.ptr(9280,9290,1),new IG.ptr(9372,9449,1),new IG.ptr(9472,9654,1),new IG.ptr(9656,9664,1),new IG.ptr(9666,9719,1),new IG.ptr(9728,9838,1),new IG.ptr(9840,10087,1),new IG.ptr(10132,10175,1),new IG.ptr(10240,10495,1),new IG.ptr(11008,11055,1),new IG.ptr(11077,11078,1),new IG.ptr(11085,11123,1),new IG.ptr(11126,11157,1),new IG.ptr(11159,11263,1),new IG.ptr(11493,11498,1),new IG.ptr(11856,11857,1),new IG.ptr(11904,11929,1),new IG.ptr(11931,12019,1),new IG.ptr(12032,12245,1),new IG.ptr(12272,12283,1),new IG.ptr(12292,12306,14),new IG.ptr(12307,12320,13),new IG.ptr(12342,12343,1),new IG.ptr(12350,12351,1),new IG.ptr(12688,12689,1),new IG.ptr(12694,12703,1),new IG.ptr(12736,12771,1),new IG.ptr(12800,12830,1),new IG.ptr(12842,12871,1),new IG.ptr(12880,12896,16),new IG.ptr(12897,12927,1),new IG.ptr(12938,12976,1),new IG.ptr(12992,13311,1),new IG.ptr(19904,19967,1),new IG.ptr(42128,42182,1),new IG.ptr(43048,43051,1),new IG.ptr(43062,43063,1),new IG.ptr(43065,43639,574),new IG.ptr(43640,43641,1),new IG.ptr(65021,65508,487),new IG.ptr(65512,65517,5),new IG.ptr(65518,65532,14),new IG.ptr(65533,65533,1)]),new JN([new IH.ptr(65847,65855,1),new IH.ptr(65913,65929,1),new IH.ptr(65932,65934,1),new IH.ptr(65936,65948,1),new IH.ptr(65952,66000,48),new IH.ptr(66001,66044,1),new IH.ptr(67703,67704,1),new IH.ptr(68296,71487,3191),new IH.ptr(73685,73692,1),new IH.ptr(73697,73713,1),new IH.ptr(92988,92991,1),new IH.ptr(92997,113820,20823),new IH.ptr(118784,119029,1),new IH.ptr(119040,119078,1),new IH.ptr(119081,119140,1),new IH.ptr(119146,119148,1),new IH.ptr(119171,119172,1),new IH.ptr(119180,119209,1),new IH.ptr(119214,119272,1),new IH.ptr(119296,119361,1),new IH.ptr(119365,119552,187),new IH.ptr(119553,119638,1),new IH.ptr(120832,121343,1),new IH.ptr(121399,121402,1),new IH.ptr(121453,121460,1),new IH.ptr(121462,121475,1),new IH.ptr(121477,121478,1),new IH.ptr(123215,126124,2909),new IH.ptr(126254,126976,722),new IH.ptr(126977,127019,1),new IH.ptr(127024,127123,1),new IH.ptr(127136,127150,1),new IH.ptr(127153,127167,1),new IH.ptr(127169,127183,1),new IH.ptr(127185,127221,1),new IH.ptr(127245,127405,1),new IH.ptr(127462,127490,1),new IH.ptr(127504,127547,1),new IH.ptr(127552,127560,1),new IH.ptr(127568,127569,1),new IH.ptr(127584,127589,1),new IH.ptr(127744,127994,1),new IH.ptr(128000,128727,1),new IH.ptr(128736,128748,1),new IH.ptr(128752,128764,1),new IH.ptr(128768,128883,1),new IH.ptr(128896,128984,1),new IH.ptr(128992,129003,1),new IH.ptr(129024,129035,1),new IH.ptr(129040,129095,1),new IH.ptr(129104,129113,1),new IH.ptr(129120,129159,1),new IH.ptr(129168,129197,1),new IH.ptr(129200,129201,1),new IH.ptr(129280,129400,1),new IH.ptr(129402,129483,1),new IH.ptr(129485,129619,1),new IH.ptr(129632,129645,1),new IH.ptr(129648,129652,1),new IH.ptr(129656,129658,1),new IH.ptr(129664,129670,1),new IH.ptr(129680,129704,1),new IH.ptr(129712,129718,1),new IH.ptr(129728,129730,1),new IH.ptr(129744,129750,1),new IH.ptr(129792,129938,1),new IH.ptr(129940,129994,1)]),2);AG=new IF.ptr(new JM([new IG.ptr(32,160,128),new IG.ptr(5760,8192,2432),new IG.ptr(8193,8202,1),new IG.ptr(8232,8233,1),new IG.ptr(8239,8287,48),new IG.ptr(12288,12288,1)]),JN.nil,1);AH=new IF.ptr(new JM([new IG.ptr(8232,8232,1)]),JN.nil,0);AI=new IF.ptr(new JM([new IG.ptr(8233,8233,1)]),JN.nil,0);AJ=new IF.ptr(new JM([new IG.ptr(32,160,128),new IG.ptr(5760,8192,2432),new IG.ptr(8193,8202,1),new IG.ptr(8239,8287,48),new IG.ptr(12288,12288,1)]),JN.nil,1);$pkg.Cc=B;$pkg.Cf=C;$pkg.Co=D;$pkg.Cs=E;$pkg.Digit=Q;$pkg.Nd=Q;$pkg.Letter=F;$pkg.L=F;$pkg.Lm=H;$pkg.Lo=I;$pkg.Ll=G;$pkg.M=L;$pkg.Mc=M;$pkg.Me=N;$pkg.Mn=O;$pkg.Nl=R;$pkg.No=S;$pkg.Number=P;$pkg.N=P;$pkg.C=A;$pkg.Pc=U;$pkg.Pd=V;$pkg.Pe=W;$pkg.Pf=X;$pkg.Pi=Y;$pkg.Po=Z;$pkg.Ps=AA;$pkg.P=T;$pkg.Sc=AC;$pkg.Sk=AD;$pkg.Sm=AE;$pkg.So=AF;$pkg.Z=AG;$pkg.S=AB;$pkg.Lt=J;$pkg.Upper=K;$pkg.Lu=K;$pkg.Zl=AH;$pkg.Zp=AI;$pkg.Zs=AJ;$pkg.Categories=$makeMap($String.keyFor,[{k:"C",v:$pkg.C},{k:"Cc",v:$pkg.Cc},{k:"Cf",v:$pkg.Cf},{k:"Co",v:$pkg.Co},{k:"Cs",v:$pkg.Cs},{k:"L",v:$pkg.L},{k:"Ll",v:$pkg.Ll},{k:"Lm",v:$pkg.Lm},{k:"Lo",v:$pkg.Lo},{k:"Lt",v:$pkg.Lt},{k:"Lu",v:$pkg.Lu},{k:"M",v:$pkg.M},{k:"Mc",v:$pkg.Mc},{k:"Me",v:$pkg.Me},{k:"Mn",v:$pkg.Mn},{k:"N",v:$pkg.N},{k:"Nd",v:$pkg.Nd},{k:"Nl",v:$pkg.Nl},{k:"No",v:$pkg.No},{k:"P",v:$pkg.P},{k:"Pc",v:$pkg.Pc},{k:"Pd",v:$pkg.Pd},{k:"Pe",v:$pkg.Pe},{k:"Pf",v:$pkg.Pf},{k:"Pi",v:$pkg.Pi},{k:"Po",v:$pkg.Po},{k:"Ps",v:$pkg.Ps},{k:"S",v:$pkg.S},{k:"Sc",v:$pkg.Sc},{k:"Sk",v:$pkg.Sk},{k:"Sm",v:$pkg.Sm},{k:"So",v:$pkg.So},{k:"Z",v:$pkg.Z},{k:"Zl",v:$pkg.Zl},{k:"Zp",v:$pkg.Zp},{k:"Zs",v:$pkg.Zs}]);AK=new IF.ptr(new JM([]),new JN([new IH.ptr(125184,125259,1),new IH.ptr(125264,125273,1),new IH.ptr(125278,125279,1)]),0);AL=new IF.ptr(new JM([]),new JN([new IH.ptr(71424,71450,1),new IH.ptr(71453,71467,1),new IH.ptr(71472,71487,1)]),0);AM=new IF.ptr(new JM([]),new JN([new IH.ptr(82944,83526,1)]),0);AN=new IF.ptr(new JM([new IG.ptr(1536,1540,1),new IG.ptr(1542,1547,1),new IG.ptr(1549,1562,1),new IG.ptr(1564,1568,2),new IG.ptr(1569,1599,1),new IG.ptr(1601,1610,1),new IG.ptr(1622,1647,1),new IG.ptr(1649,1756,1),new IG.ptr(1758,1791,1),new IG.ptr(1872,1919,1),new IG.ptr(2208,2228,1),new IG.ptr(2230,2247,1),new IG.ptr(2259,2273,1),new IG.ptr(2275,2303,1),new IG.ptr(64336,64449,1),new IG.ptr(64467,64829,1),new IG.ptr(64848,64911,1),new IG.ptr(64914,64967,1),new IG.ptr(65008,65021,1),new IG.ptr(65136,65140,1),new IG.ptr(65142,65276,1)]),new JN([new IH.ptr(69216,69246,1),new IH.ptr(126464,126467,1),new IH.ptr(126469,126495,1),new IH.ptr(126497,126498,1),new IH.ptr(126500,126503,3),new IH.ptr(126505,126514,1),new IH.ptr(126516,126519,1),new IH.ptr(126521,126523,2),new IH.ptr(126530,126535,5),new IH.ptr(126537,126541,2),new IH.ptr(126542,126543,1),new IH.ptr(126545,126546,1),new IH.ptr(126548,126551,3),new IH.ptr(126553,126561,2),new IH.ptr(126562,126564,2),new IH.ptr(126567,126570,1),new IH.ptr(126572,126578,1),new IH.ptr(126580,126583,1),new IH.ptr(126585,126588,1),new IH.ptr(126590,126592,2),new IH.ptr(126593,126601,1),new IH.ptr(126603,126619,1),new IH.ptr(126625,126627,1),new IH.ptr(126629,126633,1),new IH.ptr(126635,126651,1),new IH.ptr(126704,126705,1)]),0);AO=new IF.ptr(new JM([new IG.ptr(1329,1366,1),new IG.ptr(1369,1418,1),new IG.ptr(1421,1423,1),new IG.ptr(64275,64279,1)]),JN.nil,0);AP=new IF.ptr(new JM([]),new JN([new IH.ptr(68352,68405,1),new IH.ptr(68409,68415,1)]),0);AQ=new IF.ptr(new JM([new IG.ptr(6912,6987,1),new IG.ptr(6992,7036,1)]),JN.nil,0);AR=new IF.ptr(new JM([new IG.ptr(42656,42743,1)]),new JN([new IH.ptr(92160,92728,1)]),0);AS=new IF.ptr(new JM([]),new JN([new IH.ptr(92880,92909,1),new IH.ptr(92912,92917,1)]),0);AT=new IF.ptr(new JM([new IG.ptr(7104,7155,1),new IG.ptr(7164,7167,1)]),JN.nil,0);AU=new IF.ptr(new JM([new IG.ptr(2432,2435,1),new IG.ptr(2437,2444,1),new IG.ptr(2447,2448,1),new IG.ptr(2451,2472,1),new IG.ptr(2474,2480,1),new IG.ptr(2482,2486,4),new IG.ptr(2487,2489,1),new IG.ptr(2492,2500,1),new IG.ptr(2503,2504,1),new IG.ptr(2507,2510,1),new IG.ptr(2519,2524,5),new IG.ptr(2525,2527,2),new IG.ptr(2528,2531,1),new IG.ptr(2534,2558,1)]),JN.nil,0);AV=new IF.ptr(new JM([]),new JN([new IH.ptr(72704,72712,1),new IH.ptr(72714,72758,1),new IH.ptr(72760,72773,1),new IH.ptr(72784,72812,1)]),0);AW=new IF.ptr(new JM([new IG.ptr(746,747,1),new IG.ptr(12549,12591,1),new IG.ptr(12704,12735,1)]),JN.nil,0);AX=new IF.ptr(new JM([]),new JN([new IH.ptr(69632,69709,1),new IH.ptr(69714,69743,1),new IH.ptr(69759,69759,1)]),0);AY=new IF.ptr(new JM([new IG.ptr(10240,10495,1)]),JN.nil,0);AZ=new IF.ptr(new JM([new IG.ptr(6656,6683,1),new IG.ptr(6686,6687,1)]),JN.nil,0);BA=new IF.ptr(new JM([new IG.ptr(5952,5971,1)]),JN.nil,0);BB=new IF.ptr(new JM([new IG.ptr(5120,5759,1),new IG.ptr(6320,6389,1)]),JN.nil,0);BC=new IF.ptr(new JM([]),new JN([new IH.ptr(66208,66256,1)]),0);BD=new IF.ptr(new JM([]),new JN([new IH.ptr(66864,66915,1),new IH.ptr(66927,66927,1)]),0);BE=new IF.ptr(new JM([]),new JN([new IH.ptr(69888,69940,1),new IH.ptr(69942,69959,1)]),0);BF=new IF.ptr(new JM([new IG.ptr(43520,43574,1),new IG.ptr(43584,43597,1),new IG.ptr(43600,43609,1),new IG.ptr(43612,43615,1)]),JN.nil,0);BG=new IF.ptr(new JM([new IG.ptr(5024,5109,1),new IG.ptr(5112,5117,1),new IG.ptr(43888,43967,1)]),JN.nil,0);BH=new IF.ptr(new JM([]),new JN([new IH.ptr(69552,69579,1)]),0);BI=new IF.ptr(new JM([new IG.ptr(0,64,1),new IG.ptr(91,96,1),new IG.ptr(123,169,1),new IG.ptr(171,185,1),new IG.ptr(187,191,1),new IG.ptr(215,247,32),new IG.ptr(697,735,1),new IG.ptr(741,745,1),new IG.ptr(748,767,1),new IG.ptr(884,894,10),new IG.ptr(901,903,2),new IG.ptr(1541,1548,7),new IG.ptr(1563,1567,4),new IG.ptr(1600,1757,157),new IG.ptr(2274,2404,130),new IG.ptr(2405,3647,1242),new IG.ptr(4053,4056,1),new IG.ptr(4347,5867,1520),new IG.ptr(5868,5869,1),new IG.ptr(5941,5942,1),new IG.ptr(6146,6147,1),new IG.ptr(6149,7379,1230),new IG.ptr(7393,7401,8),new IG.ptr(7402,7404,1),new IG.ptr(7406,7411,1),new IG.ptr(7413,7415,1),new IG.ptr(7418,8192,774),new IG.ptr(8193,8203,1),new IG.ptr(8206,8292,1),new IG.ptr(8294,8304,1),new IG.ptr(8308,8318,1),new IG.ptr(8320,8334,1),new IG.ptr(8352,8383,1),new IG.ptr(8448,8485,1),new IG.ptr(8487,8489,1),new IG.ptr(8492,8497,1),new IG.ptr(8499,8525,1),new IG.ptr(8527,8543,1),new IG.ptr(8585,8587,1),new IG.ptr(8592,9254,1),new IG.ptr(9280,9290,1),new IG.ptr(9312,10239,1),new IG.ptr(10496,11123,1),new IG.ptr(11126,11157,1),new IG.ptr(11159,11263,1),new IG.ptr(11776,11858,1),new IG.ptr(12272,12283,1),new IG.ptr(12288,12292,1),new IG.ptr(12294,12296,2),new IG.ptr(12297,12320,1),new IG.ptr(12336,12343,1),new IG.ptr(12348,12351,1),new IG.ptr(12443,12444,1),new IG.ptr(12448,12539,91),new IG.ptr(12540,12688,148),new IG.ptr(12689,12703,1),new IG.ptr(12736,12771,1),new IG.ptr(12832,12895,1),new IG.ptr(12927,13007,1),new IG.ptr(13055,13144,89),new IG.ptr(13145,13311,1),new IG.ptr(19904,19967,1),new IG.ptr(42752,42785,1),new IG.ptr(42888,42890,1),new IG.ptr(43056,43065,1),new IG.ptr(43310,43471,161),new IG.ptr(43867,43882,15),new IG.ptr(43883,64830,20947),new IG.ptr(64831,65040,209),new IG.ptr(65041,65049,1),new IG.ptr(65072,65106,1),new IG.ptr(65108,65126,1),new IG.ptr(65128,65131,1),new IG.ptr(65279,65281,2),new IG.ptr(65282,65312,1),new IG.ptr(65339,65344,1),new IG.ptr(65371,65381,1),new IG.ptr(65392,65438,46),new IG.ptr(65439,65504,65),new IG.ptr(65505,65510,1),new IG.ptr(65512,65518,1),new IG.ptr(65529,65533,1)]),new JN([new IH.ptr(65792,65794,1),new IH.ptr(65799,65843,1),new IH.ptr(65847,65855,1),new IH.ptr(65936,65948,1),new IH.ptr(66000,66044,1),new IH.ptr(66273,66299,1),new IH.ptr(94178,94179,1),new IH.ptr(113824,113827,1),new IH.ptr(118784,119029,1),new IH.ptr(119040,119078,1),new IH.ptr(119081,119142,1),new IH.ptr(119146,119162,1),new IH.ptr(119171,119172,1),new IH.ptr(119180,119209,1),new IH.ptr(119214,119272,1),new IH.ptr(119520,119539,1),new IH.ptr(119552,119638,1),new IH.ptr(119648,119672,1),new IH.ptr(119808,119892,1),new IH.ptr(119894,119964,1),new IH.ptr(119966,119967,1),new IH.ptr(119970,119973,3),new IH.ptr(119974,119977,3),new IH.ptr(119978,119980,1),new IH.ptr(119982,119993,1),new IH.ptr(119995,119997,2),new IH.ptr(119998,120003,1),new IH.ptr(120005,120069,1),new IH.ptr(120071,120074,1),new IH.ptr(120077,120084,1),new IH.ptr(120086,120092,1),new IH.ptr(120094,120121,1),new IH.ptr(120123,120126,1),new IH.ptr(120128,120132,1),new IH.ptr(120134,120138,4),new IH.ptr(120139,120144,1),new IH.ptr(120146,120485,1),new IH.ptr(120488,120779,1),new IH.ptr(120782,120831,1),new IH.ptr(126065,126132,1),new IH.ptr(126209,126269,1),new IH.ptr(126976,127019,1),new IH.ptr(127024,127123,1),new IH.ptr(127136,127150,1),new IH.ptr(127153,127167,1),new IH.ptr(127169,127183,1),new IH.ptr(127185,127221,1),new IH.ptr(127232,127405,1),new IH.ptr(127462,127487,1),new IH.ptr(127489,127490,1),new IH.ptr(127504,127547,1),new IH.ptr(127552,127560,1),new IH.ptr(127568,127569,1),new IH.ptr(127584,127589,1),new IH.ptr(127744,128727,1),new IH.ptr(128736,128748,1),new IH.ptr(128752,128764,1),new IH.ptr(128768,128883,1),new IH.ptr(128896,128984,1),new IH.ptr(128992,129003,1),new IH.ptr(129024,129035,1),new IH.ptr(129040,129095,1),new IH.ptr(129104,129113,1),new IH.ptr(129120,129159,1),new IH.ptr(129168,129197,1),new IH.ptr(129200,129201,1),new IH.ptr(129280,129400,1),new IH.ptr(129402,129483,1),new IH.ptr(129485,129619,1),new IH.ptr(129632,129645,1),new IH.ptr(129648,129652,1),new IH.ptr(129656,129658,1),new IH.ptr(129664,129670,1),new IH.ptr(129680,129704,1),new IH.ptr(129712,129718,1),new IH.ptr(129728,129730,1),new IH.ptr(129744,129750,1),new IH.ptr(129792,129938,1),new IH.ptr(129940,129994,1),new IH.ptr(130032,130041,1),new IH.ptr(917505,917536,31),new IH.ptr(917537,917631,1)]),6);BJ=new IF.ptr(new JM([new IG.ptr(994,1007,1),new IG.ptr(11392,11507,1),new IG.ptr(11513,11519,1)]),JN.nil,0);BK=new IF.ptr(new JM([]),new JN([new IH.ptr(73728,74649,1),new IH.ptr(74752,74862,1),new IH.ptr(74864,74868,1),new IH.ptr(74880,75075,1)]),0);BL=new IF.ptr(new JM([]),new JN([new IH.ptr(67584,67589,1),new IH.ptr(67592,67594,2),new IH.ptr(67595,67637,1),new IH.ptr(67639,67640,1),new IH.ptr(67644,67647,3)]),0);BM=new IF.ptr(new JM([new IG.ptr(1024,1156,1),new IG.ptr(1159,1327,1),new IG.ptr(7296,7304,1),new IG.ptr(7467,7544,77),new IG.ptr(11744,11775,1),new IG.ptr(42560,42655,1),new IG.ptr(65070,65071,1)]),JN.nil,0);BN=new IF.ptr(new JM([]),new JN([new IH.ptr(66560,66639,1)]),0);BO=new IF.ptr(new JM([new IG.ptr(2304,2384,1),new IG.ptr(2389,2403,1),new IG.ptr(2406,2431,1),new IG.ptr(43232,43263,1)]),JN.nil,0);BP=new IF.ptr(new JM([]),new JN([new IH.ptr(71936,71942,1),new IH.ptr(71945,71948,3),new IH.ptr(71949,71955,1),new IH.ptr(71957,71958,1),new IH.ptr(71960,71989,1),new IH.ptr(71991,71992,1),new IH.ptr(71995,72006,1),new IH.ptr(72016,72025,1)]),0);BQ=new IF.ptr(new JM([]),new JN([new IH.ptr(71680,71739,1)]),0);BR=new IF.ptr(new JM([]),new JN([new IH.ptr(113664,113770,1),new IH.ptr(113776,113788,1),new IH.ptr(113792,113800,1),new IH.ptr(113808,113817,1),new IH.ptr(113820,113823,1)]),0);BS=new IF.ptr(new JM([]),new JN([new IH.ptr(77824,78894,1),new IH.ptr(78896,78904,1)]),0);BT=new IF.ptr(new JM([]),new JN([new IH.ptr(66816,66855,1)]),0);BU=new IF.ptr(new JM([]),new JN([new IH.ptr(69600,69622,1)]),0);BV=new IF.ptr(new JM([new IG.ptr(4608,4680,1),new IG.ptr(4682,4685,1),new IG.ptr(4688,4694,1),new IG.ptr(4696,4698,2),new IG.ptr(4699,4701,1),new IG.ptr(4704,4744,1),new IG.ptr(4746,4749,1),new IG.ptr(4752,4784,1),new IG.ptr(4786,4789,1),new IG.ptr(4792,4798,1),new IG.ptr(4800,4802,2),new IG.ptr(4803,4805,1),new IG.ptr(4808,4822,1),new IG.ptr(4824,4880,1),new IG.ptr(4882,4885,1),new IG.ptr(4888,4954,1),new IG.ptr(4957,4988,1),new IG.ptr(4992,5017,1),new IG.ptr(11648,11670,1),new IG.ptr(11680,11686,1),new IG.ptr(11688,11694,1),new IG.ptr(11696,11702,1),new IG.ptr(11704,11710,1),new IG.ptr(11712,11718,1),new IG.ptr(11720,11726,1),new IG.ptr(11728,11734,1),new IG.ptr(11736,11742,1),new IG.ptr(43777,43782,1),new IG.ptr(43785,43790,1),new IG.ptr(43793,43798,1),new IG.ptr(43808,43814,1),new IG.ptr(43816,43822,1)]),JN.nil,0);BW=new IF.ptr(new JM([new IG.ptr(4256,4293,1),new IG.ptr(4295,4301,6),new IG.ptr(4304,4346,1),new IG.ptr(4348,4351,1),new IG.ptr(7312,7354,1),new IG.ptr(7357,7359,1),new IG.ptr(11520,11557,1),new IG.ptr(11559,11565,6)]),JN.nil,0);BX=new IF.ptr(new JM([new IG.ptr(11264,11310,1),new IG.ptr(11312,11358,1)]),new JN([new IH.ptr(122880,122886,1),new IH.ptr(122888,122904,1),new IH.ptr(122907,122913,1),new IH.ptr(122915,122916,1),new IH.ptr(122918,122922,1)]),0);BY=new IF.ptr(new JM([]),new JN([new IH.ptr(66352,66378,1)]),0);BZ=new IF.ptr(new JM([]),new JN([new IH.ptr(70400,70403,1),new IH.ptr(70405,70412,1),new IH.ptr(70415,70416,1),new IH.ptr(70419,70440,1),new IH.ptr(70442,70448,1),new IH.ptr(70450,70451,1),new IH.ptr(70453,70457,1),new IH.ptr(70460,70468,1),new IH.ptr(70471,70472,1),new IH.ptr(70475,70477,1),new IH.ptr(70480,70487,7),new IH.ptr(70493,70499,1),new IH.ptr(70502,70508,1),new IH.ptr(70512,70516,1)]),0);CA=new IF.ptr(new JM([new IG.ptr(880,883,1),new IG.ptr(885,887,1),new IG.ptr(890,893,1),new IG.ptr(895,900,5),new IG.ptr(902,904,2),new IG.ptr(905,906,1),new IG.ptr(908,910,2),new IG.ptr(911,929,1),new IG.ptr(931,993,1),new IG.ptr(1008,1023,1),new IG.ptr(7462,7466,1),new IG.ptr(7517,7521,1),new IG.ptr(7526,7530,1),new IG.ptr(7615,7936,321),new IG.ptr(7937,7957,1),new IG.ptr(7960,7965,1),new IG.ptr(7968,8005,1),new IG.ptr(8008,8013,1),new IG.ptr(8016,8023,1),new IG.ptr(8025,8031,2),new IG.ptr(8032,8061,1),new IG.ptr(8064,8116,1),new IG.ptr(8118,8132,1),new IG.ptr(8134,8147,1),new IG.ptr(8150,8155,1),new IG.ptr(8157,8175,1),new IG.ptr(8178,8180,1),new IG.ptr(8182,8190,1),new IG.ptr(8486,43877,35391)]),new JN([new IH.ptr(65856,65934,1),new IH.ptr(65952,119296,53344),new IH.ptr(119297,119365,1)]),0);CB=new IF.ptr(new JM([new IG.ptr(2689,2691,1),new IG.ptr(2693,2701,1),new IG.ptr(2703,2705,1),new IG.ptr(2707,2728,1),new IG.ptr(2730,2736,1),new IG.ptr(2738,2739,1),new IG.ptr(2741,2745,1),new IG.ptr(2748,2757,1),new IG.ptr(2759,2761,1),new IG.ptr(2763,2765,1),new IG.ptr(2768,2784,16),new IG.ptr(2785,2787,1),new IG.ptr(2790,2801,1),new IG.ptr(2809,2815,1)]),JN.nil,0);CC=new IF.ptr(new JM([]),new JN([new IH.ptr(73056,73061,1),new IH.ptr(73063,73064,1),new IH.ptr(73066,73102,1),new IH.ptr(73104,73105,1),new IH.ptr(73107,73112,1),new IH.ptr(73120,73129,1)]),0);CD=new IF.ptr(new JM([new IG.ptr(2561,2563,1),new IG.ptr(2565,2570,1),new IG.ptr(2575,2576,1),new IG.ptr(2579,2600,1),new IG.ptr(2602,2608,1),new IG.ptr(2610,2611,1),new IG.ptr(2613,2614,1),new IG.ptr(2616,2617,1),new IG.ptr(2620,2622,2),new IG.ptr(2623,2626,1),new IG.ptr(2631,2632,1),new IG.ptr(2635,2637,1),new IG.ptr(2641,2649,8),new IG.ptr(2650,2652,1),new IG.ptr(2654,2662,8),new IG.ptr(2663,2678,1)]),JN.nil,0);CE=new IF.ptr(new JM([new IG.ptr(11904,11929,1),new IG.ptr(11931,12019,1),new IG.ptr(12032,12245,1),new IG.ptr(12293,12295,2),new IG.ptr(12321,12329,1),new IG.ptr(12344,12347,1),new IG.ptr(13312,19903,1),new IG.ptr(19968,40956,1),new IG.ptr(63744,64109,1),new IG.ptr(64112,64217,1)]),new JN([new IH.ptr(94192,94193,1),new IH.ptr(131072,173789,1),new IH.ptr(173824,177972,1),new IH.ptr(177984,178205,1),new IH.ptr(178208,183969,1),new IH.ptr(183984,191456,1),new IH.ptr(194560,195101,1),new IH.ptr(196608,201546,1)]),0);CF=new IF.ptr(new JM([new IG.ptr(4352,4607,1),new IG.ptr(12334,12335,1),new IG.ptr(12593,12686,1),new IG.ptr(12800,12830,1),new IG.ptr(12896,12926,1),new IG.ptr(43360,43388,1),new IG.ptr(44032,55203,1),new IG.ptr(55216,55238,1),new IG.ptr(55243,55291,1),new IG.ptr(65440,65470,1),new IG.ptr(65474,65479,1),new IG.ptr(65482,65487,1),new IG.ptr(65490,65495,1),new IG.ptr(65498,65500,1)]),JN.nil,0);CG=new IF.ptr(new JM([]),new JN([new IH.ptr(68864,68903,1),new IH.ptr(68912,68921,1)]),0);CH=new IF.ptr(new JM([new IG.ptr(5920,5940,1)]),JN.nil,0);CI=new IF.ptr(new JM([]),new JN([new IH.ptr(67808,67826,1),new IH.ptr(67828,67829,1),new IH.ptr(67835,67839,1)]),0);CJ=new IF.ptr(new JM([new IG.ptr(1425,1479,1),new IG.ptr(1488,1514,1),new IG.ptr(1519,1524,1),new IG.ptr(64285,64310,1),new IG.ptr(64312,64316,1),new IG.ptr(64318,64320,2),new IG.ptr(64321,64323,2),new IG.ptr(64324,64326,2),new IG.ptr(64327,64335,1)]),JN.nil,0);CK=new IF.ptr(new JM([new IG.ptr(12353,12438,1),new IG.ptr(12445,12447,1)]),new JN([new IH.ptr(110593,110878,1),new IH.ptr(110928,110930,1),new IH.ptr(127488,127488,1)]),0);CL=new IF.ptr(new JM([]),new JN([new IH.ptr(67648,67669,1),new IH.ptr(67671,67679,1)]),0);CM=new IF.ptr(new JM([new IG.ptr(768,879,1),new IG.ptr(1157,1158,1),new IG.ptr(1611,1621,1),new IG.ptr(1648,2385,737),new IG.ptr(2386,2388,1),new IG.ptr(6832,6848,1),new IG.ptr(7376,7378,1),new IG.ptr(7380,7392,1),new IG.ptr(7394,7400,1),new IG.ptr(7405,7412,7),new IG.ptr(7416,7417,1),new IG.ptr(7616,7673,1),new IG.ptr(7675,7679,1),new IG.ptr(8204,8205,1),new IG.ptr(8400,8432,1),new IG.ptr(12330,12333,1),new IG.ptr(12441,12442,1),new IG.ptr(65024,65039,1),new IG.ptr(65056,65069,1)]),new JN([new IH.ptr(66045,66272,227),new IH.ptr(70459,119143,48684),new IH.ptr(119144,119145,1),new IH.ptr(119163,119170,1),new IH.ptr(119173,119179,1),new IH.ptr(119210,119213,1),new IH.ptr(917760,917999,1)]),0);CN=new IF.ptr(new JM([]),new JN([new IH.ptr(68448,68466,1),new IH.ptr(68472,68479,1)]),0);CO=new IF.ptr(new JM([]),new JN([new IH.ptr(68416,68437,1),new IH.ptr(68440,68447,1)]),0);CP=new IF.ptr(new JM([new IG.ptr(43392,43469,1),new IG.ptr(43472,43481,1),new IG.ptr(43486,43487,1)]),JN.nil,0);CQ=new IF.ptr(new JM([]),new JN([new IH.ptr(69760,69825,1),new IH.ptr(69837,69837,1)]),0);CR=new IF.ptr(new JM([new IG.ptr(3200,3212,1),new IG.ptr(3214,3216,1),new IG.ptr(3218,3240,1),new IG.ptr(3242,3251,1),new IG.ptr(3253,3257,1),new IG.ptr(3260,3268,1),new IG.ptr(3270,3272,1),new IG.ptr(3274,3277,1),new IG.ptr(3285,3286,1),new IG.ptr(3294,3296,2),new IG.ptr(3297,3299,1),new IG.ptr(3302,3311,1),new IG.ptr(3313,3314,1)]),JN.nil,0);CS=new IF.ptr(new JM([new IG.ptr(12449,12538,1),new IG.ptr(12541,12543,1),new IG.ptr(12784,12799,1),new IG.ptr(13008,13054,1),new IG.ptr(13056,13143,1),new IG.ptr(65382,65391,1),new IG.ptr(65393,65437,1)]),new JN([new IH.ptr(110592,110948,356),new IH.ptr(110949,110951,1)]),0);CT=new IF.ptr(new JM([new IG.ptr(43264,43309,1),new IG.ptr(43311,43311,1)]),JN.nil,0);CU=new IF.ptr(new JM([]),new JN([new IH.ptr(68096,68099,1),new IH.ptr(68101,68102,1),new IH.ptr(68108,68115,1),new IH.ptr(68117,68119,1),new IH.ptr(68121,68149,1),new IH.ptr(68152,68154,1),new IH.ptr(68159,68168,1),new IH.ptr(68176,68184,1)]),0);CV=new IF.ptr(new JM([]),new JN([new IH.ptr(94180,101120,6940),new IH.ptr(101121,101589,1)]),0);CW=new IF.ptr(new JM([new IG.ptr(6016,6109,1),new IG.ptr(6112,6121,1),new IG.ptr(6128,6137,1),new IG.ptr(6624,6655,1)]),JN.nil,0);CX=new IF.ptr(new JM([]),new JN([new IH.ptr(70144,70161,1),new IH.ptr(70163,70206,1)]),0);CY=new IF.ptr(new JM([]),new JN([new IH.ptr(70320,70378,1),new IH.ptr(70384,70393,1)]),0);CZ=new IF.ptr(new JM([new IG.ptr(3713,3714,1),new IG.ptr(3716,3718,2),new IG.ptr(3719,3722,1),new IG.ptr(3724,3747,1),new IG.ptr(3749,3751,2),new IG.ptr(3752,3773,1),new IG.ptr(3776,3780,1),new IG.ptr(3782,3784,2),new IG.ptr(3785,3789,1),new IG.ptr(3792,3801,1),new IG.ptr(3804,3807,1)]),JN.nil,0);DA=new IF.ptr(new JM([new IG.ptr(65,90,1),new IG.ptr(97,122,1),new IG.ptr(170,186,16),new IG.ptr(192,214,1),new IG.ptr(216,246,1),new IG.ptr(248,696,1),new IG.ptr(736,740,1),new IG.ptr(7424,7461,1),new IG.ptr(7468,7516,1),new IG.ptr(7522,7525,1),new IG.ptr(7531,7543,1),new IG.ptr(7545,7614,1),new IG.ptr(7680,7935,1),new IG.ptr(8305,8319,14),new IG.ptr(8336,8348,1),new IG.ptr(8490,8491,1),new IG.ptr(8498,8526,28),new IG.ptr(8544,8584,1),new IG.ptr(11360,11391,1),new IG.ptr(42786,42887,1),new IG.ptr(42891,42943,1),new IG.ptr(42946,42954,1),new IG.ptr(42997,43007,1),new IG.ptr(43824,43866,1),new IG.ptr(43868,43876,1),new IG.ptr(43878,43881,1),new IG.ptr(64256,64262,1),new IG.ptr(65313,65338,1),new IG.ptr(65345,65370,1)]),JN.nil,5);DB=new IF.ptr(new JM([new IG.ptr(7168,7223,1),new IG.ptr(7227,7241,1),new IG.ptr(7245,7247,1)]),JN.nil,0);DC=new IF.ptr(new JM([new IG.ptr(6400,6430,1),new IG.ptr(6432,6443,1),new IG.ptr(6448,6459,1),new IG.ptr(6464,6468,4),new IG.ptr(6469,6479,1)]),JN.nil,0);DD=new IF.ptr(new JM([]),new JN([new IH.ptr(67072,67382,1),new IH.ptr(67392,67413,1),new IH.ptr(67424,67431,1)]),0);DE=new IF.ptr(new JM([]),new JN([new IH.ptr(65536,65547,1),new IH.ptr(65549,65574,1),new IH.ptr(65576,65594,1),new IH.ptr(65596,65597,1),new IH.ptr(65599,65613,1),new IH.ptr(65616,65629,1),new IH.ptr(65664,65786,1)]),0);DF=new IF.ptr(new JM([new IG.ptr(42192,42239,1)]),new JN([new IH.ptr(73648,73648,1)]),0);DG=new IF.ptr(new JM([]),new JN([new IH.ptr(66176,66204,1)]),0);DH=new IF.ptr(new JM([]),new JN([new IH.ptr(67872,67897,1),new IH.ptr(67903,67903,1)]),0);DI=new IF.ptr(new JM([]),new JN([new IH.ptr(69968,70006,1)]),0);DJ=new IF.ptr(new JM([]),new JN([new IH.ptr(73440,73464,1)]),0);DK=new IF.ptr(new JM([new IG.ptr(3328,3340,1),new IG.ptr(3342,3344,1),new IG.ptr(3346,3396,1),new IG.ptr(3398,3400,1),new IG.ptr(3402,3407,1),new IG.ptr(3412,3427,1),new IG.ptr(3430,3455,1)]),JN.nil,0);DL=new IF.ptr(new JM([new IG.ptr(2112,2139,1),new IG.ptr(2142,2142,1)]),JN.nil,0);DM=new IF.ptr(new JM([]),new JN([new IH.ptr(68288,68326,1),new IH.ptr(68331,68342,1)]),0);DN=new IF.ptr(new JM([]),new JN([new IH.ptr(72816,72847,1),new IH.ptr(72850,72871,1),new IH.ptr(72873,72886,1)]),0);DO=new IF.ptr(new JM([]),new JN([new IH.ptr(72960,72966,1),new IH.ptr(72968,72969,1),new IH.ptr(72971,73014,1),new IH.ptr(73018,73020,2),new IH.ptr(73021,73023,2),new IH.ptr(73024,73031,1),new IH.ptr(73040,73049,1)]),0);DP=new IF.ptr(new JM([]),new JN([new IH.ptr(93760,93850,1)]),0);DQ=new IF.ptr(new JM([new IG.ptr(43744,43766,1),new IG.ptr(43968,44013,1),new IG.ptr(44016,44025,1)]),JN.nil,0);DR=new IF.ptr(new JM([]),new JN([new IH.ptr(124928,125124,1),new IH.ptr(125127,125142,1)]),0);DS=new IF.ptr(new JM([]),new JN([new IH.ptr(68000,68023,1),new IH.ptr(68028,68047,1),new IH.ptr(68050,68095,1)]),0);DT=new IF.ptr(new JM([]),new JN([new IH.ptr(67968,67999,1)]),0);DU=new IF.ptr(new JM([]),new JN([new IH.ptr(93952,94026,1),new IH.ptr(94031,94087,1),new IH.ptr(94095,94111,1)]),0);DV=new IF.ptr(new JM([]),new JN([new IH.ptr(71168,71236,1),new IH.ptr(71248,71257,1)]),0);DW=new IF.ptr(new JM([new IG.ptr(6144,6145,1),new IG.ptr(6148,6150,2),new IG.ptr(6151,6158,1),new IG.ptr(6160,6169,1),new IG.ptr(6176,6264,1),new IG.ptr(6272,6314,1)]),new JN([new IH.ptr(71264,71276,1)]),0);DX=new IF.ptr(new JM([]),new JN([new IH.ptr(92736,92766,1),new IH.ptr(92768,92777,1),new IH.ptr(92782,92783,1)]),0);DY=new IF.ptr(new JM([]),new JN([new IH.ptr(70272,70278,1),new IH.ptr(70280,70282,2),new IH.ptr(70283,70285,1),new IH.ptr(70287,70301,1),new IH.ptr(70303,70313,1)]),0);DZ=new IF.ptr(new JM([new IG.ptr(4096,4255,1),new IG.ptr(43488,43518,1),new IG.ptr(43616,43647,1)]),JN.nil,0);EA=new IF.ptr(new JM([]),new JN([new IH.ptr(67712,67742,1),new IH.ptr(67751,67759,1)]),0);EB=new IF.ptr(new JM([]),new JN([new IH.ptr(72096,72103,1),new IH.ptr(72106,72151,1),new IH.ptr(72154,72164,1)]),0);EC=new IF.ptr(new JM([new IG.ptr(6528,6571,1),new IG.ptr(6576,6601,1),new IG.ptr(6608,6618,1),new IG.ptr(6622,6623,1)]),JN.nil,0);ED=new IF.ptr(new JM([]),new JN([new IH.ptr(70656,70747,1),new IH.ptr(70749,70753,1)]),0);EE=new IF.ptr(new JM([new IG.ptr(1984,2042,1),new IG.ptr(2045,2047,1)]),JN.nil,0);EF=new IF.ptr(new JM([]),new JN([new IH.ptr(94177,110960,16783),new IH.ptr(110961,111355,1)]),0);EG=new IF.ptr(new JM([]),new JN([new IH.ptr(123136,123180,1),new IH.ptr(123184,123197,1),new IH.ptr(123200,123209,1),new IH.ptr(123214,123215,1)]),0);EH=new IF.ptr(new JM([new IG.ptr(5760,5788,1)]),JN.nil,0);EI=new IF.ptr(new JM([new IG.ptr(7248,7295,1)]),JN.nil,0);EJ=new IF.ptr(new JM([]),new JN([new IH.ptr(68736,68786,1),new IH.ptr(68800,68850,1),new IH.ptr(68858,68863,1)]),0);EK=new IF.ptr(new JM([]),new JN([new IH.ptr(66304,66339,1),new IH.ptr(66349,66351,1)]),0);EL=new IF.ptr(new JM([]),new JN([new IH.ptr(68224,68255,1)]),0);EM=new IF.ptr(new JM([]),new JN([new IH.ptr(66384,66426,1)]),0);EN=new IF.ptr(new JM([]),new JN([new IH.ptr(66464,66499,1),new IH.ptr(66504,66517,1)]),0);EO=new IF.ptr(new JM([]),new JN([new IH.ptr(69376,69415,1)]),0);EP=new IF.ptr(new JM([]),new JN([new IH.ptr(68192,68223,1)]),0);EQ=new IF.ptr(new JM([]),new JN([new IH.ptr(68608,68680,1)]),0);ER=new IF.ptr(new JM([new IG.ptr(2817,2819,1),new IG.ptr(2821,2828,1),new IG.ptr(2831,2832,1),new IG.ptr(2835,2856,1),new IG.ptr(2858,2864,1),new IG.ptr(2866,2867,1),new IG.ptr(2869,2873,1),new IG.ptr(2876,2884,1),new IG.ptr(2887,2888,1),new IG.ptr(2891,2893,1),new IG.ptr(2901,2903,1),new IG.ptr(2908,2909,1),new IG.ptr(2911,2915,1),new IG.ptr(2918,2935,1)]),JN.nil,0);ES=new IF.ptr(new JM([]),new JN([new IH.ptr(66736,66771,1),new IH.ptr(66776,66811,1)]),0);ET=new IF.ptr(new JM([]),new JN([new IH.ptr(66688,66717,1),new IH.ptr(66720,66729,1)]),0);EU=new IF.ptr(new JM([]),new JN([new IH.ptr(92928,92997,1),new IH.ptr(93008,93017,1),new IH.ptr(93019,93025,1),new IH.ptr(93027,93047,1),new IH.ptr(93053,93071,1)]),0);EV=new IF.ptr(new JM([]),new JN([new IH.ptr(67680,67711,1)]),0);EW=new IF.ptr(new JM([]),new JN([new IH.ptr(72384,72440,1)]),0);EX=new IF.ptr(new JM([new IG.ptr(43072,43127,1)]),JN.nil,0);EY=new IF.ptr(new JM([]),new JN([new IH.ptr(67840,67867,1),new IH.ptr(67871,67871,1)]),0);EZ=new IF.ptr(new JM([]),new JN([new IH.ptr(68480,68497,1),new IH.ptr(68505,68508,1),new IH.ptr(68521,68527,1)]),0);FA=new IF.ptr(new JM([new IG.ptr(43312,43347,1),new IG.ptr(43359,43359,1)]),JN.nil,0);FB=new IF.ptr(new JM([new IG.ptr(5792,5866,1),new IG.ptr(5870,5880,1)]),JN.nil,0);FC=new IF.ptr(new JM([new IG.ptr(2048,2093,1),new IG.ptr(2096,2110,1)]),JN.nil,0);FD=new IF.ptr(new JM([new IG.ptr(43136,43205,1),new IG.ptr(43214,43225,1)]),JN.nil,0);FE=new IF.ptr(new JM([]),new JN([new IH.ptr(70016,70111,1)]),0);FF=new IF.ptr(new JM([]),new JN([new IH.ptr(66640,66687,1)]),0);FG=new IF.ptr(new JM([]),new JN([new IH.ptr(71040,71093,1),new IH.ptr(71096,71133,1)]),0);FH=new IF.ptr(new JM([]),new JN([new IH.ptr(120832,121483,1),new IH.ptr(121499,121503,1),new IH.ptr(121505,121519,1)]),0);FI=new IF.ptr(new JM([new IG.ptr(3457,3459,1),new IG.ptr(3461,3478,1),new IG.ptr(3482,3505,1),new IG.ptr(3507,3515,1),new IG.ptr(3517,3520,3),new IG.ptr(3521,3526,1),new IG.ptr(3530,3535,5),new IG.ptr(3536,3540,1),new IG.ptr(3542,3544,2),new IG.ptr(3545,3551,1),new IG.ptr(3558,3567,1),new IG.ptr(3570,3572,1)]),new JN([new IH.ptr(70113,70132,1)]),0);FJ=new IF.ptr(new JM([]),new JN([new IH.ptr(69424,69465,1)]),0);FK=new IF.ptr(new JM([]),new JN([new IH.ptr(69840,69864,1),new IH.ptr(69872,69881,1)]),0);FL=new IF.ptr(new JM([]),new JN([new IH.ptr(72272,72354,1)]),0);FM=new IF.ptr(new JM([new IG.ptr(7040,7103,1),new IG.ptr(7360,7367,1)]),JN.nil,0);FN=new IF.ptr(new JM([new IG.ptr(43008,43052,1)]),JN.nil,0);FO=new IF.ptr(new JM([new IG.ptr(1792,1805,1),new IG.ptr(1807,1866,1),new IG.ptr(1869,1871,1),new IG.ptr(2144,2154,1)]),JN.nil,0);FP=new IF.ptr(new JM([new IG.ptr(5888,5900,1),new IG.ptr(5902,5908,1)]),JN.nil,0);FQ=new IF.ptr(new JM([new IG.ptr(5984,5996,1),new IG.ptr(5998,6000,1),new IG.ptr(6002,6003,1)]),JN.nil,0);FR=new IF.ptr(new JM([new IG.ptr(6480,6509,1),new IG.ptr(6512,6516,1)]),JN.nil,0);FS=new IF.ptr(new JM([new IG.ptr(6688,6750,1),new IG.ptr(6752,6780,1),new IG.ptr(6783,6793,1),new IG.ptr(6800,6809,1),new IG.ptr(6816,6829,1)]),JN.nil,0);FT=new IF.ptr(new JM([new IG.ptr(43648,43714,1),new IG.ptr(43739,43743,1)]),JN.nil,0);FU=new IF.ptr(new JM([]),new JN([new IH.ptr(71296,71352,1),new IH.ptr(71360,71369,1)]),0);FV=new IF.ptr(new JM([new IG.ptr(2946,2947,1),new IG.ptr(2949,2954,1),new IG.ptr(2958,2960,1),new IG.ptr(2962,2965,1),new IG.ptr(2969,2970,1),new IG.ptr(2972,2974,2),new IG.ptr(2975,2979,4),new IG.ptr(2980,2984,4),new IG.ptr(2985,2986,1),new IG.ptr(2990,3001,1),new IG.ptr(3006,3010,1),new IG.ptr(3014,3016,1),new IG.ptr(3018,3021,1),new IG.ptr(3024,3031,7),new IG.ptr(3046,3066,1)]),new JN([new IH.ptr(73664,73713,1),new IH.ptr(73727,73727,1)]),0);FW=new IF.ptr(new JM([]),new JN([new IH.ptr(94176,94208,32),new IH.ptr(94209,100343,1),new IH.ptr(100352,101119,1),new IH.ptr(101632,101640,1)]),0);FX=new IF.ptr(new JM([new IG.ptr(3072,3084,1),new IG.ptr(3086,3088,1),new IG.ptr(3090,3112,1),new IG.ptr(3114,3129,1),new IG.ptr(3133,3140,1),new IG.ptr(3142,3144,1),new IG.ptr(3146,3149,1),new IG.ptr(3157,3158,1),new IG.ptr(3160,3162,1),new IG.ptr(3168,3171,1),new IG.ptr(3174,3183,1),new IG.ptr(3191,3199,1)]),JN.nil,0);FY=new IF.ptr(new JM([new IG.ptr(1920,1969,1)]),JN.nil,0);FZ=new IF.ptr(new JM([new IG.ptr(3585,3642,1),new IG.ptr(3648,3675,1)]),JN.nil,0);GA=new IF.ptr(new JM([new IG.ptr(3840,3911,1),new IG.ptr(3913,3948,1),new IG.ptr(3953,3991,1),new IG.ptr(3993,4028,1),new IG.ptr(4030,4044,1),new IG.ptr(4046,4052,1),new IG.ptr(4057,4058,1)]),JN.nil,0);GB=new IF.ptr(new JM([new IG.ptr(11568,11623,1),new IG.ptr(11631,11632,1),new IG.ptr(11647,11647,1)]),JN.nil,0);GC=new IF.ptr(new JM([]),new JN([new IH.ptr(70784,70855,1),new IH.ptr(70864,70873,1)]),0);GD=new IF.ptr(new JM([]),new JN([new IH.ptr(66432,66461,1),new IH.ptr(66463,66463,1)]),0);GE=new IF.ptr(new JM([new IG.ptr(42240,42539,1)]),JN.nil,0);GF=new IF.ptr(new JM([]),new JN([new IH.ptr(123584,123641,1),new IH.ptr(123647,123647,1)]),0);GG=new IF.ptr(new JM([]),new JN([new IH.ptr(71840,71922,1),new IH.ptr(71935,71935,1)]),0);GH=new IF.ptr(new JM([]),new JN([new IH.ptr(69248,69289,1),new IH.ptr(69291,69293,1),new IH.ptr(69296,69297,1)]),0);GI=new IF.ptr(new JM([new IG.ptr(40960,42124,1),new IG.ptr(42128,42182,1)]),JN.nil,0);GJ=new IF.ptr(new JM([]),new JN([new IH.ptr(72192,72263,1)]),0);$pkg.Adlam=AK;$pkg.Ahom=AL;$pkg.Anatolian_Hieroglyphs=AM;$pkg.Arabic=AN;$pkg.Armenian=AO;$pkg.Avestan=AP;$pkg.Balinese=AQ;$pkg.Bamum=AR;$pkg.Bassa_Vah=AS;$pkg.Batak=AT;$pkg.Bengali=AU;$pkg.Bhaiksuki=AV;$pkg.Bopomofo=AW;$pkg.Brahmi=AX;$pkg.Braille=AY;$pkg.Buginese=AZ;$pkg.Buhid=BA;$pkg.Canadian_Aboriginal=BB;$pkg.Carian=BC;$pkg.Caucasian_Albanian=BD;$pkg.Chakma=BE;$pkg.Cham=BF;$pkg.Cherokee=BG;$pkg.Chorasmian=BH;$pkg.Common=BI;$pkg.Coptic=BJ;$pkg.Cuneiform=BK;$pkg.Cypriot=BL;$pkg.Cyrillic=BM;$pkg.Deseret=BN;$pkg.Devanagari=BO;$pkg.Dives_Akuru=BP;$pkg.Dogra=BQ;$pkg.Duployan=BR;$pkg.Egyptian_Hieroglyphs=BS;$pkg.Elbasan=BT;$pkg.Elymaic=BU;$pkg.Ethiopic=BV;$pkg.Georgian=BW;$pkg.Glagolitic=BX;$pkg.Gothic=BY;$pkg.Grantha=BZ;$pkg.Greek=CA;$pkg.Gujarati=CB;$pkg.Gunjala_Gondi=CC;$pkg.Gurmukhi=CD;$pkg.Han=CE;$pkg.Hangul=CF;$pkg.Hanifi_Rohingya=CG;$pkg.Hanunoo=CH;$pkg.Hatran=CI;$pkg.Hebrew=CJ;$pkg.Hiragana=CK;$pkg.Imperial_Aramaic=CL;$pkg.Inherited=CM;$pkg.Inscriptional_Pahlavi=CN;$pkg.Inscriptional_Parthian=CO;$pkg.Javanese=CP;$pkg.Kaithi=CQ;$pkg.Kannada=CR;$pkg.Katakana=CS;$pkg.Kayah_Li=CT;$pkg.Kharoshthi=CU;$pkg.Khitan_Small_Script=CV;$pkg.Khmer=CW;$pkg.Khojki=CX;$pkg.Khudawadi=CY;$pkg.Lao=CZ;$pkg.Latin=DA;$pkg.Lepcha=DB;$pkg.Limbu=DC;$pkg.Linear_A=DD;$pkg.Linear_B=DE;$pkg.Lisu=DF;$pkg.Lycian=DG;$pkg.Lydian=DH;$pkg.Mahajani=DI;$pkg.Makasar=DJ;$pkg.Malayalam=DK;$pkg.Mandaic=DL;$pkg.Manichaean=DM;$pkg.Marchen=DN;$pkg.Masaram_Gondi=DO;$pkg.Medefaidrin=DP;$pkg.Meetei_Mayek=DQ;$pkg.Mende_Kikakui=DR;$pkg.Meroitic_Cursive=DS;$pkg.Meroitic_Hieroglyphs=DT;$pkg.Miao=DU;$pkg.Modi=DV;$pkg.Mongolian=DW;$pkg.Mro=DX;$pkg.Multani=DY;$pkg.Myanmar=DZ;$pkg.Nabataean=EA;$pkg.Nandinagari=EB;$pkg.New_Tai_Lue=EC;$pkg.Newa=ED;$pkg.Nko=EE;$pkg.Nushu=EF;$pkg.Nyiakeng_Puachue_Hmong=EG;$pkg.Ogham=EH;$pkg.Ol_Chiki=EI;$pkg.Old_Hungarian=EJ;$pkg.Old_Italic=EK;$pkg.Old_North_Arabian=EL;$pkg.Old_Permic=EM;$pkg.Old_Persian=EN;$pkg.Old_Sogdian=EO;$pkg.Old_South_Arabian=EP;$pkg.Old_Turkic=EQ;$pkg.Oriya=ER;$pkg.Osage=ES;$pkg.Osmanya=ET;$pkg.Pahawh_Hmong=EU;$pkg.Palmyrene=EV;$pkg.Pau_Cin_Hau=EW;$pkg.Phags_Pa=EX;$pkg.Phoenician=EY;$pkg.Psalter_Pahlavi=EZ;$pkg.Rejang=FA;$pkg.Runic=FB;$pkg.Samaritan=FC;$pkg.Saurashtra=FD;$pkg.Sharada=FE;$pkg.Shavian=FF;$pkg.Siddham=FG;$pkg.SignWriting=FH;$pkg.Sinhala=FI;$pkg.Sogdian=FJ;$pkg.Sora_Sompeng=FK;$pkg.Soyombo=FL;$pkg.Sundanese=FM;$pkg.Syloti_Nagri=FN;$pkg.Syriac=FO;$pkg.Tagalog=FP;$pkg.Tagbanwa=FQ;$pkg.Tai_Le=FR;$pkg.Tai_Tham=FS;$pkg.Tai_Viet=FT;$pkg.Takri=FU;$pkg.Tamil=FV;$pkg.Tangut=FW;$pkg.Telugu=FX;$pkg.Thaana=FY;$pkg.Thai=FZ;$pkg.Tibetan=GA;$pkg.Tifinagh=GB;$pkg.Tirhuta=GC;$pkg.Ugaritic=GD;$pkg.Vai=GE;$pkg.Wancho=GF;$pkg.Warang_Citi=GG;$pkg.Yezidi=GH;$pkg.Yi=GI;$pkg.Zanabazar_Square=GJ;$pkg.Scripts=$makeMap($String.keyFor,[{k:"Adlam",v:$pkg.Adlam},{k:"Ahom",v:$pkg.Ahom},{k:"Anatolian_Hieroglyphs",v:$pkg.Anatolian_Hieroglyphs},{k:"Arabic",v:$pkg.Arabic},{k:"Armenian",v:$pkg.Armenian},{k:"Avestan",v:$pkg.Avestan},{k:"Balinese",v:$pkg.Balinese},{k:"Bamum",v:$pkg.Bamum},{k:"Bassa_Vah",v:$pkg.Bassa_Vah},{k:"Batak",v:$pkg.Batak},{k:"Bengali",v:$pkg.Bengali},{k:"Bhaiksuki",v:$pkg.Bhaiksuki},{k:"Bopomofo",v:$pkg.Bopomofo},{k:"Brahmi",v:$pkg.Brahmi},{k:"Braille",v:$pkg.Braille},{k:"Buginese",v:$pkg.Buginese},{k:"Buhid",v:$pkg.Buhid},{k:"Canadian_Aboriginal",v:$pkg.Canadian_Aboriginal},{k:"Carian",v:$pkg.Carian},{k:"Caucasian_Albanian",v:$pkg.Caucasian_Albanian},{k:"Chakma",v:$pkg.Chakma},{k:"Cham",v:$pkg.Cham},{k:"Cherokee",v:$pkg.Cherokee},{k:"Chorasmian",v:$pkg.Chorasmian},{k:"Common",v:$pkg.Common},{k:"Coptic",v:$pkg.Coptic},{k:"Cuneiform",v:$pkg.Cuneiform},{k:"Cypriot",v:$pkg.Cypriot},{k:"Cyrillic",v:$pkg.Cyrillic},{k:"Deseret",v:$pkg.Deseret},{k:"Devanagari",v:$pkg.Devanagari},{k:"Dives_Akuru",v:$pkg.Dives_Akuru},{k:"Dogra",v:$pkg.Dogra},{k:"Duployan",v:$pkg.Duployan},{k:"Egyptian_Hieroglyphs",v:$pkg.Egyptian_Hieroglyphs},{k:"Elbasan",v:$pkg.Elbasan},{k:"Elymaic",v:$pkg.Elymaic},{k:"Ethiopic",v:$pkg.Ethiopic},{k:"Georgian",v:$pkg.Georgian},{k:"Glagolitic",v:$pkg.Glagolitic},{k:"Gothic",v:$pkg.Gothic},{k:"Grantha",v:$pkg.Grantha},{k:"Greek",v:$pkg.Greek},{k:"Gujarati",v:$pkg.Gujarati},{k:"Gunjala_Gondi",v:$pkg.Gunjala_Gondi},{k:"Gurmukhi",v:$pkg.Gurmukhi},{k:"Han",v:$pkg.Han},{k:"Hangul",v:$pkg.Hangul},{k:"Hanifi_Rohingya",v:$pkg.Hanifi_Rohingya},{k:"Hanunoo",v:$pkg.Hanunoo},{k:"Hatran",v:$pkg.Hatran},{k:"Hebrew",v:$pkg.Hebrew},{k:"Hiragana",v:$pkg.Hiragana},{k:"Imperial_Aramaic",v:$pkg.Imperial_Aramaic},{k:"Inherited",v:$pkg.Inherited},{k:"Inscriptional_Pahlavi",v:$pkg.Inscriptional_Pahlavi},{k:"Inscriptional_Parthian",v:$pkg.Inscriptional_Parthian},{k:"Javanese",v:$pkg.Javanese},{k:"Kaithi",v:$pkg.Kaithi},{k:"Kannada",v:$pkg.Kannada},{k:"Katakana",v:$pkg.Katakana},{k:"Kayah_Li",v:$pkg.Kayah_Li},{k:"Kharoshthi",v:$pkg.Kharoshthi},{k:"Khitan_Small_Script",v:$pkg.Khitan_Small_Script},{k:"Khmer",v:$pkg.Khmer},{k:"Khojki",v:$pkg.Khojki},{k:"Khudawadi",v:$pkg.Khudawadi},{k:"Lao",v:$pkg.Lao},{k:"Latin",v:$pkg.Latin},{k:"Lepcha",v:$pkg.Lepcha},{k:"Limbu",v:$pkg.Limbu},{k:"Linear_A",v:$pkg.Linear_A},{k:"Linear_B",v:$pkg.Linear_B},{k:"Lisu",v:$pkg.Lisu},{k:"Lycian",v:$pkg.Lycian},{k:"Lydian",v:$pkg.Lydian},{k:"Mahajani",v:$pkg.Mahajani},{k:"Makasar",v:$pkg.Makasar},{k:"Malayalam",v:$pkg.Malayalam},{k:"Mandaic",v:$pkg.Mandaic},{k:"Manichaean",v:$pkg.Manichaean},{k:"Marchen",v:$pkg.Marchen},{k:"Masaram_Gondi",v:$pkg.Masaram_Gondi},{k:"Medefaidrin",v:$pkg.Medefaidrin},{k:"Meetei_Mayek",v:$pkg.Meetei_Mayek},{k:"Mende_Kikakui",v:$pkg.Mende_Kikakui},{k:"Meroitic_Cursive",v:$pkg.Meroitic_Cursive},{k:"Meroitic_Hieroglyphs",v:$pkg.Meroitic_Hieroglyphs},{k:"Miao",v:$pkg.Miao},{k:"Modi",v:$pkg.Modi},{k:"Mongolian",v:$pkg.Mongolian},{k:"Mro",v:$pkg.Mro},{k:"Multani",v:$pkg.Multani},{k:"Myanmar",v:$pkg.Myanmar},{k:"Nabataean",v:$pkg.Nabataean},{k:"Nandinagari",v:$pkg.Nandinagari},{k:"New_Tai_Lue",v:$pkg.New_Tai_Lue},{k:"Newa",v:$pkg.Newa},{k:"Nko",v:$pkg.Nko},{k:"Nushu",v:$pkg.Nushu},{k:"Nyiakeng_Puachue_Hmong",v:$pkg.Nyiakeng_Puachue_Hmong},{k:"Ogham",v:$pkg.Ogham},{k:"Ol_Chiki",v:$pkg.Ol_Chiki},{k:"Old_Hungarian",v:$pkg.Old_Hungarian},{k:"Old_Italic",v:$pkg.Old_Italic},{k:"Old_North_Arabian",v:$pkg.Old_North_Arabian},{k:"Old_Permic",v:$pkg.Old_Permic},{k:"Old_Persian",v:$pkg.Old_Persian},{k:"Old_Sogdian",v:$pkg.Old_Sogdian},{k:"Old_South_Arabian",v:$pkg.Old_South_Arabian},{k:"Old_Turkic",v:$pkg.Old_Turkic},{k:"Oriya",v:$pkg.Oriya},{k:"Osage",v:$pkg.Osage},{k:"Osmanya",v:$pkg.Osmanya},{k:"Pahawh_Hmong",v:$pkg.Pahawh_Hmong},{k:"Palmyrene",v:$pkg.Palmyrene},{k:"Pau_Cin_Hau",v:$pkg.Pau_Cin_Hau},{k:"Phags_Pa",v:$pkg.Phags_Pa},{k:"Phoenician",v:$pkg.Phoenician},{k:"Psalter_Pahlavi",v:$pkg.Psalter_Pahlavi},{k:"Rejang",v:$pkg.Rejang},{k:"Runic",v:$pkg.Runic},{k:"Samaritan",v:$pkg.Samaritan},{k:"Saurashtra",v:$pkg.Saurashtra},{k:"Sharada",v:$pkg.Sharada},{k:"Shavian",v:$pkg.Shavian},{k:"Siddham",v:$pkg.Siddham},{k:"SignWriting",v:$pkg.SignWriting},{k:"Sinhala",v:$pkg.Sinhala},{k:"Sogdian",v:$pkg.Sogdian},{k:"Sora_Sompeng",v:$pkg.Sora_Sompeng},{k:"Soyombo",v:$pkg.Soyombo},{k:"Sundanese",v:$pkg.Sundanese},{k:"Syloti_Nagri",v:$pkg.Syloti_Nagri},{k:"Syriac",v:$pkg.Syriac},{k:"Tagalog",v:$pkg.Tagalog},{k:"Tagbanwa",v:$pkg.Tagbanwa},{k:"Tai_Le",v:$pkg.Tai_Le},{k:"Tai_Tham",v:$pkg.Tai_Tham},{k:"Tai_Viet",v:$pkg.Tai_Viet},{k:"Takri",v:$pkg.Takri},{k:"Tamil",v:$pkg.Tamil},{k:"Tangut",v:$pkg.Tangut},{k:"Telugu",v:$pkg.Telugu},{k:"Thaana",v:$pkg.Thaana},{k:"Thai",v:$pkg.Thai},{k:"Tibetan",v:$pkg.Tibetan},{k:"Tifinagh",v:$pkg.Tifinagh},{k:"Tirhuta",v:$pkg.Tirhuta},{k:"Ugaritic",v:$pkg.Ugaritic},{k:"Vai",v:$pkg.Vai},{k:"Wancho",v:$pkg.Wancho},{k:"Warang_Citi",v:$pkg.Warang_Citi},{k:"Yezidi",v:$pkg.Yezidi},{k:"Yi",v:$pkg.Yi},{k:"Zanabazar_Square",v:$pkg.Zanabazar_Square}]);HR=new IF.ptr(new JM([new IG.ptr(9,13,1),new IG.ptr(32,133,101),new IG.ptr(160,5760,5600),new IG.ptr(8192,8202,1),new IG.ptr(8232,8233,1),new IG.ptr(8239,8287,48),new IG.ptr(12288,12288,1)]),JN.nil,2);$pkg.White_Space=HR;HV=new JO([new IW.ptr(75,107),new IW.ptr(83,115),new IW.ptr(107,8490),new IW.ptr(115,383),new IW.ptr(181,924),new IW.ptr(197,229),new IW.ptr(223,7838),new IW.ptr(229,8491),new IW.ptr(304,304),new IW.ptr(305,305),new IW.ptr(383,83),new IW.ptr(452,453),new IW.ptr(453,454),new IW.ptr(454,452),new IW.ptr(455,456),new IW.ptr(456,457),new IW.ptr(457,455),new IW.ptr(458,459),new IW.ptr(459,460),new IW.ptr(460,458),new IW.ptr(497,498),new IW.ptr(498,499),new IW.ptr(499,497),new IW.ptr(837,921),new IW.ptr(914,946),new IW.ptr(917,949),new IW.ptr(920,952),new IW.ptr(921,953),new IW.ptr(922,954),new IW.ptr(924,956),new IW.ptr(928,960),new IW.ptr(929,961),new IW.ptr(931,962),new IW.ptr(934,966),new IW.ptr(937,969),new IW.ptr(946,976),new IW.ptr(949,1013),new IW.ptr(952,977),new IW.ptr(953,8126),new IW.ptr(954,1008),new IW.ptr(956,181),new IW.ptr(960,982),new IW.ptr(961,1009),new IW.ptr(962,963),new IW.ptr(963,931),new IW.ptr(966,981),new IW.ptr(969,8486),new IW.ptr(976,914),new IW.ptr(977,1012),new IW.ptr(981,934),new IW.ptr(982,928),new IW.ptr(1008,922),new IW.ptr(1009,929),new IW.ptr(1012,920),new IW.ptr(1013,917),new IW.ptr(1042,1074),new IW.ptr(1044,1076),new IW.ptr(1054,1086),new IW.ptr(1057,1089),new IW.ptr(1058,1090),new IW.ptr(1066,1098),new IW.ptr(1074,7296),new IW.ptr(1076,7297),new IW.ptr(1086,7298),new IW.ptr(1089,7299),new IW.ptr(1090,7300),new IW.ptr(1098,7302),new IW.ptr(1122,1123),new IW.ptr(1123,7303),new IW.ptr(7296,1042),new IW.ptr(7297,1044),new IW.ptr(7298,1054),new IW.ptr(7299,1057),new IW.ptr(7300,7301),new IW.ptr(7301,1058),new IW.ptr(7302,1066),new IW.ptr(7303,1122),new IW.ptr(7304,42570),new IW.ptr(7776,7777),new IW.ptr(7777,7835),new IW.ptr(7835,7776),new IW.ptr(7838,223),new IW.ptr(8126,837),new IW.ptr(8486,937),new IW.ptr(8490,75),new IW.ptr(8491,197),new IW.ptr(42570,42571),new IW.ptr(42571,7304)]);HW=new IF.ptr(new JM([new IG.ptr(837,837,1)]),JN.nil,0);HX=new IF.ptr(new JM([new IG.ptr(65,90,1),new IG.ptr(192,214,1),new IG.ptr(216,222,1),new IG.ptr(256,302,2),new IG.ptr(306,310,2),new IG.ptr(313,327,2),new IG.ptr(330,376,2),new IG.ptr(377,381,2),new IG.ptr(385,386,1),new IG.ptr(388,390,2),new IG.ptr(391,393,2),new IG.ptr(394,395,1),new IG.ptr(398,401,1),new IG.ptr(403,404,1),new IG.ptr(406,408,1),new IG.ptr(412,413,1),new IG.ptr(415,416,1),new IG.ptr(418,422,2),new IG.ptr(423,425,2),new IG.ptr(428,430,2),new IG.ptr(431,433,2),new IG.ptr(434,435,1),new IG.ptr(437,439,2),new IG.ptr(440,444,4),new IG.ptr(452,453,1),new IG.ptr(455,456,1),new IG.ptr(458,459,1),new IG.ptr(461,475,2),new IG.ptr(478,494,2),new IG.ptr(497,498,1),new IG.ptr(500,502,2),new IG.ptr(503,504,1),new IG.ptr(506,562,2),new IG.ptr(570,571,1),new IG.ptr(573,574,1),new IG.ptr(577,579,2),new IG.ptr(580,582,1),new IG.ptr(584,590,2),new IG.ptr(837,880,43),new IG.ptr(882,886,4),new IG.ptr(895,902,7),new IG.ptr(904,906,1),new IG.ptr(908,910,2),new IG.ptr(911,913,2),new IG.ptr(914,929,1),new IG.ptr(931,939,1),new IG.ptr(975,984,9),new IG.ptr(986,1006,2),new IG.ptr(1012,1015,3),new IG.ptr(1017,1018,1),new IG.ptr(1021,1071,1),new IG.ptr(1120,1152,2),new IG.ptr(1162,1216,2),new IG.ptr(1217,1229,2),new IG.ptr(1232,1326,2),new IG.ptr(1329,1366,1),new IG.ptr(4256,4293,1),new IG.ptr(4295,4301,6),new IG.ptr(5024,5109,1),new IG.ptr(7312,7354,1),new IG.ptr(7357,7359,1),new IG.ptr(7680,7828,2),new IG.ptr(7838,7934,2),new IG.ptr(7944,7951,1),new IG.ptr(7960,7965,1),new IG.ptr(7976,7983,1),new IG.ptr(7992,7999,1),new IG.ptr(8008,8013,1),new IG.ptr(8025,8031,2),new IG.ptr(8040,8047,1),new IG.ptr(8072,8079,1),new IG.ptr(8088,8095,1),new IG.ptr(8104,8111,1),new IG.ptr(8120,8124,1),new IG.ptr(8136,8140,1),new IG.ptr(8152,8155,1),new IG.ptr(8168,8172,1),new IG.ptr(8184,8188,1),new IG.ptr(8486,8490,4),new IG.ptr(8491,8498,7),new IG.ptr(8579,11264,2685),new IG.ptr(11265,11310,1),new IG.ptr(11360,11362,2),new IG.ptr(11363,11364,1),new IG.ptr(11367,11373,2),new IG.ptr(11374,11376,1),new IG.ptr(11378,11381,3),new IG.ptr(11390,11392,1),new IG.ptr(11394,11490,2),new IG.ptr(11499,11501,2),new IG.ptr(11506,42560,31054),new IG.ptr(42562,42604,2),new IG.ptr(42624,42650,2),new IG.ptr(42786,42798,2),new IG.ptr(42802,42862,2),new IG.ptr(42873,42877,2),new IG.ptr(42878,42886,2),new IG.ptr(42891,42893,2),new IG.ptr(42896,42898,2),new IG.ptr(42902,42922,2),new IG.ptr(42923,42926,1),new IG.ptr(42928,42932,1),new IG.ptr(42934,42942,2),new IG.ptr(42946,42948,2),new IG.ptr(42949,42951,1),new IG.ptr(42953,42997,44),new IG.ptr(65313,65338,1)]),new JN([new IH.ptr(66560,66599,1),new IH.ptr(66736,66771,1),new IH.ptr(68736,68786,1),new IH.ptr(71840,71871,1),new IH.ptr(93760,93791,1),new IH.ptr(125184,125217,1)]),3);HY=new IF.ptr(new JM([new IG.ptr(452,454,2),new IG.ptr(455,457,2),new IG.ptr(458,460,2),new IG.ptr(497,499,2),new IG.ptr(8064,8071,1),new IG.ptr(8080,8087,1),new IG.ptr(8096,8103,1),new IG.ptr(8115,8131,16),new IG.ptr(8179,8179,1)]),JN.nil,0);HZ=new IF.ptr(new JM([new IG.ptr(97,122,1),new IG.ptr(181,223,42),new IG.ptr(224,246,1),new IG.ptr(248,255,1),new IG.ptr(257,303,2),new IG.ptr(307,311,2),new IG.ptr(314,328,2),new IG.ptr(331,375,2),new IG.ptr(378,382,2),new IG.ptr(383,384,1),new IG.ptr(387,389,2),new IG.ptr(392,396,4),new IG.ptr(402,405,3),new IG.ptr(409,410,1),new IG.ptr(414,417,3),new IG.ptr(419,421,2),new IG.ptr(424,429,5),new IG.ptr(432,436,4),new IG.ptr(438,441,3),new IG.ptr(445,447,2),new IG.ptr(453,454,1),new IG.ptr(456,457,1),new IG.ptr(459,460,1),new IG.ptr(462,476,2),new IG.ptr(477,495,2),new IG.ptr(498,499,1),new IG.ptr(501,505,4),new IG.ptr(507,543,2),new IG.ptr(547,563,2),new IG.ptr(572,575,3),new IG.ptr(576,578,2),new IG.ptr(583,591,2),new IG.ptr(592,596,1),new IG.ptr(598,599,1),new IG.ptr(601,603,2),new IG.ptr(604,608,4),new IG.ptr(609,613,2),new IG.ptr(614,616,2),new IG.ptr(617,620,1),new IG.ptr(623,625,2),new IG.ptr(626,629,3),new IG.ptr(637,640,3),new IG.ptr(642,643,1),new IG.ptr(647,652,1),new IG.ptr(658,669,11),new IG.ptr(670,837,167),new IG.ptr(881,883,2),new IG.ptr(887,891,4),new IG.ptr(892,893,1),new IG.ptr(940,943,1),new IG.ptr(945,974,1),new IG.ptr(976,977,1),new IG.ptr(981,983,1),new IG.ptr(985,1007,2),new IG.ptr(1008,1011,1),new IG.ptr(1013,1019,3),new IG.ptr(1072,1119,1),new IG.ptr(1121,1153,2),new IG.ptr(1163,1215,2),new IG.ptr(1218,1230,2),new IG.ptr(1231,1327,2),new IG.ptr(1377,1414,1),new IG.ptr(4304,4346,1),new IG.ptr(4349,4351,1),new IG.ptr(5112,5117,1),new IG.ptr(7296,7304,1),new IG.ptr(7545,7549,4),new IG.ptr(7566,7681,115),new IG.ptr(7683,7829,2),new IG.ptr(7835,7841,6),new IG.ptr(7843,7935,2),new IG.ptr(7936,7943,1),new IG.ptr(7952,7957,1),new IG.ptr(7968,7975,1),new IG.ptr(7984,7991,1),new IG.ptr(8000,8005,1),new IG.ptr(8017,8023,2),new IG.ptr(8032,8039,1),new IG.ptr(8048,8061,1),new IG.ptr(8112,8113,1),new IG.ptr(8126,8144,18),new IG.ptr(8145,8160,15),new IG.ptr(8161,8165,4),new IG.ptr(8526,8580,54),new IG.ptr(11312,11358,1),new IG.ptr(11361,11365,4),new IG.ptr(11366,11372,2),new IG.ptr(11379,11382,3),new IG.ptr(11393,11491,2),new IG.ptr(11500,11502,2),new IG.ptr(11507,11520,13),new IG.ptr(11521,11557,1),new IG.ptr(11559,11565,6),new IG.ptr(42561,42605,2),new IG.ptr(42625,42651,2),new IG.ptr(42787,42799,2),new IG.ptr(42803,42863,2),new IG.ptr(42874,42876,2),new IG.ptr(42879,42887,2),new IG.ptr(42892,42897,5),new IG.ptr(42899,42900,1),new IG.ptr(42903,42921,2),new IG.ptr(42933,42943,2),new IG.ptr(42947,42952,5),new IG.ptr(42954,42998,44),new IG.ptr(43859,43888,29),new IG.ptr(43889,43967,1),new IG.ptr(65345,65370,1)]),new JN([new IH.ptr(66600,66639,1),new IH.ptr(66776,66811,1),new IH.ptr(68800,68850,1),new IH.ptr(71872,71903,1),new IH.ptr(93792,93823,1),new IH.ptr(125218,125251,1)]),4);IA=new IF.ptr(new JM([new IG.ptr(921,953,32),new IG.ptr(8126,8126,1)]),JN.nil,0);IB=new IF.ptr(new JM([new IG.ptr(921,953,32),new IG.ptr(8126,8126,1)]),JN.nil,0);$pkg.FoldCategory=$makeMap($String.keyFor,[{k:"L",v:HW},{k:"Ll",v:HX},{k:"Lt",v:HY},{k:"Lu",v:HZ},{k:"M",v:IA},{k:"Mn",v:IB}]);IC=new IF.ptr(new JM([new IG.ptr(924,956,32)]),JN.nil,0);ID=new IF.ptr(new JM([new IG.ptr(181,837,656)]),JN.nil,0);IE=new IF.ptr(new JM([new IG.ptr(921,953,32),new IG.ptr(8126,8126,1)]),JN.nil,0);$pkg.FoldScript=$makeMap($String.keyFor,[{k:"Common",v:IC},{k:"Greek",v:ID},{k:"Inherited",v:IE}]);HU=$toNativeArray($kindUint16,[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,91,92,93,94,95,96,65,66,67,68,69,70,71,72,73,74,8490,76,77,78,79,80,81,82,383,84,85,86,87,88,89,90,123,124,125,126,127]);HS=new JP([new II.ptr(65,90,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(97,122,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(181,181,$toNativeArray($kindInt32,[743,0,743])),new II.ptr(192,214,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(216,222,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(224,246,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(248,254,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(255,255,$toNativeArray($kindInt32,[121,0,121])),new II.ptr(256,303,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(304,304,$toNativeArray($kindInt32,[0,-199,0])),new II.ptr(305,305,$toNativeArray($kindInt32,[-232,0,-232])),new II.ptr(306,311,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(313,328,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(330,375,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(376,376,$toNativeArray($kindInt32,[0,-121,0])),new II.ptr(377,382,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(383,383,$toNativeArray($kindInt32,[-300,0,-300])),new II.ptr(384,384,$toNativeArray($kindInt32,[195,0,195])),new II.ptr(385,385,$toNativeArray($kindInt32,[0,210,0])),new II.ptr(386,389,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(390,390,$toNativeArray($kindInt32,[0,206,0])),new II.ptr(391,392,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(393,394,$toNativeArray($kindInt32,[0,205,0])),new II.ptr(395,396,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(398,398,$toNativeArray($kindInt32,[0,79,0])),new II.ptr(399,399,$toNativeArray($kindInt32,[0,202,0])),new II.ptr(400,400,$toNativeArray($kindInt32,[0,203,0])),new II.ptr(401,402,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(403,403,$toNativeArray($kindInt32,[0,205,0])),new II.ptr(404,404,$toNativeArray($kindInt32,[0,207,0])),new II.ptr(405,405,$toNativeArray($kindInt32,[97,0,97])),new II.ptr(406,406,$toNativeArray($kindInt32,[0,211,0])),new II.ptr(407,407,$toNativeArray($kindInt32,[0,209,0])),new II.ptr(408,409,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(410,410,$toNativeArray($kindInt32,[163,0,163])),new II.ptr(412,412,$toNativeArray($kindInt32,[0,211,0])),new II.ptr(413,413,$toNativeArray($kindInt32,[0,213,0])),new II.ptr(414,414,$toNativeArray($kindInt32,[130,0,130])),new II.ptr(415,415,$toNativeArray($kindInt32,[0,214,0])),new II.ptr(416,421,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(422,422,$toNativeArray($kindInt32,[0,218,0])),new II.ptr(423,424,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(425,425,$toNativeArray($kindInt32,[0,218,0])),new II.ptr(428,429,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(430,430,$toNativeArray($kindInt32,[0,218,0])),new II.ptr(431,432,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(433,434,$toNativeArray($kindInt32,[0,217,0])),new II.ptr(435,438,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(439,439,$toNativeArray($kindInt32,[0,219,0])),new II.ptr(440,441,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(444,445,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(447,447,$toNativeArray($kindInt32,[56,0,56])),new II.ptr(452,452,$toNativeArray($kindInt32,[0,2,1])),new II.ptr(453,453,$toNativeArray($kindInt32,[-1,1,0])),new II.ptr(454,454,$toNativeArray($kindInt32,[-2,0,-1])),new II.ptr(455,455,$toNativeArray($kindInt32,[0,2,1])),new II.ptr(456,456,$toNativeArray($kindInt32,[-1,1,0])),new II.ptr(457,457,$toNativeArray($kindInt32,[-2,0,-1])),new II.ptr(458,458,$toNativeArray($kindInt32,[0,2,1])),new II.ptr(459,459,$toNativeArray($kindInt32,[-1,1,0])),new II.ptr(460,460,$toNativeArray($kindInt32,[-2,0,-1])),new II.ptr(461,476,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(477,477,$toNativeArray($kindInt32,[-79,0,-79])),new II.ptr(478,495,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(497,497,$toNativeArray($kindInt32,[0,2,1])),new II.ptr(498,498,$toNativeArray($kindInt32,[-1,1,0])),new II.ptr(499,499,$toNativeArray($kindInt32,[-2,0,-1])),new II.ptr(500,501,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(502,502,$toNativeArray($kindInt32,[0,-97,0])),new II.ptr(503,503,$toNativeArray($kindInt32,[0,-56,0])),new II.ptr(504,543,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(544,544,$toNativeArray($kindInt32,[0,-130,0])),new II.ptr(546,563,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(570,570,$toNativeArray($kindInt32,[0,10795,0])),new II.ptr(571,572,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(573,573,$toNativeArray($kindInt32,[0,-163,0])),new II.ptr(574,574,$toNativeArray($kindInt32,[0,10792,0])),new II.ptr(575,576,$toNativeArray($kindInt32,[10815,0,10815])),new II.ptr(577,578,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(579,579,$toNativeArray($kindInt32,[0,-195,0])),new II.ptr(580,580,$toNativeArray($kindInt32,[0,69,0])),new II.ptr(581,581,$toNativeArray($kindInt32,[0,71,0])),new II.ptr(582,591,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(592,592,$toNativeArray($kindInt32,[10783,0,10783])),new II.ptr(593,593,$toNativeArray($kindInt32,[10780,0,10780])),new II.ptr(594,594,$toNativeArray($kindInt32,[10782,0,10782])),new II.ptr(595,595,$toNativeArray($kindInt32,[-210,0,-210])),new II.ptr(596,596,$toNativeArray($kindInt32,[-206,0,-206])),new II.ptr(598,599,$toNativeArray($kindInt32,[-205,0,-205])),new II.ptr(601,601,$toNativeArray($kindInt32,[-202,0,-202])),new II.ptr(603,603,$toNativeArray($kindInt32,[-203,0,-203])),new II.ptr(604,604,$toNativeArray($kindInt32,[42319,0,42319])),new II.ptr(608,608,$toNativeArray($kindInt32,[-205,0,-205])),new II.ptr(609,609,$toNativeArray($kindInt32,[42315,0,42315])),new II.ptr(611,611,$toNativeArray($kindInt32,[-207,0,-207])),new II.ptr(613,613,$toNativeArray($kindInt32,[42280,0,42280])),new II.ptr(614,614,$toNativeArray($kindInt32,[42308,0,42308])),new II.ptr(616,616,$toNativeArray($kindInt32,[-209,0,-209])),new II.ptr(617,617,$toNativeArray($kindInt32,[-211,0,-211])),new II.ptr(618,618,$toNativeArray($kindInt32,[42308,0,42308])),new II.ptr(619,619,$toNativeArray($kindInt32,[10743,0,10743])),new II.ptr(620,620,$toNativeArray($kindInt32,[42305,0,42305])),new II.ptr(623,623,$toNativeArray($kindInt32,[-211,0,-211])),new II.ptr(625,625,$toNativeArray($kindInt32,[10749,0,10749])),new II.ptr(626,626,$toNativeArray($kindInt32,[-213,0,-213])),new II.ptr(629,629,$toNativeArray($kindInt32,[-214,0,-214])),new II.ptr(637,637,$toNativeArray($kindInt32,[10727,0,10727])),new II.ptr(640,640,$toNativeArray($kindInt32,[-218,0,-218])),new II.ptr(642,642,$toNativeArray($kindInt32,[42307,0,42307])),new II.ptr(643,643,$toNativeArray($kindInt32,[-218,0,-218])),new II.ptr(647,647,$toNativeArray($kindInt32,[42282,0,42282])),new II.ptr(648,648,$toNativeArray($kindInt32,[-218,0,-218])),new II.ptr(649,649,$toNativeArray($kindInt32,[-69,0,-69])),new II.ptr(650,651,$toNativeArray($kindInt32,[-217,0,-217])),new II.ptr(652,652,$toNativeArray($kindInt32,[-71,0,-71])),new II.ptr(658,658,$toNativeArray($kindInt32,[-219,0,-219])),new II.ptr(669,669,$toNativeArray($kindInt32,[42261,0,42261])),new II.ptr(670,670,$toNativeArray($kindInt32,[42258,0,42258])),new II.ptr(837,837,$toNativeArray($kindInt32,[84,0,84])),new II.ptr(880,883,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(886,887,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(891,893,$toNativeArray($kindInt32,[130,0,130])),new II.ptr(895,895,$toNativeArray($kindInt32,[0,116,0])),new II.ptr(902,902,$toNativeArray($kindInt32,[0,38,0])),new II.ptr(904,906,$toNativeArray($kindInt32,[0,37,0])),new II.ptr(908,908,$toNativeArray($kindInt32,[0,64,0])),new II.ptr(910,911,$toNativeArray($kindInt32,[0,63,0])),new II.ptr(913,929,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(931,939,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(940,940,$toNativeArray($kindInt32,[-38,0,-38])),new II.ptr(941,943,$toNativeArray($kindInt32,[-37,0,-37])),new II.ptr(945,961,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(962,962,$toNativeArray($kindInt32,[-31,0,-31])),new II.ptr(963,971,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(972,972,$toNativeArray($kindInt32,[-64,0,-64])),new II.ptr(973,974,$toNativeArray($kindInt32,[-63,0,-63])),new II.ptr(975,975,$toNativeArray($kindInt32,[0,8,0])),new II.ptr(976,976,$toNativeArray($kindInt32,[-62,0,-62])),new II.ptr(977,977,$toNativeArray($kindInt32,[-57,0,-57])),new II.ptr(981,981,$toNativeArray($kindInt32,[-47,0,-47])),new II.ptr(982,982,$toNativeArray($kindInt32,[-54,0,-54])),new II.ptr(983,983,$toNativeArray($kindInt32,[-8,0,-8])),new II.ptr(984,1007,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(1008,1008,$toNativeArray($kindInt32,[-86,0,-86])),new II.ptr(1009,1009,$toNativeArray($kindInt32,[-80,0,-80])),new II.ptr(1010,1010,$toNativeArray($kindInt32,[7,0,7])),new II.ptr(1011,1011,$toNativeArray($kindInt32,[-116,0,-116])),new II.ptr(1012,1012,$toNativeArray($kindInt32,[0,-60,0])),new II.ptr(1013,1013,$toNativeArray($kindInt32,[-96,0,-96])),new II.ptr(1015,1016,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(1017,1017,$toNativeArray($kindInt32,[0,-7,0])),new II.ptr(1018,1019,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(1021,1023,$toNativeArray($kindInt32,[0,-130,0])),new II.ptr(1024,1039,$toNativeArray($kindInt32,[0,80,0])),new II.ptr(1040,1071,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(1072,1103,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(1104,1119,$toNativeArray($kindInt32,[-80,0,-80])),new II.ptr(1120,1153,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(1162,1215,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(1216,1216,$toNativeArray($kindInt32,[0,15,0])),new II.ptr(1217,1230,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(1231,1231,$toNativeArray($kindInt32,[-15,0,-15])),new II.ptr(1232,1327,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(1329,1366,$toNativeArray($kindInt32,[0,48,0])),new II.ptr(1377,1414,$toNativeArray($kindInt32,[-48,0,-48])),new II.ptr(4256,4293,$toNativeArray($kindInt32,[0,7264,0])),new II.ptr(4295,4295,$toNativeArray($kindInt32,[0,7264,0])),new II.ptr(4301,4301,$toNativeArray($kindInt32,[0,7264,0])),new II.ptr(4304,4346,$toNativeArray($kindInt32,[3008,0,0])),new II.ptr(4349,4351,$toNativeArray($kindInt32,[3008,0,0])),new II.ptr(5024,5103,$toNativeArray($kindInt32,[0,38864,0])),new II.ptr(5104,5109,$toNativeArray($kindInt32,[0,8,0])),new II.ptr(5112,5117,$toNativeArray($kindInt32,[-8,0,-8])),new II.ptr(7296,7296,$toNativeArray($kindInt32,[-6254,0,-6254])),new II.ptr(7297,7297,$toNativeArray($kindInt32,[-6253,0,-6253])),new II.ptr(7298,7298,$toNativeArray($kindInt32,[-6244,0,-6244])),new II.ptr(7299,7300,$toNativeArray($kindInt32,[-6242,0,-6242])),new II.ptr(7301,7301,$toNativeArray($kindInt32,[-6243,0,-6243])),new II.ptr(7302,7302,$toNativeArray($kindInt32,[-6236,0,-6236])),new II.ptr(7303,7303,$toNativeArray($kindInt32,[-6181,0,-6181])),new II.ptr(7304,7304,$toNativeArray($kindInt32,[35266,0,35266])),new II.ptr(7312,7354,$toNativeArray($kindInt32,[0,-3008,0])),new II.ptr(7357,7359,$toNativeArray($kindInt32,[0,-3008,0])),new II.ptr(7545,7545,$toNativeArray($kindInt32,[35332,0,35332])),new II.ptr(7549,7549,$toNativeArray($kindInt32,[3814,0,3814])),new II.ptr(7566,7566,$toNativeArray($kindInt32,[35384,0,35384])),new II.ptr(7680,7829,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(7835,7835,$toNativeArray($kindInt32,[-59,0,-59])),new II.ptr(7838,7838,$toNativeArray($kindInt32,[0,-7615,0])),new II.ptr(7840,7935,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(7936,7943,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(7944,7951,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(7952,7957,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(7960,7965,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(7968,7975,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(7976,7983,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(7984,7991,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(7992,7999,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8000,8005,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8008,8013,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8017,8017,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8019,8019,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8021,8021,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8023,8023,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8025,8025,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8027,8027,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8029,8029,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8031,8031,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8032,8039,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8040,8047,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8048,8049,$toNativeArray($kindInt32,[74,0,74])),new II.ptr(8050,8053,$toNativeArray($kindInt32,[86,0,86])),new II.ptr(8054,8055,$toNativeArray($kindInt32,[100,0,100])),new II.ptr(8056,8057,$toNativeArray($kindInt32,[128,0,128])),new II.ptr(8058,8059,$toNativeArray($kindInt32,[112,0,112])),new II.ptr(8060,8061,$toNativeArray($kindInt32,[126,0,126])),new II.ptr(8064,8071,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8072,8079,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8080,8087,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8088,8095,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8096,8103,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8104,8111,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8112,8113,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8115,8115,$toNativeArray($kindInt32,[9,0,9])),new II.ptr(8120,8121,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8122,8123,$toNativeArray($kindInt32,[0,-74,0])),new II.ptr(8124,8124,$toNativeArray($kindInt32,[0,-9,0])),new II.ptr(8126,8126,$toNativeArray($kindInt32,[-7205,0,-7205])),new II.ptr(8131,8131,$toNativeArray($kindInt32,[9,0,9])),new II.ptr(8136,8139,$toNativeArray($kindInt32,[0,-86,0])),new II.ptr(8140,8140,$toNativeArray($kindInt32,[0,-9,0])),new II.ptr(8144,8145,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8152,8153,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8154,8155,$toNativeArray($kindInt32,[0,-100,0])),new II.ptr(8160,8161,$toNativeArray($kindInt32,[8,0,8])),new II.ptr(8165,8165,$toNativeArray($kindInt32,[7,0,7])),new II.ptr(8168,8169,$toNativeArray($kindInt32,[0,-8,0])),new II.ptr(8170,8171,$toNativeArray($kindInt32,[0,-112,0])),new II.ptr(8172,8172,$toNativeArray($kindInt32,[0,-7,0])),new II.ptr(8179,8179,$toNativeArray($kindInt32,[9,0,9])),new II.ptr(8184,8185,$toNativeArray($kindInt32,[0,-128,0])),new II.ptr(8186,8187,$toNativeArray($kindInt32,[0,-126,0])),new II.ptr(8188,8188,$toNativeArray($kindInt32,[0,-9,0])),new II.ptr(8486,8486,$toNativeArray($kindInt32,[0,-7517,0])),new II.ptr(8490,8490,$toNativeArray($kindInt32,[0,-8383,0])),new II.ptr(8491,8491,$toNativeArray($kindInt32,[0,-8262,0])),new II.ptr(8498,8498,$toNativeArray($kindInt32,[0,28,0])),new II.ptr(8526,8526,$toNativeArray($kindInt32,[-28,0,-28])),new II.ptr(8544,8559,$toNativeArray($kindInt32,[0,16,0])),new II.ptr(8560,8575,$toNativeArray($kindInt32,[-16,0,-16])),new II.ptr(8579,8580,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(9398,9423,$toNativeArray($kindInt32,[0,26,0])),new II.ptr(9424,9449,$toNativeArray($kindInt32,[-26,0,-26])),new II.ptr(11264,11310,$toNativeArray($kindInt32,[0,48,0])),new II.ptr(11312,11358,$toNativeArray($kindInt32,[-48,0,-48])),new II.ptr(11360,11361,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(11362,11362,$toNativeArray($kindInt32,[0,-10743,0])),new II.ptr(11363,11363,$toNativeArray($kindInt32,[0,-3814,0])),new II.ptr(11364,11364,$toNativeArray($kindInt32,[0,-10727,0])),new II.ptr(11365,11365,$toNativeArray($kindInt32,[-10795,0,-10795])),new II.ptr(11366,11366,$toNativeArray($kindInt32,[-10792,0,-10792])),new II.ptr(11367,11372,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(11373,11373,$toNativeArray($kindInt32,[0,-10780,0])),new II.ptr(11374,11374,$toNativeArray($kindInt32,[0,-10749,0])),new II.ptr(11375,11375,$toNativeArray($kindInt32,[0,-10783,0])),new II.ptr(11376,11376,$toNativeArray($kindInt32,[0,-10782,0])),new II.ptr(11378,11379,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(11381,11382,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(11390,11391,$toNativeArray($kindInt32,[0,-10815,0])),new II.ptr(11392,11491,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(11499,11502,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(11506,11507,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(11520,11557,$toNativeArray($kindInt32,[-7264,0,-7264])),new II.ptr(11559,11559,$toNativeArray($kindInt32,[-7264,0,-7264])),new II.ptr(11565,11565,$toNativeArray($kindInt32,[-7264,0,-7264])),new II.ptr(42560,42605,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42624,42651,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42786,42799,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42802,42863,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42873,42876,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42877,42877,$toNativeArray($kindInt32,[0,-35332,0])),new II.ptr(42878,42887,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42891,42892,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42893,42893,$toNativeArray($kindInt32,[0,-42280,0])),new II.ptr(42896,42899,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42900,42900,$toNativeArray($kindInt32,[48,0,48])),new II.ptr(42902,42921,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42922,42922,$toNativeArray($kindInt32,[0,-42308,0])),new II.ptr(42923,42923,$toNativeArray($kindInt32,[0,-42319,0])),new II.ptr(42924,42924,$toNativeArray($kindInt32,[0,-42315,0])),new II.ptr(42925,42925,$toNativeArray($kindInt32,[0,-42305,0])),new II.ptr(42926,42926,$toNativeArray($kindInt32,[0,-42308,0])),new II.ptr(42928,42928,$toNativeArray($kindInt32,[0,-42258,0])),new II.ptr(42929,42929,$toNativeArray($kindInt32,[0,-42282,0])),new II.ptr(42930,42930,$toNativeArray($kindInt32,[0,-42261,0])),new II.ptr(42931,42931,$toNativeArray($kindInt32,[0,928,0])),new II.ptr(42932,42943,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42946,42947,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42948,42948,$toNativeArray($kindInt32,[0,-48,0])),new II.ptr(42949,42949,$toNativeArray($kindInt32,[0,-42307,0])),new II.ptr(42950,42950,$toNativeArray($kindInt32,[0,-35384,0])),new II.ptr(42951,42954,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(42997,42998,$toNativeArray($kindInt32,[1114112,1114112,1114112])),new II.ptr(43859,43859,$toNativeArray($kindInt32,[-928,0,-928])),new II.ptr(43888,43967,$toNativeArray($kindInt32,[-38864,0,-38864])),new II.ptr(65313,65338,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(65345,65370,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(66560,66599,$toNativeArray($kindInt32,[0,40,0])),new II.ptr(66600,66639,$toNativeArray($kindInt32,[-40,0,-40])),new II.ptr(66736,66771,$toNativeArray($kindInt32,[0,40,0])),new II.ptr(66776,66811,$toNativeArray($kindInt32,[-40,0,-40])),new II.ptr(68736,68786,$toNativeArray($kindInt32,[0,64,0])),new II.ptr(68800,68850,$toNativeArray($kindInt32,[-64,0,-64])),new II.ptr(71840,71871,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(71872,71903,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(93760,93791,$toNativeArray($kindInt32,[0,32,0])),new II.ptr(93792,93823,$toNativeArray($kindInt32,[-32,0,-32])),new II.ptr(125184,125217,$toNativeArray($kindInt32,[0,34,0])),new II.ptr(125218,125251,$toNativeArray($kindInt32,[-34,0,-34]))]);$pkg.CaseRanges=HS;HT=$toNativeArray($kindUint8,[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,144,130,130,130,136,130,130,130,130,130,130,136,130,130,130,130,132,132,132,132,132,132,132,132,132,132,130,130,136,136,136,130,130,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,130,130,130,136,130,136,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,130,136,130,136,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,16,130,136,136,136,136,136,130,136,136,224,130,136,0,136,136,136,136,132,132,136,192,130,130,136,132,224,130,132,132,132,130,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,160,136,160,160,160,160,160,160,160,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,136,192,192,192,192,192,192,192,192]);$pkg.GraphicRanges=new JS([$pkg.L,$pkg.M,$pkg.N,$pkg.P,$pkg.S,$pkg.Zs]);$pkg.PrintRanges=new JS([$pkg.L,$pkg.M,$pkg.N,$pkg.P,$pkg.S]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["unicode/utf8"]=(function(){var $pkg={},$init,B,A,C,D,F,G,H,I,J,K,N,O,P,R,S;B=$pkg.acceptRange=$newType(0,$kindStruct,"utf8.acceptRange",true,"unicode/utf8",false,function(lo_,hi_){this.$val=this;if(arguments.length===0){this.lo=0;this.hi=0;return;}this.lo=lo_;this.hi=hi_;});D=function(a){var a,b,c,d,e,f;b=a.$length;if(b===0){return false;}d=(c=(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]),((c<0||c>=A.length)?($throwRuntimeError("index out of range"),undefined):A[c]));if(b>=((((d&7)>>>0)>>0))){return true;}f=$clone((e=d>>>4<<24>>>24,((e<0||e>=C.length)?($throwRuntimeError("index out of range"),undefined):C[e])),B);if(b>1&&((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1])=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]))){return true;}else if(b>2&&((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2])<128||191<(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]))){return true;}return false;};$pkg.FullRune=D;F=function(a){var a,aa,ab,ac,ad,ae,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;b=0;c=0;d=a.$length;if(d<1){e=65533;f=0;b=e;c=f;return[b,c];}g=(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]);h=((g<0||g>=A.length)?($throwRuntimeError("index out of range"),undefined):A[g]);if(h>=240){i=(((h>>0))<<31>>0)>>31>>0;j=(((((0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0])>>0))&~i)>>0)|(65533&i);k=1;b=j;c=k;return[b,c];}l=((((h&7)>>>0)>>0));n=$clone((m=h>>>4<<24>>>24,((m<0||m>=C.length)?($throwRuntimeError("index out of range"),undefined):C[m])),B);if(d=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]);if(q>>0)>>0))<<6>>0)|((((q&63)>>>0)>>0));u=2;b=t;c=u;return[b,c];}v=(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]);if(v<128||191>>0)>>0))<<12>>0)|(((((q&63)>>>0)>>0))<<6>>0))|((((v&63)>>>0)>>0));z=3;b=y;c=z;return[b,c];}aa=(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]);if(aa<128||191>>0)>>0))<<18>>0)|(((((q&63)>>>0)>>0))<<12>>0))|(((((v&63)>>>0)>>0))<<6>>0))|((((aa&63)>>>0)>>0));ae=4;b=ad;c=ae;return[b,c];};$pkg.DecodeRune=F;G=function(a){var a,aa,ab,ac,ad,ae,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;b=0;c=0;d=a.length;if(d<1){e=65533;f=0;b=e;c=f;return[b,c];}g=a.charCodeAt(0);h=((g<0||g>=A.length)?($throwRuntimeError("index out of range"),undefined):A[g]);if(h>=240){i=(((h>>0))<<31>>0)>>31>>0;j=((((a.charCodeAt(0)>>0))&~i)>>0)|(65533&i);k=1;b=j;c=k;return[b,c];}l=((((h&7)>>>0)>>0));n=$clone((m=h>>>4<<24>>>24,((m<0||m>=C.length)?($throwRuntimeError("index out of range"),undefined):C[m])),B);if(d>>0)>>0))<<6>>0)|((((q&63)>>>0)>>0));u=2;b=t;c=u;return[b,c];}v=a.charCodeAt(2);if(v<128||191>>0)>>0))<<12>>0)|(((((q&63)>>>0)>>0))<<6>>0))|((((v&63)>>>0)>>0));z=3;b=y;c=z;return[b,c];}aa=a.charCodeAt(3);if(aa<128||191>>0)>>0))<<18>>0)|(((((q&63)>>>0)>>0))<<12>>0))|(((((v&63)>>>0)>>0))<<6>>0))|((((aa&63)>>>0)>>0));ae=4;b=ad;c=ae;return[b,c];};$pkg.DecodeRuneInString=G;H=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=0;c=0;d=a.$length;if(d===0){e=65533;f=0;b=e;c=f;return[b,c];}g=d-1>>0;b=((((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g])>>0));if(b<128){h=b;i=1;b=h;c=i;return[b,c];}j=d-4>>0;if(j<0){j=0;}g=g-(1)>>0;while(true){if(!(g>=j)){break;}if(P(((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g]))){break;}g=g-(1)>>0;}if(g<0){g=0;}k=F($subslice(a,g,d));b=k[0];c=k[1];if(!(((g+c>>0)===d))){l=65533;m=1;b=l;c=m;return[b,c];}n=b;o=c;b=n;c=o;return[b,c];};$pkg.DecodeLastRune=H;I=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=0;c=0;d=a.length;if(d===0){e=65533;f=0;b=e;c=f;return[b,c];}g=d-1>>0;b=((a.charCodeAt(g)>>0));if(b<128){h=b;i=1;b=h;c=i;return[b,c];}j=d-4>>0;if(j<0){j=0;}g=g-(1)>>0;while(true){if(!(g>=j)){break;}if(P(a.charCodeAt(g))){break;}g=g-(1)>>0;}if(g<0){g=0;}k=G($substring(a,g,d));b=k[0];c=k[1];if(!(((g+c>>0)===d))){l=65533;m=1;b=l;c=m;return[b,c];}n=b;o=c;b=n;c=o;return[b,c];};$pkg.DecodeLastRuneInString=I;J=function(a){var a;if(a<0){return-1;}else if(a<=127){return 1;}else if(a<=2047){return 2;}else if(55296<=a&&a<=57343){return-1;}else if(a<=65535){return 3;}else if(a<=1114111){return 4;}return-1;};$pkg.RuneLen=J;K=function(a,b){var a,b,c;c=((b>>>0));if(c<=127){(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((b<<24>>>24)));return 1;}else if(c<=2047){$unused((1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((192|(((b>>6>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 2;}else if((c>1114111)||(55296<=c&&c<=57343)){b=65533;$unused((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((224|(((b>>12>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|(((((b>>6>>0)<<24>>>24))&63)>>>0))>>>0));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 3;}else if(c<=65535){$unused((2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((224|(((b>>12>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|(((((b>>6>>0)<<24>>>24))&63)>>>0))>>>0));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 3;}else{$unused((3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]));(0>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+0]=((240|(((b>>18>>0)<<24>>>24)))>>>0));(1>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+1]=((128|(((((b>>12>>0)<<24>>>24))&63)>>>0))>>>0));(2>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+2]=((128|(((((b>>6>>0)<<24>>>24))&63)>>>0))>>>0));(3>=a.$length?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+3]=((128|((((b<<24>>>24))&63)>>>0))>>>0));return 4;}};$pkg.EncodeRune=K;N=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o;b=a.$length;c=0;d=0;while(true){if(!(d>0;e=((d<0||d>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+d]);if(e<128){d=d+(1)>>0;continue;}f=((e<0||e>=A.length)?($throwRuntimeError("index out of range"),undefined):A[e]);if(f===241){d=d+(1)>>0;continue;}g=((((f&7)>>>0)>>0));if((d+g>>0)>b){d=d+(1)>>0;continue;}i=$clone((h=f>>>4<<24>>>24,((h<0||h>=C.length)?($throwRuntimeError("index out of range"),undefined):C[h])),B);k=(j=d+1>>0,((j<0||j>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+j]));if(k>0,((l<0||l>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+l]));if(m<128||191>0,((n<0||n>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+n]));if(o<128||191>0;}return c;};$pkg.RuneCount=N;O=function(a){var a,b,c,d,e,f,g,h,i,j,k,l;b=0;c=a.length;d=0;while(true){if(!(d>0;b=b+(1)>>0;continue;}f=((e<0||e>=A.length)?($throwRuntimeError("index out of range"),undefined):A[e]);if(f===241){d=d+(1)>>0;b=b+(1)>>0;continue;}g=((((f&7)>>>0)>>0));if((d+g>>0)>c){d=d+(1)>>0;b=b+(1)>>0;continue;}i=$clone((h=f>>>4<<24>>>24,((h<0||h>=C.length)?($throwRuntimeError("index out of range"),undefined):C[h])),B);j=a.charCodeAt((d+1>>0));if(j>0));if(k<128||191>0));if(l<128||191>0;b=b+(1)>>0;}b=b;return b;};$pkg.RuneCountInString=O;P=function(a){var a;return!((((a&192)>>>0)===128));};$pkg.RuneStart=P;R=function(a){var a,b,c,d,e,f,g,h,i,j,k,l,m;while(true){if(!(a.length>=8)){break;}b=(((((((a.charCodeAt(0)>>>0))|(((a.charCodeAt(1)>>>0))<<8>>>0))>>>0)|(((a.charCodeAt(2)>>>0))<<16>>>0))>>>0)|(((a.charCodeAt(3)>>>0))<<24>>>0))>>>0;c=(((((((a.charCodeAt(4)>>>0))|(((a.charCodeAt(5)>>>0))<<8>>>0))>>>0)|(((a.charCodeAt(6)>>>0))<<16>>>0))>>>0)|(((a.charCodeAt(7)>>>0))<<24>>>0))>>>0;if(!(((((((b|c)>>>0))&2155905152)>>>0)===0))){break;}a=$substring(a,8);}d=a.length;e=0;while(true){if(!(e>0;continue;}g=((f<0||f>=A.length)?($throwRuntimeError("index out of range"),undefined):A[f]);if(g===241){return false;}h=((((g&7)>>>0)>>0));if((e+h>>0)>d){return false;}j=$clone((i=g>>>4<<24>>>24,((i<0||i>=C.length)?($throwRuntimeError("index out of range"),undefined):C[i])),B);k=a.charCodeAt((e+1>>0));if(k>0));if(l<128||191>0));if(m<128||191>0;}return true;};$pkg.ValidString=R;S=function(a){var a;if(0<=a&&a<55296){return true;}else if(57343f.$high||(e.$high===f.$high&&e.$low>=f.$low)))){return 0;}return(((g=(h=(new $Int64(0,d.s.$length)),i=d.i,new $Int64(h.$high-i.$high,h.$low-i.$low)),g.$low+((g.$high>>31)*4294967296))>>0));};F.prototype.Len=function(){return this.$val.Len();};F.ptr.prototype.Size=function(){var d;d=this;return(new $Int64(0,d.s.$length));};F.prototype.Size=function(){return this.$val.Size();};F.ptr.prototype.Read=function(d){var d,e,f,g,h,i,j,k,l,m;e=0;f=$ifaceNil;g=this;if((h=g.i,i=(new $Int64(0,g.s.$length)),(h.$high>i.$high||(h.$high===i.$high&&h.$low>=i.$low)))){j=0;k=B.EOF;e=j;f=k;return[e,f];}g.prevRune=-1;e=$copySlice(d,$subslice(g.s,$flatten64(g.i)));g.i=(l=g.i,m=(new $Int64(0,e)),new $Int64(l.$high+m.$high,l.$low+m.$low));return[e,f];};F.prototype.Read=function(d){return this.$val.Read(d);};F.ptr.prototype.ReadAt=function(d,e){var d,e,f,g,h,i,j,k,l,m;f=0;g=$ifaceNil;h=this;if((e.$high<0||(e.$high===0&&e.$low<0))){i=0;j=A.New("bytes.Reader.ReadAt: negative offset");f=i;g=j;return[f,g];}if((k=(new $Int64(0,h.s.$length)),(e.$high>k.$high||(e.$high===k.$high&&e.$low>=k.$low)))){l=0;m=B.EOF;f=l;g=m;return[f,g];}f=$copySlice(d,$subslice(h.s,$flatten64(e)));if(ff.$high||(e.$high===f.$high&&e.$low>=f.$low)))){return[0,B.EOF];}i=(g=d.s,h=d.i,(($flatten64(h)<0||$flatten64(h)>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+$flatten64(h)]));d.i=(j=d.i,k=new $Int64(0,1),new $Int64(j.$high+k.$high,j.$low+k.$low));return[i,$ifaceNil];};F.prototype.ReadByte=function(){return this.$val.ReadByte();};F.ptr.prototype.UnreadByte=function(){var d,e,f,g;d=this;if((e=d.i,(e.$high<0||(e.$high===0&&e.$low<=0)))){return A.New("bytes.Reader.UnreadByte: at beginning of slice");}d.prevRune=-1;d.i=(f=d.i,g=new $Int64(0,1),new $Int64(f.$high-g.$high,f.$low-g.$low));return $ifaceNil;};F.prototype.UnreadByte=function(){return this.$val.UnreadByte();};F.ptr.prototype.ReadRune=function(){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;d=0;e=0;f=$ifaceNil;g=this;if((h=g.i,i=(new $Int64(0,g.s.$length)),(h.$high>i.$high||(h.$high===i.$high&&h.$low>=i.$low)))){g.prevRune=-1;j=0;k=0;l=B.EOF;d=j;e=k;f=l;return[d,e,f];}g.prevRune=(((m=g.i,m.$low+((m.$high>>31)*4294967296))>>0));p=(n=g.s,o=g.i,(($flatten64(o)<0||$flatten64(o)>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+$flatten64(o)]));if(p<128){g.i=(q=g.i,r=new $Int64(0,1),new $Int64(q.$high+r.$high,q.$low+r.$low));s=((p>>0));t=1;u=$ifaceNil;d=s;e=t;f=u;return[d,e,f];}v=C.DecodeRune($subslice(g.s,$flatten64(g.i)));d=v[0];e=v[1];g.i=(w=g.i,x=(new $Int64(0,e)),new $Int64(w.$high+x.$high,w.$low+x.$low));return[d,e,f];};F.prototype.ReadRune=function(){return this.$val.ReadRune();};F.ptr.prototype.UnreadRune=function(){var d,e;d=this;if((e=d.i,(e.$high<0||(e.$high===0&&e.$low<=0)))){return A.New("bytes.Reader.UnreadRune: at beginning of slice");}if(d.prevRune<0){return A.New("bytes.Reader.UnreadRune: previous operation was not ReadRune");}d.i=(new $Int64(0,d.prevRune));d.prevRune=-1;return $ifaceNil;};F.prototype.UnreadRune=function(){return this.$val.UnreadRune();};F.ptr.prototype.Seek=function(d,e){var d,e,f,g,h,i,j;f=this;f.prevRune=-1;g=new $Int64(0,0);h=e;if(h===(0)){g=d;}else if(h===(1)){g=(i=f.i,new $Int64(i.$high+d.$high,i.$low+d.$low));}else if(h===(2)){g=(j=(new $Int64(0,f.s.$length)),new $Int64(j.$high+d.$high,j.$low+d.$low));}else{return[new $Int64(0,0),A.New("bytes.Reader.Seek: invalid whence")];}if((g.$high<0||(g.$high===0&&g.$low<0))){return[new $Int64(0,0),A.New("bytes.Reader.Seek: negative position")];}f.i=g;return[g,$ifaceNil];};F.prototype.Seek=function(d,e){return this.$val.Seek(d,e);};F.ptr.prototype.WriteTo=function(d){var{d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;g.prevRune=-1;if((h=g.i,i=(new $Int64(0,g.s.$length)),(h.$high>i.$high||(h.$high===i.$high&&h.$low>=i.$low)))){j=new $Int64(0,0);k=$ifaceNil;e=j;f=k;$s=-1;return[e,f];}l=$subslice(g.s,$flatten64(g.i));n=d.Write(l);$s=1;case 1:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}m=n;o=m[0];f=m[1];if(o>l.$length){$panic(new $String("bytes.Reader.WriteTo: invalid Write count"));}g.i=(p=g.i,q=(new $Int64(0,o)),new $Int64(p.$high+q.$high,p.$low+q.$low));e=(new $Int64(0,o));if(!((o===l.$length))&&$interfaceIsEqual(f,$ifaceNil)){f=B.ErrShortWrite;}$s=-1;return[e,f];}return;}var $f={$blk:F.ptr.prototype.WriteTo,$c:true,$r,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s};return $f;};F.prototype.WriteTo=function(d){return this.$val.WriteTo(d);};F.ptr.prototype.Reset=function(d){var d,e;e=this;F.copy(e,new F.ptr(d,new $Int64(0,0),-1));};F.prototype.Reset=function(d){return this.$val.Reset(d);};G=function(d){var d;return new F.ptr(d,new $Int64(0,0),-1);};$pkg.NewReader=G;H=function(d,e){var d,e,f,g,h,i;f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(i===e){return h;}g++;}return-1;};$pkg.IndexByte=H;I=function(d,e){var d,e,f,g,h,i;if(!((d.$length===e.$length))){return false;}f=d;g=0;while(true){if(!(g=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+g]);if(!((i===((h<0||h>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+h])))){return false;}g++;}return true;};$pkg.Equal=I;L=function(d,e){var d,e,f,g;if(e.$length===0){return C.RuneCount(d)+1>>0;}if(e.$length===1){return D.Count(d,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]));}f=0;while(true){g=BR(d,e);if(g===-1){return f;}f=f+(1)>>0;d=$subslice(d,(g+e.$length>>0));}};$pkg.Count=L;M=function(d,e){var d,e;return!((BR(d,e)===-1));};$pkg.Contains=M;Q=function(d,e){var d,e,f,g,h,i,j,k,l,m,n;f=e.$length;if((f===0)){return d.$length;}else if((f===1)){return R(d,(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]));}else if((f===d.$length)){if(I(d,e)){return 0;}return-1;}else if(f>d.$length){return-1;}g=D.HashStrRevBytes(e);h=g[0];i=g[1];j=d.$length-f>>0;k=0;l=d.$length-1>>0;while(true){if(!(l>=j)){break;}k=($imul(k,16777619)>>>0)+((((l<0||l>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+l])>>>0))>>>0;l=l-(1)>>0;}if((k===h)&&I($subslice(d,j),e)){return j;}m=j-1>>0;while(true){if(!(m>=0)){break;}k=$imul(k,(16777619))>>>0;k=k+(((((m<0||m>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+m])>>>0)))>>>0;k=k-(($imul(i,(((n=m+f>>0,((n<0||n>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+n]))>>>0)))>>>0))>>>0;if((k===h)&&I($subslice(d,m,(m+f>>0)),e)){return m;}m=m-(1)>>0;}return-1;};$pkg.LastIndex=Q;R=function(d,e){var d,e,f;f=d.$length-1>>0;while(true){if(!(f>=0)){break;}if(((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])===e){return f;}f=f-(1)>>0;}return-1;};$pkg.LastIndexByte=R;S=function(d,e){var d,e,f,g,h,i,j,k;if(0<=e&&e<128){return H(d,((e<<24>>>24)));}else if((e===65533)){f=0;while(true){if(!(f>0;}return-1;}else if(!C.ValidRune(e)){return-1;}else{j=CC.zero();k=C.EncodeRune(new CA(j),e);return BR(d,$subslice(new CA(j),0,k));}};$pkg.IndexRune=S;T=function(d,e){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y;if(e===""){return-1;}if(d.$length===1){f=(((0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])>>0));if(f>=128){g=e;h=0;while(true){if(!(h=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0]))>=0){return 0;}return-1;}if(e.length===1){j=((e.charCodeAt(0)>>0));if(j>=128){j=65533;}return S(d,j);}if(d.$length>8){k=BB(e);l=$clone(k[0],BA);m=k[1];if(m){n=d;o=0;while(true){if(!(o=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]);if(new CD(l).contains(q)){return p;}o++;}return-1;}}r=0;s=0;while(true){if(!(s=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+s])>>0));if(t<128){if(D.IndexByteString(e,((s<0||s>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+s]))>=0){return s;}r=1;s=s+(r)>>0;continue;}u=C.DecodeRune($subslice(d,s));t=u[0];r=u[1];if(!((t===65533))){if(e.length===r){if(e===($encodeRune(t))){return s;}s=s+(r)>>0;continue;}if(D.MaxLen>=r){if(D.IndexString(e,($encodeRune(t)))>=0){return s;}s=s+(r)>>0;continue;}}v=e;w=0;while(true){if(!(w>0;}return-1;};$pkg.IndexAny=T;AE=function(d,e){var d,e;return d.$length>=e.$length&&I($subslice(d,0,e.$length),e);};$pkg.HasPrefix=AE;AR=function(d,e){var{d,e,f,g,$s,$r,$c}=$restore(this,{d,e});$s=$s||0;s:while(true){switch($s){case 0:f=AY(d,e,false);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(g===-1){$s=-1;return CA.nil;}$s=-1;return $subslice(d,g);}return;}var $f={$blk:AR,$c:true,$r,d,e,f,g,$s};return $f;};$pkg.TrimLeftFunc=AR;AS=function(d,e){var{d,e,f,g,h,i,$s,$r,$c}=$restore(this,{d,e});$s=$s||0;s:while(true){switch($s){case 0:f=AZ(d,e,false);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;if(g>=0&&((g<0||g>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+g])>=128){h=C.DecodeRune($subslice(d,g));i=h[1];g=g+(i)>>0;}else{g=g+(1)>>0;}$s=-1;return $subslice(d,0,g);}return;}var $f={$blk:AS,$c:true,$r,d,e,f,g,h,i,$s};return $f;};$pkg.TrimRightFunc=AS;AT=function(d,e){var{d,e,f,g,h,$s,$r,$c}=$restore(this,{d,e});$s=$s||0;s:while(true){switch($s){case 0:f=AR(d,e);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=AS(f,e);$s=2;case 2:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;$s=3;case 3:return h;}return;}var $f={$blk:AT,$c:true,$r,d,e,f,g,h,$s};return $f;};$pkg.TrimFunc=AT;AY=function(d,e,f){var{d,e,f,g,h,i,j,k,$s,$r,$c}=$restore(this,{d,e,f});$s=$s||0;s:while(true){switch($s){case 0:g=0;case 1:if(!(g=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+g])>>0));if(i>=128){j=C.DecodeRune($subslice(d,g));i=j[0];h=j[1];}k=e(i);$s=5;case 5:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}if(k===f){$s=3;continue;}$s=4;continue;case 3:$s=-1;return g;case 4:g=g+(h)>>0;$s=1;continue;case 2:$s=-1;return-1;}return;}var $f={$blk:AY,$c:true,$r,d,e,f,g,h,i,j,k,$s};return $f;};AZ=function(d,e,f){var{d,e,f,g,h,i,j,k,l,m,n,$s,$r,$c}=$restore(this,{d,e,f});$s=$s||0;s:while(true){switch($s){case 0:g=d.$length;case 1:if(!(g>0)){$s=2;continue;}h=(((i=g-1>>0,((i<0||i>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i]))>>0));j=1;k=h;l=j;if(k>=128){m=C.DecodeLastRune($subslice(d,0,g));k=m[0];l=m[1];}g=g-(l)>>0;n=e(k);$s=5;case 5:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}if(n===f){$s=3;continue;}$s=4;continue;case 3:$s=-1;return g;case 4:$s=1;continue;case 2:$s=-1;return-1;}return;}var $f={$blk:AZ,$c:true,$r,d,e,f,g,h,i,j,k,l,m,n,$s};return $f;};BB=function(d){var d,e,f,g,h,i,j,k,l,m,n,o,p;e=CG.zero();f=false;g=0;while(true){if(!(g=128){i=$clone(e,BA);j=false;BA.copy(e,i);f=j;return[e,f];}l=(k=h/32,(k===k&&k!==1/0&&k!==-1/0)?k>>>0:$throwRuntimeError("integer divide by zero"));((l<0||l>=e.length)?($throwRuntimeError("index out of range"),undefined):e[l]=((((l<0||l>=e.length)?($throwRuntimeError("index out of range"),undefined):e[l])|(((m=((n=h%32,n===n?n:$throwRuntimeError("integer divide by zero"))),m<32?(1<>>0)))>>>0));g=g+(1)>>0;}o=$clone(e,BA);p=true;BA.copy(e,o);f=p;return[e,f];};BA.prototype.contains=function(d){var d,e,f,g,h,i,j;e=this.$val;return!((((((f=e,g=(h=d/32,(h===h&&h!==1/0&&h!==-1/0)?h>>>0:$throwRuntimeError("integer divide by zero")),((g<0||g>=f.length)?($throwRuntimeError("index out of range"),undefined):f[g]))&(((i=((j=d%32,j===j?j:$throwRuntimeError("integer divide by zero"))),i<32?(1<>>0)))>>>0))===0));};$ptrType(BA).prototype.contains=function(d){return(new BA(this.$get())).contains(d);};BC=function(d,e){var d,e,f,g,h,i;f=d;g=0;while(true){if(!(g0&&((f=d.$length-1>>0,((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f]))===e))){break;}d=$subslice(d,0,(d.$length-1>>0));}return d;};BK=function(d,e){var d,e,f;while(true){if(!(d.$length>0)){break;}if(!new CD(e).contains((f=d.$length-1>>0,((f<0||f>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+f])))){break;}d=$subslice(d,0,(d.$length-1>>0));}return d;};BL=function(d,e){var d,e,f,g,h,i,j,k;while(true){if(!(d.$length>0)){break;}f=(((g=d.$length-1>>0,((g<0||g>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+g]))>>0));h=1;i=f;j=h;if(i>=128){k=C.DecodeLastRune(d);i=k[0];j=k[1];}if(!BC(e,i)){break;}d=$subslice(d,0,(d.$length-j>>0));}return d;};BM=function(d){var{d,e,f,g,h,i,j,k,l,m,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=0;case 1:if(!(e=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+e]);if(f>=128){$s=3;continue;}$s=4;continue;case 3:g=AT($subslice(d,e),E.IsSpace);$s=5;case 5:if($c){$c=false;g=g.$blk();}if(g&&g.$blk!==undefined){break s;}h=g;$s=6;case 6:return h;case 4:if(((f<0||f>=AA.length)?($throwRuntimeError("index out of range"),undefined):AA[f])===0){$s=2;continue;}e=e+(1)>>0;$s=1;continue;case 2:i=d.$length;case 7:if(!(i>e)){$s=8;continue;}k=(j=i-1>>0,((j<0||j>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+j]));if(k>=128){$s=9;continue;}$s=10;continue;case 9:l=AT($subslice(d,e,i),E.IsSpace);$s=11;case 11:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}m=l;$s=12;case 12:return m;case 10:if(((k<0||k>=AA.length)?($throwRuntimeError("index out of range"),undefined):AA[k])===0){$s=8;continue;}i=i-(1)>>0;$s=7;continue;case 8:if(e===i){$s=-1;return CA.nil;}$s=-1;return $subslice(d,e,i);}return;}var $f={$blk:BM,$c:true,$r,d,e,f,g,h,i,j,k,l,m,$s};return $f;};$pkg.TrimSpace=BM;BO=function(d,e,f,g){var d,e,f,g,h,i,j,k,l,m,n,o;h=0;if(!((g===0))){h=L(d,e);}if(h===0){return $appendSlice((CA.nil),d);}if(g<0||h>0))))>>0));j=0;k=0;l=0;while(true){if(!(l0){n=C.DecodeRune($subslice(d,k));o=n[1];m=m+(o)>>0;}}else{m=m+(BR($subslice(d,k),e))>>0;}j=j+($copySlice($subslice(i,j),$subslice(d,k,m)))>>0;j=j+($copySlice($subslice(i,j),f))>>0;k=m+e.$length>>0;l=l+(1)>>0;}j=j+($copySlice($subslice(i,j),$subslice(d,k)))>>0;return $subslice(i,0,j);};$pkg.Replace=BO;BQ=function(d,e){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;while(true){if(!(!((d.$length===0))&&!((e.$length===0)))){break;}f=0;g=0;h=f;i=g;if((0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])<128){j=(((0>=d.$length?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+0])>>0));k=$subslice(d,1);h=j;d=k;}else{l=C.DecodeRune(d);m=l[0];n=l[1];o=m;p=$subslice(d,n);h=o;d=p;}if((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])<128){q=(((0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0])>>0));r=$subslice(e,1);i=q;e=r;}else{s=C.DecodeRune(e);t=s[0];u=s[1];v=t;w=$subslice(e,u);i=v;e=w;}if(i===h){continue;}if(i>0)-65>>0))){continue;}return false;}z=E.SimpleFold(h);while(true){if(!(!((z===h))&&z=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]));}else if((f===d.$length)){if(I(e,d)){return 0;}return-1;}else if(f>d.$length){return-1;}else if(f<=D.MaxLen){if(d.$length<=0){return D.Index(d,e);}g=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]);h=(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1]);i=0;j=(d.$length-f>>0)+1>>0;k=0;while(true){if(!(i=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+i])===g))){l=H($subslice(d,(i+1>>0),j),g);if(l<0){return-1;}i=i+((l+1>>0))>>0;}if(((m=i+1>>0,((m<0||m>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+m]))===h)&&I($subslice(d,i,(i+f>>0)),e)){return i;}k=k+(1)>>0;i=i+(1)>>0;if(k>D.Cutover(i)){n=D.Index($subslice(d,i),e);if(n>=0){return n+i>>0;}return-1;}}return-1;}o=(0>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+0]);p=(1>=e.$length?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+1]);q=0;r=0;s=(d.$length-f>>0)+1>>0;while(true){if(!(q=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+q])===o))){t=H($subslice(d,(q+1>>0),s),o);if(t<0){break;}q=q+((t+1>>0))>>0;}if(((u=q+1>>0,((u<0||u>=d.$length)?($throwRuntimeError("index out of range"),undefined):d.$array[d.$offset+u]))===p)&&I($subslice(d,q,(q+f>>0)),e)){return q;}q=q+(1)>>0;r=r+(1)>>0;if(r>=(4+(q>>4>>0)>>0)&&q>0;}}return-1;};$pkg.Index=BR;BS=function(d,e){var d,e,f,g,h,i,j,k,l,m,n,o;f=CA.nil;g=CA.nil;h=false;i=BR(d,e);if(i>=0){j=$subslice(d,0,i);k=$subslice(d,(i+e.$length>>0));l=true;f=j;g=k;h=l;return[f,g,h];}m=d;n=CA.nil;o=false;f=m;g=n;h=o;return[f,g,h];};$pkg.Cut=BS;BT.ptr.prototype.Bytes=function(){var d;d=this;return $subslice(d.buf,d.off);};BT.prototype.Bytes=function(){return this.$val.Bytes();};BT.ptr.prototype.String=function(){var d;d=this;if(d===CI.nil){return"";}return($bytesToString($subslice(d.buf,d.off)));};BT.prototype.String=function(){return this.$val.String();};BT.ptr.prototype.empty=function(){var d;d=this;return d.buf.$length<=d.off;};BT.prototype.empty=function(){return this.$val.empty();};BT.ptr.prototype.Len=function(){var d;d=this;return d.buf.$length-d.off>>0;};BT.prototype.Len=function(){return this.$val.Len();};BT.ptr.prototype.Cap=function(){var d;d=this;return d.buf.$capacity;};BT.prototype.Cap=function(){return this.$val.Cap();};BT.ptr.prototype.Truncate=function(d){var d,e;e=this;if(d===0){e.Reset();return;}e.lastRead=0;if(d<0||d>e.Len()){$panic(new $String("bytes.Buffer: truncation out of range"));}e.buf=$subslice(e.buf,0,(e.off+d>>0));};BT.prototype.Truncate=function(d){return this.$val.Truncate(d);};BT.ptr.prototype.Reset=function(){var d;d=this;d.buf=$subslice(d.buf,0,0);d.off=0;d.lastRead=0;};BT.prototype.Reset=function(){return this.$val.Reset();};BT.ptr.prototype.tryGrowByReslice=function(d){var d,e,f;e=this;f=e.buf.$length;if(d<=(e.buf.$capacity-f>>0)){e.buf=$subslice(e.buf,0,(f+d>>0));return[f,true];}return[0,false];};BT.prototype.tryGrowByReslice=function(d){return this.$val.tryGrowByReslice(d);};BT.ptr.prototype.grow=function(d){var{d,e,f,g,h,i,j,k,l,m,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=this;f=e.Len();if((f===0)&&!((e.off===0))){e.Reset();}g=e.tryGrowByReslice(d);h=g[0];i=g[1];if(i){$s=-1;return h;}if(e.buf===CA.nil&&d<=64){e.buf=$makeSlice(CA,d,64);$s=-1;return 0;}j=e.buf.$capacity;if(d<=((k=j/2,(k===k&&k!==1/0&&k!==-1/0)?k>>0:$throwRuntimeError("integer divide by zero"))-f>>0)){$s=1;continue;}if(j>((2147483647-j>>0)-d>>0)){$s=2;continue;}$s=3;continue;case 1:$copySlice(e.buf,$subslice(e.buf,e.off));$s=4;continue;case 2:$panic($pkg.ErrTooLarge);$s=4;continue;case 3:l=BW(($imul(2,j))+d>>0);$s=5;case 5:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}m=l;$copySlice(m,$subslice(e.buf,e.off));e.buf=m;case 4:e.off=0;e.buf=$subslice(e.buf,0,(f+d>>0));$s=-1;return f;}return;}var $f={$blk:BT.ptr.prototype.grow,$c:true,$r,d,e,f,g,h,i,j,k,l,m,$s};return $f;};BT.prototype.grow=function(d){return this.$val.grow(d);};BT.ptr.prototype.Grow=function(d){var{d,e,f,g,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=this;if(d<0){$panic(new $String("bytes.Buffer.Grow: negative count"));}f=e.grow(d);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}g=f;e.buf=$subslice(e.buf,0,g);$s=-1;return;}return;}var $f={$blk:BT.ptr.prototype.Grow,$c:true,$r,d,e,f,g,$s};return $f;};BT.prototype.Grow=function(d){return this.$val.Grow(d);};BT.ptr.prototype.Write=function(d){var{d,e,f,g,h,i,j,k,l,m,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=this;g.lastRead=0;h=g.tryGrowByReslice(d.$length);i=h[0];j=h[1];if(!j){$s=1;continue;}$s=2;continue;case 1:k=g.grow(d.$length);$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}i=k;case 2:l=$copySlice($subslice(g.buf,i),d);m=$ifaceNil;e=l;f=m;$s=-1;return[e,f];}return;}var $f={$blk:BT.ptr.prototype.Write,$c:true,$r,d,e,f,g,h,i,j,k,l,m,$s};return $f;};BT.prototype.Write=function(d){return this.$val.Write(d);};BT.ptr.prototype.WriteString=function(d){var{d,e,f,g,h,i,j,k,l,m,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=this;g.lastRead=0;h=g.tryGrowByReslice(d.length);i=h[0];j=h[1];if(!j){$s=1;continue;}$s=2;continue;case 1:k=g.grow(d.length);$s=3;case 3:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}i=k;case 2:l=$copyString($subslice(g.buf,i),d);m=$ifaceNil;e=l;f=m;$s=-1;return[e,f];}return;}var $f={$blk:BT.ptr.prototype.WriteString,$c:true,$r,d,e,f,g,h,i,j,k,l,m,$s};return $f;};BT.prototype.WriteString=function(d){return this.$val.WriteString(d);};BT.ptr.prototype.ReadFrom=function(d){var{d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;g.lastRead=0;case 1:h=g.grow(512);$s=3;case 3:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;g.buf=$subslice(g.buf,0,i);k=d.Read($subslice(g.buf,i,g.buf.$capacity));$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;l=j[0];m=j[1];if(l<0){$panic(BV);}g.buf=$subslice(g.buf,0,(i+l>>0));e=(n=(new $Int64(0,l)),new $Int64(e.$high+n.$high,e.$low+n.$low));if($interfaceIsEqual(m,B.EOF)){o=e;p=$ifaceNil;e=o;f=p;$s=-1;return[e,f];}if(!($interfaceIsEqual(m,$ifaceNil))){q=e;r=m;e=q;f=r;$s=-1;return[e,f];}$s=1;continue;case 2:$s=-1;return[e,f];}return;}var $f={$blk:BT.ptr.prototype.ReadFrom,$c:true,$r,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s};return $f;};BT.prototype.ReadFrom=function(d){return this.$val.ReadFrom(d);};BW=function(d){var{d,e,$s,$deferred,$r,$c}=$restore(this,{d});$s=$s||0;var $err=null;try{s:while(true){switch($s){case 0:$deferred=[];$curGoroutine.deferStack.push($deferred);$deferred.push([(function(){if(!($interfaceIsEqual($recover(),$ifaceNil))){$panic($pkg.ErrTooLarge);}}),[]]);e=$makeSlice(CA,d);$s=1;case 1:return e;}return;}}catch(err){$err=err;$s=-1;return CA.nil;}finally{$callDeferred($deferred,$err);if($curGoroutine.asleep){var $f={$blk:BW,$c:true,$r,d,e,$s,$deferred};return $f;}}};BT.ptr.prototype.WriteTo=function(d){var{d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=new $Int64(0,0);f=$ifaceNil;g=this;g.lastRead=0;h=g.Len();if(h>0){$s=1;continue;}$s=2;continue;case 1:j=d.Write($subslice(g.buf,g.off));$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;k=i[0];l=i[1];if(k>h){$panic(new $String("bytes.Buffer.WriteTo: invalid Write count"));}g.off=g.off+(k)>>0;e=(new $Int64(0,k));if(!($interfaceIsEqual(l,$ifaceNil))){m=e;n=l;e=m;f=n;$s=-1;return[e,f];}if(!((k===h))){o=e;p=B.ErrShortWrite;e=o;f=p;$s=-1;return[e,f];}case 2:g.Reset();q=e;r=$ifaceNil;e=q;f=r;$s=-1;return[e,f];}return;}var $f={$blk:BT.ptr.prototype.WriteTo,$c:true,$r,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,$s};return $f;};BT.prototype.WriteTo=function(d){return this.$val.WriteTo(d);};BT.ptr.prototype.WriteByte=function(d){var{d,e,f,g,h,i,j,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=this;e.lastRead=0;f=e.tryGrowByReslice(1);g=f[0];h=f[1];if(!h){$s=1;continue;}$s=2;continue;case 1:i=e.grow(1);$s=3;case 3:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}g=i;case 2:(j=e.buf,((g<0||g>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+g]=d));$s=-1;return $ifaceNil;}return;}var $f={$blk:BT.ptr.prototype.WriteByte,$c:true,$r,d,e,f,g,h,i,j,$s};return $f;};BT.prototype.WriteByte=function(d){return this.$val.WriteByte(d);};BT.ptr.prototype.WriteRune=function(d){var{d,e,f,g,h,i,j,k,l,m,n,o,p,$s,$r,$c}=$restore(this,{d});$s=$s||0;s:while(true){switch($s){case 0:e=0;f=$ifaceNil;g=this;if(((d>>>0))<128){$s=1;continue;}$s=2;continue;case 1:h=g.WriteByte(((d<<24>>>24)));$s=3;case 3:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}h;i=1;j=$ifaceNil;e=i;f=j;$s=-1;return[e,f];case 2:g.lastRead=0;k=g.tryGrowByReslice(4);l=k[0];m=k[1];if(!m){$s=4;continue;}$s=5;continue;case 4:n=g.grow(4);$s=6;case 6:if($c){$c=false;n=n.$blk();}if(n&&n.$blk!==undefined){break s;}l=n;case 5:e=C.EncodeRune($subslice(g.buf,l,(l+4>>0)),d);g.buf=$subslice(g.buf,0,(l+e>>0));o=e;p=$ifaceNil;e=o;f=p;$s=-1;return[e,f];}return;}var $f={$blk:BT.ptr.prototype.WriteRune,$c:true,$r,d,e,f,g,h,i,j,k,l,m,n,o,p,$s};return $f;};BT.prototype.WriteRune=function(d){return this.$val.WriteRune(d);};BT.ptr.prototype.Read=function(d){var d,e,f,g,h,i,j,k,l,m;e=0;f=$ifaceNil;g=this;g.lastRead=0;if(g.empty()){g.Reset();if(d.$length===0){h=0;i=$ifaceNil;e=h;f=i;return[e,f];}j=0;k=B.EOF;e=j;f=k;return[e,f];}e=$copySlice(d,$subslice(g.buf,g.off));g.off=g.off+(e)>>0;if(e>0){g.lastRead=-1;}l=e;m=$ifaceNil;e=l;f=m;return[e,f];};BT.prototype.Read=function(d){return this.$val.Read(d);};BT.ptr.prototype.Next=function(d){var d,e,f,g;e=this;e.lastRead=0;f=e.Len();if(d>f){d=f;}g=$subslice(e.buf,e.off,(e.off+d>>0));e.off=e.off+(d)>>0;if(d>0){e.lastRead=-1;}return g;};BT.prototype.Next=function(d){return this.$val.Next(d);};BT.ptr.prototype.ReadByte=function(){var d,e,f,g;d=this;if(d.empty()){d.Reset();return[0,B.EOF];}g=(e=d.buf,f=d.off,((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]));d.off=d.off+(1)>>0;d.lastRead=-1;return[g,$ifaceNil];};BT.prototype.ReadByte=function(){return this.$val.ReadByte();};BT.ptr.prototype.ReadRune=function(){var d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;d=0;e=0;f=$ifaceNil;g=this;if(g.empty()){g.Reset();h=0;i=0;j=B.EOF;d=h;e=i;f=j;return[d,e,f];}m=(k=g.buf,l=g.off,((l<0||l>=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+l]));if(m<128){g.off=g.off+(1)>>0;g.lastRead=1;n=((m>>0));o=1;p=$ifaceNil;d=n;e=o;f=p;return[d,e,f];}q=C.DecodeRune($subslice(g.buf,g.off));d=q[0];r=q[1];g.off=g.off+(r)>>0;g.lastRead=((r<<24>>24));s=d;t=r;u=$ifaceNil;d=s;e=t;f=u;return[d,e,f];};BT.prototype.ReadRune=function(){return this.$val.ReadRune();};BT.ptr.prototype.UnreadRune=function(){var d;d=this;if(d.lastRead<=0){return A.New("bytes.Buffer: UnreadRune: previous operation was not a successful ReadRune");}if(d.off>=((d.lastRead>>0))){d.off=d.off-(((d.lastRead>>0)))>>0;}d.lastRead=0;return $ifaceNil;};BT.prototype.UnreadRune=function(){return this.$val.UnreadRune();};BT.ptr.prototype.UnreadByte=function(){var d;d=this;if(d.lastRead===0){return BX;}d.lastRead=0;if(d.off>0){d.off=d.off-(1)>>0;}return $ifaceNil;};BT.prototype.UnreadByte=function(){return this.$val.UnreadByte();};BT.ptr.prototype.ReadBytes=function(d){var d,e,f,g,h,i,j,k;e=CA.nil;f=$ifaceNil;g=this;h=g.readSlice(d);i=h[0];f=h[1];e=$appendSlice(e,i);j=e;k=f;e=j;f=k;return[e,f];};BT.prototype.ReadBytes=function(d){return this.$val.ReadBytes(d);};BT.ptr.prototype.readSlice=function(d){var d,e,f,g,h,i,j,k;e=CA.nil;f=$ifaceNil;g=this;h=H($subslice(g.buf,g.off),d);i=(g.off+h>>0)+1>>0;if(h<0){i=g.buf.$length;f=B.EOF;}e=$subslice(g.buf,g.off,i);g.off=i;g.lastRead=-1;j=e;k=f;e=j;f=k;return[e,f];};BT.prototype.readSlice=function(d){return this.$val.readSlice(d);};BT.ptr.prototype.ReadString=function(d){var d,e,f,g,h,i,j,k;e="";f=$ifaceNil;g=this;h=g.readSlice(d);i=h[0];f=h[1];j=($bytesToString(i));k=f;e=j;f=k;return[e,f];};BT.prototype.ReadString=function(d){return this.$val.ReadString(d);};BY=function(d){var d;return new BT.ptr(d,0,0);};$pkg.NewBuffer=BY;BZ=function(d){var d;return new BT.ptr((new CA($stringToBytes(d))),0,0);};$pkg.NewBufferString=BZ;CJ.methods=[{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([CA],[$Int,$error],false)},{prop:"ReadAt",name:"ReadAt",pkg:"",typ:$funcType([CA,$Int64],[$Int,$error],false)},{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"Seek",name:"Seek",pkg:"",typ:$funcType([$Int64,$Int],[$Int64,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([B.Writer],[$Int64,$error],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([CA],[],false)}];CD.methods=[{prop:"contains",name:"contains",pkg:"bytes",typ:$funcType([$Uint8],[$Bool],false)}];CI.methods=[{prop:"Bytes",name:"Bytes",pkg:"",typ:$funcType([],[CA],false)},{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"empty",name:"empty",pkg:"bytes",typ:$funcType([],[$Bool],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Cap",name:"Cap",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Truncate",name:"Truncate",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([],[],false)},{prop:"tryGrowByReslice",name:"tryGrowByReslice",pkg:"bytes",typ:$funcType([$Int],[$Int,$Bool],false)},{prop:"grow",name:"grow",pkg:"bytes",typ:$funcType([$Int],[$Int],false)},{prop:"Grow",name:"Grow",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([CA],[$Int,$error],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)},{prop:"ReadFrom",name:"ReadFrom",pkg:"",typ:$funcType([B.Reader],[$Int64,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([B.Writer],[$Int64,$error],false)},{prop:"WriteByte",name:"WriteByte",pkg:"",typ:$funcType([$Uint8],[$error],false)},{prop:"WriteRune",name:"WriteRune",pkg:"",typ:$funcType([$Int32],[$Int,$error],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([CA],[$Int,$error],false)},{prop:"Next",name:"Next",pkg:"",typ:$funcType([$Int],[CA],false)},{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)},{prop:"ReadBytes",name:"ReadBytes",pkg:"",typ:$funcType([$Uint8],[CA,$error],false)},{prop:"readSlice",name:"readSlice",pkg:"bytes",typ:$funcType([$Uint8],[CA,$error],false)},{prop:"ReadString",name:"ReadString",pkg:"",typ:$funcType([$Uint8],[$String,$error],false)}];F.init("bytes",[{prop:"s",name:"s",embedded:false,exported:false,typ:CA,tag:""},{prop:"i",name:"i",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"prevRune",name:"prevRune",embedded:false,exported:false,typ:$Int,tag:""}]);BA.init($Uint32,8);BT.init("bytes",[{prop:"buf",name:"buf",embedded:false,exported:false,typ:CA,tag:""},{prop:"off",name:"off",embedded:false,exported:false,typ:$Int,tag:""},{prop:"lastRead",name:"lastRead",embedded:false,exported:false,typ:BU,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}AA=$toNativeArray($kindUint8,[0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);$pkg.ErrTooLarge=A.New("bytes.Buffer: too large");BV=A.New("bytes.Buffer: reader returned negative count from Read");BX=A.New("bytes.Buffer: UnreadByte: previous operation was not a successful read");}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["strings"]=(function(){var $pkg={},$init,F,G,A,D,E,B,C,AS,BK,BO,BP,BR,BS,BU,BV,BX,BZ,CA,CB,CJ,CN,CL,CM,CO,CP,CQ,CR,CS,CT,CU,CV,CW,CX,CY,CZ,DA,DB,DC,DD,DE,DF,U,H,I,J,K,L,M,N,O,P,Q,S,V,W,X,Y,Z,AA,AB,AC,AD,AL,AM,AN,AO,AQ,AR,AT,AU,AV,AW,AX,AY,BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BL,BM,BN,BQ,BT,BW,BY,CC,CD,CE,CF,CG;F=$packages["errors"];G=$packages["github.com/gopherjs/gopherjs/js"];A=$packages["internal/bytealg"];D=$packages["io"];E=$packages["sync"];B=$packages["unicode"];C=$packages["unicode/utf8"];AS=$pkg.asciiSet=$newType(32,$kindArray,"strings.asciiSet",true,"strings",false,null);BK=$pkg.stringFinder=$newType(0,$kindStruct,"strings.stringFinder",true,"strings",false,function(pattern_,badCharSkip_,goodSuffixSkip_){this.$val=this;if(arguments.length===0){this.pattern="";this.badCharSkip=CS.zero();this.goodSuffixSkip=CT.nil;return;}this.pattern=pattern_;this.badCharSkip=badCharSkip_;this.goodSuffixSkip=goodSuffixSkip_;});BO=$pkg.Replacer=$newType(0,$kindStruct,"strings.Replacer",true,"strings",true,function(once_,r_,oldnew_){this.$val=this;if(arguments.length===0){this.once=new E.Once.ptr(0,new E.Mutex.ptr(0,0));this.r=$ifaceNil;this.oldnew=CL.nil;return;}this.once=once_;this.r=r_;this.oldnew=oldnew_;});BP=$pkg.replacer=$newType(8,$kindInterface,"strings.replacer",true,"strings",false,null);BR=$pkg.trieNode=$newType(0,$kindStruct,"strings.trieNode",true,"strings",false,function(value_,priority_,prefix_,next_,table_){this.$val=this;if(arguments.length===0){this.value="";this.priority=0;this.prefix="";this.next=CX.nil;this.table=CY.nil;return;}this.value=value_;this.priority=priority_;this.prefix=prefix_;this.next=next_;this.table=table_;});BS=$pkg.genericReplacer=$newType(0,$kindStruct,"strings.genericReplacer",true,"strings",false,function(root_,tableSize_,mapping_){this.$val=this;if(arguments.length===0){this.root=new BR.ptr("",0,"",CX.nil,CY.nil);this.tableSize=0;this.mapping=CU.zero();return;}this.root=root_;this.tableSize=tableSize_;this.mapping=mapping_;});BU=$pkg.appendSliceWriter=$newType(12,$kindSlice,"strings.appendSliceWriter",true,"strings",false,null);BV=$pkg.stringWriter=$newType(0,$kindStruct,"strings.stringWriter",true,"strings",false,function(w_){this.$val=this;if(arguments.length===0){this.w=$ifaceNil;return;}this.w=w_;});BX=$pkg.singleStringReplacer=$newType(0,$kindStruct,"strings.singleStringReplacer",true,"strings",false,function(finder_,value_){this.$val=this;if(arguments.length===0){this.finder=DA.nil;this.value="";return;}this.finder=finder_;this.value=value_;});BZ=$pkg.byteReplacer=$newType(256,$kindArray,"strings.byteReplacer",true,"strings",false,null);CA=$pkg.byteStringReplacer=$newType(0,$kindStruct,"strings.byteStringReplacer",true,"strings",false,function(replacements_,toReplace_){this.$val=this;if(arguments.length===0){this.replacements=CW.zero();this.toReplace=CL.nil;return;}this.replacements=replacements_;this.toReplace=toReplace_;});CB=$pkg.Reader=$newType(0,$kindStruct,"strings.Reader",true,"strings",true,function(s_,i_,prevRune_){this.$val=this;if(arguments.length===0){this.s="";this.i=new $Int64(0,0);this.prevRune=0;return;}this.s=s_;this.i=i_;this.prevRune=prevRune_;});CJ=$pkg.Builder=$newType(0,$kindStruct,"strings.Builder",true,"strings",true,function(addr_,buf_){this.$val=this;if(arguments.length===0){this.addr=CP.nil;this.buf=CQ.nil;return;}this.addr=addr_;this.buf=buf_;});CN=$newType(0,$kindStruct,"strings.span",true,"strings",false,function(start_,end_){this.$val=this;if(arguments.length===0){this.start=0;this.end=0;return;}this.start=start_;this.end=end_;});CL=$sliceType($String);CM=$ptrType(AS);CO=$sliceType(CN);CP=$ptrType(CJ);CQ=$sliceType($Uint8);CR=$arrayType($Uint32,8);CS=$arrayType($Int,256);CT=$sliceType($Int);CU=$arrayType($Uint8,256);CV=$ptrType(BZ);CW=$arrayType(CQ,256);CX=$ptrType(BR);CY=$sliceType(CX);CZ=$ptrType(BU);DA=$ptrType(BK);DB=$ptrType(BO);DC=$ptrType(BS);DD=$ptrType(BX);DE=$ptrType(CA);DF=$ptrType(CB);H=function(f,g){var f,g,h,i,j,k,l,m,n;h=C.RuneCountInString(f);if(g<0||g>h){g=h;}i=$makeSlice(CL,g);j=0;while(true){if(!(j<(g-1>>0))){break;}k=C.DecodeRuneInString(f);l=k[0];m=k[1];((j<0||j>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]=$substring(f,0,m));f=$substring(f,m);if(l===65533){((j<0||j>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]="\xEF\xBF\xBD");}j=j+(1)>>0;}if(g>0){(n=g-1>>0,((n<0||n>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+n]=f));}return i;};I=function(f,g){var f,g;return CE(f,g)>=0;};$pkg.Contains=I;J=function(f,g){var f,g;return M(f,g)>=0;};$pkg.ContainsAny=J;K=function(f,g){var f,g;return L(f,g)>=0;};$pkg.ContainsRune=K;L=function(f,g){var f,g,h,i,j,k,l;if(0<=g&&g<128){return CD(f,((g<<24>>>24)));}else if((g===65533)){h=f;i=0;while(true){if(!(i>0));if(h>=128){h=65533;}return L(f,h);}if(f.length>8){i=AT(g);j=$clone(i[0],AS);k=i[1];if(k){l=0;while(true){if(!(l>0;}return-1;}}m=f;n=0;while(true){if(!(n=0){return p;}n+=o[1];}return-1;};$pkg.IndexAny=M;N=function(f,g){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;if(g===""){return-1;}if(f.length===1){h=((f.charCodeAt(0)>>0));if(h>=128){h=65533;}if(L(g,h)>=0){return 0;}return-1;}if(f.length>8){i=AT(g);j=$clone(i[0],AS);k=i[1];if(k){l=f.length-1>>0;while(true){if(!(l>=0)){break;}if(new CM(j).contains(f.charCodeAt(l))){return l;}l=l-(1)>>0;}return-1;}}if(g.length===1){m=((g.charCodeAt(0)>>0));if(m>=128){m=65533;}n=f.length;while(true){if(!(n>0)){break;}o=C.DecodeLastRuneInString($substring(f,0,n));p=o[0];q=o[1];n=n-(q)>>0;if(m===p){return n;}}return-1;}r=f.length;while(true){if(!(r>0)){break;}s=C.DecodeLastRuneInString($substring(f,0,r));t=s[0];u=s[1];r=r-(u)>>0;if(L(g,t)>=0){return r;}}return-1;};$pkg.LastIndexAny=N;O=function(f,g){var f,g,h;h=f.length-1>>0;while(true){if(!(h>=0)){break;}if(f.charCodeAt(h)===g){return h;}h=h-(1)>>0;}return-1;};$pkg.LastIndexByte=O;P=function(f,g,h,i){var f,g,h,i,j,k,l;if(i===0){return CL.nil;}if(g===""){return H(f,i);}if(i<0){i=CG(f,g)+1>>0;}j=$makeSlice(CL,i);i=i-(1)>>0;k=0;while(true){if(!(k=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]=$substring(f,0,(l+h>>0)));f=$substring(f,(l+g.length>>0));k=k+(1)>>0;}((k<0||k>=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]=f);return $subslice(j,0,(k+1>>0));};Q=function(f,g,h){var f,g,h;return P(f,g,0,h);};$pkg.SplitN=Q;S=function(f,g){var f,g;return P(f,g,0,-1);};$pkg.Split=S;V=function(f){var{f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=0;h=1;i=0;j=0;while(true){if(!(j>>0;l=((((k<0||k>=U.length)?($throwRuntimeError("index out of range"),undefined):U[k])>>0));g=g+((h&(~l>>0)))>>0;h=l;j=j+(1)>>0;}if(i>=128){$s=1;continue;}$s=2;continue;case 1:m=W(f,B.IsSpace);$s=3;case 3:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=m;$s=4;case 4:return n;case 2:o=$makeSlice(CL,g);p=0;q=0;r=0;while(true){if(!(r=U.length)?($throwRuntimeError("index out of range"),undefined):U[s]))===0)))){break;}r=r+(1)>>0;}q=r;while(true){if(!(r=U.length)?($throwRuntimeError("index out of range"),undefined):U[t]))===0){r=r+(1)>>0;continue;}((p<0||p>=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+p]=$substring(f,q,r));p=p+(1)>>0;r=r+(1)>>0;while(true){if(!(r=U.length)?($throwRuntimeError("index out of range"),undefined):U[u]))===0)))){break;}r=r+(1)>>0;}q=r;}if(q=o.$length)?($throwRuntimeError("index out of range"),undefined):o.$array[o.$offset+p]=$substring(f,q));}$s=-1;return o;}return;}var $f={$blk:V,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,$s};return $f;};$pkg.Fields=V;W=function(f,g){var{f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=$makeSlice(CO,0,32);i=-1;j=f;k=0;case 1:if(!(k=0){h=$append(h,new CN.ptr(i,m));i=~i>>0;}$s=5;continue;case 4:if(i<0){i=m;}case 5:k+=l[1];$s=1;continue;case 2:if(i>=0){h=$append(h,new CN.ptr(i,f.length));}p=$makeSlice(CL,h.$length);q=h;r=0;while(true){if(!(r=q.$length)?($throwRuntimeError("index out of range"),undefined):q.$array[q.$offset+r]),CN);((s<0||s>=p.$length)?($throwRuntimeError("index out of range"),undefined):p.$array[p.$offset+s]=$substring(f,t.start,t.end));r++;}$s=-1;return p;}return;}var $f={$blk:W,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,$s};return $f;};$pkg.FieldsFunc=W;X=function(f,g){var f,g,h,i,j,k,l,m,n;h=f.$length;if(h===(0)){return"";}else if(h===(1)){return(0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]);}i=$imul(g.length,((f.$length-1>>0)));j=0;while(true){if(!(j=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+j]).length)>>0;j=j+(1)>>0;}k=new CJ.ptr(CP.nil,CQ.nil);k.Grow(i);k.WriteString((0>=f.$length?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+0]));l=$subslice(f,1);m=0;while(true){if(!(m=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+m]);k.WriteString(g);k.WriteString(n);m++;}return k.String();};$pkg.Join=X;Y=function(f,g){var f,g;return f.length>=g.length&&$substring(f,0,g.length)===g;};$pkg.HasPrefix=Y;Z=function(f,g){var f,g;return f.length>=g.length&&$substring(f,(f.length-g.length>>0))===g;};$pkg.HasSuffix=Z;AA=function(f,g){var{f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=new CJ.ptr(CP.nil,CQ.nil);i=g;j=0;case 1:if(!(j>0);h.WriteString($substring(g,0,l));if(o>=0){h.WriteRune(o);}g=$substring(g,(l+p>>0));$s=2;continue;case 2:if(h.Cap()===0){$s=-1;return g;}r=g;s=0;case 4:if(!(s=0){if(w<128){h.WriteByte(((w<<24>>>24)));}else{h.WriteRune(w);}}s+=t[1];$s=4;continue;case 5:$s=-1;return h.String();}return;}var $f={$blk:AA,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,$s};return $f;};$pkg.Map=AA;AB=function(f,g){var f,g,h,i,j,k;if(g===0){return"";}if(g<0){$panic(new $String("strings: negative Repeat count"));}else if(!(((h=($imul(f.length,g))/g,(h===h&&h!==1/0&&h!==-1/0)?h>>0:$throwRuntimeError("integer divide by zero"))===f.length))){$panic(new $String("strings: Repeat count causes overflow"));}i=$imul(f.length,g);j=new CJ.ptr(CP.nil,CQ.nil);j.Grow(i);j.WriteString(f);while(true){if(!(j.Len()>0:$throwRuntimeError("integer divide by zero"))){j.WriteString(j.String());}else{j.WriteString($substring(j.String(),0,(i-j.Len()>>0)));break;}}return j.String();};$pkg.Repeat=AB;AC=function(f){var{f,g,h,i,j,k,l,m,n,o,p,q,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=true;h=false;i=g;j=h;k=0;while(true){if(!(k=128){i=false;break;}j=j||(97<=l&&l<=122);k=k+(1)>>0;}if(i){if(!j){$s=-1;return f;}m=new CJ.ptr(CP.nil,CQ.nil);m.Grow(f.length);n=0;while(true){if(!(n>>24;}m.WriteByte(o);n=n+(1)>>0;}$s=-1;return m.String();}p=AA(B.ToUpper,f);$s=1;case 1:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}q=p;$s=2;case 2:return q;}return;}var $f={$blk:AC,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,$s};return $f;};$pkg.ToUpper=AC;AD=function(f){var{f,g,h,i,j,k,l,m,n,o,p,q,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=true;h=false;i=g;j=h;k=0;while(true){if(!(k=128){i=false;break;}j=j||(65<=l&&l<=90);k=k+(1)>>0;}if(i){if(!j){$s=-1;return f;}m=new CJ.ptr(CP.nil,CQ.nil);m.Grow(f.length);n=0;while(true){if(!(n>>24;}m.WriteByte(o);n=n+(1)>>0;}$s=-1;return m.String();}p=AA(B.ToLower,f);$s=1;case 1:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}q=p;$s=2;case 2:return q;}return;}var $f={$blk:AD,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,$s};return $f;};$pkg.ToLower=AD;AL=function(f,g){var{f,g,h,i,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=AQ(f,g,false);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;if(i===-1){$s=-1;return"";}$s=-1;return $substring(f,i);}return;}var $f={$blk:AL,$c:true,$r,f,g,h,i,$s};return $f;};$pkg.TrimLeftFunc=AL;AM=function(f,g){var{f,g,h,i,j,k,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=AR(f,g,false);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;if(i>=0&&f.charCodeAt(i)>=128){j=C.DecodeRuneInString($substring(f,i));k=j[1];i=i+(k)>>0;}else{i=i+(1)>>0;}$s=-1;return $substring(f,0,i);}return;}var $f={$blk:AM,$c:true,$r,f,g,h,i,j,k,$s};return $f;};$pkg.TrimRightFunc=AM;AN=function(f,g){var{f,g,h,i,j,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=AL(f,g);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=AM(h,g);$s=2;case 2:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;$s=3;case 3:return j;}return;}var $f={$blk:AN,$c:true,$r,f,g,h,i,j,$s};return $f;};$pkg.TrimFunc=AN;AO=function(f,g){var{f,g,h,i,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=AQ(f,g,true);$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;$s=2;case 2:return i;}return;}var $f={$blk:AO,$c:true,$r,f,g,h,i,$s};return $f;};$pkg.IndexFunc=AO;AQ=function(f,g,h){var{f,g,h,i,j,k,l,m,n,$s,$r,$c}=$restore(this,{f,g,h});$s=$s||0;s:while(true){switch($s){case 0:i=f;j=0;case 1:if(!(j0)){$s=2;continue;}j=C.DecodeLastRuneInString($substring(f,0,i));k=j[0];l=j[1];i=i-(l)>>0;m=g(k);$s=5;case 5:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}if(m===h){$s=3;continue;}$s=4;continue;case 3:$s=-1;return i;case 4:$s=1;continue;case 2:$s=-1;return-1;}return;}var $f={$blk:AR,$c:true,$r,f,g,h,i,j,k,l,m,$s};return $f;};AT=function(f){var f,g,h,i,j,k,l,m,n,o,p,q,r;g=CR.zero();h=false;i=0;while(true){if(!(i=128){k=$clone(g,AS);l=false;AS.copy(g,k);h=l;return[g,h];}n=(m=j/32,(m===m&&m!==1/0&&m!==-1/0)?m>>>0:$throwRuntimeError("integer divide by zero"));((n<0||n>=g.length)?($throwRuntimeError("index out of range"),undefined):g[n]=((((n<0||n>=g.length)?($throwRuntimeError("index out of range"),undefined):g[n])|(((o=((p=j%32,p===p?p:$throwRuntimeError("integer divide by zero"))),o<32?(1<>>0)))>>>0));i=i+(1)>>0;}q=$clone(g,AS);r=true;AS.copy(g,q);h=r;return[g,h];};AS.prototype.contains=function(f){var f,g,h,i,j,k,l;g=this.$val;return!((((((h=g,i=(j=f/32,(j===j&&j!==1/0&&j!==-1/0)?j>>>0:$throwRuntimeError("integer divide by zero")),((i<0||i>=h.length)?($throwRuntimeError("index out of range"),undefined):h[i]))&(((k=((l=f%32,l===l?l:$throwRuntimeError("integer divide by zero"))),k<32?(1<>>0)))>>>0))===0));};$ptrType(AS).prototype.contains=function(f){return(new AS(this.$get())).contains(f);};AU=function(f,g){var f,g,h,i,j;if(f===""||g===""){return f;}if((g.length===1)&&g.charCodeAt(0)<128){return AW(BA(f,g.charCodeAt(0)),g.charCodeAt(0));}h=AT(g);i=$clone(h[0],AS);j=h[1];if(j){return AX(BB(f,i),i);}return AY(BC(f,g),g);};$pkg.Trim=AU;AV=function(f,g){var f,g,h,i,j;if(f===""||g===""){return f;}if((g.length===1)&&g.charCodeAt(0)<128){return AW(f,g.charCodeAt(0));}h=AT(g);i=$clone(h[0],AS);j=h[1];if(j){return AX(f,i);}return AY(f,g);};$pkg.TrimLeft=AV;AW=function(f,g){var f,g;while(true){if(!(f.length>0&&(f.charCodeAt(0)===g))){break;}f=$substring(f,1);}return f;};AX=function(f,g){var f,g;while(true){if(!(f.length>0)){break;}if(!new CM(g).contains(f.charCodeAt(0))){break;}f=$substring(f,1);}return f;};AY=function(f,g){var f,g,h,i,j,k,l;while(true){if(!(f.length>0)){break;}h=((f.charCodeAt(0)>>0));i=1;j=h;k=i;if(j>=128){l=C.DecodeRuneInString(f);j=l[0];k=l[1];}if(!K(g,j)){break;}f=$substring(f,k);}return f;};BA=function(f,g){var f,g;while(true){if(!(f.length>0&&(f.charCodeAt((f.length-1>>0))===g))){break;}f=$substring(f,0,(f.length-1>>0));}return f;};BB=function(f,g){var f,g;while(true){if(!(f.length>0)){break;}if(!new CM(g).contains(f.charCodeAt((f.length-1>>0)))){break;}f=$substring(f,0,(f.length-1>>0));}return f;};BC=function(f,g){var f,g,h,i,j,k,l;while(true){if(!(f.length>0)){break;}h=((f.charCodeAt((f.length-1>>0))>>0));i=1;j=h;k=i;if(j>=128){l=C.DecodeLastRuneInString(f);j=l[0];k=l[1];}if(!K(g,j)){break;}f=$substring(f,0,(f.length-k>>0));}return f;};BD=function(f){var{f,g,h,i,j,k,l,m,n,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=0;case 1:if(!(g=128){$s=3;continue;}$s=4;continue;case 3:i=AN($substring(f,g),B.IsSpace);$s=5;case 5:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}j=i;$s=6;case 6:return j;case 4:if(((h<0||h>=U.length)?($throwRuntimeError("index out of range"),undefined):U[h])===0){$s=2;continue;}g=g+(1)>>0;$s=1;continue;case 2:k=f.length;case 7:if(!(k>g)){$s=8;continue;}l=f.charCodeAt((k-1>>0));if(l>=128){$s=9;continue;}$s=10;continue;case 9:m=AN($substring(f,g,k),B.IsSpace);$s=11;case 11:if($c){$c=false;m=m.$blk();}if(m&&m.$blk!==undefined){break s;}n=m;$s=12;case 12:return n;case 10:if(((l<0||l>=U.length)?($throwRuntimeError("index out of range"),undefined):U[l])===0){$s=8;continue;}k=k-(1)>>0;$s=7;continue;case 8:$s=-1;return $substring(f,g,k);}return;}var $f={$blk:BD,$c:true,$r,f,g,h,i,j,k,l,m,n,$s};return $f;};$pkg.TrimSpace=BD;BE=function(f,g){var f,g;if(Y(f,g)){return $substring(f,g.length);}return f;};$pkg.TrimPrefix=BE;BF=function(f,g){var f,g;if(Z(f,g)){return $substring(f,0,(f.length-g.length>>0));}return f;};$pkg.TrimSuffix=BF;BG=function(f,g,h,i){var f,g,h,i,j,k,l,m,n,o,p;if(g===h||(i===0)){return f;}j=CG(f,g);if(j===0){return f;}else if(i<0||j>0))))>>0);l=0;m=0;while(true){if(!(m0){o=C.DecodeRuneInString($substring(f,l));p=o[1];n=n+(p)>>0;}}else{n=n+(CE($substring(f,l),g))>>0;}k.WriteString($substring(f,l,n));k.WriteString(h);l=n+g.length>>0;m=m+(1)>>0;}k.WriteString($substring(f,l));return k.String();};$pkg.Replace=BG;BH=function(f,g,h){var f,g,h;return BG(f,g,h,-1);};$pkg.ReplaceAll=BH;BI=function(f,g){var aa,ab,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;while(true){if(!(!(f==="")&&!(g===""))){break;}h=0;i=0;j=h;k=i;if(f.charCodeAt(0)<128){l=((f.charCodeAt(0)>>0));m=$substring(f,1);j=l;f=m;}else{n=C.DecodeRuneInString(f);o=n[0];p=n[1];q=o;r=$substring(f,p);j=q;f=r;}if(g.charCodeAt(0)<128){s=((g.charCodeAt(0)>>0));t=$substring(g,1);k=s;g=t;}else{u=C.DecodeRuneInString(g);v=u[0];w=u[1];x=v;y=$substring(g,w);k=x;g=y;}if(k===j){continue;}if(k>0)-65>>0))){continue;}return false;}ab=B.SimpleFold(j);while(true){if(!(!((ab===j))&&ab=0){l=$substring(f,0,k);m=$substring(f,(k+g.length>>0));n=true;h=l;i=m;j=n;return[h,i,j];}o=f;p="";q=false;h=o;i=p;j=q;return[h,i,j];};$pkg.Cut=BJ;BL=function(f){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;g=new BK.ptr(f,CS.zero(),$makeSlice(CT,f.length));h=f.length-1>>0;i=g.badCharSkip;j=0;while(true){if(!(j<256)){break;}k=j;(l=g.badCharSkip,((k<0||k>=l.length)?($throwRuntimeError("index out of range"),undefined):l[k]=f.length));j++;}m=0;while(true){if(!(m=n.length)?($throwRuntimeError("index out of range"),undefined):n[o]=(h-m>>0)));m=m+(1)>>0;}p=h;q=h;while(true){if(!(q>=0)){break;}if(Y(f,$substring(f,(q+1>>0)))){p=q+1>>0;}(r=g.goodSuffixSkip,((q<0||q>=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+q]=((p+h>>0)-q>>0)));q=q-(1)>>0;}s=0;while(true){if(!(s>0)));if(!((f.charCodeAt((s-t>>0))===f.charCodeAt((h-t>>0))))){(u=g.goodSuffixSkip,v=h-t>>0,((v<0||v>=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+v]=((t+h>>0)-s>>0)));}s=s+(1)>>0;}return g;};BM=function(f,g){var f,g,h;h=0;while(true){if(!(h>0)-h>>0))===g.charCodeAt(((g.length-1>>0)-h>>0))))){break;}h=h+(1)>>0;}return h;};BK.ptr.prototype.next=function(f){var f,g,h,i,j,k,l;g=this;h=g.pattern.length-1>>0;while(true){if(!(h>0;while(true){if(!(i>=0&&(f.charCodeAt(h)===g.pattern.charCodeAt(i)))){break;}h=h-(1)>>0;i=i-(1)>>0;}if(i<0){return h+1>>0;}h=h+(BN((j=g.badCharSkip,k=f.charCodeAt(h),((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k])),(l=g.goodSuffixSkip,((i<0||i>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+i]))))>>0;}return-1;};BK.prototype.next=function(f){return this.$val.next(f);};BN=function(f,g){var f,g;if(f>g){return f;}return g;};BQ=function(f){var f,g;if((g=f.$length%2,g===g?g:$throwRuntimeError("integer divide by zero"))===1){$panic(new $String("strings.NewReplacer: odd argument count"));}return new BO.ptr(new E.Once.ptr(0,new E.Mutex.ptr(0,0)),$ifaceNil,$appendSlice((CL.nil),f));};$pkg.NewReplacer=BQ;BO.ptr.prototype.buildOnce=function(){var f;f=this;f.r=f.build();f.oldnew=CL.nil;};BO.prototype.buildOnce=function(){return this.$val.buildOnce();};BO.ptr.prototype.build=function(){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;f=this;g=f.oldnew;if((g.$length===2)&&(0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]).length>1){return BY((0>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+0]),(1>=g.$length?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+1]));}h=true;i=0;while(true){if(!(i=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+i]).length===1))){return BT(g);}if(!(((j=i+1>>0,((j<0||j>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+j])).length===1))){h=false;}i=i+(2)>>0;}if(h){k=CU.zero();l=k;m=0;while(true){if(!(m<256)){break;}n=m;((n<0||n>=k.length)?($throwRuntimeError("index out of range"),undefined):k[n]=((n<<24>>>24)));m++;}o=g.$length-2>>0;while(true){if(!(o>=0)){break;}p=((o<0||o>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+o]).charCodeAt(0);r=(q=o+1>>0,((q<0||q>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+q])).charCodeAt(0);((p<0||p>=k.length)?($throwRuntimeError("index out of range"),undefined):k[p]=r);o=o-(2)>>0;}return new CV(k);}t=new CA.ptr(CW.zero(),$makeSlice(CL,0,(s=g.$length/2,(s===s&&s!==1/0&&s!==-1/0)?s>>0:$throwRuntimeError("integer divide by zero"))));u=g.$length-2>>0;while(true){if(!(u>=0)){break;}v=((u<0||u>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+u]).charCodeAt(0);x=(w=u+1>>0,((w<0||w>=g.$length)?($throwRuntimeError("index out of range"),undefined):g.$array[g.$offset+w]));if((y=t.replacements,((v<0||v>=y.length)?($throwRuntimeError("index out of range"),undefined):y[v]))===CQ.nil){t.toReplace=$append(t.toReplace,($bytesToString(new CQ([v]))));}(z=t.replacements,((v<0||v>=z.length)?($throwRuntimeError("index out of range"),undefined):z[v]=(new CQ($stringToBytes(x)))));u=u-(2)>>0;}return t;};BO.prototype.build=function(){return this.$val.build();};BO.ptr.prototype.Replace=function(f){var{f,g,h,i,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=this;$r=g.once.Do($methodVal(g,"buildOnce"));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}h=g.r.Replace(f);$s=2;case 2:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;$s=3;case 3:return i;}return;}var $f={$blk:BO.ptr.prototype.Replace,$c:true,$r,f,g,h,i,$s};return $f;};BO.prototype.Replace=function(f){return this.$val.Replace(f);};BO.ptr.prototype.WriteString=function(f,g){var{f,g,h,i,j,k,l,m,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=0;i=$ifaceNil;j=this;$r=j.once.Do($methodVal(j,"buildOnce"));$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}l=j.r.WriteString(f,g);$s=2;case 2:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;h=k[0];i=k[1];m=[h,i];$s=3;case 3:return m;}return;}var $f={$blk:BO.ptr.prototype.WriteString,$c:true,$r,f,g,h,i,j,k,l,m,$s};return $f;};BO.prototype.WriteString=function(f,g){return this.$val.WriteString(f,g);};BR.ptr.prototype.add=function(f,g,h,i){var aa,ab,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;j=this;if(f===""){if(j.priority===0){j.value=g;j.priority=h;}return;}if(!(j.prefix==="")){k=0;while(true){if(!(k>0;}if(k===j.prefix.length){j.next.add($substring(f,k),g,h,i);}else if(k===0){l=CX.nil;if(j.prefix.length===1){l=j.next;}else{l=new BR.ptr("",0,$substring(j.prefix,1),j.next,CY.nil);}m=new BR.ptr("",0,"",CX.nil,CY.nil);j.table=$makeSlice(CY,i.tableSize);(n=j.table,o=(p=i.mapping,q=j.prefix.charCodeAt(0),((q<0||q>=p.length)?($throwRuntimeError("index out of range"),undefined):p[q])),((o<0||o>=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]=l));(r=j.table,s=(t=i.mapping,u=f.charCodeAt(0),((u<0||u>=t.length)?($throwRuntimeError("index out of range"),undefined):t[u])),((s<0||s>=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+s]=m));j.prefix="";j.next=CX.nil;m.add($substring(f,1),g,h,i);}else{v=new BR.ptr("",0,$substring(j.prefix,k),j.next,CY.nil);j.prefix=$substring(j.prefix,0,k);j.next=v;v.add($substring(f,k),g,h,i);}}else if(!(j.table===CY.nil)){y=(w=i.mapping,x=f.charCodeAt(0),((x<0||x>=w.length)?($throwRuntimeError("index out of range"),undefined):w[x]));if((z=j.table,((y<0||y>=z.$length)?($throwRuntimeError("index out of range"),undefined):z.$array[z.$offset+y]))===CX.nil){(aa=j.table,((y<0||y>=aa.$length)?($throwRuntimeError("index out of range"),undefined):aa.$array[aa.$offset+y]=new BR.ptr("",0,"",CX.nil,CY.nil)));}(ab=j.table,((y<0||y>=ab.$length)?($throwRuntimeError("index out of range"),undefined):ab.$array[ab.$offset+y])).add($substring(f,1),g,h,i);}else{j.prefix=f;j.next=new BR.ptr("",0,"",CX.nil,CY.nil);j.next.add("",g,h,i);}};BR.prototype.add=function(f,g,h,i){return this.$val.add(f,g,h,i);};BS.ptr.prototype.lookup=function(f,g){var f,g,h,i,j,k,l,m,n,o,p,q,r;h="";i=0;j=false;k=this;l=0;m=k.root;n=0;while(true){if(!(!(m===CX.nil))){break;}if(m.priority>l&&!(g&&m===k.root)){l=m.priority;h=m.value;i=n;j=true;}if(f===""){break;}if(!(m.table===CY.nil)){q=(o=k.mapping,p=f.charCodeAt(0),((p<0||p>=o.length)?($throwRuntimeError("index out of range"),undefined):o[p]));if(((q>>0))===k.tableSize){break;}m=(r=m.table,((q<0||q>=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+q]));f=$substring(f,1);n=n+(1)>>0;}else if(!(m.prefix==="")&&Y(f,m.prefix)){n=n+(m.prefix.length)>>0;f=$substring(f,m.prefix.length);m=m.next;}else{break;}}return[h,i,j];};BS.prototype.lookup=function(f,g){return this.$val.lookup(f,g);};BT=function(f){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;g=new BS.ptr(new BR.ptr("",0,"",CX.nil,CY.nil),0,CU.zero());h=0;while(true){if(!(h=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+h]);j=0;while(true){if(!(j=k.length)?($throwRuntimeError("index out of range"),undefined):k[l]=1));j=j+(1)>>0;}h=h+(2)>>0;}m=g.mapping;n=0;while(true){if(!(n<256)){break;}o=((n<0||n>=m.length)?($throwRuntimeError("index out of range"),undefined):m[n]);g.tableSize=g.tableSize+(((o>>0)))>>0;n++;}p=0;q=g.mapping;r=0;while(true){if(!(r<256)){break;}s=r;t=((r<0||r>=q.length)?($throwRuntimeError("index out of range"),undefined):q[r]);if(t===0){(u=g.mapping,((s<0||s>=u.length)?($throwRuntimeError("index out of range"),undefined):u[s]=((g.tableSize<<24>>>24))));}else{(v=g.mapping,((s<0||s>=v.length)?($throwRuntimeError("index out of range"),undefined):v[s]=p));p=p+(1)<<24>>>24;}r++;}g.root.table=$makeSlice(CY,g.tableSize);w=0;while(true){if(!(w=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+w]),(x=w+1>>0,((x<0||x>=f.$length)?($throwRuntimeError("index out of range"),undefined):f.$array[f.$offset+x])),f.$length-w>>0,g);w=w+(2)>>0;}return g;};$ptrType(BU).prototype.Write=function(f){var f,g;g=this;g.$set($appendSlice(g.$get(),f));return[f.$length,$ifaceNil];};$ptrType(BU).prototype.WriteString=function(f){var f,g;g=this;g.$set($appendSlice(g.$get(),f));return[f.length,$ifaceNil];};BV.ptr.prototype.WriteString=function(f){var{f,g,h,i,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=this;h=g.w.Write((new CQ($stringToBytes(f))));$s=1;case 1:if($c){$c=false;h=h.$blk();}if(h&&h.$blk!==undefined){break s;}i=h;$s=2;case 2:return i;}return;}var $f={$blk:BV.ptr.prototype.WriteString,$c:true,$r,f,g,h,i,$s};return $f;};BV.prototype.WriteString=function(f){return this.$val.WriteString(f);};BW=function(f){var f,g,h,i,j;g=$assertType(f,D.StringWriter,true);h=g[0];i=g[1];if(!i){h=(j=new BV.ptr(f),new j.constructor.elem(j));}return h;};BS.ptr.prototype.Replace=function(f){var{f,g,h,i,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=[g];h=this;g[0]=$makeSlice(BU,0,f.length);i=h.WriteString((g.$ptr||(g.$ptr=new CZ(function(){return this.$target[0];},function($v){this.$target[0]=$v;},g))),f);$s=1;case 1:if($c){$c=false;i=i.$blk();}if(i&&i.$blk!==undefined){break s;}i;$s=-1;return($bytesToString(g[0]));}return;}var $f={$blk:BS.ptr.prototype.Replace,$c:true,$r,f,g,h,i,$s};return $f;};BS.prototype.Replace=function(f){return this.$val.Replace(f);};BS.ptr.prototype.WriteString=function(f,g){var{aa,ab,ac,ad,ae,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=0;i=$ifaceNil;j=this;k=BW(f);l=0;m=0;n=l;o=m;p=false;q=0;case 1:if(!(q<=g.length)){$s=2;continue;}if(!((q===g.length))&&(j.root.priority===0)){t=(((r=j.mapping,s=g.charCodeAt(q),((s<0||s>=r.length)?($throwRuntimeError("index out of range"),undefined):r[s]))>>0));if((t===j.tableSize)||(u=j.root.table,((t<0||t>=u.$length)?($throwRuntimeError("index out of range"),undefined):u.$array[u.$offset+t]))===CX.nil){q=q+(1)>>0;$s=1;continue;}}v=j.lookup($substring(g,q),p);w=v[0];x=v[1];y=v[2];p=y&&(x===0);if(y){$s=3;continue;}$s=4;continue;case 3:aa=k.WriteString($substring(g,n,q));$s=5;case 5:if($c){$c=false;aa=aa.$blk();}if(aa&&aa.$blk!==undefined){break s;}z=aa;o=z[0];i=z[1];h=h+(o)>>0;if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[h,i];}ac=k.WriteString(w);$s=6;case 6:if($c){$c=false;ac=ac.$blk();}if(ac&&ac.$blk!==undefined){break s;}ab=ac;o=ab[0];i=ab[1];h=h+(o)>>0;if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[h,i];}q=q+(x)>>0;n=q;$s=1;continue;case 4:q=q+(1)>>0;$s=1;continue;case 2:if(!((n===g.length))){$s=7;continue;}$s=8;continue;case 7:ae=k.WriteString($substring(g,n));$s=9;case 9:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}ad=ae;o=ad[0];i=ad[1];h=h+(o)>>0;case 8:$s=-1;return[h,i];}return;}var $f={$blk:BS.ptr.prototype.WriteString,$c:true,$r,aa,ab,ac,ad,ae,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};BS.prototype.WriteString=function(f,g){return this.$val.WriteString(f,g);};BY=function(f,g){var f,g;return new BX.ptr(BL(f),g);};BX.ptr.prototype.Replace=function(f){var f,g,h,i,j,k,l,m;g=this;h=new CJ.ptr(CP.nil,CQ.nil);i=0;j=false;k=i;l=j;while(true){m=g.finder.next($substring(f,k));if(m===-1){break;}l=true;h.Grow(m+g.value.length>>0);h.WriteString($substring(f,k,(k+m>>0)));h.WriteString(g.value);k=k+((m+g.finder.pattern.length>>0))>>0;}if(!l){return f;}h.WriteString($substring(f,k));return h.String();};BX.prototype.Replace=function(f){return this.$val.Replace(f);};BX.ptr.prototype.WriteString=function(f,g){var{f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=0;i=$ifaceNil;j=this;k=BW(f);l=0;m=0;n=l;o=m;case 1:p=j.finder.next($substring(g,n));if(p===-1){$s=2;continue;}r=k.WriteString($substring(g,n,(n+p>>0)));$s=3;case 3:if($c){$c=false;r=r.$blk();}if(r&&r.$blk!==undefined){break s;}q=r;o=q[0];i=q[1];h=h+(o)>>0;if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[h,i];}t=k.WriteString(j.value);$s=4;case 4:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}s=t;o=s[0];i=s[1];h=h+(o)>>0;if(!($interfaceIsEqual(i,$ifaceNil))){$s=-1;return[h,i];}n=n+((p+j.finder.pattern.length>>0))>>0;$s=1;continue;case 2:v=k.WriteString($substring(g,n));$s=5;case 5:if($c){$c=false;v=v.$blk();}if(v&&v.$blk!==undefined){break s;}u=v;o=u[0];i=u[1];h=h+(o)>>0;$s=-1;return[h,i];}return;}var $f={$blk:BX.ptr.prototype.WriteString,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,$s};return $f;};BX.prototype.WriteString=function(f,g){return this.$val.WriteString(f,g);};BZ.prototype.Replace=function(f){var f,g,h,i,j,k,l;g=this.$val;h=CQ.nil;i=0;while(true){if(!(i=k.length)?($throwRuntimeError("index out of range"),undefined):k[j]))===j))){if(h===CQ.nil){h=(new CQ($stringToBytes(f)));}((i<0||i>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+i]=(l=g,((j<0||j>=l.length)?($throwRuntimeError("index out of range"),undefined):l[j])));}i=i+(1)>>0;}if(h===CQ.nil){return f;}return($bytesToString(h));};$ptrType(BZ).prototype.Replace=function(f){return(new BZ(this.$get())).Replace(f);};BZ.prototype.WriteString=function(f,g){var{f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=0;i=$ifaceNil;j=this.$val;k=32768;if(g.length0)){$s=2;continue;}m=$copyString(l,g);g=$substring(g,m);n=$subslice(l,0,m);o=0;while(true){if(!(o=n.$length)?($throwRuntimeError("index out of range"),undefined):n.$array[n.$offset+o]);((p<0||p>=l.$length)?($throwRuntimeError("index out of range"),undefined):l.$array[l.$offset+p]=(r=j,((q<0||q>=r.length)?($throwRuntimeError("index out of range"),undefined):r[q])));o++;}t=f.Write($subslice(l,0,m));$s=3;case 3:if($c){$c=false;t=t.$blk();}if(t&&t.$blk!==undefined){break s;}s=t;u=s[0];v=s[1];h=h+(u)>>0;if(!($interfaceIsEqual(v,$ifaceNil))){w=h;x=v;h=w;i=x;$s=-1;return[h,i];}$s=1;continue;case 2:y=h;z=$ifaceNil;h=y;i=z;$s=-1;return[h,i];}return;}var $f={$blk:BZ.prototype.WriteString,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};$ptrType(BZ).prototype.WriteString=function(f,g){return(new BZ(this.$get())).WriteString(f,g);};CA.ptr.prototype.Replace=function(f){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y;g=this;h=f.length;i=false;if(($imul(g.toReplace.$length,8))<=f.length){j=g.toReplace;k=0;while(true){if(!(k=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]);m=CG(f,l);if(!((m===0))){h=h+(($imul(m,(((n=g.replacements,o=l.charCodeAt(0),((o<0||o>=n.length)?($throwRuntimeError("index out of range"),undefined):n[o])).$length-1>>0)))))>>0;i=true;}k++;}}else{p=0;while(true){if(!(p=r.length)?($throwRuntimeError("index out of range"),undefined):r[q]))===CQ.nil)){h=h+(((s=g.replacements,((q<0||q>=s.length)?($throwRuntimeError("index out of range"),undefined):s[q])).$length-1>>0))>>0;i=true;}p=p+(1)>>0;}}if(!i){return f;}t=$makeSlice(CQ,h);u=0;v=0;while(true){if(!(v=x.length)?($throwRuntimeError("index out of range"),undefined):x[w]))===CQ.nil)){u=u+($copySlice($subslice(t,u),(y=g.replacements,((w<0||w>=y.length)?($throwRuntimeError("index out of range"),undefined):y[w]))))>>0;}else{((u<0||u>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+u]=w);u=u+(1)>>0;}v=v+(1)>>0;}return($bytesToString(t));};CA.prototype.Replace=function(f){return this.$val.Replace(f);};CA.ptr.prototype.WriteString=function(f,g){var{aa,ab,ac,ad,ae,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{f,g});$s=$s||0;s:while(true){switch($s){case 0:h=0;i=$ifaceNil;j=this;k=BW(f);l=0;m=0;case 1:if(!(m=o.length)?($throwRuntimeError("index out of range"),undefined):o[n]))===CQ.nil){m=m+(1)>>0;$s=1;continue;}if(!((l===m))){$s=3;continue;}$s=4;continue;case 3:q=k.WriteString($substring(g,l,m));$s=5;case 5:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;r=p[0];s=p[1];h=h+(r)>>0;if(!($interfaceIsEqual(s,$ifaceNil))){t=h;u=s;h=t;i=u;$s=-1;return[h,i];}case 4:l=m+1>>0;x=f.Write((w=j.replacements,((n<0||n>=w.length)?($throwRuntimeError("index out of range"),undefined):w[n])));$s=6;case 6:if($c){$c=false;x=x.$blk();}if(x&&x.$blk!==undefined){break s;}v=x;y=v[0];z=v[1];h=h+(y)>>0;if(!($interfaceIsEqual(z,$ifaceNil))){aa=h;ab=z;h=aa;i=ab;$s=-1;return[h,i];}m=m+(1)>>0;$s=1;continue;case 2:if(!((l===g.length))){$s=7;continue;}$s=8;continue;case 7:ac=0;ae=k.WriteString($substring(g,l));$s=9;case 9:if($c){$c=false;ae=ae.$blk();}if(ae&&ae.$blk!==undefined){break s;}ad=ae;ac=ad[0];i=ad[1];h=h+(ac)>>0;case 8:$s=-1;return[h,i];}return;}var $f={$blk:CA.ptr.prototype.WriteString,$c:true,$r,aa,ab,ac,ad,ae,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s};return $f;};CA.prototype.WriteString=function(f,g){return this.$val.WriteString(f,g);};CB.ptr.prototype.Len=function(){var f,g,h,i,j,k;f=this;if((g=f.i,h=(new $Int64(0,f.s.length)),(g.$high>h.$high||(g.$high===h.$high&&g.$low>=h.$low)))){return 0;}return(((i=(j=(new $Int64(0,f.s.length)),k=f.i,new $Int64(j.$high-k.$high,j.$low-k.$low)),i.$low+((i.$high>>31)*4294967296))>>0));};CB.prototype.Len=function(){return this.$val.Len();};CB.ptr.prototype.Size=function(){var f;f=this;return(new $Int64(0,f.s.length));};CB.prototype.Size=function(){return this.$val.Size();};CB.ptr.prototype.Read=function(f){var f,g,h,i,j,k,l,m,n,o;g=0;h=$ifaceNil;i=this;if((j=i.i,k=(new $Int64(0,i.s.length)),(j.$high>k.$high||(j.$high===k.$high&&j.$low>=k.$low)))){l=0;m=D.EOF;g=l;h=m;return[g,h];}i.prevRune=-1;g=$copyString(f,$substring(i.s,$flatten64(i.i)));i.i=(n=i.i,o=(new $Int64(0,g)),new $Int64(n.$high+o.$high,n.$low+o.$low));return[g,h];};CB.prototype.Read=function(f){return this.$val.Read(f);};CB.ptr.prototype.ReadAt=function(f,g){var f,g,h,i,j,k,l,m,n,o;h=0;i=$ifaceNil;j=this;if((g.$high<0||(g.$high===0&&g.$low<0))){k=0;l=F.New("strings.Reader.ReadAt: negative offset");h=k;i=l;return[h,i];}if((m=(new $Int64(0,j.s.length)),(g.$high>m.$high||(g.$high===m.$high&&g.$low>=m.$low)))){n=0;o=D.EOF;h=n;i=o;return[h,i];}h=$copyString(f,$substring(j.s,$flatten64(g)));if(hh.$high||(g.$high===h.$high&&g.$low>=h.$low)))){return[0,D.EOF];}i=f.s.charCodeAt($flatten64(f.i));f.i=(j=f.i,k=new $Int64(0,1),new $Int64(j.$high+k.$high,j.$low+k.$low));return[i,$ifaceNil];};CB.prototype.ReadByte=function(){return this.$val.ReadByte();};CB.ptr.prototype.UnreadByte=function(){var f,g,h,i;f=this;if((g=f.i,(g.$high<0||(g.$high===0&&g.$low<=0)))){return F.New("strings.Reader.UnreadByte: at beginning of string");}f.prevRune=-1;f.i=(h=f.i,i=new $Int64(0,1),new $Int64(h.$high-i.$high,h.$low-i.$low));return $ifaceNil;};CB.prototype.UnreadByte=function(){return this.$val.UnreadByte();};CB.ptr.prototype.ReadRune=function(){var f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x;f=0;g=0;h=$ifaceNil;i=this;if((j=i.i,k=(new $Int64(0,i.s.length)),(j.$high>k.$high||(j.$high===k.$high&&j.$low>=k.$low)))){i.prevRune=-1;l=0;m=0;n=D.EOF;f=l;g=m;h=n;return[f,g,h];}i.prevRune=(((o=i.i,o.$low+((o.$high>>31)*4294967296))>>0));p=i.s.charCodeAt($flatten64(i.i));if(p<128){i.i=(q=i.i,r=new $Int64(0,1),new $Int64(q.$high+r.$high,q.$low+r.$low));s=((p>>0));t=1;u=$ifaceNil;f=s;g=t;h=u;return[f,g,h];}v=C.DecodeRuneInString($substring(i.s,$flatten64(i.i)));f=v[0];g=v[1];i.i=(w=i.i,x=(new $Int64(0,g)),new $Int64(w.$high+x.$high,w.$low+x.$low));return[f,g,h];};CB.prototype.ReadRune=function(){return this.$val.ReadRune();};CB.ptr.prototype.UnreadRune=function(){var f,g;f=this;if((g=f.i,(g.$high<0||(g.$high===0&&g.$low<=0)))){return F.New("strings.Reader.UnreadRune: at beginning of string");}if(f.prevRune<0){return F.New("strings.Reader.UnreadRune: previous operation was not ReadRune");}f.i=(new $Int64(0,f.prevRune));f.prevRune=-1;return $ifaceNil;};CB.prototype.UnreadRune=function(){return this.$val.UnreadRune();};CB.ptr.prototype.Seek=function(f,g){var f,g,h,i,j,k,l;h=this;h.prevRune=-1;i=new $Int64(0,0);j=g;if(j===(0)){i=f;}else if(j===(1)){i=(k=h.i,new $Int64(k.$high+f.$high,k.$low+f.$low));}else if(j===(2)){i=(l=(new $Int64(0,h.s.length)),new $Int64(l.$high+f.$high,l.$low+f.$low));}else{return[new $Int64(0,0),F.New("strings.Reader.Seek: invalid whence")];}if((i.$high<0||(i.$high===0&&i.$low<0))){return[new $Int64(0,0),F.New("strings.Reader.Seek: negative position")];}h.i=i;return[i,$ifaceNil];};CB.prototype.Seek=function(f,g){return this.$val.Seek(f,g);};CB.ptr.prototype.WriteTo=function(f){var{f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s,$r,$c}=$restore(this,{f});$s=$s||0;s:while(true){switch($s){case 0:g=new $Int64(0,0);h=$ifaceNil;i=this;i.prevRune=-1;if((j=i.i,k=(new $Int64(0,i.s.length)),(j.$high>k.$high||(j.$high===k.$high&&j.$low>=k.$low)))){l=new $Int64(0,0);m=$ifaceNil;g=l;h=m;$s=-1;return[g,h];}n=$substring(i.s,$flatten64(i.i));p=D.WriteString(f,n);$s=1;case 1:if($c){$c=false;p=p.$blk();}if(p&&p.$blk!==undefined){break s;}o=p;q=o[0];h=o[1];if(q>n.length){$panic(new $String("strings.Reader.WriteTo: invalid WriteString count"));}i.i=(r=i.i,s=(new $Int64(0,q)),new $Int64(r.$high+s.$high,r.$low+s.$low));g=(new $Int64(0,q));if(!((q===n.length))&&$interfaceIsEqual(h,$ifaceNil)){h=D.ErrShortWrite;}$s=-1;return[g,h];}return;}var $f={$blk:CB.ptr.prototype.WriteTo,$c:true,$r,f,g,h,i,j,k,l,m,n,o,p,q,r,s,$s};return $f;};CB.prototype.WriteTo=function(f){return this.$val.WriteTo(f);};CB.ptr.prototype.Reset=function(f){var f,g;g=this;CB.copy(g,new CB.ptr(f,new $Int64(0,0),-1));};CB.prototype.Reset=function(f){return this.$val.Reset(f);};CC=function(f){var f;return new CB.ptr(f,new $Int64(0,0),-1);};$pkg.NewReader=CC;CD=function(f,g){var f,g;return $parseInt(f.indexOf($global.String.fromCharCode(g)))>>0;};$pkg.IndexByte=CD;CE=function(f,g){var f,g;return $parseInt(f.indexOf(g))>>0;};$pkg.Index=CE;CF=function(f,g){var f,g;return $parseInt(f.lastIndexOf(g))>>0;};$pkg.LastIndex=CF;CG=function(f,g){var f,g,h,i;h=0;if((g.length===0)){return C.RuneCountInString(f)+1>>0;}else if(g.length>f.length){return 0;}else if((g.length===f.length)){if(g===f){return 1;}return 0;}while(true){i=CE(f,g);if(i===-1){break;}h=h+(1)>>0;f=$substring(f,(i+g.length>>0));}return h;};$pkg.Count=CG;CJ.ptr.prototype.String=function(){var f;f=this;return($bytesToString(f.buf));};CJ.prototype.String=function(){return this.$val.String();};CJ.ptr.prototype.copyCheck=function(){var f;f=this;if(f.addr===CP.nil){f.addr=f;}else if(!(f.addr===f)){$panic(new $String("strings: illegal use of non-zero Builder copied by value"));}};CJ.prototype.copyCheck=function(){return this.$val.copyCheck();};CJ.ptr.prototype.Len=function(){var f;f=this;return f.buf.$length;};CJ.prototype.Len=function(){return this.$val.Len();};CJ.ptr.prototype.Cap=function(){var f;f=this;return f.buf.$capacity;};CJ.prototype.Cap=function(){return this.$val.Cap();};CJ.ptr.prototype.Reset=function(){var f;f=this;f.addr=CP.nil;f.buf=CQ.nil;};CJ.prototype.Reset=function(){return this.$val.Reset();};CJ.ptr.prototype.grow=function(f){var f,g,h;g=this;h=$makeSlice(CQ,g.buf.$length,(($imul(2,g.buf.$capacity))+f>>0));$copySlice(h,g.buf);g.buf=h;};CJ.prototype.grow=function(f){return this.$val.grow(f);};CJ.ptr.prototype.Grow=function(f){var f,g;g=this;g.copyCheck();if(f<0){$panic(new $String("strings.Builder.Grow: negative count"));}if((g.buf.$capacity-g.buf.$length>>0)>>0))<128){g.buf=$append(g.buf,((f<<24>>>24)));return[1,$ifaceNil];}h=g.buf.$length;if((g.buf.$capacity-h>>0)<4){g.grow(4);}i=C.EncodeRune($subslice(g.buf,h,(h+4>>0)),f);g.buf=$subslice(g.buf,0,(h+i>>0));return[i,$ifaceNil];};CJ.prototype.WriteRune=function(f){return this.$val.WriteRune(f);};CJ.ptr.prototype.WriteString=function(f){var f,g;g=this;g.copyCheck();g.buf=$appendSlice(g.buf,f);return[f.length,$ifaceNil];};CJ.prototype.WriteString=function(f){return this.$val.WriteString(f);};CM.methods=[{prop:"contains",name:"contains",pkg:"strings",typ:$funcType([$Uint8],[$Bool],false)}];DA.methods=[{prop:"next",name:"next",pkg:"strings",typ:$funcType([$String],[$Int],false)}];DB.methods=[{prop:"buildOnce",name:"buildOnce",pkg:"strings",typ:$funcType([],[],false)},{prop:"build",name:"build",pkg:"strings",typ:$funcType([],[BP],false)},{prop:"Replace",name:"Replace",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([D.Writer,$String],[$Int,$error],false)}];CX.methods=[{prop:"add",name:"add",pkg:"strings",typ:$funcType([$String,$String,$Int,DC],[],false)}];DC.methods=[{prop:"lookup",name:"lookup",pkg:"strings",typ:$funcType([$String,$Bool],[$String,$Int,$Bool],false)},{prop:"Replace",name:"Replace",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([D.Writer,$String],[$Int,$error],false)}];CZ.methods=[{prop:"Write",name:"Write",pkg:"",typ:$funcType([CQ],[$Int,$error],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)}];BV.methods=[{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)}];DD.methods=[{prop:"Replace",name:"Replace",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([D.Writer,$String],[$Int,$error],false)}];CV.methods=[{prop:"Replace",name:"Replace",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([D.Writer,$String],[$Int,$error],false)}];DE.methods=[{prop:"Replace",name:"Replace",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([D.Writer,$String],[$Int,$error],false)}];DF.methods=[{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int64],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([CQ],[$Int,$error],false)},{prop:"ReadAt",name:"ReadAt",pkg:"",typ:$funcType([CQ,$Int64],[$Int,$error],false)},{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"Seek",name:"Seek",pkg:"",typ:$funcType([$Int64,$Int],[$Int64,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([D.Writer],[$Int64,$error],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([$String],[],false)}];CP.methods=[{prop:"String",name:"String",pkg:"",typ:$funcType([],[$String],false)},{prop:"copyCheck",name:"copyCheck",pkg:"strings",typ:$funcType([],[],false)},{prop:"Len",name:"Len",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Cap",name:"Cap",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([],[],false)},{prop:"grow",name:"grow",pkg:"strings",typ:$funcType([$Int],[],false)},{prop:"Grow",name:"Grow",pkg:"",typ:$funcType([$Int],[],false)},{prop:"Write",name:"Write",pkg:"",typ:$funcType([CQ],[$Int,$error],false)},{prop:"WriteByte",name:"WriteByte",pkg:"",typ:$funcType([$Uint8],[$error],false)},{prop:"WriteRune",name:"WriteRune",pkg:"",typ:$funcType([$Int32],[$Int,$error],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([$String],[$Int,$error],false)}];AS.init($Uint32,8);BK.init("strings",[{prop:"pattern",name:"pattern",embedded:false,exported:false,typ:$String,tag:""},{prop:"badCharSkip",name:"badCharSkip",embedded:false,exported:false,typ:CS,tag:""},{prop:"goodSuffixSkip",name:"goodSuffixSkip",embedded:false,exported:false,typ:CT,tag:""}]);BO.init("strings",[{prop:"once",name:"once",embedded:false,exported:false,typ:E.Once,tag:""},{prop:"r",name:"r",embedded:false,exported:false,typ:BP,tag:""},{prop:"oldnew",name:"oldnew",embedded:false,exported:false,typ:CL,tag:""}]);BP.init([{prop:"Replace",name:"Replace",pkg:"",typ:$funcType([$String],[$String],false)},{prop:"WriteString",name:"WriteString",pkg:"",typ:$funcType([D.Writer,$String],[$Int,$error],false)}]);BR.init("strings",[{prop:"value",name:"value",embedded:false,exported:false,typ:$String,tag:""},{prop:"priority",name:"priority",embedded:false,exported:false,typ:$Int,tag:""},{prop:"prefix",name:"prefix",embedded:false,exported:false,typ:$String,tag:""},{prop:"next",name:"next",embedded:false,exported:false,typ:CX,tag:""},{prop:"table",name:"table",embedded:false,exported:false,typ:CY,tag:""}]);BS.init("strings",[{prop:"root",name:"root",embedded:false,exported:false,typ:BR,tag:""},{prop:"tableSize",name:"tableSize",embedded:false,exported:false,typ:$Int,tag:""},{prop:"mapping",name:"mapping",embedded:false,exported:false,typ:CU,tag:""}]);BU.init($Uint8);BV.init("strings",[{prop:"w",name:"w",embedded:false,exported:false,typ:D.Writer,tag:""}]);BX.init("strings",[{prop:"finder",name:"finder",embedded:false,exported:false,typ:DA,tag:""},{prop:"value",name:"value",embedded:false,exported:false,typ:$String,tag:""}]);BZ.init($Uint8,256);CA.init("strings",[{prop:"replacements",name:"replacements",embedded:false,exported:false,typ:CW,tag:""},{prop:"toReplace",name:"toReplace",embedded:false,exported:false,typ:CL,tag:""}]);CB.init("strings",[{prop:"s",name:"s",embedded:false,exported:false,typ:$String,tag:""},{prop:"i",name:"i",embedded:false,exported:false,typ:$Int64,tag:""},{prop:"prevRune",name:"prevRune",embedded:false,exported:false,typ:$Int,tag:""}]);CJ.init("strings",[{prop:"addr",name:"addr",embedded:false,exported:false,typ:CP,tag:""},{prop:"buf",name:"buf",embedded:false,exported:false,typ:CQ,tag:""}]);CN.init("strings",[{prop:"start",name:"start",embedded:false,exported:false,typ:$Int,tag:""},{prop:"end",name:"end",embedded:false,exported:false,typ:$Int,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=F.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=G.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=6;case 6:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=7;case 7:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}U=$toNativeArray($kindUint8,[0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["bufio"]=(function(){var $pkg={},$init,A,B,C,E,D,F,G,P,Z,AA,AB,AC,AE,S,T,H,L,M,Q,R;A=$packages["bytes"];B=$packages["errors"];C=$packages["io"];E=$packages["strings"];D=$packages["unicode/utf8"];F=$pkg.Scanner=$newType(0,$kindStruct,"bufio.Scanner",true,"bufio",true,function(r_,split_,maxTokenSize_,token_,buf_,start_,end_,err_,empties_,scanCalled_,done_){this.$val=this;if(arguments.length===0){this.r=$ifaceNil;this.split=$throwNilPointerError;this.maxTokenSize=0;this.token=Z.nil;this.buf=Z.nil;this.start=0;this.end=0;this.err=$ifaceNil;this.empties=0;this.scanCalled=false;this.done=false;return;}this.r=r_;this.split=split_;this.maxTokenSize=maxTokenSize_;this.token=token_;this.buf=buf_;this.start=start_;this.end=end_;this.err=err_;this.empties=empties_;this.scanCalled=scanCalled_;this.done=done_;});G=$pkg.SplitFunc=$newType(4,$kindFunc,"bufio.SplitFunc",true,"bufio",true,null);P=$pkg.Reader=$newType(0,$kindStruct,"bufio.Reader",true,"bufio",true,function(buf_,rd_,r_,w_,err_,lastByte_,lastRuneSize_){this.$val=this;if(arguments.length===0){this.buf=Z.nil;this.rd=$ifaceNil;this.r=0;this.w=0;this.err=$ifaceNil;this.lastByte=0;this.lastRuneSize=0;return;}this.buf=buf_;this.rd=rd_;this.r=r_;this.w=w_;this.err=err_;this.lastByte=lastByte_;this.lastRuneSize=lastRuneSize_;});Z=$sliceType($Uint8);AA=$ptrType(P);AB=$sliceType(Z);AC=$ptrType(E.Builder);AE=$ptrType(F);H=function(a){var a;return new F.ptr(a,M,65536,Z.nil,Z.nil,0,0,$ifaceNil,0,false,false);};$pkg.NewScanner=H;F.ptr.prototype.Err=function(){var a;a=this;if($interfaceIsEqual(a.err,C.EOF)){return $ifaceNil;}return a.err;};F.prototype.Err=function(){return this.$val.Err();};F.ptr.prototype.Bytes=function(){var a;a=this;return a.token;};F.prototype.Bytes=function(){return this.$val.Bytes();};F.ptr.prototype.Text=function(){var a;a=this;return($bytesToString(a.token));};F.prototype.Text=function(){return this.$val.Text();};F.ptr.prototype.Scan=function(){var{a,b,c,d,e,f,g,h,i,j,k,l,m,n,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:a=this;if(a.done){$s=-1;return false;}a.scanCalled=true;case 1:if(a.end>a.start||!($interfaceIsEqual(a.err,$ifaceNil))){$s=3;continue;}$s=4;continue;case 3:c=a.split($subslice(a.buf,a.start,a.end),!($interfaceIsEqual(a.err,$ifaceNil)));$s=5;case 5:if($c){$c=false;c=c.$blk();}if(c&&c.$blk!==undefined){break s;}b=c;d=b[0];e=b[1];f=b[2];if(!($interfaceIsEqual(f,$ifaceNil))){if($interfaceIsEqual(f,$pkg.ErrFinalToken)){a.token=e;a.done=true;$s=-1;return true;}a.setErr(f);$s=-1;return false;}if(!a.advance(d)){$s=-1;return false;}a.token=e;if(!(e===Z.nil)){if($interfaceIsEqual(a.err,$ifaceNil)||d>0){a.empties=0;}else{a.empties=a.empties+(1)>>0;if(a.empties>100){$panic(new $String("bufio.Scan: too many empty tokens without progressing"));}}$s=-1;return true;}case 4:if(!($interfaceIsEqual(a.err,$ifaceNil))){a.start=0;a.end=0;$s=-1;return false;}if(a.start>0&&((a.end===a.buf.$length)||a.start>(g=a.buf.$length/2,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero")))){$copySlice(a.buf,$subslice(a.buf,a.start,a.end));a.end=a.end-(a.start)>>0;a.start=0;}if(a.end===a.buf.$length){if(a.buf.$length>=a.maxTokenSize||a.buf.$length>1073741823){a.setErr($pkg.ErrTooLong);$s=-1;return false;}h=$imul(a.buf.$length,2);if(h===0){h=4096;}if(h>a.maxTokenSize){h=a.maxTokenSize;}i=$makeSlice(Z,h);$copySlice(i,$subslice(a.buf,a.start,a.end));a.buf=i;a.end=a.end-(a.start)>>0;a.start=0;}j=0;case 6:l=a.r.Read($subslice(a.buf,a.end,a.buf.$length));$s=8;case 8:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;m=k[0];n=k[1];if(m<0||(a.buf.$length-a.end>>0)>0;if(!($interfaceIsEqual(n,$ifaceNil))){a.setErr(n);$s=7;continue;}if(m>0){a.empties=0;$s=7;continue;}j=j+(1)>>0;if(j>100){a.setErr(C.ErrNoProgress);$s=7;continue;}$s=6;continue;case 7:$s=1;continue;case 2:$s=-1;return false;}return;}var $f={$blk:F.ptr.prototype.Scan,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,m,n,$s};return $f;};F.prototype.Scan=function(){return this.$val.Scan();};F.ptr.prototype.advance=function(a){var a,b;b=this;if(a<0){b.setErr($pkg.ErrNegativeAdvance);return false;}if(a>(b.end-b.start>>0)){b.setErr($pkg.ErrAdvanceTooFar);return false;}b.start=b.start+(a)>>0;return true;};F.prototype.advance=function(a){return this.$val.advance(a);};F.ptr.prototype.setErr=function(a){var a,b;b=this;if($interfaceIsEqual(b.err,$ifaceNil)||$interfaceIsEqual(b.err,C.EOF)){b.err=a;}};F.prototype.setErr=function(a){return this.$val.setErr(a);};F.ptr.prototype.Buffer=function(a,b){var a,b,c;c=this;if(c.scanCalled){$panic(new $String("Buffer called after Scan"));}c.buf=$subslice(a,0,a.$capacity);c.maxTokenSize=b;};F.prototype.Buffer=function(a,b){return this.$val.Buffer(a,b);};F.ptr.prototype.Split=function(a){var a,b;b=this;if(b.scanCalled){$panic(new $String("Split called after Scan"));}b.split=a;};F.prototype.Split=function(a){return this.$val.Split(a);};L=function(a){var a,b;if(a.$length>0&&((b=a.$length-1>>0,((b<0||b>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+b]))===13)){return $subslice(a,0,(a.$length-1>>0));}return a;};M=function(a,b){var a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r;c=0;d=Z.nil;e=$ifaceNil;if(b&&(a.$length===0)){f=0;g=Z.nil;h=$ifaceNil;c=f;d=g;e=h;return[c,d,e];}i=A.IndexByte(a,10);if(i>=0){j=i+1>>0;k=L($subslice(a,0,i));l=$ifaceNil;c=j;d=k;e=l;return[c,d,e];}if(b){m=a.$length;n=L(a);o=$ifaceNil;c=m;d=n;e=o;return[c,d,e];}p=0;q=Z.nil;r=$ifaceNil;c=p;d=q;e=r;return[c,d,e];};$pkg.ScanLines=M;Q=function(a,b){var a,b,c,d,e,f;c=$assertType(a,AA,true);d=c[0];e=c[1];if(e&&d.buf.$length>=b){return d;}if(b<16){b=16;}f=new P.ptr(Z.nil,$ifaceNil,0,0,$ifaceNil,0,0);f.reset($makeSlice(Z,b),a);return f;};$pkg.NewReaderSize=Q;R=function(a){var a;return Q(a,4096);};$pkg.NewReader=R;P.ptr.prototype.Size=function(){var a;a=this;return a.buf.$length;};P.prototype.Size=function(){return this.$val.Size();};P.ptr.prototype.Reset=function(a){var a,b;b=this;if(b.buf===Z.nil){b.buf=$makeSlice(Z,4096);}b.reset(b.buf,a);};P.prototype.Reset=function(a){return this.$val.Reset(a);};P.ptr.prototype.reset=function(a,b){var a,b,c;c=this;P.copy(c,new P.ptr(a,b,0,0,$ifaceNil,-1,-1));};P.prototype.reset=function(a,b){return this.$val.reset(a,b);};P.ptr.prototype.fill=function(){var{a,b,c,d,e,f,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:a=this;if(a.r>0){$copySlice(a.buf,$subslice(a.buf,a.r,a.w));a.w=a.w-(a.r)>>0;a.r=0;}if(a.w>=a.buf.$length){$panic(new $String("bufio: tried to fill full buffer"));}b=100;case 1:if(!(b>0)){$s=2;continue;}d=a.rd.Read($subslice(a.buf,a.w));$s=3;case 3:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}c=d;e=c[0];f=c[1];if(e<0){$panic(S);}a.w=a.w+(e)>>0;if(!($interfaceIsEqual(f,$ifaceNil))){a.err=f;$s=-1;return;}if(e>0){$s=-1;return;}b=b-(1)>>0;$s=1;continue;case 2:a.err=C.ErrNoProgress;$s=-1;return;}return;}var $f={$blk:P.ptr.prototype.fill,$c:true,$r,a,b,c,d,e,f,$s};return $f;};P.prototype.fill=function(){return this.$val.fill();};P.ptr.prototype.readErr=function(){var a,b;a=this;b=a.err;a.err=$ifaceNil;return b;};P.prototype.readErr=function(){return this.$val.readErr();};P.ptr.prototype.Peek=function(a){var{a,b,c,d,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=this;if(a<0){$s=-1;return[Z.nil,$pkg.ErrNegativeCount];}b.lastByte=-1;b.lastRuneSize=-1;case 1:if(!((b.w-b.r>>0)>0)b.buf.$length){$s=-1;return[$subslice(b.buf,b.r,b.w),$pkg.ErrBufferFull];}c=$ifaceNil;d=b.w-b.r>>0;if(d>0)),c];}return;}var $f={$blk:P.ptr.prototype.Peek,$c:true,$r,a,b,c,d,$s};return $f;};P.prototype.Peek=function(a){return this.$val.Peek(a);};P.ptr.prototype.Discard=function(a){var{a,b,c,d,e,f,g,h,i,j,k,l,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=0;c=$ifaceNil;d=this;if(a<0){e=0;f=$pkg.ErrNegativeCount;b=e;c=f;$s=-1;return[b,c];}if(a===0){$s=-1;return[b,c];}d.lastByte=-1;d.lastRuneSize=-1;g=a;case 1:h=d.Buffered();if(h===0){$s=3;continue;}$s=4;continue;case 3:$r=d.fill();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}h=d.Buffered();case 4:if(h>g){h=g;}d.r=d.r+(h)>>0;g=g-(h)>>0;if(g===0){i=a;j=$ifaceNil;b=i;c=j;$s=-1;return[b,c];}if(!($interfaceIsEqual(d.err,$ifaceNil))){k=a-g>>0;l=d.readErr();b=k;c=l;$s=-1;return[b,c];}$s=1;continue;case 2:$s=-1;return[b,c];}return;}var $f={$blk:P.ptr.prototype.Discard,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,$s};return $f;};P.prototype.Discard=function(a){return this.$val.Discard(a);};P.ptr.prototype.Read=function(a){var{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=0;c=$ifaceNil;d=this;b=a.$length;if(b===0){if(d.Buffered()>0){e=0;f=$ifaceNil;b=e;c=f;$s=-1;return[b,c];}g=0;h=d.readErr();b=g;c=h;$s=-1;return[b,c];}if(d.r===d.w){$s=1;continue;}$s=2;continue;case 1:if(!($interfaceIsEqual(d.err,$ifaceNil))){i=0;j=d.readErr();b=i;c=j;$s=-1;return[b,c];}if(a.$length>=d.buf.$length){$s=3;continue;}$s=4;continue;case 3:l=d.rd.Read(a);$s=5;case 5:if($c){$c=false;l=l.$blk();}if(l&&l.$blk!==undefined){break s;}k=l;b=k[0];d.err=k[1];if(b<0){$panic(S);}if(b>0){d.lastByte=(((m=b-1>>0,((m<0||m>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+m]))>>0));d.lastRuneSize=-1;}n=b;o=d.readErr();b=n;c=o;$s=-1;return[b,c];case 4:d.r=0;d.w=0;q=d.rd.Read(d.buf);$s=6;case 6:if($c){$c=false;q=q.$blk();}if(q&&q.$blk!==undefined){break s;}p=q;b=p[0];d.err=p[1];if(b<0){$panic(S);}if(b===0){r=0;s=d.readErr();b=r;c=s;$s=-1;return[b,c];}d.w=d.w+(b)>>0;case 2:b=$copySlice(a,$subslice(d.buf,d.r,d.w));d.r=d.r+(b)>>0;d.lastByte=(((t=d.buf,u=d.r-1>>0,((u<0||u>=t.$length)?($throwRuntimeError("index out of range"),undefined):t.$array[t.$offset+u]))>>0));d.lastRuneSize=-1;v=b;w=$ifaceNil;b=v;c=w;$s=-1;return[b,c];}return;}var $f={$blk:P.ptr.prototype.Read,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,$s};return $f;};P.prototype.Read=function(a){return this.$val.Read(a);};P.ptr.prototype.ReadByte=function(){var{a,b,c,d,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:a=this;a.lastRuneSize=-1;case 1:if(!(a.r===a.w)){$s=2;continue;}if(!($interfaceIsEqual(a.err,$ifaceNil))){$s=-1;return[0,a.readErr()];}$r=a.fill();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=1;continue;case 2:d=(b=a.buf,c=a.r,((c<0||c>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c]));a.r=a.r+(1)>>0;a.lastByte=((d>>0));$s=-1;return[d,$ifaceNil];}return;}var $f={$blk:P.ptr.prototype.ReadByte,$c:true,$r,a,b,c,d,$s};return $f;};P.prototype.ReadByte=function(){return this.$val.ReadByte();};P.ptr.prototype.UnreadByte=function(){var a,b,c;a=this;if(a.lastByte<0||(a.r===0)&&a.w>0){return $pkg.ErrInvalidUnreadByte;}if(a.r>0){a.r=a.r-(1)>>0;}else{a.w=1;}(b=a.buf,c=a.r,((c<0||c>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+c]=((a.lastByte<<24>>>24))));a.lastByte=-1;a.lastRuneSize=-1;return $ifaceNil;};P.prototype.UnreadByte=function(){return this.$val.UnreadByte();};P.ptr.prototype.ReadRune=function(){var{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:a=0;b=0;c=$ifaceNil;d=this;case 1:if(!((d.r+4>>0)>d.w&&!D.FullRune($subslice(d.buf,d.r,d.w))&&$interfaceIsEqual(d.err,$ifaceNil)&&(d.w-d.r>>0)=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+j]))>>0));k=1;a=h;b=k;if(a>=128){l=D.DecodeRune($subslice(d.buf,d.r,d.w));a=l[0];b=l[1];}d.r=d.r+(b)>>0;d.lastByte=(((m=d.buf,n=d.r-1>>0,((n<0||n>=m.$length)?($throwRuntimeError("index out of range"),undefined):m.$array[m.$offset+n]))>>0));d.lastRuneSize=b;o=a;p=b;q=$ifaceNil;a=o;b=p;c=q;$s=-1;return[a,b,c];}return;}var $f={$blk:P.ptr.prototype.ReadRune,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,$s};return $f;};P.prototype.ReadRune=function(){return this.$val.ReadRune();};P.ptr.prototype.UnreadRune=function(){var a;a=this;if(a.lastRuneSize<0||a.r>0;a.lastByte=-1;a.lastRuneSize=-1;return $ifaceNil;};P.prototype.UnreadRune=function(){return this.$val.UnreadRune();};P.ptr.prototype.Buffered=function(){var a;a=this;return a.w-a.r>>0;};P.prototype.Buffered=function(){return this.$val.Buffered();};P.ptr.prototype.ReadSlice=function(a){var{a,b,c,d,e,f,g,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=Z.nil;c=$ifaceNil;d=this;e=0;case 1:f=A.IndexByte($subslice(d.buf,(d.r+e>>0),d.w),a);if(f>=0){f=f+(e)>>0;b=$subslice(d.buf,d.r,((d.r+f>>0)+1>>0));d.r=d.r+((f+1>>0))>>0;$s=2;continue;}if(!($interfaceIsEqual(d.err,$ifaceNil))){b=$subslice(d.buf,d.r,d.w);d.r=d.w;c=d.readErr();$s=2;continue;}if(d.Buffered()>=d.buf.$length){d.r=d.w;b=d.buf;c=$pkg.ErrBufferFull;$s=2;continue;}e=d.w-d.r>>0;$r=d.fill();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$s=1;continue;case 2:g=b.$length-1>>0;if(g>=0){d.lastByte=((((g<0||g>=b.$length)?($throwRuntimeError("index out of range"),undefined):b.$array[b.$offset+g])>>0));d.lastRuneSize=-1;}$s=-1;return[b,c];}return;}var $f={$blk:P.ptr.prototype.ReadSlice,$c:true,$r,a,b,c,d,e,f,g,$s};return $f;};P.prototype.ReadSlice=function(a){return this.$val.ReadSlice(a);};P.ptr.prototype.ReadLine=function(){var{a,b,c,d,e,f,g,h,i,j,k,l,m,$s,$r,$c}=$restore(this,{});$s=$s||0;s:while(true){switch($s){case 0:a=Z.nil;b=false;c=$ifaceNil;d=this;f=d.ReadSlice(10);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;a=e[0];c=e[1];if($interfaceIsEqual(c,$pkg.ErrBufferFull)){if(a.$length>0&&((g=a.$length-1>>0,((g<0||g>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+g]))===13)){if(d.r===0){$panic(new $String("bufio: tried to rewind past start of buffer"));}d.r=d.r-(1)>>0;a=$subslice(a,0,(a.$length-1>>0));}h=a;i=true;j=$ifaceNil;a=h;b=i;c=j;$s=-1;return[a,b,c];}if(a.$length===0){if(!($interfaceIsEqual(c,$ifaceNil))){a=Z.nil;}$s=-1;return[a,b,c];}c=$ifaceNil;if((k=a.$length-1>>0,((k<0||k>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+k]))===10){l=1;if(a.$length>1&&((m=a.$length-2>>0,((m<0||m>=a.$length)?($throwRuntimeError("index out of range"),undefined):a.$array[a.$offset+m]))===13)){l=2;}a=$subslice(a,0,(a.$length-l>>0));}$s=-1;return[a,b,c];}return;}var $f={$blk:P.ptr.prototype.ReadLine,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,m,$s};return $f;};P.prototype.ReadLine=function(){return this.$val.ReadLine();};P.ptr.prototype.collectFragments=function(a){var{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=AB.nil;c=Z.nil;d=0;e=$ifaceNil;f=this;g=Z.nil;case 1:h=$ifaceNil;j=f.ReadSlice(a);$s=3;case 3:if($c){$c=false;j=j.$blk();}if(j&&j.$blk!==undefined){break s;}i=j;g=i[0];h=i[1];if($interfaceIsEqual(h,$ifaceNil)){$s=2;continue;}if(!($interfaceIsEqual(h,$pkg.ErrBufferFull))){e=h;$s=2;continue;}k=$makeSlice(Z,g.$length);$copySlice(k,g);b=$append(b,k);d=d+(k.$length)>>0;$s=1;continue;case 2:d=d+(g.$length)>>0;l=b;m=g;n=d;o=e;b=l;c=m;d=n;e=o;$s=-1;return[b,c,d,e];}return;}var $f={$blk:P.ptr.prototype.collectFragments,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,$s};return $f;};P.prototype.collectFragments=function(a){return this.$val.collectFragments(a);};P.ptr.prototype.ReadBytes=function(a){var{a,b,c,d,e,f,g,h,i,j,k,l,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=this;d=b.collectFragments(a);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}c=d;e=c[0];f=c[1];g=c[2];h=c[3];i=$makeSlice(Z,g);g=0;j=e;k=0;while(true){if(!(k=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+l])))>>0;k++;}$copySlice($subslice(i,g),f);$s=-1;return[i,h];}return;}var $f={$blk:P.ptr.prototype.ReadBytes,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,$s};return $f;};P.prototype.ReadBytes=function(a){return this.$val.ReadBytes(a);};P.ptr.prototype.ReadString=function(a){var{a,b,c,d,e,f,g,h,i,j,k,l,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=this;d=b.collectFragments(a);$s=1;case 1:if($c){$c=false;d=d.$blk();}if(d&&d.$blk!==undefined){break s;}c=d;e=c[0];f=c[1];g=c[2];h=c[3];i=new E.Builder.ptr(AC.nil,Z.nil);i.Grow(g);j=e;k=0;while(true){if(!(k=j.$length)?($throwRuntimeError("index out of range"),undefined):j.$array[j.$offset+k]);i.Write(l);k++;}i.Write(f);$s=-1;return[i.String(),h];}return;}var $f={$blk:P.ptr.prototype.ReadString,$c:true,$r,a,b,c,d,e,f,g,h,i,j,k,l,$s};return $f;};P.prototype.ReadString=function(a){return this.$val.ReadString(a);};P.ptr.prototype.WriteTo=function(a){var{a,aa,ab,ac,ad,ae,af,ag,ah,ai,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$s,$r,$c}=$restore(this,{a});$s=$s||0;s:while(true){switch($s){case 0:b=new $Int64(0,0);c=$ifaceNil;d=this;d.lastByte=-1;d.lastRuneSize=-1;f=d.writeBuf(a);$s=1;case 1:if($c){$c=false;f=f.$blk();}if(f&&f.$blk!==undefined){break s;}e=f;b=e[0];c=e[1];if(!($interfaceIsEqual(c,$ifaceNil))){$s=-1;return[b,c];}g=$assertType(d.rd,C.WriterTo,true);h=g[0];i=g[1];if(i){$s=2;continue;}$s=3;continue;case 2:k=h.WriteTo(a);$s=4;case 4:if($c){$c=false;k=k.$blk();}if(k&&k.$blk!==undefined){break s;}j=k;l=j[0];m=j[1];b=(n=l,new $Int64(b.$high+n.$high,b.$low+n.$low));o=b;p=m;b=o;c=p;$s=-1;return[b,c];case 3:q=$assertType(a,C.ReaderFrom,true);r=q[0];s=q[1];if(s){$s=5;continue;}$s=6;continue;case 5:u=r.ReadFrom(d.rd);$s=7;case 7:if($c){$c=false;u=u.$blk();}if(u&&u.$blk!==undefined){break s;}t=u;v=t[0];w=t[1];b=(x=v,new $Int64(b.$high+x.$high,b.$low+x.$low));y=b;z=w;b=y;c=z;$s=-1;return[b,c];case 6:if((d.w-d.r>>0)>0;$s=-1;return[(new $Int64(0,e)),f];}return;}var $f={$blk:P.ptr.prototype.writeBuf,$c:true,$r,a,b,c,d,e,f,$s};return $f;};P.prototype.writeBuf=function(a){return this.$val.writeBuf(a);};AE.methods=[{prop:"Err",name:"Err",pkg:"",typ:$funcType([],[$error],false)},{prop:"Bytes",name:"Bytes",pkg:"",typ:$funcType([],[Z],false)},{prop:"Text",name:"Text",pkg:"",typ:$funcType([],[$String],false)},{prop:"Scan",name:"Scan",pkg:"",typ:$funcType([],[$Bool],false)},{prop:"advance",name:"advance",pkg:"bufio",typ:$funcType([$Int],[$Bool],false)},{prop:"setErr",name:"setErr",pkg:"bufio",typ:$funcType([$error],[],false)},{prop:"Buffer",name:"Buffer",pkg:"",typ:$funcType([Z,$Int],[],false)},{prop:"Split",name:"Split",pkg:"",typ:$funcType([G],[],false)}];AA.methods=[{prop:"Size",name:"Size",pkg:"",typ:$funcType([],[$Int],false)},{prop:"Reset",name:"Reset",pkg:"",typ:$funcType([C.Reader],[],false)},{prop:"reset",name:"reset",pkg:"bufio",typ:$funcType([Z,C.Reader],[],false)},{prop:"fill",name:"fill",pkg:"bufio",typ:$funcType([],[],false)},{prop:"readErr",name:"readErr",pkg:"bufio",typ:$funcType([],[$error],false)},{prop:"Peek",name:"Peek",pkg:"",typ:$funcType([$Int],[Z,$error],false)},{prop:"Discard",name:"Discard",pkg:"",typ:$funcType([$Int],[$Int,$error],false)},{prop:"Read",name:"Read",pkg:"",typ:$funcType([Z],[$Int,$error],false)},{prop:"ReadByte",name:"ReadByte",pkg:"",typ:$funcType([],[$Uint8,$error],false)},{prop:"UnreadByte",name:"UnreadByte",pkg:"",typ:$funcType([],[$error],false)},{prop:"ReadRune",name:"ReadRune",pkg:"",typ:$funcType([],[$Int32,$Int,$error],false)},{prop:"UnreadRune",name:"UnreadRune",pkg:"",typ:$funcType([],[$error],false)},{prop:"Buffered",name:"Buffered",pkg:"",typ:$funcType([],[$Int],false)},{prop:"ReadSlice",name:"ReadSlice",pkg:"",typ:$funcType([$Uint8],[Z,$error],false)},{prop:"ReadLine",name:"ReadLine",pkg:"",typ:$funcType([],[Z,$Bool,$error],false)},{prop:"collectFragments",name:"collectFragments",pkg:"bufio",typ:$funcType([$Uint8],[AB,Z,$Int,$error],false)},{prop:"ReadBytes",name:"ReadBytes",pkg:"",typ:$funcType([$Uint8],[Z,$error],false)},{prop:"ReadString",name:"ReadString",pkg:"",typ:$funcType([$Uint8],[$String,$error],false)},{prop:"WriteTo",name:"WriteTo",pkg:"",typ:$funcType([C.Writer],[$Int64,$error],false)},{prop:"writeBuf",name:"writeBuf",pkg:"bufio",typ:$funcType([C.Writer],[$Int64,$error],false)}];F.init("bufio",[{prop:"r",name:"r",embedded:false,exported:false,typ:C.Reader,tag:""},{prop:"split",name:"split",embedded:false,exported:false,typ:G,tag:""},{prop:"maxTokenSize",name:"maxTokenSize",embedded:false,exported:false,typ:$Int,tag:""},{prop:"token",name:"token",embedded:false,exported:false,typ:Z,tag:""},{prop:"buf",name:"buf",embedded:false,exported:false,typ:Z,tag:""},{prop:"start",name:"start",embedded:false,exported:false,typ:$Int,tag:""},{prop:"end",name:"end",embedded:false,exported:false,typ:$Int,tag:""},{prop:"err",name:"err",embedded:false,exported:false,typ:$error,tag:""},{prop:"empties",name:"empties",embedded:false,exported:false,typ:$Int,tag:""},{prop:"scanCalled",name:"scanCalled",embedded:false,exported:false,typ:$Bool,tag:""},{prop:"done",name:"done",embedded:false,exported:false,typ:$Bool,tag:""}]);G.init([Z,$Bool],[$Int,Z,$error],false);P.init("bufio",[{prop:"buf",name:"buf",embedded:false,exported:false,typ:Z,tag:""},{prop:"rd",name:"rd",embedded:false,exported:false,typ:C.Reader,tag:""},{prop:"r",name:"r",embedded:false,exported:false,typ:$Int,tag:""},{prop:"w",name:"w",embedded:false,exported:false,typ:$Int,tag:""},{prop:"err",name:"err",embedded:false,exported:false,typ:$error,tag:""},{prop:"lastByte",name:"lastByte",embedded:false,exported:false,typ:$Int,tag:""},{prop:"lastRuneSize",name:"lastRuneSize",embedded:false,exported:false,typ:$Int,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=B.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=C.$init();$s=3;case 3:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=E.$init();$s=4;case 4:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=D.$init();$s=5;case 5:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$pkg.ErrTooLong=B.New("bufio.Scanner: token too long");$pkg.ErrNegativeAdvance=B.New("bufio.Scanner: SplitFunc returns negative advance count");$pkg.ErrAdvanceTooFar=B.New("bufio.Scanner: SplitFunc returns advance count beyond input");$pkg.ErrBadReadCount=B.New("bufio.Scanner: Read returned impossible count");$pkg.ErrFinalToken=B.New("final token");$pkg.ErrInvalidUnreadByte=B.New("bufio: invalid use of UnreadByte");$pkg.ErrInvalidUnreadRune=B.New("bufio: invalid use of UnreadRune");$pkg.ErrBufferFull=B.New("bufio: buffer full");$pkg.ErrNegativeCount=B.New("bufio: negative count");S=B.New("bufio: reader returned negative count from Read");T=B.New("bufio: writer returned negative count from Write");}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/abi"]=(function(){var $pkg={},$init,A,D;A=$packages["internal/goarch"];D=function(){$throwRuntimeError("native function not implemented: internal/abi.FuncPCABI0");};$pkg.FuncPCABI0=D;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=A.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/goexperiment"]=(function(){var $pkg={},$init,A;A=$pkg.Flags=$newType(0,$kindStruct,"goexperiment.Flags",true,"internal/goexperiment",true,function(FieldTrack_,PreemptibleLoops_,StaticLockRanking_,Unified_,RegabiWrappers_,RegabiReflect_,RegabiArgs_,PacerRedesign_,HeapMinimum512KiB_){this.$val=this;if(arguments.length===0){this.FieldTrack=false;this.PreemptibleLoops=false;this.StaticLockRanking=false;this.Unified=false;this.RegabiWrappers=false;this.RegabiReflect=false;this.RegabiArgs=false;this.PacerRedesign=false;this.HeapMinimum512KiB=false;return;}this.FieldTrack=FieldTrack_;this.PreemptibleLoops=PreemptibleLoops_;this.StaticLockRanking=StaticLockRanking_;this.Unified=Unified_;this.RegabiWrappers=RegabiWrappers_;this.RegabiReflect=RegabiReflect_;this.RegabiArgs=RegabiArgs_;this.PacerRedesign=PacerRedesign_;this.HeapMinimum512KiB=HeapMinimum512KiB_;});A.init("",[{prop:"FieldTrack",name:"FieldTrack",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"PreemptibleLoops",name:"PreemptibleLoops",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"StaticLockRanking",name:"StaticLockRanking",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"Unified",name:"Unified",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"RegabiWrappers",name:"RegabiWrappers",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"RegabiReflect",name:"RegabiReflect",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"RegabiArgs",name:"RegabiArgs",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"PacerRedesign",name:"PacerRedesign",embedded:false,exported:true,typ:$Bool,tag:""},{prop:"HeapMinimum512KiB",name:"HeapMinimum512KiB",embedded:false,exported:true,typ:$Bool,tag:""}]);$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["internal/itoa"]=(function(){var $pkg={},$init,C,D,A,B;C=$arrayType($Uint8,20);D=$sliceType($Uint8);A=function(a){var a;if(a<0){return"-"+B(((-a>>>0)));}return B(((a>>>0)));};$pkg.Itoa=A;B=function(a){var a,b,c,d,e;if(a===0){return"0";}b=C.zero();c=19;while(true){if(!(a>=10)){break;}e=(d=a/10,(d===d&&d!==1/0&&d!==-1/0)?d>>>0:$throwRuntimeError("integer divide by zero"));((c<0||c>=b.length)?($throwRuntimeError("index out of range"),undefined):b[c]=((((48+a>>>0)-(e*10>>>0)>>>0)<<24>>>24)));c=c-(1)>>0;a=e;}((c<0||c>=b.length)?($throwRuntimeError("index out of range"),undefined):b[c]=(((48+a>>>0)<<24>>>24)));return($bytesToString($subslice(new D(b),c)));};$pkg.Uitoa=B;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["math/bits"]=(function(){var $pkg={},$init,A,B,C,M,N,D,E,F,H,K,L,O,R,S,AB,AL,AM,AP,AQ,AR,AS,AT,AU,AV,AW,AX,AY,AZ;A=$pkg._err=$newType(8,$kindString,"bits._err",true,"math/bits",false,null);A.prototype.Error=function(){var e;e=this.$val;return(e);};$ptrType(A).prototype.Error=function(){return new A(this.$get()).Error();};A.prototype.RuntimeError=function(){var e;e=this.$val;};$ptrType(A).prototype.RuntimeError=function(){return new A(this.$get()).RuntimeError();};D=function(e,f){var e,f,g,h,i,j,k,l,m,n,o,p;g=0;h=0;i=(e&65535)>>>0;j=e>>>16>>>0;k=(f&65535)>>>0;l=f>>>16>>>0;m=$imul(i,k)>>>0;n=($imul(j,k)>>>0)+(m>>>16>>>0)>>>0;o=(n&65535)>>>0;p=n>>>16>>>0;o=o+(($imul(i,l)>>>0))>>>0;g=(($imul(j,l)>>>0)+p>>>0)+(o>>>16>>>0)>>>0;h=$imul(e,f)>>>0;return[g,h];};$pkg.Mul32=D;E=function(e,f,g){var e,f,g,h,i;h=0;i=0;h=(e+f>>>0)+g>>>0;i=((((((e&f)>>>0))|((((((e|f)>>>0))&~h)>>>0)))>>>0))>>>31>>>0;return[h,i];};$pkg.Add32=E;F=function(e,f,g){var aa,ab,ac,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;h=0;i=0;if(g===0){$panic(C);}if(g<=e){$panic(B);}j=((K(g)>>>0));g=(k=(j),k<32?(g<>>0;l=g>>>16>>>0;m=(g&65535)>>>0;p=(((n=j,n<32?(e<>>0)|((o=((32-j>>>0)),o<32?(f>>>o):0)>>>0))>>>0;r=(q=j,q<32?(f<>>0;s=r>>>16>>>0;t=(r&65535)>>>0;v=(u=p/l,(u===u&&u!==1/0&&u!==-1/0)?u>>>0:$throwRuntimeError("integer divide by zero"));w=p-($imul(v,l)>>>0)>>>0;while(true){if(!(v>=65536||($imul(v,m)>>>0)>(($imul(65536,w)>>>0)+s>>>0))){break;}v=v-(1)>>>0;w=w+(l)>>>0;if(w>=65536){break;}}x=(($imul(p,65536)>>>0)+s>>>0)-($imul(v,g)>>>0)>>>0;z=(y=x/l,(y===y&&y!==1/0&&y!==-1/0)?y>>>0:$throwRuntimeError("integer divide by zero"));w=x-($imul(z,l)>>>0)>>>0;while(true){if(!(z>=65536||($imul(z,m)>>>0)>(($imul(65536,w)>>>0)+t>>>0))){break;}z=z-(1)>>>0;w=w+(l)>>>0;if(w>=65536){break;}}aa=($imul(v,65536)>>>0)+z>>>0;ab=(ac=j,ac<32?((((($imul(x,65536)>>>0)+t>>>0)-($imul(z,g)>>>0)>>>0))>>>ac):0)>>>0;h=aa;i=ab;return[h,i];};$pkg.Div32=F;H=function(e){var e;return 32-AM(e)>>0;};$pkg.LeadingZeros=H;K=function(e){var e;return 32-AP(e)>>0;};$pkg.LeadingZeros32=K;L=function(e){var e;return 64-AQ(e)>>0;};$pkg.LeadingZeros64=L;O=function(e){var e;if(true){return R(((e>>>0)));}return S((new $Uint64(0,e)));};$pkg.TrailingZeros=O;R=function(e){var e,f;if(e===0){return 32;}return(((f=($imul((((e&(-e>>>0))>>>0)),125613361)>>>0)>>>27>>>0,((f<0||f>=M.length)?($throwRuntimeError("index out of range"),undefined):M[f]))>>0));};$pkg.TrailingZeros32=R;S=function(e){var e,f,g;if((e.$high===0&&e.$low===0)){return 64;}return(((f=$shiftRightUint64($mul64(((g=new $Uint64(-e.$high,-e.$low),new $Uint64(e.$high&g.$high,(e.$low&g.$low)>>>0))),new $Uint64(66559345,3033172745)),58),(($flatten64(f)<0||$flatten64(f)>=N.length)?($throwRuntimeError("index out of range"),undefined):N[$flatten64(f)]))>>0));};$pkg.TrailingZeros64=S;AB=function(e,f){var e,f,g,h,i;g=(((f>>>0))&31)>>>0;return(((h=g,h<32?(e<>>0)|((i=((32-g>>>0)),i<32?(e>>>i):0)>>>0))>>>0;};$pkg.RotateLeft32=AB;AL=function(e){var e,f,g,h,i,j,k,l,m;e=(f=(g=$shiftRightUint64(e,8),new $Uint64(g.$high&16711935,(g.$low&16711935)>>>0)),h=$shiftLeft64(new $Uint64(e.$high&16711935,(e.$low&16711935)>>>0),8),new $Uint64(f.$high|h.$high,(f.$low|h.$low)>>>0));e=(i=(j=$shiftRightUint64(e,16),new $Uint64(j.$high&65535,(j.$low&65535)>>>0)),k=$shiftLeft64(new $Uint64(e.$high&65535,(e.$low&65535)>>>0),16),new $Uint64(i.$high|k.$high,(i.$low|k.$low)>>>0));return(l=$shiftRightUint64(e,32),m=$shiftLeft64(e,32),new $Uint64(l.$high|m.$high,(l.$low|m.$low)>>>0));};$pkg.ReverseBytes64=AL;AM=function(e){var e;if(true){return AP(((e>>>0)));}return AQ((new $Uint64(0,e)));};$pkg.Len=AM;AP=function(e){var e,f,g,h;f=0;if(e>=65536){e=(g=(16),g<32?(e>>>g):0)>>>0;f=16;}if(e>=256){e=(h=(8),h<32?(e>>>h):0)>>>0;f=f+(8)>>0;}f=f+(("\x00\x01\x02\x02\x03\x03\x03\x03\x04\x04\x04\x04\x04\x04\x04\x04\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b".charCodeAt(e)>>0))>>0;return f;};$pkg.Len32=AP;AQ=function(e){var e,f;f=0;if((e.$high>1||(e.$high===1&&e.$low>=0))){e=$shiftRightUint64(e,(32));f=32;}if((e.$high>0||(e.$high===0&&e.$low>=65536))){e=$shiftRightUint64(e,(16));f=f+(16)>>0;}if((e.$high>0||(e.$high===0&&e.$low>=256))){e=$shiftRightUint64(e,(8));f=f+(8)>>0;}f=f+(("\x00\x01\x02\x02\x03\x03\x03\x03\x04\x04\x04\x04\x04\x04\x04\x04\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x05\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x06\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\x07\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b".charCodeAt($flatten64(e))>>0))>>0;return f;};$pkg.Len64=AQ;AR=function(e,f,g){var e,f,g,h,i,j,k,l,m,n,o,p,q,r,s;h=0;i=0;if(true){j=E(((e>>>0)),((f>>>0)),((g>>>0)));k=j[0];l=j[1];m=((k>>>0));n=((l>>>0));h=m;i=n;return[h,i];}o=AS((new $Uint64(0,e)),(new $Uint64(0,f)),(new $Uint64(0,g)));p=o[0];q=o[1];r=((p.$low>>>0));s=((q.$low>>>0));h=r;i=s;return[h,i];};$pkg.Add=AR;AS=function(e,f,g){var e,f,g,h,i,j,k,l,m;h=new $Uint64(0,0);i=new $Uint64(0,0);h=(j=new $Uint64(e.$high+f.$high,e.$low+f.$low),new $Uint64(j.$high+g.$high,j.$low+g.$low));i=$shiftRightUint64(((k=new $Uint64(e.$high&f.$high,(e.$low&f.$low)>>>0),l=(m=new $Uint64(e.$high|f.$high,(e.$low|f.$low)>>>0),new $Uint64(m.$high&~h.$high,(m.$low&~h.$low)>>>0)),new $Uint64(k.$high|l.$high,(k.$low|l.$low)>>>0))),63);return[h,i];};$pkg.Add64=AS;AT=function(e,f,g){var e,f,g,h,i,j,k,l,m,n,o,p,q,r,s;h=0;i=0;if(true){j=AU(((e>>>0)),((f>>>0)),((g>>>0)));k=j[0];l=j[1];m=((k>>>0));n=((l>>>0));h=m;i=n;return[h,i];}o=AV((new $Uint64(0,e)),(new $Uint64(0,f)),(new $Uint64(0,g)));p=o[0];q=o[1];r=((p.$low>>>0));s=((q.$low>>>0));h=r;i=s;return[h,i];};$pkg.Sub=AT;AU=function(e,f,g){var e,f,g,h,i;h=0;i=0;h=(e-f>>>0)-g>>>0;i=(((((((~e>>>0)&f)>>>0))|((((~(((e^f)>>>0))>>>0)&h)>>>0)))>>>0))>>>31>>>0;return[h,i];};$pkg.Sub32=AU;AV=function(e,f,g){var e,f,g,h,i,j,k,l,m,n,o;h=new $Uint64(0,0);i=new $Uint64(0,0);h=(j=new $Uint64(e.$high-f.$high,e.$low-f.$low),new $Uint64(j.$high-g.$high,j.$low-g.$low));i=$shiftRightUint64(((k=(l=new $Uint64(~e.$high,~e.$low>>>0),new $Uint64(l.$high&f.$high,(l.$low&f.$low)>>>0)),m=(n=(o=new $Uint64(e.$high^f.$high,(e.$low^f.$low)>>>0),new $Uint64(~o.$high,~o.$low>>>0)),new $Uint64(n.$high&h.$high,(n.$low&h.$low)>>>0)),new $Uint64(k.$high|m.$high,(k.$low|m.$low)>>>0))),63);return[h,i];};$pkg.Sub64=AV;AW=function(e,f){var e,f,g,h,i,j,k,l,m,n,o,p,q,r;g=0;h=0;if(true){i=D(((e>>>0)),((f>>>0)));j=i[0];k=i[1];l=((j>>>0));m=((k>>>0));g=l;h=m;return[g,h];}n=AX((new $Uint64(0,e)),(new $Uint64(0,f)));o=n[0];p=n[1];q=((o.$low>>>0));r=((p.$low>>>0));g=q;h=r;return[g,h];};$pkg.Mul=AW;AX=function(e,f){var e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v;g=new $Uint64(0,0);h=new $Uint64(0,0);i=new $Uint64(e.$high&0,(e.$low&4294967295)>>>0);j=$shiftRightUint64(e,32);k=new $Uint64(f.$high&0,(f.$low&4294967295)>>>0);l=$shiftRightUint64(f,32);m=$mul64(i,k);p=(n=$mul64(j,k),o=$shiftRightUint64(m,32),new $Uint64(n.$high+o.$high,n.$low+o.$low));q=new $Uint64(p.$high&0,(p.$low&4294967295)>>>0);r=$shiftRightUint64(p,32);q=(s=$mul64(i,l),new $Uint64(q.$high+s.$high,q.$low+s.$low));g=(t=(u=$mul64(j,l),new $Uint64(u.$high+r.$high,u.$low+r.$low)),v=$shiftRightUint64(q,32),new $Uint64(t.$high+v.$high,t.$low+v.$low));h=$mul64(e,f);return[g,h];};$pkg.Mul64=AX;AY=function(e,f,g){var e,f,g,h,i,j,k,l,m,n,o,p,q,r,s;h=0;i=0;if(true){j=F(((e>>>0)),((f>>>0)),((g>>>0)));k=j[0];l=j[1];m=((k>>>0));n=((l>>>0));h=m;i=n;return[h,i];}o=AZ((new $Uint64(0,e)),(new $Uint64(0,f)),(new $Uint64(0,g)));p=o[0];q=o[1];r=((p.$low>>>0));s=((q.$low>>>0));h=r;i=s;return[h,i];};$pkg.Div=AY;AZ=function(e,f,g){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;h=new $Uint64(0,0);i=new $Uint64(0,0);if((g.$high===0&&g.$low===0)){$panic(C);}if((g.$high>>0));g=$shiftLeft64(g,(j));k=$shiftRightUint64(g,32);l=new $Uint64(g.$high&0,(g.$low&4294967295)>>>0);o=(m=$shiftLeft64(e,j),n=$shiftRightUint64(f,((64-j>>>0))),new $Uint64(m.$high|n.$high,(m.$low|n.$low)>>>0));p=$shiftLeft64(f,j);q=$shiftRightUint64(p,32);r=new $Uint64(p.$high&0,(p.$low&4294967295)>>>0);s=$div64(o,k,false);u=(t=$mul64(s,k),new $Uint64(o.$high-t.$high,o.$low-t.$low));while(true){if(!((s.$high>1||(s.$high===1&&s.$low>=0))||(v=$mul64(s,l),w=(x=$mul64(new $Uint64(1,0),u),new $Uint64(x.$high+q.$high,x.$low+q.$low)),(v.$high>w.$high||(v.$high===w.$high&&v.$low>w.$low))))){break;}s=(y=new $Uint64(0,1),new $Uint64(s.$high-y.$high,s.$low-y.$low));u=(z=k,new $Uint64(u.$high+z.$high,u.$low+z.$low));if((u.$high>1||(u.$high===1&&u.$low>=0))){break;}}ad=(aa=(ab=$mul64(o,new $Uint64(1,0)),new $Uint64(ab.$high+q.$high,ab.$low+q.$low)),ac=$mul64(s,g),new $Uint64(aa.$high-ac.$high,aa.$low-ac.$low));ae=$div64(ad,k,false);u=(af=$mul64(ae,k),new $Uint64(ad.$high-af.$high,ad.$low-af.$low));while(true){if(!((ae.$high>1||(ae.$high===1&&ae.$low>=0))||(ag=$mul64(ae,l),ah=(ai=$mul64(new $Uint64(1,0),u),new $Uint64(ai.$high+r.$high,ai.$low+r.$low)),(ag.$high>ah.$high||(ag.$high===ah.$high&&ag.$low>ah.$low))))){break;}ae=(aj=new $Uint64(0,1),new $Uint64(ae.$high-aj.$high,ae.$low-aj.$low));u=(ak=k,new $Uint64(u.$high+ak.$high,u.$low+ak.$low));if((u.$high>1||(u.$high===1&&u.$low>=0))){break;}}al=(am=$mul64(s,new $Uint64(1,0)),new $Uint64(am.$high+ae.$high,am.$low+ae.$low));an=$shiftRightUint64(((ao=(ap=$mul64(ad,new $Uint64(1,0)),new $Uint64(ap.$high+r.$high,ap.$low+r.$low)),aq=$mul64(ae,g),new $Uint64(ao.$high-aq.$high,ao.$low-aq.$low))),j);h=al;i=an;return[h,i];};$pkg.Div64=AZ;A.methods=[{prop:"Error",name:"Error",pkg:"",typ:$funcType([],[$String],false)},{prop:"RuntimeError",name:"RuntimeError",pkg:"",typ:$funcType([],[],false)}];$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:B=new A("runtime error: integer overflow");C=new A("runtime error: integer divide by zero");M=$toNativeArray($kindUint8,[0,1,28,2,29,14,24,3,30,22,20,15,25,17,4,8,31,27,13,23,21,19,16,7,26,12,18,6,11,5,10,9]);N=$toNativeArray($kindUint8,[0,1,56,2,57,49,28,3,61,58,42,50,38,29,17,4,62,47,59,36,45,43,51,22,53,39,33,30,24,18,12,5,63,55,48,27,60,41,37,16,46,35,44,21,52,32,23,11,54,26,40,15,34,20,31,10,25,14,19,9,13,8,7,6]);}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["math"]=(function(){var $pkg={},$init,B,A,IT,IU,IV,IW,DN,DO,DP,DQ,DR,FJ,BJ,BU,EB,EG,EK,EM,EN,EO,EP,EQ,ET,EY,EZ,FB,FF,FK,FL,FM,FN,FO,FV,HC,HM;B=$packages["github.com/gopherjs/gopherjs/js"];A=$packages["math/bits"];IT=$arrayType($Uint32,2);IU=$arrayType($Float32,2);IV=$arrayType($Float64,1);IW=$structType("math",[{prop:"uint32array",name:"uint32array",embedded:false,exported:false,typ:IT,tag:""},{prop:"float32array",name:"float32array",embedded:false,exported:false,typ:IU,tag:""},{prop:"float64array",name:"float64array",embedded:false,exported:false,typ:IV,tag:""}]);BJ=function(av){var av,aw,ax,ay;aw=EK(av);ax=aw[0];ay=aw[1];if(ax===0.5){return((ay-1>>0));}return EQ(ax)*1.4426950408889634+(ay);};BU=function(av,aw){var av,aw,ax,ay,az,ba,bb,bc;if((av===0)){return av;}else if(EN(av,0)||EO(av)){return av;}ax=HC(av);av=ax[0];ay=ax[1];aw=aw+(ay)>>0;az=FN(av);aw=aw+((((($shiftRightUint64(az,52).$low>>0))&2047)-1023>>0))>>0;if(aw<-1075){return EB(0,av);}if(aw>1023){if(av<0){return EM(-1);}return EM(1);}ba=1;if(aw<-1022){aw=aw+(53)>>0;ba=1.1102230246251565e-16;}az=(bb=new $Uint64(2146435072,0),new $Uint64(az.$high&~bb.$high,(az.$low&~bb.$low)>>>0));az=(bc=$shiftLeft64((new $Uint64(0,(aw+1023>>0))),52),new $Uint64(az.$high|bc.$high,(az.$low|bc.$low)>>>0));return ba*FO(az);};EB=function(av,aw){var av,aw;if(!((av<0||(1/av===DQ))===(aw<0||(1/aw===DQ)))){return-av;}return av;};$pkg.Copysign=EB;EG=function(av){var av;return $parseFloat(DN.exp(av));};$pkg.Exp=EG;EK=function(av){var av,aw,ax,ay;aw=0;ax=0;ay=FV(av);aw=ay[0];ax=ay[1];return[aw,ax];};$pkg.Frexp=EK;EM=function(av){var av;if(av>=0){return DP;}else{return DQ;}};$pkg.Inf=EM;EN=function(av,aw){var av,aw;if(av===DP){return aw>=0;}if(av===DQ){return aw<=0;}return false;};$pkg.IsInf=EN;EO=function(av){var av,aw;aw=false;aw=!((av===av));return aw;};$pkg.IsNaN=EO;EP=function(av,aw){var av,aw;if(-1024>>0));FJ.uint32array[1]=(($shiftRightUint64(av,32).$low>>>0));return FJ.float64array[0];};$pkg.Float64frombits=FO;FV=function(av){var av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg;aw=0;ax=0;if((av===0)){ay=av;az=0;aw=ay;ax=az;return[aw,ax];}else if(EN(av,0)||EO(av)){ba=av;bb=0;aw=ba;ax=bb;return[aw,ax];}bc=HC(av);av=bc[0];ax=bc[1];bd=FN(av);ax=ax+((((((be=$shiftRightUint64(bd,52),new $Uint64(be.$high&0,(be.$low&2047)>>>0)).$low>>0))-1023>>0)+1>>0))>>0;bd=(bf=new $Uint64(2146435072,0),new $Uint64(bd.$high&~bf.$high,(bd.$low&~bf.$low)>>>0));bd=(bg=new $Uint64(1071644672,0),new $Uint64(bd.$high|bg.$high,(bd.$low|bg.$low)>>>0));aw=FO(bd);return[aw,ax];};HC=function(av){var av,aw,ax,ay,az,ba,bb;aw=0;ax=0;if(HM(av)<2.2250738585072014e-308){ay=av*4.503599627370496e+15;az=-52;aw=ay;ax=az;return[aw,ax];}ba=av;bb=0;aw=ba;ax=bb;return[aw,ax];};HM=function(av){var av,aw;return FO((aw=FN(av),new $Uint64(aw.$high&~2147483648,(aw.$low&~0)>>>0)));};$pkg.Abs=HM;$init=function(){$pkg.$init=function(){};var $f,$c=false,$s=0,$r;if(this!==undefined&&this.$blk!==undefined){$f=this;$c=true;$s=$f.$s;$r=$f.$r;}s:while(true){switch($s){case 0:$r=B.$init();$s=1;case 1:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}$r=A.$init();$s=2;case 2:if($c){$c=false;$r=$r.$blk();}if($r&&$r.$blk!==undefined){break s;}FJ=new IW.ptr(IT.zero(),IU.zero(),IV.zero());DN=$global.Math;DO=0;DP=1/DO;DQ=-1/DO;DR=$parseFloat($NaN);FK();}return;}if($f===undefined){$f={$blk:$init};}$f.$s=$s;$f.$r=$r;return $f;};$pkg.$init=$init;return $pkg;})();
+$packages["strconv"]=(function(){var $pkg={},$init,F,C,E,D,B,A,BL,BU,CE,CI,CQ,DT,DU,DV,DW,DX,DY,DZ,EA,EB,EC,ED,EE,EF,EG,EH,EI,AQ,AR,AS,AT,AU,AZ,BM,DR,BN,DS,CD,CJ,CY,DC,DD,DE,G,H,J,K,L,M,N,O,P,T,V,Y,Z,AA,AC,AD,AE,AF,AG,AI,AJ,AK,AL,AM,AN,AO,AP,AV,AW,AX,AY,BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BK,BO,BP,BQ,BR,BS,BT,BV,BW,BX,BY,BZ,CA,CB,CC,CF,CG,CH,CK,CL,CM,CO,CP,CR,CS,CT,CU,CV,CW,CX,CZ,DA,DB,DF,DG,DH,DI,DJ,DK,DL,DP;F=$packages["errors"];C=$packages["github.com/gopherjs/gopherjs/js"];E=$packages["internal/bytealg"];D=$packages["math"];B=$packages["math/bits"];A=$packages["unicode/utf8"];BL=$pkg.floatInfo=$newType(0,$kindStruct,"strconv.floatInfo",true,"strconv",false,function(mantbits_,expbits_,bias_){this.$val=this;if(arguments.length===0){this.mantbits=0;this.expbits=0;this.bias=0;return;}this.mantbits=mantbits_;this.expbits=expbits_;this.bias=bias_;});BU=$pkg.decimalSlice=$newType(0,$kindStruct,"strconv.decimalSlice",true,"strconv",false,function(d_,nd_,dp_,neg_){this.$val=this;if(arguments.length===0){this.d=EA.nil;this.nd=0;this.dp=0;this.neg=false;return;}this.d=d_;this.nd=nd_;this.dp=dp_;this.neg=neg_;});CE=$pkg.decimal=$newType(0,$kindStruct,"strconv.decimal",true,"strconv",false,function(d_,nd_,dp_,neg_,trunc_){this.$val=this;if(arguments.length===0){this.d=EG.zero();this.nd=0;this.dp=0;this.neg=false;this.trunc=false;return;}this.d=d_;this.nd=nd_;this.dp=dp_;this.neg=neg_;this.trunc=trunc_;});CI=$pkg.leftCheat=$newType(0,$kindStruct,"strconv.leftCheat",true,"strconv",false,function(delta_,cutoff_){this.$val=this;if(arguments.length===0){this.delta=0;this.cutoff="";return;}this.delta=delta_;this.cutoff=cutoff_;});CQ=$pkg.NumError=$newType(0,$kindStruct,"strconv.NumError",true,"strconv",true,function(Func_,Num_,Err_){this.$val=this;if(arguments.length===0){this.Func="";this.Num="";this.Err=$ifaceNil;return;}this.Func=Func_;this.Num=Num_;this.Err=Err_;});DT=$sliceType($Uint16);DU=$sliceType($Uint32);DV=$arrayType($Uint64,2);DW=$sliceType(CI);DX=$sliceType($Int);DY=$sliceType($Float64);DZ=$sliceType($Float32);EA=$sliceType($Uint8);EB=$arrayType($Uint8,4);EC=$arrayType($Uint8,65);ED=$ptrType(BL);EE=$arrayType($Uint8,32);EF=$arrayType($Uint8,24);EG=$arrayType($Uint8,800);EH=$ptrType(CQ);EI=$ptrType(CE);G=function(c,d){var c,d;return!((CO(c,d)===-1));};H=function(c,d,e,f){var c,d,e,f,g;return($bytesToString(J($makeSlice(EA,0,(g=($imul(3,c.length))/2,(g===g&&g!==1/0&&g!==-1/0)?g>>0:$throwRuntimeError("integer divide by zero"))),c,d,e,f)));};J=function(c,d,e,f,g){var c,d,e,f,g,h,i,j,k;if((c.$capacity-c.$length>>0)>0)+d.length>>0)+1>>0));$copySlice(h,c);c=h;}c=$append(c,e);i=0;while(true){if(!(d.length>0)){break;}j=((d.charCodeAt(0)>>0));i=1;if(j>=128){k=A.DecodeRuneInString(d);j=k[0];i=k[1];}if((i===1)&&(j===65533)){c=$appendSlice(c,"\\x");c=$append(c,"0123456789abcdef".charCodeAt((d.charCodeAt(0)>>>4<<24>>>24)));c=$append(c,"0123456789abcdef".charCodeAt(((d.charCodeAt(0)&15)>>>0)));d=$substring(d,i);continue;}c=L(c,j,e,f,g);d=$substring(d,i);}c=$append(c,e);return c;};K=function(c,d,e,f,g){var c,d,e,f,g;c=$append(c,e);if(!A.ValidRune(d)){d=65533;}c=L(c,d,e,f,g);c=$append(c,e);return c;};L=function(c,d,e,f,g){var c,d,e,f,g,h,i,j,k,l;h=EB.zero();if((d===((e>>0)))||(d===92)){c=$append(c,92);c=$append(c,((d<<24>>>24)));return c;}if(f){if(d<128&&AG(d)){c=$append(c,((d<<24>>>24)));return c;}}else if(AG(d)||g&&AI(d)){i=A.EncodeRune(new EA(h),d);c=$appendSlice(c,$subslice(new EA(h),0,i));return c;}j=d;if(j===(7)){c=$appendSlice(c,"\\a");}else if(j===(8)){c=$appendSlice(c,"\\b");}else if(j===(12)){c=$appendSlice(c,"\\f");}else if(j===(10)){c=$appendSlice(c,"\\n");}else if(j===(13)){c=$appendSlice(c,"\\r");}else if(j===(9)){c=$appendSlice(c,"\\t");}else if(j===(11)){c=$appendSlice(c,"\\v");}else{if(d<32){c=$appendSlice(c,"\\x");c=$append(c,"0123456789abcdef".charCodeAt((((d<<24>>>24))>>>4<<24>>>24)));c=$append(c,"0123456789abcdef".charCodeAt(((((d<<24>>>24))&15)>>>0)));}else if(!A.ValidRune(d)){d=65533;c=$appendSlice(c,"\\u");k=12;while(true){if(!(k>=0)){break;}c=$append(c,"0123456789abcdef".charCodeAt((((d>>$min(((k>>>0)),31))>>0)&15)));k=k-(4)>>0;}}else if(d<65536){c=$appendSlice(c,"\\u");k=12;while(true){if(!(k>=0)){break;}c=$append(c,"0123456789abcdef".charCodeAt((((d>>$min(((k>>>0)),31))>>0)&15)));k=k-(4)>>0;}}else{c=$appendSlice(c,"\\U");l=28;while(true){if(!(l>=0)){break;}c=$append(c,"0123456789abcdef".charCodeAt((((d>>$min(((l>>>0)),31))>>0)&15)));l=l-(4)>>0;}}}return c;};M=function(c){var c;return H(c,34,false,false);};$pkg.Quote=M;N=function(c,d){var c,d;return J(c,d,34,false,false);};$pkg.AppendQuote=N;O=function(c){var c;return H(c,34,true,false);};$pkg.QuoteToASCII=O;P=function(c,d){var c,d;return J(c,d,34,true,false);};$pkg.AppendQuoteToASCII=P;T=function(c,d){var c,d;return K(c,d,39,false,false);};$pkg.AppendQuoteRune=T;V=function(c,d){var c,d;return K(c,d,39,true,false);};$pkg.AppendQuoteRuneToASCII=V;Y=function(c){var c,d,e,f;while(true){if(!(c.length>0)){break;}d=A.DecodeRuneInString(c);e=d[0];f=d[1];c=$substring(c,f);if(f>1){if(e===65279){return false;}continue;}if(e===65533){return false;}if((e<32&&!((e===9)))||(e===96)||(e===127)){return false;}}return true;};$pkg.CanBackquote=Y;Z=function(c){var c,d,e,f,g,h,i,j,k,l;d=0;e=false;f=((c>>0));if(48<=f&&f<=57){g=f-48>>0;h=true;d=g;e=h;return[d,e];}else if(97<=f&&f<=102){i=(f-97>>0)+10>>0;j=true;d=i;e=j;return[d,e];}else if(65<=f&&f<=70){k=(f-65>>0)+10>>0;l=true;d=k;e=l;return[d,e];}return[d,e];};AA=function(c,d){var aa,ab,ac,ad,ae,af,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;e=0;f=false;g="";h=$ifaceNil;if(c.length===0){h=$pkg.ErrSyntax;return[e,f,g,h];}i=c.charCodeAt(0);if((i===d)&&((d===39)||(d===34))){h=$pkg.ErrSyntax;return[e,f,g,h];}else if(i>=128){j=A.DecodeRuneInString(c);k=j[0];l=j[1];m=k;n=true;o=$substring(c,l);p=$ifaceNil;e=m;f=n;g=o;h=p;return[e,f,g,h];}else if(!((i===92))){q=((c.charCodeAt(0)>>0));r=false;s=$substring(c,1);t=$ifaceNil;e=q;f=r;g=s;h=t;return[e,f,g,h];}if(c.length<=1){h=$pkg.ErrSyntax;return[e,f,g,h];}u=c.charCodeAt(1);c=$substring(c,2);switch(0){default:v=u;if(v===(97)){e=7;}else if(v===(98)){e=8;}else if(v===(102)){e=12;}else if(v===(110)){e=10;}else if(v===(114)){e=13;}else if(v===(116)){e=9;}else if(v===(118)){e=11;}else if((v===(120))||(v===(117))||(v===(85))){w=0;x=u;if(x===(120)){w=2;}else if(x===(117)){w=4;}else if(x===(85)){w=8;}y=0;if(c.length>0)|ab;z=z+(1)>>0;}c=$substring(c,w);if(u===120){e=y;break;}if(!A.ValidRune(y)){h=$pkg.ErrSyntax;return[e,f,g,h];}e=y;f=true;}else if((v===(48))||(v===(49))||(v===(50))||(v===(51))||(v===(52))||(v===(53))||(v===(54))||(v===(55))){ad=((u>>0))-48>>0;if(c.length<2){h=$pkg.ErrSyntax;return[e,f,g,h];}ae=0;while(true){if(!(ae<2)){break;}af=((c.charCodeAt(ae)>>0))-48>>0;if(af<0||af>7){h=$pkg.ErrSyntax;return[e,f,g,h];}ad=((ad<<3>>0))|af;ae=ae+(1)>>0;}c=$substring(c,2);if(ad>255){h=$pkg.ErrSyntax;return[e,f,g,h];}e=ad;}else if(v===(92)){e=92;}else if((v===(39))||(v===(34))){if(!((u===d))){h=$pkg.ErrSyntax;return[e,f,g,h];}e=((u>>0));}else{h=$pkg.ErrSyntax;return[e,f,g,h];}}g=c;return[e,f,g,h];};$pkg.UnquoteChar=AA;AC=function(c){var c,d,e,f,g;d=AD(c,true);e=d[0];f=d[1];g=d[2];if(f.length>0){return["",$pkg.ErrSyntax];}return[e,g];};$pkg.Unquote=AC;AD=function(c,d){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;e="";f="";g=$ifaceNil;if(c.length<2){h="";i=c;j=$pkg.ErrSyntax;e=h;f=i;g=j;return[e,f,g];}k=c.charCodeAt(0);l=CO($substring(c,1),k);if(l<0){m="";n=c;o=$pkg.ErrSyntax;e=m;f=n;g=o;return[e,f,g];}l=l+(2)>>0;p=k;if(p===(96)){if(!d){e=$substring(c,0,l);}else if(!G($substring(c,0,l),13)){e=$substring(c,1,(l-1>>0));}else{q=$makeSlice(EA,0,(((l-1>>0)-1>>0)-1>>0));r=1;while(true){if(!(r<(l-1>>0))){break;}if(!((c.charCodeAt(r)===13))){q=$append(q,c.charCodeAt(r));}r=r+(1)>>0;}e=($bytesToString(q));}s=e;t=$substring(c,l);u=$ifaceNil;e=s;f=t;g=u;return[e,f,g];}else if((p===(34))||(p===(39))){if(!G($substring(c,0,l),92)&&!G($substring(c,0,l),10)){v=false;w=k;if(w===(34)){v=A.ValidString($substring(c,1,(l-1>>0)));}else if(w===(39)){x=A.DecodeRuneInString($substring(c,1,(l-1>>0)));y=x[0];z=x[1];v=(((1+z>>0)+1>>0)===l)&&(!((y===65533))||!((z===1)));}if(v){e=$substring(c,0,l);if(d){e=$substring(e,1,(l-1>>0));}aa=e;ab=$substring(c,l);ac=$ifaceNil;e=aa;f=ab;g=ac;return[e,f,g];}}ad=EA.nil;ae=c;c=$substring(c,1);if(d){ad=$makeSlice(EA,0,(af=($imul(3,l))/2,(af===af&&af!==1/0&&af!==-1/0)?af>>0:$throwRuntimeError("integer divide by zero")));}while(true){if(!(c.length>0&&!((c.charCodeAt(0)===k)))){break;}ag=AA(c,k);ah=ag[0];ai=ag[1];aj=ag[2];ak=ag[3];if((c.charCodeAt(0)===10)||!($interfaceIsEqual(ak,$ifaceNil))){al="";am=ae;an=$pkg.ErrSyntax;e=al;f=am;g=an;return[e,f,g];}c=aj;if(d){if(ah<128||!ai){ad=$append(ad,((ah<<24>>>24)));}else{ao=EB.zero();ap=A.EncodeRune(new EA(ao),ah);ad=$appendSlice(ad,$subslice(new EA(ao),0,ap));}}if(k===39){break;}}if(!(c.length>0&&(c.charCodeAt(0)===k))){aq="";ar=ae;as=$pkg.ErrSyntax;e=aq;f=ar;g=as;return[e,f,g];}c=$substring(c,1);if(d){at=($bytesToString(ad));au=c;av=$ifaceNil;e=at;f=au;g=av;return[e,f,g];}aw=$substring(ae,0,(ae.length-c.length>>0));ax=c;ay=$ifaceNil;e=aw;f=ax;g=ay;return[e,f,g];}else{az="";ba=c;bb=$pkg.ErrSyntax;e=az;f=ba;g=bb;return[e,f,g];}};AE=function(c,d){var c,d,e,f,g,h,i;e=0;f=c.$length;g=e;h=f;while(true){if(!(g>0))>>1>>0)>>0;if(((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i])>0;}else{h=i;}}return g;};AF=function(c,d){var c,d,e,f,g,h,i;e=0;f=c.$length;g=e;h=f;while(true){if(!(g>0))>>1>>0)>>0;if(((i<0||i>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+i])>0;}else{h=i;}}return g;};AG=function(c){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;if(c<=255){if(32<=c&&c<=126){return true;}if(161<=c&&c<=255){return!((c===173));}return false;}if(0<=c&&c<65536){d=((c<<16>>>16));e=AQ;f=AR;g=d;h=e;i=f;j=AE(h,g);if(j>=h.$length||g<(k=(j&~1)>>0,((k<0||k>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+k]))||(l=j|1,((l<0||l>=h.$length)?($throwRuntimeError("index out of range"),undefined):h.$array[h.$offset+l]))=i.$length||!((((m<0||m>=i.$length)?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+m])===g));}n=((c>>>0));o=AS;p=AT;q=n;r=o;s=p;t=AF(r,q);if(t>=r.$length||q<(u=(t&~1)>>0,((u<0||u>=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+u]))||(v=t|1,((v<0||v>=r.$length)?($throwRuntimeError("index out of range"),undefined):r.$array[r.$offset+v]))=131072){return true;}c=c-(65536)>>0;w=AE(s,((c<<16>>>16)));return w>=s.$length||!((((w<0||w>=s.$length)?($throwRuntimeError("index out of range"),undefined):s.$array[s.$offset+w])===((c<<16>>>16))));};$pkg.IsPrint=AG;AI=function(c){var c,d,e;if(c>65535){return false;}d=((c<<16>>>16));e=AE(AU,d);return e=AU.$length)?($throwRuntimeError("index out of range"),undefined):AU.$array[AU.$offset+e]));};AJ=function(c,d){var c,d,e,f;if(true&&(c.$high<0||(c.$high===0&&c.$low<100))&&(d===10)){return AN(((c.$low>>0)));}e=AO(EA.nil,c,d,false,false);f=e[1];return f;};$pkg.FormatUint=AJ;AK=function(c,d){var c,d,e,f;if(true&&(0>31)*4294967296))>>0)));}e=AO(EA.nil,(new $Uint64(c.$high,c.$low)),d,(c.$high<0||(c.$high===0&&c.$low<0)),false);f=e[1];return f;};$pkg.FormatInt=AK;AL=function(c,d,e){var c,d,e,f;if(true&&(0>31)*4294967296))>>0))));}f=AO(c,(new $Uint64(d.$high,d.$low)),e,(d.$high<0||(d.$high===0&&d.$low<0)),true);c=f[0];return c;};$pkg.AppendInt=AL;AM=function(c,d,e){var c,d,e,f;if(true&&(d.$high<0||(d.$high===0&&d.$low<100))&&(e===10)){return $appendSlice(c,AN(((d.$low>>0))));}f=AO(c,d,e,false,true);c=f[0];return c;};$pkg.AppendUint=AM;AN=function(c){var c;if(c<10){return $substring("0123456789abcdefghijklmnopqrstuvwxyz",c,(c+1>>0));}return $substring("00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899",($imul(c,2)),(($imul(c,2))+2>>0));};AO=function(c,d,e,f,g){var aa,ab,ac,ad,ae,af,ag,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;h=EA.nil;i="";if(e<2||e>36){$panic(new $String("strconv: illegal AppendInt/FormatInt base"));}j=EC.zero();k=65;if(f){d=new $Uint64(-d.$high,-d.$low);}if(e===10){if(true){while(true){if(!((d.$high>0||(d.$high===0&&d.$low>=1000000000)))){break;}l=$div64(d,new $Uint64(0,1000000000),false);n=(((m=$mul64(l,new $Uint64(0,1000000000)),new $Uint64(d.$high-m.$high,d.$low-m.$low)).$low>>>0));o=4;while(true){if(!(o>0)){break;}q=(p=n%100,p===p?p:$throwRuntimeError("integer divide by zero"))*2>>>0;n=(r=n/(100),(r===r&&r!==1/0&&r!==-1/0)?r>>>0:$throwRuntimeError("integer divide by zero"));k=k-(2)>>0;(s=k+1>>0,((s<0||s>=j.length)?($throwRuntimeError("index out of range"),undefined):j[s]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((q+1>>>0))));(t=k+0>>0,((t<0||t>=j.length)?($throwRuntimeError("index out of range"),undefined):j[t]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((q+0>>>0))));o=o-(1)>>0;}k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(((n*2>>>0)+1>>>0)));d=l;}}u=((d.$low>>>0));while(true){if(!(u>=100)){break;}w=(v=u%100,v===v?v:$throwRuntimeError("integer divide by zero"))*2>>>0;u=(x=u/(100),(x===x&&x!==1/0&&x!==-1/0)?x>>>0:$throwRuntimeError("integer divide by zero"));k=k-(2)>>0;(y=k+1>>0,((y<0||y>=j.length)?($throwRuntimeError("index out of range"),undefined):j[y]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((w+1>>>0))));(z=k+0>>0,((z<0||z>=j.length)?($throwRuntimeError("index out of range"),undefined):j[z]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((w+0>>>0))));}aa=u*2>>>0;k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((aa+1>>>0)));if(u>=10){k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt(aa));}}else if(AP(e)){ab=(((B.TrailingZeros(((e>>>0)))>>>0))&7)>>>0;ac=(new $Uint64(0,e));ad=((e>>>0))-1>>>0;while(true){if(!((d.$high>ac.$high||(d.$high===ac.$high&&d.$low>=ac.$low)))){break;}k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((((d.$low>>>0))&ad)>>>0)));d=$shiftRightUint64(d,(ab));}k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((d.$low>>>0))));}else{ae=(new $Uint64(0,e));while(true){if(!((d.$high>ae.$high||(d.$high===ae.$high&&d.$low>=ae.$low)))){break;}k=k-(1)>>0;af=$div64(d,ae,false);((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((((ag=$mul64(af,ae),new $Uint64(d.$high-ag.$high,d.$low-ag.$low)).$low>>>0))));d=af;}k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]="0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((d.$low>>>0))));}if(f){k=k-(1)>>0;((k<0||k>=j.length)?($throwRuntimeError("index out of range"),undefined):j[k]=45);}if(g){h=$appendSlice(c,$subslice(new EA(j),k));return[h,i];}i=($bytesToString($subslice(new EA(j),k)));return[h,i];};AP=function(c){var c;return(c&((c-1>>0)))===0;};AV=function(c){var c;return $internalize(c.toString(),$String);};$pkg.Itoa=AV;AW=function(c){var c,d,e,f,g;if(c.length===0){return[0,CR("Atoi",c)];}d=0;while(true){if(!(d57){if(!((e===43))&&!((e===45))){return[0,CR("Atoi",c)];}}d=d+(1)>>0;}f=$global.Number($externalize(c,$String),10);if(!!!($global.isFinite(f))){return[0,CR("Atoi",c)];}g=$parseFloat(f);if(g>2.147483647e+09){return[2147483647,CS("Atoi",c)];}else if(g<-2.147483648e+09){return[-2147483648,CS("Atoi",c)];}return[$parseInt(f)>>0,$ifaceNil];};$pkg.Atoi=AW;AX=function(c,d,e,f){var aa,ab,ac,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if(f<0){$panic(new $String("ryuFtoaFixed32 called with negative prec"));}if(f>9){$panic(new $String("ryuFtoaFixed32 called with prec > 9"));}if(d===0){g=0;h=0;c.nd=g;c.dp=h;return;}i=e;j=B.Len32(d);if(j<25){d=(k=((((25-j>>0)>>>0))),k<32?(d<>>0;i=i+(((j)-25>>0))>>0;}l=(-BC(i+24>>0)+f>>0)-1>>0;m=l<=27&&l>=0;n=BH(d,i,l);o=n[0];p=n[1];q=n[2];if(p>=0){$panic(new $String("not enough significant bits after mult64bitPow10"));}if(l<0&&l>=-10&&BJ((new $Uint64(0,d)),-l)){m=true;q=true;}r=((-p>>>0));t=((((s=r,s<32?(1<>>0)-1>>>0));u=(v=r,v<32?(o>>>v):0)>>>0;w=(o&t)>>>0;o=u;x=w;y=false;if(m){y=x>((z=((r-1>>>0)),z<32?(1<>>0)||((x===((aa=((r-1>>>0)),aa<32?(1<>>0))&&!q)||((x===((ab=((r-1>>>0)),ab<32?(1<>>0))&&q&&(((o&1)>>>0)===1));}else{y=((ac=((r-1>>>0)),ac<32?(x>>>ac):0)>>>0)===1;}if(!((x===0))){q=false;}BA(c,(new $Uint64(0,o)),!q,y,f);c.dp=c.dp-(l)>>0;};AY=function(c,d,e,f){var aa,ab,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if(f>18){$panic(new $String("ryuFtoaFixed64 called with prec > 18"));}if((d.$high===0&&d.$low===0)){g=0;h=0;c.nd=g;c.dp=h;return;}i=e;j=B.Len64(d);if(j<55){d=$shiftLeft64(d,(((55-j>>0)>>>0)));i=i+(((j)-55>>0))>>0;}k=(-BC(i+54>>0)+f>>0)-1>>0;l=k<=55&&k>=0;m=BI(d,i,k);n=m[0];o=m[1];p=m[2];if(o>=0){$panic(new $String("not enough significant bits after mult128bitPow10"));}if(k<0&&k>=-22&&BJ(d,-k)){l=true;p=true;}q=((-o>>>0));s=((r=$shiftLeft64(new $Uint64(0,1),q),new $Uint64(r.$high-0,r.$low-1)));t=$shiftRightUint64(n,q);u=new $Uint64(n.$high&s.$high,(n.$low&s.$low)>>>0);n=t;v=u;w=false;if(l){w=(x=$shiftLeft64(new $Uint64(0,1),((q-1>>>0))),(v.$high>x.$high||(v.$high===x.$high&&v.$low>x.$low)))||((y=$shiftLeft64(new $Uint64(0,1),((q-1>>>0))),(v.$high===y.$high&&v.$low===y.$low))&&!p)||((z=$shiftLeft64(new $Uint64(0,1),((q-1>>>0))),(v.$high===z.$high&&v.$low===z.$low))&&p&&(aa=new $Uint64(n.$high&0,(n.$low&1)>>>0),(aa.$high===0&&aa.$low===1)));}else{w=(ab=$shiftRightUint64(v,((q-1>>>0))),(ab.$high===0&&ab.$low===1));}if(!((v.$high===0&&v.$low===0))){p=false;}BA(c,n,!p,w,f);c.dp=c.dp-(k)>>0;};BA=function(c,d,e,f,g){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;h=((g<0||g>=AZ.length)?($throwRuntimeError("index out of range"),undefined):AZ[g]);i=0;while(true){if(!((d.$high>h.$high||(d.$high===h.$high&&d.$low>=h.$low)))){break;}j=$div64(d,new $Uint64(0,10),false);k=$div64(d,new $Uint64(0,10),true);l=j;m=k;d=l;i=i+(1)>>0;if((m.$high>0||(m.$high===0&&m.$low>5))){f=true;}else if((m.$high<0||(m.$high===0&&m.$low<5))){f=false;}else{f=e||(n=new $Uint64(d.$high&0,(d.$low&1)>>>0),(n.$high===0&&n.$low===1));}if(!((m.$high===0&&m.$low===0))){e=true;}}if(f){d=(o=new $Uint64(0,1),new $Uint64(d.$high+o.$high,d.$low+o.$low));}if((d.$high>h.$high||(d.$high===h.$high&&d.$low>=h.$low))){d=$div64(d,(new $Uint64(0,10)),false);i=i+(1)>>0;}p=((g>>>0));c.nd=(g);q=d;while(true){if(!((q.$high>0||(q.$high===0&&q.$low>=100)))){break;}r=new $Uint64(0,0);s=new $Uint64(0,0);t=r;u=s;if((v=$shiftRightUint64(q,32),(v.$high===0&&v.$low===0))){w=(new $Uint64(0,(x=((q.$low>>>0))/100,(x===x&&x!==1/0&&x!==-1/0)?x>>>0:$throwRuntimeError("integer divide by zero"))));y=(new $Uint64(0,(z=((q.$low>>>0))%100,z===z?z:$throwRuntimeError("integer divide by zero"))));t=w;u=y;}else{aa=$div64(q,new $Uint64(0,100),false);ab=$div64(q,new $Uint64(0,100),true);t=aa;u=ab;}p=p-(2)>>>0;(ad=c.d,ae=p+1>>>0,((ae<0||ae>=ad.$length)?($throwRuntimeError("index out of range"),undefined):ad.$array[ad.$offset+ae]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt($flatten64((ac=$mul64(new $Uint64(0,2),u),new $Uint64(ac.$high+0,ac.$low+1))))));(ag=c.d,ah=p+0>>>0,((ah<0||ah>=ag.$length)?($throwRuntimeError("index out of range"),undefined):ag.$array[ag.$offset+ah]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt($flatten64((af=$mul64(new $Uint64(0,2),u),new $Uint64(af.$high+0,af.$low+0))))));q=t;}if((q.$high>0||(q.$high===0&&q.$low>0))){p=p-(1)>>>0;(aj=c.d,((p<0||p>=aj.$length)?($throwRuntimeError("index out of range"),undefined):aj.$array[aj.$offset+p]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt($flatten64((ai=$mul64(new $Uint64(0,2),q),new $Uint64(ai.$high+0,ai.$low+1))))));}if((q.$high>0||(q.$high===0&&q.$low>=10))){p=p-(1)>>>0;(ak=c.d,((p<0||p>=ak.$length)?($throwRuntimeError("index out of range"),undefined):ak.$array[ak.$offset+p]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt($flatten64($mul64(new $Uint64(0,2),q)))));}while(true){if(!((al=c.d,am=c.nd-1>>0,((am<0||am>=al.$length)?($throwRuntimeError("index out of range"),undefined):al.$array[al.$offset+am]))===48)){break;}c.nd=c.nd-(1)>>0;i=i+(1)>>0;}c.dp=c.nd+i>>0;};BB=function(c,d,e,f){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,be,bf,bg,bh,bi,bj,bk,bl,bm,bn,bo,bp,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if((d.$high===0&&d.$low===0)){g=0;h=0;c.nd=g;c.dp=h;return;}if(e<=0&&B.TrailingZeros64(d)>=-e){d=$shiftRightUint64(d,(((-e>>>0))));BF(c,d,d,d,true,false);return;}i=BE(d,e,f);j=i[0];k=i[1];l=i[2];m=i[3];if(m===0){BF(c,j,k,l,true,false);return;}n=BC(-m)+1>>0;o=new $Uint64(0,0);p=new $Uint64(0,0);q=new $Uint64(0,0);r=o;s=p;t=q;u=false;v=false;w=false;x=u;y=v;z=w;if(f===BM){aa=0;ab=0;ac=0;ad=aa;ae=ab;af=ac;ag=BH(((j.$low>>>0)),m,n);ad=ag[0];x=ag[2];ah=BH(((k.$low>>>0)),m,n);ae=ah[0];y=ah[2];ai=BH(((l.$low>>>0)),m,n);af=ai[0];m=ai[1];z=ai[2];aj=(new $Uint64(0,ad));ak=(new $Uint64(0,ae));al=(new $Uint64(0,af));r=aj;s=ak;t=al;}else{am=BI(j,m,n);r=am[0];x=am[2];an=BI(k,m,n);s=an[0];y=an[2];ao=BI(l,m,n);t=ao[0];m=ao[1];z=ao[2];}if(m>=0){$panic(new $String("not enough significant bits after mult128bitPow10"));}if(n>55){ap=false;aq=false;ar=false;x=ap;y=aq;z=ar;}if(n<0&&n>=-24){if(BJ(j,-n)){x=true;}if(BJ(k,-n)){y=true;}if(BJ(l,-n)){z=true;}}as=((-m>>>0));au=((at=$shiftLeft64(new $Uint64(0,1),as),new $Uint64(at.$high-0,at.$low-1)));av=$shiftRightUint64(r,as);aw=new $Uint64(r.$high&au.$high,(r.$low&au.$low)>>>0);r=av;ax=aw;ay=$shiftRightUint64(s,as);az=new $Uint64(s.$high&au.$high,(s.$low&au.$low)>>>0);s=ay;ba=az;bb=$shiftRightUint64(t,as);bc=new $Uint64(t.$high&au.$high,(t.$low&au.$low)>>>0);t=bb;bd=bc;be=!z||(bd.$high>0||(bd.$high===0&&bd.$low>0));if(z&&(bd.$high===0&&bd.$low===0)){be=(bf=new $Uint64(d.$high&0,(d.$low&1)>>>0),(bf.$high===0&&bf.$low===0));}if(!be){t=(bg=new $Uint64(0,1),new $Uint64(t.$high-bg.$high,t.$low-bg.$low));}bh=false;if(y){bh=(bi=$shiftLeft64(new $Uint64(0,1),((as-1>>>0))),(ba.$high>bi.$high||(ba.$high===bi.$high&&ba.$low>bi.$low)))||((bj=$shiftLeft64(new $Uint64(0,1),((as-1>>>0))),(ba.$high===bj.$high&&ba.$low===bj.$low))&&(bk=new $Uint64(s.$high&0,(s.$low&1)>>>0),(bk.$high===0&&bk.$low===1)));}else{bh=(bl=$shiftRightUint64(ba,((as-1>>>0))),(bl.$high===0&&bl.$low===1));}bn=x&&(ax.$high===0&&ax.$low===0)&&((bm=new $Uint64(d.$high&0,(d.$low&1)>>>0),(bm.$high===0&&bm.$low===0)));if(!bn){r=(bo=new $Uint64(0,1),new $Uint64(r.$high+bo.$high,r.$low+bo.$low));}bp=y&&(ba.$high===0&&ba.$low===0);BF(c,r,s,t,bp,bh);c.dp=c.dp-(n)>>0;};BC=function(c){var c;return(($imul(c,78913)))>>18>>0;};BD=function(c){var c;return(($imul(c,108853)))>>15>>0;};BE=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t;f=new $Uint64(0,0);g=new $Uint64(0,0);h=new $Uint64(0,0);i=0;if(!((j=$shiftLeft64(new $Uint64(0,1),e.mantbits),(c.$high===j.$high&&c.$low===j.$low)))||(d===((e.bias+1>>0)-((e.mantbits>>0))>>0))){k=(l=$mul64(new $Uint64(0,2),c),new $Uint64(l.$high-0,l.$low-1));m=$mul64(new $Uint64(0,2),c);n=(o=$mul64(new $Uint64(0,2),c),new $Uint64(o.$high+0,o.$low+1));f=k;g=m;h=n;i=d-1>>0;return[f,g,h,i];}else{p=(q=$mul64(new $Uint64(0,4),c),new $Uint64(q.$high-0,q.$low-1));r=$mul64(new $Uint64(0,4),c);s=(t=$mul64(new $Uint64(0,4),c),new $Uint64(t.$high+0,t.$low+2));f=p;g=r;h=s;i=d-2>>0;return[f,g,h,i];}};BF=function(c,d,e,f,g,h){var aa,ab,ac,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;i=BK(d);j=i[0];k=i[1];l=BK(e);m=l[0];n=l[1];o=BK(f);p=o[0];q=o[1];if(p===0){BG(c,k,n,q,g,h,8);}else if(j>>0;}g=g&&(n===0);h=(n>500000000)||((n===500000000)&&h);BG(c,j,m,p,g,h,8);c.dp=c.dp+(9)>>0;}else{c.nd=0;r=9;s=m;while(true){if(!(s>0)){break;}t=(u=s/10,(u===u&&u!==1/0&&u!==-1/0)?u>>>0:$throwRuntimeError("integer divide by zero"));v=(w=s%10,w===w?w:$throwRuntimeError("integer divide by zero"));x=t;y=v;s=x;r=r-(1)>>>0;(z=c.d,((r<0||r>=z.$length)?($throwRuntimeError("index out of range"),undefined):z.$array[z.$offset+r]=(((y+48>>>0)<<24>>>24))));}c.d=$subslice(c.d,r);c.nd=(((9-r>>>0)>>0));BG(c,k,n,q,g,h,c.nd+8>>0);}while(true){if(!(c.nd>0&&((aa=c.d,ab=c.nd-1>>0,((ab<0||ab>=aa.$length)?($throwRuntimeError("index out of range"),undefined):aa.$array[aa.$offset+ab]))===48))){break;}c.nd=c.nd-(1)>>0;}while(true){if(!(c.nd>0&&((ac=c.d,(0>=ac.$length?($throwRuntimeError("index out of range"),undefined):ac.$array[ac.$offset+0]))===48))){break;}c.nd=c.nd-(1)>>0;c.dp=c.dp-(1)>>0;c.d=$subslice(c.d,1);}};BG=function(c,d,e,f,g,h,i){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if(f===0){c.dp=i+1>>0;return;}j=0;k=0;while(true){if(!(f>0)){break;}m=(l=((d+9>>>0))/10,(l===l&&l!==1/0&&l!==-1/0)?l>>>0:$throwRuntimeError("integer divide by zero"));n=(o=e/10,(o===o&&o!==1/0&&o!==-1/0)?o>>>0:$throwRuntimeError("integer divide by zero"));p=(q=e%10,q===q?q:$throwRuntimeError("integer divide by zero"));r=n;s=p;u=(t=f/10,(t===t&&t!==1/0&&t!==-1/0)?t>>>0:$throwRuntimeError("integer divide by zero"));if(m>u){break;}if((m===(r+1>>>0))&&r>>0;s=0;h=false;}j=j+(1)>>0;g=g&&(k===0);k=((s>>0));v=m;w=r;x=u;d=v;e=w;f=x;}if(j>0){h=k>5||((k===5)&&!g)||((k===5)&&g&&(((e&1)>>>0)===1));}if(e>>0;}i=i-(j)>>0;y=e;z=i;while(true){if(!(z>c.nd)){break;}aa=(ab=y/100,(ab===ab&&ab!==1/0&&ab!==-1/0)?ab>>>0:$throwRuntimeError("integer divide by zero"));ac=(ad=y%100,ad===ad?ad:$throwRuntimeError("integer divide by zero"));ae=aa;af=ac;(ag=c.d,((z<0||z>=ag.$length)?($throwRuntimeError("index out of range"),undefined):ag.$array[ag.$offset+z]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((($imul(2,af)>>>0)+1>>>0))));(ah=c.d,ai=z-1>>0,((ai<0||ai>=ah.$length)?($throwRuntimeError("index out of range"),undefined):ah.$array[ah.$offset+ai]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899".charCodeAt((($imul(2,af)>>>0)+0>>>0))));z=z-(2)>>0;y=ae;}if(z===c.nd){(aj=c.d,((z<0||z>=aj.$length)?($throwRuntimeError("index out of range"),undefined):aj.$array[aj.$offset+z]=(((y+48>>>0)<<24>>>24))));}c.nd=i+1>>0;c.dp=c.nd+j>>0;};BH=function(c,d,e){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w;f=0;g=0;h=false;if(e===0){i=c<<6>>>0;j=d-6>>0;k=true;f=i;g=j;h=k;return[f,g,h];}if(e<-348||347>0,((l<0||l>=CD.length)?($throwRuntimeError("index out of range"),undefined):CD[l]))[1];if(e<0){m=(n=new $Uint64(0,1),new $Uint64(m.$high+n.$high,m.$low+n.$low));}o=B.Mul64((new $Uint64(0,c)),m);p=o[0];q=o[1];d=d+(((BD(e)-63>>0)+57>>0))>>0;r=(((s=$shiftLeft64(p,7),t=$shiftRightUint64(q,57),new $Uint64(s.$high|t.$high,(s.$low|t.$low)>>>0)).$low>>>0));u=d;v=(w=$shiftLeft64(q,7),(w.$high===0&&w.$low===0));f=r;g=u;h=v;return[f,g,h];};BI=function(c,d,e){var aa,ab,ac,ad,ae,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;f=new $Uint64(0,0);g=0;h=false;if(e===0){i=$shiftLeft64(c,8);j=d-8>>0;k=true;f=i;g=j;h=k;return[f,g,h];}if(e<-348||347>0,((l<0||l>=CD.length)?($throwRuntimeError("index out of range"),undefined):CD[l])),DV);if(e<0){m[0]=(n=m[0],o=new $Uint64(0,1),new $Uint64(n.$high+o.$high,n.$low+o.$low));}d=d+(((BD(e)-127>>0)+119>>0))>>0;p=B.Mul64(c,m[0]);q=p[0];r=p[1];s=B.Mul64(c,m[1]);t=s[0];u=s[1];v=B.Add64(q,u,new $Uint64(0,0));w=v[0];x=v[1];t=(y=x,new $Uint64(t.$high+y.$high,t.$low+y.$low));z=(aa=$shiftLeft64(t,9),ab=$shiftRightUint64(w,55),new $Uint64(aa.$high|ab.$high,(aa.$low|ab.$low)>>>0));ac=d;ad=(ae=$shiftLeft64(w,9),(ae.$high===0&&ae.$low===0))&&(r.$high===0&&r.$low===0);f=z;g=ac;h=ad;return[f,g,h];};BJ=function(c,d){var c,d,e,f;if((c.$high===0&&c.$low===0)){return true;}e=0;while(true){if(!(e>0;}return true;};BK=function(c){var c,d,e,f,g;if(false){return[(($div64(c,new $Uint64(0,1000000000),false).$low>>>0)),(($div64(c,new $Uint64(0,1000000000),true).$low>>>0))];}d=B.Mul64($shiftRightUint64(c,1),new $Uint64(2305843009,917808536));e=d[0];f=$shiftRightUint64(e,28);return[((f.$low>>>0)),(((g=$mul64(f,new $Uint64(0,1000000000)),new $Uint64(c.$high-g.$high,c.$low-g.$low)).$low>>>0))];};BO=function(c,d,e,f){var c,d,e,f;return($bytesToString(BQ($makeSlice(EA,0,CA(e+4>>0,24)),c,d,e,f)));};$pkg.FormatFloat=BO;BP=function(c,d,e,f,g){var c,d,e,f,g;return BQ(c,d,e,f,g);};$pkg.AppendFloat=BP;BQ=function(c,d,e,f,g){var aa,ab,ac,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;h=new $Uint64(0,0);i=ED.nil;j=g;if(j===(32)){h=(new $Uint64(0,D.Float32bits(($fround(d)))));i=BM;}else if(j===(64)){h=D.Float64bits(d);i=BN;}else{$panic(new $String("strconv: illegal AppendFloat/FormatFloat bitSize"));}l=!((k=$shiftRightUint64(h,((i.expbits+i.mantbits>>>0))),(k.$high===0&&k.$low===0)));n=(($shiftRightUint64(h,i.mantbits).$low>>0))&((((m=i.expbits,m<32?(1<>0)-1>>0));q=(o=(p=$shiftLeft64(new $Uint64(0,1),i.mantbits),new $Uint64(p.$high-0,p.$low-1)),new $Uint64(h.$high&o.$high,(h.$low&o.$low)>>>0));r=n;if(r===((((s=i.expbits,s<32?(1<>0)-1>>0))){t="";if(!((q.$high===0&&q.$low===0))){t="NaN";}else if(l){t="-Inf";}else{t="+Inf";}return $appendSlice(c,t);}else if(r===(0)){n=n+(1)>>0;}else{q=(u=$shiftLeft64(new $Uint64(0,1),i.mantbits),new $Uint64(q.$high|u.$high,(q.$low|u.$low)>>>0));}n=n+(i.bias)>>0;if(e===98){return BX(c,l,q,n,i);}if((e===120)||(e===88)){return BY(c,f,e,l,q,n,i);}if(!CY){return BR(c,f,e,l,q,n,i);}v=new BU.ptr(EA.nil,0,0,false);w=false;x=f<0;if(x){y=EE.zero();v.d=new EA(y);BB(v,q,n-((i.mantbits>>0))>>0,i);w=true;z=e;if((z===(101))||(z===(69))){f=CA(v.nd-1>>0,0);}else if(z===(102)){f=CA(v.nd-v.dp>>0,0);}else if((z===(103))||(z===(71))){f=v.nd;}}else if(!((e===102))){aa=f;ab=e;if((ab===(101))||(ab===(69))){aa=aa+(1)>>0;}else if((ab===(103))||(ab===(71))){if(f===0){f=1;}aa=f;}ac=EF.zero();if((g===32)&&aa<=9){v.d=new EA(ac);AX(v,((q.$low>>>0)),n-((i.mantbits>>0))>>0,aa);w=true;}else if(aa<=18){v.d=new EA(ac);AY(v,q,n-((i.mantbits>>0))>>0,aa);w=true;}}if(!w){return BR(c,f,e,l,q,n,i);}return BS(c,x,l,$clone(v,BU),f,e);};BR=function(c,d,e,f,g,h,i){var c,d,e,f,g,h,i,j,k,l,m,n;j=new CE.ptr(EG.zero(),0,0,false,false);j.Assign(g);j.Shift(h-((i.mantbits>>0))>>0);k=new BU.ptr(EA.nil,0,0,false);l=d<0;if(l){BT(j,g,h,i);BU.copy(k,new BU.ptr(new EA(j.d),j.nd,j.dp,false));m=e;if((m===(101))||(m===(69))){d=k.nd-1>>0;}else if(m===(102)){d=CA(k.nd-k.dp>>0,0);}else if((m===(103))||(m===(71))){d=k.nd;}}else{n=e;if((n===(101))||(n===(69))){j.Round(d+1>>0);}else if(n===(102)){j.Round(j.dp+d>>0);}else if((n===(103))||(n===(71))){if(d===0){d=1;}j.Round(d);}BU.copy(k,new BU.ptr(new EA(j.d),j.nd,j.dp,false));}return BS(c,l,f,$clone(k,BU),d,e);};BS=function(c,d,e,f,g,h){var c,d,e,f,g,h,i,j,k;i=h;if((i===(101))||(i===(69))){return BV(c,e,$clone(f,BU),g,h);}else if(i===(102)){return BW(c,e,$clone(f,BU),g);}else if((i===(103))||(i===(71))){j=g;if(j>f.nd&&f.nd>=f.dp){j=f.nd;}if(d){j=6;}k=f.dp-1>>0;if(k<-4||k>=j){if(g>f.nd){g=f.nd;}return BV(c,e,$clone(f,BU),g-1>>0,(h+101<<24>>>24)-103<<24>>>24);}if(g>f.dp){g=f.nd;}return BW(c,e,$clone(f,BU),CA(g-f.dp>>0,0));}return $append(c,37,h);};BT=function(c,d,e,f){var aa,ab,ac,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if((d.$high===0&&d.$low===0)){c.nd=0;return;}g=f.bias+1>>0;if(e>g&&($imul(332,((c.dp-c.nd>>0))))>=($imul(100,((e-((f.mantbits>>0))>>0))))){return;}h=new CE.ptr(EG.zero(),0,0,false,false);h.Assign((i=$mul64(d,new $Uint64(0,2)),new $Uint64(i.$high+0,i.$low+1)));h.Shift((e-((f.mantbits>>0))>>0)-1>>0);j=new $Uint64(0,0);k=0;if((l=$shiftLeft64(new $Uint64(0,1),f.mantbits),(d.$high>l.$high||(d.$high===l.$high&&d.$low>l.$low)))||(e===g)){j=new $Uint64(d.$high-0,d.$low-1);k=e;}else{j=(m=$mul64(d,new $Uint64(0,2)),new $Uint64(m.$high-0,m.$low-1));k=e-1>>0;}n=new CE.ptr(EG.zero(),0,0,false,false);n.Assign((o=$mul64(j,new $Uint64(0,2)),new $Uint64(o.$high+0,o.$low+1)));n.Shift((k-((f.mantbits>>0))>>0)-1>>0);q=(p=$div64(d,new $Uint64(0,2),true),(p.$high===0&&p.$low===0));r=0;s=0;while(true){t=(s-h.dp>>0)+c.dp>>0;if(t>=c.nd){break;}u=(s-h.dp>>0)+n.dp>>0;v=48;if(u>=0&&u=w.length)?($throwRuntimeError("index out of range"),undefined):w[u]));}x=48;if(t>=0){x=(y=c.d,((t<0||t>=y.length)?($throwRuntimeError("index out of range"),undefined):y[t]));}z=48;if(s=aa.length)?($throwRuntimeError("index out of range"),undefined):aa[s]));}ab=!((v===x))||q&&((u+1>>0)===n.nd);if((r===0)&&(x+1<<24>>>24)0&&(q||r>1||(s+1>>0)>0);return;}else if(ab){c.RoundDown(t+1>>0);return;}else if(ac){c.RoundUp(t+1>>0);return;}s=s+(1)>>0;}};BV=function(c,d,e,f,g){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r;if(d){c=$append(c,45);}h=48;if(!((e.nd===0))){h=(i=e.d,(0>=i.$length?($throwRuntimeError("index out of range"),undefined):i.$array[i.$offset+0]));}c=$append(c,h);if(f>0){c=$append(c,46);j=1;k=BZ(e.nd,f+1>>0);if(j>0;}}c=$append(c,g);l=e.dp-1>>0;if(e.nd===0){l=0;}if(l<0){h=45;l=-l;}else{h=43;}c=$append(c,h);if(l<10){c=$append(c,48,((l<<24>>>24))+48<<24>>>24);}else if(l<100){c=$append(c,(((m=l/10,(m===m&&m!==1/0&&m!==-1/0)?m>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(((n=l%10,n===n?n:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24);}else{c=$append(c,(((o=l/100,(o===o&&o!==1/0&&o!==-1/0)?o>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(p=(((q=l/10,(q===q&&q!==1/0&&q!==-1/0)?q>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))%10,p===p?p:$throwRuntimeError("integer divide by zero"))+48<<24>>>24,(((r=l%10,r===r?r:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24);}return c;};BW=function(c,d,e,f){var c,d,e,f,g,h,i,j,k;if(d){c=$append(c,45);}if(e.dp>0){g=BZ(e.nd,e.dp);c=$appendSlice(c,$subslice(e.d,0,g));while(true){if(!(g>0;}}else{c=$append(c,48);}if(f>0){c=$append(c,46);h=0;while(true){if(!(h>0;if(0<=j&&j=k.$length)?($throwRuntimeError("index out of range"),undefined):k.$array[k.$offset+j]));}c=$append(c,i);h=h+(1)>>0;}}return c;};BX=function(c,d,e,f,g){var c,d,e,f,g,h,i;if(d){c=$append(c,45);}h=AO(c,e,10,false,true);c=h[0];c=$append(c,112);f=f-(((g.mantbits>>0)))>>0;if(f>=0){c=$append(c,43);}i=AO(c,(new $Uint64(0,f)),10,f<0,true);c=i[0];return c;};BY=function(c,d,e,f,g,h,i){var aa,ab,ac,ad,ae,af,ag,ah,ai,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;if((g.$high===0&&g.$low===0)){h=0;}g=$shiftLeft64(g,((60-i.mantbits>>>0)));while(true){if(!(!((g.$high===0&&g.$low===0))&&(j=new $Uint64(g.$high&268435456,(g.$low&0)>>>0),(j.$high===0&&j.$low===0)))){break;}g=$shiftLeft64(g,(1));h=h-(1)>>0;}if(d>=0&&d<15){k=((($imul(d,4))>>>0));m=(l=$shiftLeft64(g,k),new $Uint64(l.$high&268435455,(l.$low&4294967295)>>>0));g=$shiftRightUint64(g,((60-k>>>0)));if((n=(o=new $Uint64(g.$high&0,(g.$low&1)>>>0),new $Uint64(m.$high|o.$high,(m.$low|o.$low)>>>0)),(n.$high>134217728||(n.$high===134217728&&n.$low>0)))){g=(p=new $Uint64(0,1),new $Uint64(g.$high+p.$high,g.$low+p.$low));}g=$shiftLeft64(g,((60-k>>>0)));if(!((q=new $Uint64(g.$high&536870912,(g.$low&0)>>>0),(q.$high===0&&q.$low===0)))){g=$shiftRightUint64(g,(1));h=h+(1)>>0;}}r="0123456789abcdef";if(e===88){r="0123456789ABCDEF";}if(f){c=$append(c,45);}c=$append(c,48,e,48+(((s=$shiftRightUint64(g,60),new $Uint64(s.$high&0,(s.$low&1)>>>0)).$low<<24>>>24))<<24>>>24);g=$shiftLeft64(g,(4));if(d<0&&!((g.$high===0&&g.$low===0))){c=$append(c,46);while(true){if(!(!((g.$high===0&&g.$low===0)))){break;}c=$append(c,r.charCodeAt($flatten64((t=$shiftRightUint64(g,60),new $Uint64(t.$high&0,(t.$low&15)>>>0)))));g=$shiftLeft64(g,(4));}}else if(d>0){c=$append(c,46);u=0;while(true){if(!(u>>0)))));g=$shiftLeft64(g,(4));u=u+(1)>>0;}}w=80;if(e===CP(e)){w=112;}c=$append(c,w);if(h<0){w=45;h=-h;}else{w=43;}c=$append(c,w);if(h<100){c=$append(c,(((x=h/10,(x===x&&x!==1/0&&x!==-1/0)?x>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(((y=h%10,y===y?y:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24);}else if(h<1000){c=$append(c,(((z=h/100,(z===z&&z!==1/0&&z!==-1/0)?z>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(((aa=((ab=h/10,(ab===ab&&ab!==1/0&&ab!==-1/0)?ab>>0:$throwRuntimeError("integer divide by zero")))%10,aa===aa?aa:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(((ac=h%10,ac===ac?ac:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24);}else{c=$append(c,(((ad=h/1000,(ad===ad&&ad!==1/0&&ad!==-1/0)?ad>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(ae=(((af=h/100,(af===af&&af!==1/0&&af!==-1/0)?af>>0:$throwRuntimeError("integer divide by zero"))<<24>>>24))%10,ae===ae?ae:$throwRuntimeError("integer divide by zero"))+48<<24>>>24,(((ag=((ah=h/10,(ah===ah&&ah!==1/0&&ah!==-1/0)?ah>>0:$throwRuntimeError("integer divide by zero")))%10,ag===ag?ag:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24,(((ai=h%10,ai===ai?ai:$throwRuntimeError("integer divide by zero"))<<24>>>24))+48<<24>>>24);}return c;};BZ=function(c,d){var c,d;if(cd){return c;}return d;};CB=function(c,d,e){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;f=0;g=false;if((c.$high===0&&c.$low===0)){if(e){f=D.Float64frombits(new $Uint64(2147483648,0));}h=f;i=true;f=h;g=i;return[f,g];}if(d<-348||347>>0))));o=(m=(new $Uint64(0,(((($imul(217706,d))>>16>>0)+64>>0)+1023>>0))),n=(new $Uint64(0,l)),new $Uint64(m.$high-n.$high,m.$low-n.$low));p=B.Mul64(c,(q=d- -348>>0,((q<0||q>=CD.length)?($throwRuntimeError("index out of range"),undefined):CD[q]))[1]);r=p[0];s=p[1];if((t=new $Uint64(r.$high&0,(r.$low&511)>>>0),(t.$high===0&&t.$low===511))&&(u=new $Uint64(s.$high+c.$high,s.$low+c.$low),(u.$high>0,((w<0||w>=CD.length)?($throwRuntimeError("index out of range"),undefined):CD[w]))[0]);x=v[0];y=v[1];z=r;aa=new $Uint64(s.$high+x.$high,s.$low+x.$low);ab=z;ac=aa;if((ac.$high>>0),(ae.$high===0&&ae.$low===511))&&(af=new $Uint64(ac.$high+0,ac.$low+1),(af.$high===0&&af.$low===0))&&(ag=new $Uint64(y.$high+c.$high,y.$low+c.$low),(ag.$high>>0),new $Uint64(o.$high-an.$high,o.$low-an.$low));if((s.$high===0&&s.$low===0)&&(ao=new $Uint64(r.$high&0,(r.$low&511)>>>0),(ao.$high===0&&ao.$low===0))&&(ap=new $Uint64(am.$high&0,(am.$low&3)>>>0),(ap.$high===0&&ap.$low===1))){aq=0;ar=false;f=aq;g=ar;return[f,g];}am=(as=new $Uint64(am.$high&0,(am.$low&1)>>>0),new $Uint64(am.$high+as.$high,am.$low+as.$low));am=$shiftRightUint64(am,(1));if((at=$shiftRightUint64(am,53),(at.$high>0||(at.$high===0&&at.$low>0)))){am=$shiftRightUint64(am,(1));o=(au=new $Uint64(0,1),new $Uint64(o.$high+au.$high,o.$low+au.$low));}if((av=new $Uint64(o.$high-0,o.$low-1),(av.$high>0||(av.$high===0&&av.$low>=2046)))){aw=0;ax=false;f=aw;g=ax;return[f,g];}ba=(ay=$shiftLeft64(o,52),az=new $Uint64(am.$high&1048575,(am.$low&4294967295)>>>0),new $Uint64(ay.$high|az.$high,(ay.$low|az.$low)>>>0));if(e){ba=(bb=new $Uint64(2147483648,0),new $Uint64(ba.$high|bb.$high,(ba.$low|bb.$low)>>>0));}bc=D.Float64frombits(ba);bd=true;f=bc;g=bd;return[f,g];};CC=function(c,d,e){var aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;f=0;g=false;if((c.$high===0&&c.$low===0)){if(e){f=D.Float32frombits(2147483648);}h=f;i=true;f=h;g=i;return[f,g];}if(d<-348||347>>0))));o=(m=(new $Uint64(0,(((($imul(217706,d))>>16>>0)+64>>0)+127>>0))),n=(new $Uint64(0,l)),new $Uint64(m.$high-n.$high,m.$low-n.$low));p=B.Mul64(c,(q=d- -348>>0,((q<0||q>=CD.length)?($throwRuntimeError("index out of range"),undefined):CD[q]))[1]);r=p[0];s=p[1];if((t=new $Uint64(r.$high&63,(r.$low&4294967295)>>>0),(t.$high===63&&t.$low===4294967295))&&(u=new $Uint64(s.$high+c.$high,s.$low+c.$low),(u.$high>0,((w<0||w>=CD.length)?($throwRuntimeError("index out of range"),undefined):CD[w]))[0]);x=v[0];y=v[1];z=r;aa=new $Uint64(s.$high+x.$high,s.$low+x.$low);ab=z;ac=aa;if((ac.$high>>0),(ae.$high===63&&ae.$low===4294967295))&&(af=new $Uint64(ac.$high+0,ac.$low+1),(af.$high===0&&af.$low===0))&&(ag=new $Uint64(y.$high+c.$high,y.$low+c.$low),(ag.$high>>0),new $Uint64(o.$high-an.$high,o.$low-an.$low));if((s.$high===0&&s.$low===0)&&(ao=new $Uint64(r.$high&63,(r.$low&4294967295)>>>0),(ao.$high===0&&ao.$low===0))&&(ap=new $Uint64(am.$high&0,(am.$low&3)>>>0),(ap.$high===0&&ap.$low===1))){aq=0;ar=false;f=aq;g=ar;return[f,g];}am=(as=new $Uint64(am.$high&0,(am.$low&1)>>>0),new $Uint64(am.$high+as.$high,am.$low+as.$low));am=$shiftRightUint64(am,(1));if((at=$shiftRightUint64(am,24),(at.$high>0||(at.$high===0&&at.$low>0)))){am=$shiftRightUint64(am,(1));o=(au=new $Uint64(0,1),new $Uint64(o.$high+au.$high,o.$low+au.$low));}if((av=new $Uint64(o.$high-0,o.$low-1),(av.$high>0||(av.$high===0&&av.$low>=254)))){aw=0;ax=false;f=aw;g=ax;return[f,g];}ba=(ay=$shiftLeft64(o,23),az=new $Uint64(am.$high&0,(am.$low&8388607)>>>0),new $Uint64(ay.$high|az.$high,(ay.$low|az.$low)>>>0));if(e){ba=(bb=new $Uint64(0,2147483648),new $Uint64(ba.$high|bb.$high,(ba.$low|bb.$low)>>>0));}bc=D.Float32frombits(((ba.$low>>>0)));bd=true;f=bc;g=bd;return[f,g];};CE.ptr.prototype.String=function(){var c,d,e,f;c=this;d=10+c.nd>>0;if(c.dp>0){d=d+(c.dp)>>0;}if(c.dp<0){d=d+(-c.dp)>>0;}e=$makeSlice(EA,d);f=0;if((c.nd===0)){return"0";}else if(c.dp<=0){((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]=48);f=f+(1)>>0;((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]=46);f=f+(1)>>0;f=f+(CF($subslice(e,f,(f+-c.dp>>0))))>>0;f=f+($copySlice($subslice(e,f),$subslice(new EA(c.d),0,c.nd)))>>0;}else if(c.dp>0;((f<0||f>=e.$length)?($throwRuntimeError("index out of range"),undefined):e.$array[e.$offset+f]=46);f=f+(1)>>0;f=f+($copySlice($subslice(e,f),$subslice(new EA(c.d),c.dp,c.nd)))>>0;}else{f=f+($copySlice($subslice(e,f),$subslice(new EA(c.d),0,c.nd)))>>0;f=f+(CF($subslice(e,f,((f+c.dp>>0)-c.nd>>0))))>>0;}return($bytesToString($subslice(e,0,f)));};CE.prototype.String=function(){return this.$val.String();};CF=function(c){var c,d,e,f;d=c;e=0;while(true){if(!(e=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+f]=48);e++;}return c.$length;};CG=function(c){var c,d,e;while(true){if(!(c.nd>0&&((d=c.d,e=c.nd-1>>0,((e<0||e>=d.length)?($throwRuntimeError("index out of range"),undefined):d[e]))===48))){break;}c.nd=c.nd-(1)>>0;}if(c.nd===0){c.dp=0;}};CE.ptr.prototype.Assign=function(c){var c,d,e,f,g,h,i,j;d=this;e=EF.zero();f=0;while(true){if(!((c.$high>0||(c.$high===0&&c.$low>0)))){break;}g=$div64(c,new $Uint64(0,10),false);c=(h=$mul64(new $Uint64(0,10),g),new $Uint64(c.$high-h.$high,c.$low-h.$low));((f<0||f>=e.length)?($throwRuntimeError("index out of range"),undefined):e[f]=((new $Uint64(c.$high+0,c.$low+48).$low<<24>>>24)));f=f+(1)>>0;c=g;}d.nd=0;f=f-(1)>>0;while(true){if(!(f>=0)){break;}(i=d.d,j=d.nd,((j<0||j>=i.length)?($throwRuntimeError("index out of range"),undefined):i[j]=((f<0||f>=e.length)?($throwRuntimeError("index out of range"),undefined):e[f])));d.nd=d.nd+(1)>>0;f=f-(1)>>0;}d.dp=d.nd;CG(d);};CE.prototype.Assign=function(c){return this.$val.Assign(c);};CH=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u;e=0;f=0;g=0;while(true){if(!(((h=d,h<32?(g>>>h):0)>>>0)===0)){break;}if(e>=c.nd){if(g===0){c.nd=0;return;}while(true){if(!(((i=d,i<32?(g>>>i):0)>>>0)===0)){break;}g=g*10>>>0;e=e+(1)>>0;}break;}k=(((j=c.d,((e<0||e>=j.length)?($throwRuntimeError("index out of range"),undefined):j[e]))>>>0));g=((g*10>>>0)+k>>>0)-48>>>0;e=e+(1)>>0;}c.dp=c.dp-((e-1>>0))>>0;m=(((l=d,l<32?(1<>>0))-1>>>0;while(true){if(!(e=n.length)?($throwRuntimeError("index out of range"),undefined):n[e]))>>>0));q=(p=d,p<32?(g>>>p):0)>>>0;g=(g&(m))>>>0;(r=c.d,((f<0||f>=r.length)?($throwRuntimeError("index out of range"),undefined):r[f]=(((q+48>>>0)<<24>>>24))));f=f+(1)>>0;g=((g*10>>>0)+o>>>0)-48>>>0;e=e+(1)>>0;}while(true){if(!(g>0)){break;}t=(s=d,s<32?(g>>>s):0)>>>0;g=(g&(m))>>>0;if(f<800){(u=c.d,((f<0||f>=u.length)?($throwRuntimeError("index out of range"),undefined):u[f]=(((t+48>>>0)<<24>>>24))));f=f+(1)>>0;}else if(t>0){c.trunc=true;}g=g*10>>>0;}c.nd=f;CG(c);};CK=function(c,d){var c,d,e;e=0;while(true){if(!(e=c.$length){return true;}if(!((((e<0||e>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+e])===d.charCodeAt(e)))){return((e<0||e>=c.$length)?($throwRuntimeError("index out of range"),undefined):c.$array[c.$offset+e])>0;}return false;};CL=function(c,d){var c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r;e=((d<0||d>=CJ.$length)?($throwRuntimeError("index out of range"),undefined):CJ.$array[CJ.$offset+d]).delta;if(CK($subslice(new EA(c.d),0,c.nd),((d<0||d>=CJ.$length)?($throwRuntimeError("index out of range"),undefined):CJ.$array[CJ.$offset+d]).cutoff)){e=e-(1)>>0;}f=c.nd;g=c.nd+e>>0;h=0;f=f-(1)>>0;while(true){if(!(f>=0)){break;}h=h+(((i=d,i<32?((((((j=c.d,((f<0||f>=j.length)?($throwRuntimeError("index out of range"),undefined):j[f]))>>>0))-48>>>0))<>>0))>>>0;l=(k=h/10,(k===k&&k!==1/0&&k!==-1/0)?k>>>0:$throwRuntimeError("integer divide by zero"));m=h-(10*l>>>0)>>>0;g=g-(1)>>0;if(g<800){(n=c.d,((g<0||g>=n.length)?($throwRuntimeError("index out of range"),undefined):n[g]=(((m+48>>>0)<<24>>>24))));}else if(!((m===0))){c.trunc=true;}h=l;f=f-(1)>>0;}while(true){if(!(h>0)){break;}p=(o=h/10,(o===o&&o!==1/0&&o!==-1/0)?o>>>0:$throwRuntimeError("integer divide by zero"));q=h-(10*p>>>0)>>>0;g=g-(1)>>0;if(g<800){(r=c.d,((g<0||g>=r.length)?($throwRuntimeError("index out of range"),undefined):r[g]=(((q+48>>>0)<<24>>>24))));}else if(!((q===0))){c.trunc=true;}h=p;}c.nd=c.nd+(e)>>0;if(c.nd>=800){c.nd=800;}c.dp=c.dp+(e)>>0;CG(c);};CE.ptr.prototype.Shift=function(c){var c,d;d=this;if((d.nd===0)){}else if(c>0){while(true){if(!(c>28)){break;}CL(d,28);c=c-(28)>>0;}CL(d,((c>>>0)));}else if(c<0){while(true){if(!(c<-28)){break;}CH(d,28);c=c+(28)>>0;}CH(d,((-c>>>0)));}};CE.prototype.Shift=function(c){return this.$val.Shift(c);};CM=function(c,d){var c,d,e,f,g,h,i;if(d<0||d>=c.nd){return false;}if(((e=c.d,((d<0||d>=e.length)?($throwRuntimeError("index out of range"),undefined):e[d]))===53)&&((d+1>>0)===c.nd)){if(c.trunc){return true;}return d>0&&!(((f=(((g=c.d,h=d-1>>0,((h<0||h>=g.length)?($throwRuntimeError("index out of range"),undefined):g[h]))-48<<24>>>24))%2,f===f?f:$throwRuntimeError("integer divide by zero"))===0));}return(i=c.d,((d<0||d>=i.length)?($throwRuntimeError("index out of range"),undefined):i[d]))>=53;};CE.ptr.prototype.Round=function(c){var c,d;d=this;if(c<0||c>=d.nd){return;}if(CM(d,c)){d.RoundUp(c);}else{d.RoundDown(c);}};CE.prototype.Round=function(c){return this.$val.Round(c);};CE.ptr.prototype.RoundDown=function(c){var c,d;d=this;if(c<0||c>=d.nd){return;}d.nd=c;CG(d);};CE.prototype.RoundDown=function(c){return this.$val.RoundDown(c);};CE.ptr.prototype.RoundUp=function(c){var c,d,e,f,g,h,i;d=this;if(c<0||c>=d.nd){return;}e=c-1>>0;while(true){if(!(e>=0)){break;}g=(f=d.d,((e<0||e>=f.length)?($throwRuntimeError("index out of range"),undefined):f[e]));if(g<57){(i=d.d,((e<0||e>=i.length)?($throwRuntimeError("index out of range"),undefined):i[e]=((h=d.d,((e<0||e>=h.length)?($throwRuntimeError("index out of range"),undefined):h[e]))+(1)<<24>>>24)));d.nd=e+1>>0;return;}e=e-(1)>>0;}d.d[0]=49;d.nd=1;d.dp=d.dp+(1)>>0;};CE.prototype.RoundUp=function(c){return this.$val.RoundUp(c);};CE.ptr.prototype.RoundedInteger=function(){var c,d,e,f,g,h,i;c=this;if(c.dp>20){return new $Uint64(4294967295,4294967295);}d=0;e=new $Uint64(0,0);d=0;while(true){if(!(d=h.length)?($throwRuntimeError("index out of range"),undefined):h[d]))-48<<24>>>24))),new $Uint64(f.$high+g.$high,f.$low+g.$low));d=d+(1)>>0;}while(true){if(!(d
-