cue: prepare to hoist builtin code · mvdan.cc/cue@ce28b20

+979 -982

2 changed files

expand all

cue

builtin.go

builtins.go

+99 -102

cue/builtin.go

··· 38 38 "cuelang.org/go/internal/core/runtime" 39 39 ) 40 40 41 - // A builtin is a builtin function or constant. 41 + // A Builtin is a builtin function or constant. 42 42 // 43 43 // A function may return and a constant may be any of the following types: 44 44 // ··· 56 56 // []T 57 57 // map[string]T 58 58 // 59 - type builtin struct { 59 + type Builtin struct { 60 60 Name string 61 - pkg label 62 - Params []kind 63 - Result kind 64 - Func func(c *callCtxt) 65 - // Const interface{} 66 - Const string 61 + Pkg adt.Feature 62 + Params []adt.Kind 63 + Result adt.Kind 64 + Func func(c *CallCtxt) 65 + Const string 67 66 } 68 67 69 - type builtinPkg struct { 70 - native []*builtin 71 - cue string 68 + type Package struct { 69 + Native []*Builtin 70 + CUE string 72 71 } 73 72 74 - func mustCompileBuiltins(ctx *context, p *builtinPkg, pkgName string) *adt.Vertex { 73 + func (p *Package) MustCompile(ctx *adt.OpContext, pkgName string) *adt.Vertex { 75 74 obj := &adt.Vertex{} 76 - pkgLabel := ctx.Label(pkgName, false) 75 + pkgLabel := ctx.StringLabel(pkgName) 77 76 st := &adt.StructLit{} 78 - if len(p.native) > 0 { 77 + if len(p.Native) > 0 { 79 78 obj.AddConjunct(adt.MakeConjunct(nil, st)) 80 79 } 81 - for _, b := range p.native { 82 - b.pkg = pkgLabel 80 + for _, b := range p.Native { 81 + b.Pkg = pkgLabel 83 82 84 - f := ctx.Label(b.Name, false) // never starts with _ 83 + f := ctx.StringLabel(b.Name) // never starts with _ 85 84 // n := &node{baseValue: newBase(imp.Path)} 86 85 var v adt.Expr = toBuiltin(ctx, b) 87 86 if b.Const != "" { ··· 94 93 } 95 94 96 95 // Parse builtin CUE 97 - if p.cue != "" { 98 - expr, err := parser.ParseExpr(pkgName, p.cue) 96 + if p.CUE != "" { 97 + expr, err := parser.ParseExpr(pkgName, p.CUE) 99 98 if err != nil { 100 - panic(fmt.Errorf("could not parse %v: %v", p.cue, err)) 99 + panic(fmt.Errorf("could not parse %v: %v", p.CUE, err)) 101 100 } 102 - c, err := compile.Expr(nil, ctx.opCtx.Runtime, expr) 101 + c, err := compile.Expr(nil, ctx.Runtime, expr) 103 102 if err != nil { 104 - panic(fmt.Errorf("could compile parse %v: %v", p.cue, err)) 103 + panic(fmt.Errorf("could compile parse %v: %v", p.CUE, err)) 105 104 } 106 105 obj.AddConjunct(c) 107 106 } 108 107 109 108 // We could compile lazily, but this is easier for debugging. 110 - obj.Finalize(ctx.opCtx) 111 - if err := obj.Err(ctx.opCtx, adt.Finalized); err != nil { 109 + obj.Finalize(ctx) 110 + if err := obj.Err(ctx, adt.Finalized); err != nil { 112 111 panic(err.Err) 113 112 } 114 113 115 114 return obj 116 115 } 117 116 118 - func toBuiltin(ctx *context, b *builtin) *adt.Builtin { 117 + func toBuiltin(ctx *adt.OpContext, b *Builtin) *adt.Builtin { 119 118 x := &adt.Builtin{ 120 119 Params: b.Params, 121 120 Result: b.Result, 122 - Package: b.pkg, 121 + Package: b.Pkg, 123 122 Name: b.Name, 124 123 } 125 124 x.Func = func(ctx *adt.OpContext, args []adt.Value) (ret adt.Expr) { ··· 127 126 index := runtime.Data.(*index) 128 127 129 128 // call, _ := ctx.Source().(*ast.CallExpr) 130 - c := &callCtxt{ 131 - idx: index, 129 + c := &CallCtxt{ 132 130 // src: call, 133 131 ctx: index.newContext(), 134 132 args: args, 135 133 builtin: b, 136 134 } 137 135 defer func() { 138 - var errVal interface{} = c.err 136 + var errVal interface{} = c.Err 139 137 if err := recover(); err != nil { 140 138 errVal = err 141 139 } 142 140 ret = processErr(c, errVal, ret) 143 141 }() 144 142 b.Func(c) 145 - switch v := c.ret.(type) { 143 + switch v := c.Ret.(type) { 146 144 case adt.Value: 147 145 return v 148 146 case *valueError: 149 147 return v.err 150 148 } 151 - if c.err != nil { 149 + if c.Err != nil { 152 150 return nil 153 151 } 154 - return convert.GoValueToValue(ctx, c.ret, true) 152 + return convert.GoValueToValue(ctx, c.Ret, true) 155 153 } 156 154 return x 157 155 } 158 156 159 157 // newConstBuiltin parses and creates any CUE expression that does not have 160 158 // fields. 161 - func mustParseConstBuiltin(ctx *context, name, val string) adt.Expr { 159 + func mustParseConstBuiltin(ctx *adt.OpContext, name, val string) adt.Expr { 162 160 expr, err := parser.ParseExpr("<builtin:"+name+">", val) 163 161 if err != nil { 164 162 panic(err) 165 163 } 166 - c, err := compile.Expr(nil, ctx.Runtime, expr) 164 + c, err := compile.Expr(nil, ctx, expr) 167 165 if err != nil { 168 166 panic(err) 169 167 } ··· 182 180 return src.Pos() 183 181 } 184 182 185 - func (x *builtin) name(ctx *context) string { 186 - if x.pkg == 0 { 183 + func (x *Builtin) name(ctx *context) string { 184 + if x.Pkg == 0 { 187 185 return x.Name 188 186 } 189 - return fmt.Sprintf("%s.%s", ctx.LabelStr(x.pkg), x.Name) 187 + return fmt.Sprintf("%s.%s", ctx.LabelStr(x.Pkg), x.Name) 190 188 } 191 189 192 - func (x *builtin) isValidator() bool { 193 - return len(x.Params) == 1 && x.Result == boolKind 190 + func (x *Builtin) isValidator() bool { 191 + return len(x.Params) == 1 && x.Result == adt.BoolKind 194 192 } 195 193 196 - func processErr(call *callCtxt, errVal interface{}, ret adt.Expr) adt.Expr { 194 + func processErr(call *CallCtxt, errVal interface{}, ret adt.Expr) adt.Expr { 197 195 ctx := call.ctx 198 196 src := call.src 199 197 switch err := errVal.(type) { ··· 211 209 case errors.Error: 212 210 ret = wrapCallErr(call, &adt.Bottom{Err: err}) 213 211 case error: 214 - if call.err == internal.ErrIncomplete { 212 + if call.Err == internal.ErrIncomplete { 215 213 ret = ctx.mkErr(src, codeIncomplete, "incomplete value") 216 214 } else { 217 215 // TODO: store the underlying error explicitly ··· 226 224 return ret 227 225 } 228 226 229 - func wrapCallErr(c *callCtxt, b *adt.Bottom) *adt.Bottom { 227 + func wrapCallErr(c *CallCtxt, b *adt.Bottom) *adt.Bottom { 230 228 pos := token.NoPos 231 229 if c.src != nil { 232 230 if src := c.src.Source(); src != nil { ··· 240 238 } 241 239 } 242 240 243 - func (c *callCtxt) convertError(x interface{}, name string) *adt.Bottom { 241 + func (c *CallCtxt) convertError(x interface{}, name string) *adt.Bottom { 244 242 var err errors.Error 245 243 switch v := x.(type) { 246 244 case nil: ··· 259 257 if name != "" { 260 258 err = errors.Newf(c.Pos(), "%s: %v", name, v) 261 259 } else { 262 - err = errors.Newf(c.Pos(), "error in call to %s: %v", c.name(), v) 260 + err = errors.Newf(c.Pos(), "error in call to %s: %v", c.Name(), v) 263 261 } 264 262 265 263 default: ··· 268 266 if err != internal.ErrIncomplete { 269 267 return &adt.Bottom{ 270 268 // Wrap to preserve position information. 271 - Err: errors.Wrapf(err, c.Pos(), "error in call to %s", c.name()), 269 + Err: errors.Wrapf(err, c.Pos(), "error in call to %s", c.Name()), 272 270 } 273 271 } 274 272 return &adt.Bottom{ 275 273 Code: adt.IncompleteError, 276 - Err: errors.Newf(c.Pos(), "incomplete values in call to %s", c.name()), 274 + Err: errors.Newf(c.Pos(), "incomplete values in call to %s", c.Name()), 277 275 } 278 276 } 279 277 280 - // callCtxt is passed to builtin implementations. 281 - type callCtxt struct { 282 - idx *index 278 + // CallCtxt is passed to builtin implementations that need to use a cue.Value. This is an internal type. It's interface may change. 279 + type CallCtxt struct { 283 280 src adt.Expr // *adt.CallExpr 284 281 ctx *context 285 - builtin *builtin 286 - err interface{} 287 - ret interface{} 282 + builtin *Builtin 283 + Err interface{} 284 + Ret interface{} 288 285 289 286 args []adt.Value 290 287 } 291 288 292 - func (c *callCtxt) Pos() token.Pos { 289 + func (c *CallCtxt) Pos() token.Pos { 293 290 return c.ctx.opCtx.Pos() 294 291 } 295 292 296 - func (c *callCtxt) name() string { 293 + func (c *CallCtxt) Name() string { 297 294 return c.builtin.name(c.ctx) 298 295 } 299 296 300 297 var builtins = map[string]*Instance{} 301 298 302 - func initBuiltins(pkgs map[string]*builtinPkg) { 303 - ctx := sharedIndex.newContext() 299 + func initBuiltins(pkgs map[string]*Package) { 300 + ctx := sharedIndex.newContext().opCtx 304 301 keys := []string{} 305 302 for k := range pkgs { 306 303 keys = append(keys, k) ··· 308 305 sort.Strings(keys) 309 306 for _, k := range keys { 310 307 b := pkgs[k] 311 - e := mustCompileBuiltins(ctx, b, k) 308 + e := b.MustCompile(ctx, k) 312 309 313 310 i := sharedIndex.addInst(&Instance{ 314 311 ImportPath: k, ··· 349 346 } 350 347 } 351 348 352 - // do returns whether the call should be done. 353 - func (c *callCtxt) do() bool { 354 - return c.err == nil 349 + // Do returns whether the call should be done. 350 + func (c *CallCtxt) Do() bool { 351 + return c.Err == nil 355 352 } 356 353 357 354 type callError struct { 358 - b *bottom 355 + b *adt.Bottom 359 356 } 360 357 361 358 func (e *callError) Error() string { 362 359 return fmt.Sprint(e.b) 363 360 } 364 361 365 - func (c *callCtxt) errf(src source, underlying error, format string, args ...interface{}) { 362 + func (c *CallCtxt) errf(src adt.Node, underlying error, format string, args ...interface{}) { 366 363 a := make([]interface{}, 0, 2+len(args)) 367 364 if err, ok := underlying.(*valueError); ok { 368 365 a = append(a, err.err) ··· 370 367 a = append(a, format) 371 368 a = append(a, args...) 372 369 err := c.ctx.mkErr(src, a...) 373 - c.err = &callError{err} 370 + c.Err = &callError{err} 374 371 } 375 372 376 - func (c *callCtxt) errcf(src source, code adt.ErrorCode, format string, args ...interface{}) { 373 + func (c *CallCtxt) errcf(src adt.Node, code adt.ErrorCode, format string, args ...interface{}) { 377 374 a := make([]interface{}, 0, 2+len(args)) 378 375 a = append(a, code) 379 376 a = append(a, format) 380 377 a = append(a, args...) 381 378 err := c.ctx.mkErr(src, a...) 382 - c.err = &callError{err} 379 + c.Err = &callError{err} 383 380 } 384 381 385 - func (c *callCtxt) value(i int) Value { 382 + func (c *CallCtxt) Value(i int) Value { 386 383 v := newValueRoot(c.ctx, c.args[i]) 387 384 // TODO: remove default 388 385 // v, _ = v.Default() ··· 392 389 return v 393 390 } 394 391 395 - func (c *callCtxt) structVal(i int) *Struct { 392 + func (c *CallCtxt) Struct(i int) *Struct { 396 393 v := newValueRoot(c.ctx, c.args[i]) 397 394 s, err := v.Struct() 398 395 if err != nil { ··· 402 399 return s 403 400 } 404 401 405 - func (c *callCtxt) invalidArgType(arg value, i int, typ string, err error) { 402 + func (c *CallCtxt) invalidArgType(arg adt.Expr, i int, typ string, err error) { 406 403 if ve, ok := err.(*valueError); ok && ve.err.IsIncomplete() { 407 - c.err = ve 404 + c.Err = ve 408 405 return 409 406 } 410 407 v, ok := arg.(adt.Value) ··· 413 410 if !ok { 414 411 c.errf(c.src, nil, 415 412 "cannot use incomplete value %s as %s in argument %d to %s: %v", 416 - c.ctx.str(arg), typ, i, c.name(), err) 413 + c.ctx.str(arg), typ, i, c.Name(), err) 417 414 } 418 415 if err != nil { 419 416 c.errf(c.src, err, 420 417 "cannot use %s (type %s) as %s in argument %d to %s: %v", 421 - c.ctx.str(arg), v.Kind(), typ, i, c.name(), err) 418 + c.ctx.str(arg), v.Kind(), typ, i, c.Name(), err) 422 419 } else { 423 420 c.errf(c.src, err, 424 421 "cannot use %s (type %s) as %s in argument %d to %s", 425 - c.ctx.str(arg), v.Kind(), typ, i, c.name()) 422 + c.ctx.str(arg), v.Kind(), typ, i, c.Name()) 426 423 } 427 424 } 428 425 429 - func (c *callCtxt) int(i int) int { return int(c.intValue(i, 64, "int64")) } 430 - func (c *callCtxt) int8(i int) int8 { return int8(c.intValue(i, 8, "int8")) } 431 - func (c *callCtxt) int16(i int) int16 { return int16(c.intValue(i, 16, "int16")) } 432 - func (c *callCtxt) int32(i int) int32 { return int32(c.intValue(i, 32, "int32")) } 433 - func (c *callCtxt) rune(i int) rune { return rune(c.intValue(i, 32, "rune")) } 434 - func (c *callCtxt) int64(i int) int64 { return int64(c.intValue(i, 64, "int64")) } 426 + func (c *CallCtxt) Int(i int) int { return int(c.intValue(i, 64, "int64")) } 427 + func (c *CallCtxt) Int8(i int) int8 { return int8(c.intValue(i, 8, "int8")) } 428 + func (c *CallCtxt) Int16(i int) int16 { return int16(c.intValue(i, 16, "int16")) } 429 + func (c *CallCtxt) Int32(i int) int32 { return int32(c.intValue(i, 32, "int32")) } 430 + func (c *CallCtxt) Rune(i int) rune { return rune(c.intValue(i, 32, "rune")) } 431 + func (c *CallCtxt) Int64(i int) int64 { return int64(c.intValue(i, 64, "int64")) } 435 432 436 - func (c *callCtxt) intValue(i, bits int, typ string) int64 { 433 + func (c *CallCtxt) intValue(i, bits int, typ string) int64 { 437 434 arg := c.args[i] 438 435 x := newValueRoot(c.ctx, arg) 439 436 n, err := x.Int(nil) ··· 443 440 } 444 441 if n.BitLen() > bits { 445 442 c.errf(c.src, err, "int %s overflows %s in argument %d in call to %s", 446 - n, typ, i, c.name()) 443 + n, typ, i, c.Name()) 447 444 } 448 445 res, _ := x.Int64() 449 446 return res 450 447 } 451 448 452 - func (c *callCtxt) uint(i int) uint { return uint(c.uintValue(i, 64, "uint64")) } 453 - func (c *callCtxt) uint8(i int) uint8 { return uint8(c.uintValue(i, 8, "uint8")) } 454 - func (c *callCtxt) byte(i int) uint8 { return byte(c.uintValue(i, 8, "byte")) } 455 - func (c *callCtxt) uint16(i int) uint16 { return uint16(c.uintValue(i, 16, "uint16")) } 456 - func (c *callCtxt) uint32(i int) uint32 { return uint32(c.uintValue(i, 32, "uint32")) } 457 - func (c *callCtxt) uint64(i int) uint64 { return uint64(c.uintValue(i, 64, "uint64")) } 449 + func (c *CallCtxt) Uint(i int) uint { return uint(c.uintValue(i, 64, "uint64")) } 450 + func (c *CallCtxt) Uint8(i int) uint8 { return uint8(c.uintValue(i, 8, "uint8")) } 451 + func (c *CallCtxt) Byte(i int) uint8 { return byte(c.uintValue(i, 8, "byte")) } 452 + func (c *CallCtxt) Uint16(i int) uint16 { return uint16(c.uintValue(i, 16, "uint16")) } 453 + func (c *CallCtxt) Uint32(i int) uint32 { return uint32(c.uintValue(i, 32, "uint32")) } 454 + func (c *CallCtxt) Uint64(i int) uint64 { return uint64(c.uintValue(i, 64, "uint64")) } 458 455 459 - func (c *callCtxt) uintValue(i, bits int, typ string) uint64 { 456 + func (c *CallCtxt) uintValue(i, bits int, typ string) uint64 { 460 457 x := newValueRoot(c.ctx, c.args[i]) 461 458 n, err := x.Int(nil) 462 459 if err != nil || n.Sign() < 0 { ··· 465 462 } 466 463 if n.BitLen() > bits { 467 464 c.errf(c.src, err, "int %s overflows %s in argument %d in call to %s", 468 - n, typ, i, c.name()) 465 + n, typ, i, c.Name()) 469 466 } 470 467 res, _ := x.Uint64() 471 468 return res 472 469 } 473 470 474 - func (c *callCtxt) decimal(i int) *apd.Decimal { 471 + func (c *CallCtxt) Decimal(i int) *apd.Decimal { 475 472 x := newValueRoot(c.ctx, c.args[i]) 476 473 if _, err := x.MantExp(nil); err != nil { 477 474 c.invalidArgType(c.args[i], i, "Decimal", err) ··· 480 477 return &c.args[i].(*numLit).X 481 478 } 482 479 483 - func (c *callCtxt) float64(i int) float64 { 480 + func (c *CallCtxt) Float64(i int) float64 { 484 481 x := newValueRoot(c.ctx, c.args[i]) 485 482 res, err := x.Float64() 486 483 if err != nil { ··· 490 487 return res 491 488 } 492 489 493 - func (c *callCtxt) bigInt(i int) *big.Int { 490 + func (c *CallCtxt) BigInt(i int) *big.Int { 494 491 x := newValueRoot(c.ctx, c.args[i]) 495 492 n, err := x.Int(nil) 496 493 if err != nil { ··· 502 499 503 500 var ten = big.NewInt(10) 504 501 505 - func (c *callCtxt) bigFloat(i int) *big.Float { 502 + func (c *CallCtxt) BigFloat(i int) *big.Float { 506 503 x := newValueRoot(c.ctx, c.args[i]) 507 504 var mant big.Int 508 505 exp, err := x.MantExp(&mant) ··· 520 517 return f 521 518 } 522 519 523 - func (c *callCtxt) string(i int) string { 520 + func (c *CallCtxt) String(i int) string { 524 521 x := newValueRoot(c.ctx, c.args[i]) 525 522 v, err := x.String() 526 523 if err != nil { ··· 530 527 return v 531 528 } 532 529 533 - func (c *callCtxt) bytes(i int) []byte { 530 + func (c *CallCtxt) Bytes(i int) []byte { 534 531 x := newValueRoot(c.ctx, c.args[i]) 535 532 v, err := x.Bytes() 536 533 if err != nil { ··· 540 537 return v 541 538 } 542 539 543 - func (c *callCtxt) reader(i int) io.Reader { 540 + func (c *CallCtxt) Reader(i int) io.Reader { 544 541 x := newValueRoot(c.ctx, c.args[i]) 545 542 // TODO: optimize for string and bytes cases 546 543 r, err := x.Reader() ··· 551 548 return r 552 549 } 553 550 554 - func (c *callCtxt) bool(i int) bool { 551 + func (c *CallCtxt) Bool(i int) bool { 555 552 x := newValueRoot(c.ctx, c.args[i]) 556 553 b, err := x.Bool() 557 554 if err != nil { ··· 561 558 return b 562 559 } 563 560 564 - func (c *callCtxt) list(i int) (a []Value) { 561 + func (c *CallCtxt) List(i int) (a []Value) { 565 562 arg := c.args[i] 566 563 x := newValueRoot(c.ctx, arg) 567 564 v, err := x.List() ··· 575 572 return a 576 573 } 577 574 578 - func (c *callCtxt) iter(i int) (a Iterator) { 575 + func (c *CallCtxt) Iter(i int) (a Iterator) { 579 576 arg := c.args[i] 580 577 x := newValueRoot(c.ctx, arg) 581 578 v, err := x.List() ··· 586 583 return v 587 584 } 588 585 589 - func (c *callCtxt) decimalList(i int) (a []*apd.Decimal) { 586 + func (c *CallCtxt) DecimalList(i int) (a []*apd.Decimal) { 590 587 arg := c.args[i] 591 588 x := newValueRoot(c.ctx, arg) 592 589 v, err := x.List() ··· 598 595 num, err := v.Value().getNum(numKind) 599 596 if err != nil { 600 597 c.errf(c.src, err, "invalid list element %d in argument %d to %s: %v", 601 - j, i, c.name(), err) 598 + j, i, c.Name(), err) 602 599 break 603 600 } 604 601 a = append(a, &num.X) ··· 606 603 return a 607 604 } 608 605 609 - func (c *callCtxt) strList(i int) (a []string) { 606 + func (c *CallCtxt) StringList(i int) (a []string) { 610 607 arg := c.args[i] 611 608 x := newValueRoot(c.ctx, arg) 612 609 v, err := x.List() ··· 617 614 for j := 0; v.Next(); j++ { 618 615 str, err := v.Value().String() 619 616 if err != nil { 620 - c.err = errors.Wrapf(err, c.Pos(), 617 + c.Err = errors.Wrapf(err, c.Pos(), 621 618 "element %d of list argument %d", j, i) 622 619 break 623 620 }

+880 -880

cue/builtins.go

··· 147 147 return true, nil 148 148 } 149 149 150 - var builtinPackages = map[string]*builtinPkg{ 150 + var builtinPackages = map[string]*Package{ 151 151 // "": { 152 152 // native: []*builtin{}, 153 153 // }, 154 154 "crypto/md5": { 155 - native: []*builtin{{ 155 + Native: []*Builtin{{ 156 156 Name: "Size", 157 157 Const: "16", 158 158 }, { ··· 162 162 Name: "Sum", 163 163 Params: []kind{bytesKind | stringKind}, 164 164 Result: bytesKind | stringKind, 165 - Func: func(c *callCtxt) { 166 - data := c.bytes(0) 167 - if c.do() { 168 - c.ret = func() interface{} { 165 + Func: func(c *CallCtxt) { 166 + data := c.Bytes(0) 167 + if c.Do() { 168 + c.Ret = func() interface{} { 169 169 a := md5.Sum(data) 170 170 return a[:] 171 171 }() ··· 174 174 }}, 175 175 }, 176 176 "crypto/sha1": { 177 - native: []*builtin{{ 177 + Native: []*Builtin{{ 178 178 Name: "Size", 179 179 Const: "20", 180 180 }, { ··· 184 184 Name: "Sum", 185 185 Params: []kind{bytesKind | stringKind}, 186 186 Result: bytesKind | stringKind, 187 - Func: func(c *callCtxt) { 188 - data := c.bytes(0) 189 - if c.do() { 190 - c.ret = func() interface{} { 187 + Func: func(c *CallCtxt) { 188 + data := c.Bytes(0) 189 + if c.Do() { 190 + c.Ret = func() interface{} { 191 191 a := sha1.Sum(data) 192 192 return a[:] 193 193 }() ··· 196 196 }}, 197 197 }, 198 198 "crypto/sha256": { 199 - native: []*builtin{{ 199 + Native: []*Builtin{{ 200 200 Name: "Size", 201 201 Const: "32", 202 202 }, { ··· 209 209 Name: "Sum256", 210 210 Params: []kind{bytesKind | stringKind}, 211 211 Result: bytesKind | stringKind, 212 - Func: func(c *callCtxt) { 213 - data := c.bytes(0) 214 - if c.do() { 215 - c.ret = func() interface{} { 212 + Func: func(c *CallCtxt) { 213 + data := c.Bytes(0) 214 + if c.Do() { 215 + c.Ret = func() interface{} { 216 216 a := sha256.Sum256(data) 217 217 return a[:] 218 218 }() ··· 222 222 Name: "Sum224", 223 223 Params: []kind{bytesKind | stringKind}, 224 224 Result: bytesKind | stringKind, 225 - Func: func(c *callCtxt) { 226 - data := c.bytes(0) 227 - if c.do() { 228 - c.ret = func() interface{} { 225 + Func: func(c *CallCtxt) { 226 + data := c.Bytes(0) 227 + if c.Do() { 228 + c.Ret = func() interface{} { 229 229 a := sha256.Sum224(data) 230 230 return a[:] 231 231 }() ··· 234 234 }}, 235 235 }, 236 236 "crypto/sha512": { 237 - native: []*builtin{{ 237 + Native: []*Builtin{{ 238 238 Name: "Size", 239 239 Const: "64", 240 240 }, { ··· 253 253 Name: "Sum512", 254 254 Params: []kind{bytesKind | stringKind}, 255 255 Result: bytesKind | stringKind, 256 - Func: func(c *callCtxt) { 257 - data := c.bytes(0) 258 - if c.do() { 259 - c.ret = func() interface{} { 256 + Func: func(c *CallCtxt) { 257 + data := c.Bytes(0) 258 + if c.Do() { 259 + c.Ret = func() interface{} { 260 260 a := sha512.Sum512(data) 261 261 return a[:] 262 262 }() ··· 266 266 Name: "Sum384", 267 267 Params: []kind{bytesKind | stringKind}, 268 268 Result: bytesKind | stringKind, 269 - Func: func(c *callCtxt) { 270 - data := c.bytes(0) 271 - if c.do() { 272 - c.ret = func() interface{} { 269 + Func: func(c *CallCtxt) { 270 + data := c.Bytes(0) 271 + if c.Do() { 272 + c.Ret = func() interface{} { 273 273 a := sha512.Sum384(data) 274 274 return a[:] 275 275 }() ··· 279 279 Name: "Sum512_224", 280 280 Params: []kind{bytesKind | stringKind}, 281 281 Result: bytesKind | stringKind, 282 - Func: func(c *callCtxt) { 283 - data := c.bytes(0) 284 - if c.do() { 285 - c.ret = func() interface{} { 282 + Func: func(c *CallCtxt) { 283 + data := c.Bytes(0) 284 + if c.Do() { 285 + c.Ret = func() interface{} { 286 286 a := sha512.Sum512_224(data) 287 287 return a[:] 288 288 }() ··· 292 292 Name: "Sum512_256", 293 293 Params: []kind{bytesKind | stringKind}, 294 294 Result: bytesKind | stringKind, 295 - Func: func(c *callCtxt) { 296 - data := c.bytes(0) 297 - if c.do() { 298 - c.ret = func() interface{} { 295 + Func: func(c *CallCtxt) { 296 + data := c.Bytes(0) 297 + if c.Do() { 298 + c.Ret = func() interface{} { 299 299 a := sha512.Sum512_256(data) 300 300 return a[:] 301 301 }() ··· 304 304 }}, 305 305 }, 306 306 "encoding/base64": { 307 - native: []*builtin{{ 307 + Native: []*Builtin{{ 308 308 Name: "EncodedLen", 309 309 Params: []kind{topKind, intKind}, 310 310 Result: intKind, 311 - Func: func(c *callCtxt) { 312 - encoding, n := c.value(0), c.int(1) 313 - if c.do() { 314 - c.ret, c.err = func() (interface{}, error) { 311 + Func: func(c *CallCtxt) { 312 + encoding, n := c.Value(0), c.Int(1) 313 + if c.Do() { 314 + c.Ret, c.Err = func() (interface{}, error) { 315 315 if err := encoding.Null(); err != nil { 316 316 return 0, fmt.Errorf("base64: unsupported encoding: %v", err) 317 317 } ··· 323 323 Name: "DecodedLen", 324 324 Params: []kind{topKind, intKind}, 325 325 Result: intKind, 326 - Func: func(c *callCtxt) { 327 - encoding, x := c.value(0), c.int(1) 328 - if c.do() { 329 - c.ret, c.err = func() (interface{}, error) { 326 + Func: func(c *CallCtxt) { 327 + encoding, x := c.Value(0), c.Int(1) 328 + if c.Do() { 329 + c.Ret, c.Err = func() (interface{}, error) { 330 330 if err := encoding.Null(); err != nil { 331 331 return 0, fmt.Errorf("base64: unsupported encoding: %v", err) 332 332 } ··· 338 338 Name: "Encode", 339 339 Params: []kind{topKind, bytesKind | stringKind}, 340 340 Result: stringKind, 341 - Func: func(c *callCtxt) { 342 - encoding, src := c.value(0), c.bytes(1) 343 - if c.do() { 344 - c.ret, c.err = func() (interface{}, error) { 341 + Func: func(c *CallCtxt) { 342 + encoding, src := c.Value(0), c.Bytes(1) 343 + if c.Do() { 344 + c.Ret, c.Err = func() (interface{}, error) { 345 345 if err := encoding.Null(); err != nil { 346 346 return "", fmt.Errorf("base64: unsupported encoding: %v", err) 347 347 } ··· 353 353 Name: "Decode", 354 354 Params: []kind{topKind, stringKind}, 355 355 Result: bytesKind | stringKind, 356 - Func: func(c *callCtxt) { 357 - encoding, s := c.value(0), c.string(1) 358 - if c.do() { 359 - c.ret, c.err = func() (interface{}, error) { 356 + Func: func(c *CallCtxt) { 357 + encoding, s := c.Value(0), c.String(1) 358 + if c.Do() { 359 + c.Ret, c.Err = func() (interface{}, error) { 360 360 if err := encoding.Null(); err != nil { 361 361 return nil, fmt.Errorf("base64: unsupported encoding: %v", err) 362 362 } ··· 367 367 }}, 368 368 }, 369 369 "encoding/csv": { 370 - native: []*builtin{{ 370 + Native: []*Builtin{{ 371 371 Name: "Encode", 372 372 Params: []kind{topKind}, 373 373 Result: stringKind, 374 - Func: func(c *callCtxt) { 375 - x := c.value(0) 376 - if c.do() { 377 - c.ret, c.err = func() (interface{}, error) { 374 + Func: func(c *CallCtxt) { 375 + x := c.Value(0) 376 + if c.Do() { 377 + c.Ret, c.Err = func() (interface{}, error) { 378 378 buf := &bytes.Buffer{} 379 379 w := csv.NewWriter(buf) 380 380 iter, err := x.List() ··· 410 410 Name: "Decode", 411 411 Params: []kind{bytesKind | stringKind}, 412 412 Result: listKind, 413 - Func: func(c *callCtxt) { 414 - r := c.reader(0) 415 - if c.do() { 416 - c.ret, c.err = func() (interface{}, error) { 413 + Func: func(c *CallCtxt) { 414 + r := c.Reader(0) 415 + if c.Do() { 416 + c.Ret, c.Err = func() (interface{}, error) { 417 417 return csv.NewReader(r).ReadAll() 418 418 }() 419 419 } ··· 421 421 }}, 422 422 }, 423 423 "encoding/hex": { 424 - native: []*builtin{{ 424 + Native: []*Builtin{{ 425 425 Name: "EncodedLen", 426 426 Params: []kind{intKind}, 427 427 Result: intKind, 428 - Func: func(c *callCtxt) { 429 - n := c.int(0) 430 - if c.do() { 431 - c.ret = func() interface{} { 428 + Func: func(c *CallCtxt) { 429 + n := c.Int(0) 430 + if c.Do() { 431 + c.Ret = func() interface{} { 432 432 return hex.EncodedLen(n) 433 433 }() 434 434 } ··· 437 437 Name: "DecodedLen", 438 438 Params: []kind{intKind}, 439 439 Result: intKind, 440 - Func: func(c *callCtxt) { 441 - x := c.int(0) 442 - if c.do() { 443 - c.ret = func() interface{} { 440 + Func: func(c *CallCtxt) { 441 + x := c.Int(0) 442 + if c.Do() { 443 + c.Ret = func() interface{} { 444 444 return hex.DecodedLen(x) 445 445 }() 446 446 } ··· 449 449 Name: "Decode", 450 450 Params: []kind{stringKind}, 451 451 Result: bytesKind | stringKind, 452 - Func: func(c *callCtxt) { 453 - s := c.string(0) 454 - if c.do() { 455 - c.ret, c.err = func() (interface{}, error) { 452 + Func: func(c *CallCtxt) { 453 + s := c.String(0) 454 + if c.Do() { 455 + c.Ret, c.Err = func() (interface{}, error) { 456 456 return hex.DecodeString(s) 457 457 }() 458 458 } ··· 461 461 Name: "Dump", 462 462 Params: []kind{bytesKind | stringKind}, 463 463 Result: stringKind, 464 - Func: func(c *callCtxt) { 465 - data := c.bytes(0) 466 - if c.do() { 467 - c.ret = func() interface{} { 464 + Func: func(c *CallCtxt) { 465 + data := c.Bytes(0) 466 + if c.Do() { 467 + c.Ret = func() interface{} { 468 468 return hex.Dump(data) 469 469 }() 470 470 } ··· 473 473 Name: "Encode", 474 474 Params: []kind{bytesKind | stringKind}, 475 475 Result: stringKind, 476 - Func: func(c *callCtxt) { 477 - src := c.bytes(0) 478 - if c.do() { 479 - c.ret = func() interface{} { 476 + Func: func(c *CallCtxt) { 477 + src := c.Bytes(0) 478 + if c.Do() { 479 + c.Ret = func() interface{} { 480 480 return hex.EncodeToString(src) 481 481 }() 482 482 } ··· 484 484 }}, 485 485 }, 486 486 "encoding/json": { 487 - native: []*builtin{{ 487 + Native: []*Builtin{{ 488 488 Name: "Valid", 489 489 Params: []kind{bytesKind | stringKind}, 490 490 Result: boolKind, 491 - Func: func(c *callCtxt) { 492 - data := c.bytes(0) 493 - if c.do() { 494 - c.ret = func() interface{} { 491 + Func: func(c *CallCtxt) { 492 + data := c.Bytes(0) 493 + if c.Do() { 494 + c.Ret = func() interface{} { 495 495 return json.Valid(data) 496 496 }() 497 497 } ··· 500 500 Name: "Compact", 501 501 Params: []kind{bytesKind | stringKind}, 502 502 Result: stringKind, 503 - Func: func(c *callCtxt) { 504 - src := c.bytes(0) 505 - if c.do() { 506 - c.ret, c.err = func() (interface{}, error) { 503 + Func: func(c *CallCtxt) { 504 + src := c.Bytes(0) 505 + if c.Do() { 506 + c.Ret, c.Err = func() (interface{}, error) { 507 507 dst := bytes.Buffer{} 508 508 if err := json.Compact(&dst, src); err != nil { 509 509 return "", err ··· 516 516 Name: "Indent", 517 517 Params: []kind{bytesKind | stringKind, stringKind, stringKind}, 518 518 Result: stringKind, 519 - Func: func(c *callCtxt) { 520 - src, prefix, indent := c.bytes(0), c.string(1), c.string(2) 521 - if c.do() { 522 - c.ret, c.err = func() (interface{}, error) { 519 + Func: func(c *CallCtxt) { 520 + src, prefix, indent := c.Bytes(0), c.String(1), c.String(2) 521 + if c.Do() { 522 + c.Ret, c.Err = func() (interface{}, error) { 523 523 dst := bytes.Buffer{} 524 524 if err := json.Indent(&dst, src, prefix, indent); err != nil { 525 525 return "", err ··· 532 532 Name: "HTMLEscape", 533 533 Params: []kind{bytesKind | stringKind}, 534 534 Result: stringKind, 535 - Func: func(c *callCtxt) { 536 - src := c.bytes(0) 537 - if c.do() { 538 - c.ret = func() interface{} { 535 + Func: func(c *CallCtxt) { 536 + src := c.Bytes(0) 537 + if c.Do() { 538 + c.Ret = func() interface{} { 539 539 dst := &bytes.Buffer{} 540 540 json.HTMLEscape(dst, src) 541 541 return dst.String() ··· 546 546 Name: "Marshal", 547 547 Params: []kind{topKind}, 548 548 Result: stringKind, 549 - Func: func(c *callCtxt) { 550 - v := c.value(0) 551 - if c.do() { 552 - c.ret, c.err = func() (interface{}, error) { 549 + Func: func(c *CallCtxt) { 550 + v := c.Value(0) 551 + if c.Do() { 552 + c.Ret, c.Err = func() (interface{}, error) { 553 553 b, err := json.Marshal(v) 554 554 return string(b), err 555 555 }() ··· 559 559 Name: "MarshalStream", 560 560 Params: []kind{topKind}, 561 561 Result: stringKind, 562 - Func: func(c *callCtxt) { 563 - v := c.value(0) 564 - if c.do() { 565 - c.ret, c.err = func() (interface{}, error) { 562 + Func: func(c *CallCtxt) { 563 + v := c.Value(0) 564 + if c.Do() { 565 + c.Ret, c.Err = func() (interface{}, error) { 566 566 567 567 iter, err := v.List() 568 568 if err != nil { ··· 585 585 Name: "Unmarshal", 586 586 Params: []kind{bytesKind | stringKind}, 587 587 Result: topKind, 588 - Func: func(c *callCtxt) { 589 - b := c.bytes(0) 590 - if c.do() { 591 - c.ret, c.err = func() (interface{}, error) { 588 + Func: func(c *CallCtxt) { 589 + b := c.Bytes(0) 590 + if c.Do() { 591 + c.Ret, c.Err = func() (interface{}, error) { 592 592 if !json.Valid(b) { 593 593 return nil, fmt.Errorf("json: invalid JSON") 594 594 } ··· 605 605 Name: "Validate", 606 606 Params: []kind{bytesKind | stringKind, topKind}, 607 607 Result: boolKind, 608 - Func: func(c *callCtxt) { 609 - b, v := c.bytes(0), c.value(1) 610 - if c.do() { 611 - c.ret, c.err = func() (interface{}, error) { 608 + Func: func(c *CallCtxt) { 609 + b, v := c.Bytes(0), c.Value(1) 610 + if c.Do() { 611 + c.Ret, c.Err = func() (interface{}, error) { 612 612 if !json.Valid(b) { 613 613 return false, fmt.Errorf("json: invalid JSON") 614 614 } ··· 631 631 }}, 632 632 }, 633 633 "encoding/yaml": { 634 - native: []*builtin{{ 634 + Native: []*Builtin{{ 635 635 Name: "Marshal", 636 636 Params: []kind{topKind}, 637 637 Result: stringKind, 638 - Func: func(c *callCtxt) { 639 - v := c.value(0) 640 - if c.do() { 641 - c.ret, c.err = func() (interface{}, error) { 638 + Func: func(c *CallCtxt) { 639 + v := c.Value(0) 640 + if c.Do() { 641 + c.Ret, c.Err = func() (interface{}, error) { 642 642 if err := v.Validate(Concrete(true)); err != nil { 643 643 if err := v.Validate(); err != nil { 644 644 return "", err ··· 655 655 Name: "MarshalStream", 656 656 Params: []kind{topKind}, 657 657 Result: stringKind, 658 - Func: func(c *callCtxt) { 659 - v := c.value(0) 660 - if c.do() { 661 - c.ret, c.err = func() (interface{}, error) { 658 + Func: func(c *CallCtxt) { 659 + v := c.Value(0) 660 + if c.Do() { 661 + c.Ret, c.Err = func() (interface{}, error) { 662 662 663 663 iter, err := v.List() 664 664 if err != nil { ··· 691 691 Name: "Unmarshal", 692 692 Params: []kind{bytesKind | stringKind}, 693 693 Result: topKind, 694 - Func: func(c *callCtxt) { 695 - data := c.bytes(0) 696 - if c.do() { 697 - c.ret, c.err = func() (interface{}, error) { 694 + Func: func(c *CallCtxt) { 695 + data := c.Bytes(0) 696 + if c.Do() { 697 + c.Ret, c.Err = func() (interface{}, error) { 698 698 return yaml.Unmarshal("", data) 699 699 }() 700 700 } ··· 703 703 Name: "Validate", 704 704 Params: []kind{bytesKind | stringKind, topKind}, 705 705 Result: boolKind, 706 - Func: func(c *callCtxt) { 707 - b, v := c.bytes(0), c.value(1) 708 - if c.do() { 709 - c.ret, c.err = func() (interface{}, error) { 706 + Func: func(c *CallCtxt) { 707 + b, v := c.Bytes(0), c.Value(1) 708 + if c.Do() { 709 + c.Ret, c.Err = func() (interface{}, error) { 710 710 d, err := yaml.NewDecoder("yaml.Validate", b) 711 711 if err != nil { 712 712 return false, err ··· 742 742 Name: "ValidatePartial", 743 743 Params: []kind{bytesKind | stringKind, topKind}, 744 744 Result: boolKind, 745 - Func: func(c *callCtxt) { 746 - b, v := c.bytes(0), c.value(1) 747 - if c.do() { 748 - c.ret, c.err = func() (interface{}, error) { 745 + Func: func(c *CallCtxt) { 746 + b, v := c.Bytes(0), c.Value(1) 747 + if c.Do() { 748 + c.Ret, c.Err = func() (interface{}, error) { 749 749 d, err := yaml.NewDecoder("yaml.ValidatePartial", b) 750 750 if err != nil { 751 751 return false, err ··· 775 775 }}, 776 776 }, 777 777 "html": { 778 - native: []*builtin{{ 778 + Native: []*Builtin{{ 779 779 Name: "Escape", 780 780 Params: []kind{stringKind}, 781 781 Result: stringKind, 782 - Func: func(c *callCtxt) { 783 - s := c.string(0) 784 - if c.do() { 785 - c.ret = func() interface{} { 782 + Func: func(c *CallCtxt) { 783 + s := c.String(0) 784 + if c.Do() { 785 + c.Ret = func() interface{} { 786 786 return html.EscapeString(s) 787 787 }() 788 788 } ··· 791 791 Name: "Unescape", 792 792 Params: []kind{stringKind}, 793 793 Result: stringKind, 794 - Func: func(c *callCtxt) { 795 - s := c.string(0) 796 - if c.do() { 797 - c.ret = func() interface{} { 794 + Func: func(c *CallCtxt) { 795 + s := c.String(0) 796 + if c.Do() { 797 + c.Ret = func() interface{} { 798 798 return html.UnescapeString(s) 799 799 }() 800 800 } ··· 802 802 }}, 803 803 }, 804 804 "list": { 805 - native: []*builtin{{ 805 + Native: []*Builtin{{ 806 806 Name: "Drop", 807 807 Params: []kind{listKind, intKind}, 808 808 Result: listKind, 809 - Func: func(c *callCtxt) { 810 - x, n := c.list(0), c.int(1) 811 - if c.do() { 812 - c.ret, c.err = func() (interface{}, error) { 809 + Func: func(c *CallCtxt) { 810 + x, n := c.List(0), c.Int(1) 811 + if c.Do() { 812 + c.Ret, c.Err = func() (interface{}, error) { 813 813 if n < 0 { 814 814 return nil, fmt.Errorf("negative index") 815 815 } ··· 826 826 Name: "FlattenN", 827 827 Params: []kind{topKind, intKind}, 828 828 Result: listKind, 829 - Func: func(c *callCtxt) { 830 - xs, depth := c.value(0), c.int(1) 831 - if c.do() { 832 - c.ret, c.err = func() (interface{}, error) { 829 + Func: func(c *CallCtxt) { 830 + xs, depth := c.Value(0), c.Int(1) 831 + if c.Do() { 832 + c.Ret, c.Err = func() (interface{}, error) { 833 833 var flattenN func(Value, int) ([]Value, error) 834 834 flattenN = func(xs Value, depth int) ([]Value, error) { 835 835 var res []Value ··· 860 860 Name: "Take", 861 861 Params: []kind{listKind, intKind}, 862 862 Result: listKind, 863 - Func: func(c *callCtxt) { 864 - x, n := c.list(0), c.int(1) 865 - if c.do() { 866 - c.ret, c.err = func() (interface{}, error) { 863 + Func: func(c *CallCtxt) { 864 + x, n := c.List(0), c.Int(1) 865 + if c.Do() { 866 + c.Ret, c.Err = func() (interface{}, error) { 867 867 if n < 0 { 868 868 return nil, fmt.Errorf("negative index") 869 869 } ··· 880 880 Name: "Slice", 881 881 Params: []kind{listKind, intKind, intKind}, 882 882 Result: listKind, 883 - Func: func(c *callCtxt) { 884 - x, i, j := c.list(0), c.int(1), c.int(2) 885 - if c.do() { 886 - c.ret, c.err = func() (interface{}, error) { 883 + Func: func(c *CallCtxt) { 884 + x, i, j := c.List(0), c.Int(1), c.Int(2) 885 + if c.Do() { 886 + c.Ret, c.Err = func() (interface{}, error) { 887 887 if i < 0 { 888 888 return nil, fmt.Errorf("negative index") 889 889 } ··· 908 908 Name: "MinItems", 909 909 Params: []kind{listKind, intKind}, 910 910 Result: boolKind, 911 - Func: func(c *callCtxt) { 912 - a, n := c.list(0), c.int(1) 913 - if c.do() { 914 - c.ret = func() interface{} { 911 + Func: func(c *CallCtxt) { 912 + a, n := c.List(0), c.Int(1) 913 + if c.Do() { 914 + c.Ret = func() interface{} { 915 915 return len(a) >= n 916 916 }() 917 917 } ··· 920 920 Name: "MaxItems", 921 921 Params: []kind{listKind, intKind}, 922 922 Result: boolKind, 923 - Func: func(c *callCtxt) { 924 - a, n := c.list(0), c.int(1) 925 - if c.do() { 926 - c.ret = func() interface{} { 923 + Func: func(c *CallCtxt) { 924 + a, n := c.List(0), c.Int(1) 925 + if c.Do() { 926 + c.Ret = func() interface{} { 927 927 return len(a) <= n 928 928 }() 929 929 } ··· 932 932 Name: "UniqueItems", 933 933 Params: []kind{listKind}, 934 934 Result: boolKind, 935 - Func: func(c *callCtxt) { 936 - a := c.list(0) 937 - if c.do() { 938 - c.ret = func() interface{} { 935 + Func: func(c *CallCtxt) { 936 + a := c.List(0) 937 + if c.Do() { 938 + c.Ret = func() interface{} { 939 939 b := []string{} 940 940 for _, v := range a { 941 941 b = append(b, fmt.Sprint(v)) ··· 954 954 Name: "Contains", 955 955 Params: []kind{listKind, topKind}, 956 956 Result: boolKind, 957 - Func: func(c *callCtxt) { 958 - a, v := c.list(0), c.value(1) 959 - if c.do() { 960 - c.ret = func() interface{} { 957 + Func: func(c *CallCtxt) { 958 + a, v := c.List(0), c.Value(1) 959 + if c.Do() { 960 + c.Ret = func() interface{} { 961 961 for _, w := range a { 962 962 if v.Equals(w) { 963 963 return true ··· 971 971 Name: "Avg", 972 972 Params: []kind{listKind}, 973 973 Result: numKind, 974 - Func: func(c *callCtxt) { 975 - xs := c.decimalList(0) 976 - if c.do() { 977 - c.ret, c.err = func() (interface{}, error) { 974 + Func: func(c *CallCtxt) { 975 + xs := c.DecimalList(0) 976 + if c.Do() { 977 + c.Ret, c.Err = func() (interface{}, error) { 978 978 if 0 == len(xs) { 979 979 return nil, fmt.Errorf("empty list") 980 980 } ··· 1001 1001 Name: "Max", 1002 1002 Params: []kind{listKind}, 1003 1003 Result: numKind, 1004 - Func: func(c *callCtxt) { 1005 - xs := c.decimalList(0) 1006 - if c.do() { 1007 - c.ret, c.err = func() (interface{}, error) { 1004 + Func: func(c *CallCtxt) { 1005 + xs := c.DecimalList(0) 1006 + if c.Do() { 1007 + c.Ret, c.Err = func() (interface{}, error) { 1008 1008 if 0 == len(xs) { 1009 1009 return nil, fmt.Errorf("empty list") 1010 1010 } ··· 1023 1023 Name: "Min", 1024 1024 Params: []kind{listKind}, 1025 1025 Result: numKind, 1026 - Func: func(c *callCtxt) { 1027 - xs := c.decimalList(0) 1028 - if c.do() { 1029 - c.ret, c.err = func() (interface{}, error) { 1026 + Func: func(c *CallCtxt) { 1027 + xs := c.DecimalList(0) 1028 + if c.Do() { 1029 + c.Ret, c.Err = func() (interface{}, error) { 1030 1030 if 0 == len(xs) { 1031 1031 return nil, fmt.Errorf("empty list") 1032 1032 } ··· 1045 1045 Name: "Product", 1046 1046 Params: []kind{listKind}, 1047 1047 Result: numKind, 1048 - Func: func(c *callCtxt) { 1049 - xs := c.decimalList(0) 1050 - if c.do() { 1051 - c.ret, c.err = func() (interface{}, error) { 1048 + Func: func(c *CallCtxt) { 1049 + xs := c.DecimalList(0) 1050 + if c.Do() { 1051 + c.Ret, c.Err = func() (interface{}, error) { 1052 1052 d := apd.New(1, 0) 1053 1053 for _, x := range xs { 1054 1054 _, err := internal.BaseContext.Mul(d, x, d) ··· 1064 1064 Name: "Range", 1065 1065 Params: []kind{numKind, numKind, numKind}, 1066 1066 Result: listKind, 1067 - Func: func(c *callCtxt) { 1068 - start, limit, step := c.decimal(0), c.decimal(1), c.decimal(2) 1069 - if c.do() { 1070 - c.ret, c.err = func() (interface{}, error) { 1067 + Func: func(c *CallCtxt) { 1068 + start, limit, step := c.Decimal(0), c.Decimal(1), c.Decimal(2) 1069 + if c.Do() { 1070 + c.Ret, c.Err = func() (interface{}, error) { 1071 1071 if step.IsZero() { 1072 1072 return nil, fmt.Errorf("step must be non zero") 1073 1073 } ··· 1107 1107 Name: "Sum", 1108 1108 Params: []kind{listKind}, 1109 1109 Result: numKind, 1110 - Func: func(c *callCtxt) { 1111 - xs := c.decimalList(0) 1112 - if c.do() { 1113 - c.ret, c.err = func() (interface{}, error) { 1110 + Func: func(c *CallCtxt) { 1111 + xs := c.DecimalList(0) 1112 + if c.Do() { 1113 + c.Ret, c.Err = func() (interface{}, error) { 1114 1114 d := apd.New(0, 0) 1115 1115 for _, x := range xs { 1116 1116 _, err := internal.BaseContext.Add(d, x, d) ··· 1126 1126 Name: "Sort", 1127 1127 Params: []kind{listKind, topKind}, 1128 1128 Result: listKind, 1129 - Func: func(c *callCtxt) { 1130 - list, cmp := c.list(0), c.value(1) 1131 - if c.do() { 1132 - c.ret, c.err = func() (interface{}, error) { 1129 + Func: func(c *CallCtxt) { 1130 + list, cmp := c.List(0), c.Value(1) 1131 + if c.Do() { 1132 + c.Ret, c.Err = func() (interface{}, error) { 1133 1133 s := valueSorter{list, cmp, nil} 1134 1134 1135 1135 sort.Sort(&s) ··· 1141 1141 Name: "SortStable", 1142 1142 Params: []kind{listKind, topKind}, 1143 1143 Result: listKind, 1144 - Func: func(c *callCtxt) { 1145 - list, cmp := c.list(0), c.value(1) 1146 - if c.do() { 1147 - c.ret, c.err = func() (interface{}, error) { 1144 + Func: func(c *CallCtxt) { 1145 + list, cmp := c.List(0), c.Value(1) 1146 + if c.Do() { 1147 + c.Ret, c.Err = func() (interface{}, error) { 1148 1148 s := valueSorter{list, cmp, nil} 1149 1149 sort.Stable(&s) 1150 1150 return s.ret() ··· 1155 1155 Name: "SortStrings", 1156 1156 Params: []kind{listKind}, 1157 1157 Result: listKind, 1158 - Func: func(c *callCtxt) { 1159 - a := c.strList(0) 1160 - if c.do() { 1161 - c.ret = func() interface{} { 1158 + Func: func(c *CallCtxt) { 1159 + a := c.StringList(0) 1160 + if c.Do() { 1161 + c.Ret = func() interface{} { 1162 1162 sort.Strings(a) 1163 1163 return a 1164 1164 }() ··· 1168 1168 Name: "IsSorted", 1169 1169 Params: []kind{listKind, topKind}, 1170 1170 Result: boolKind, 1171 - Func: func(c *callCtxt) { 1172 - list, cmp := c.list(0), c.value(1) 1173 - if c.do() { 1174 - c.ret = func() interface{} { 1171 + Func: func(c *CallCtxt) { 1172 + list, cmp := c.List(0), c.Value(1) 1173 + if c.Do() { 1174 + c.Ret = func() interface{} { 1175 1175 s := valueSorter{list, cmp, nil} 1176 1176 return sort.IsSorted(&s) 1177 1177 }() ··· 1181 1181 Name: "IsSortedStrings", 1182 1182 Params: []kind{listKind}, 1183 1183 Result: boolKind, 1184 - Func: func(c *callCtxt) { 1185 - a := c.strList(0) 1186 - if c.do() { 1187 - c.ret = func() interface{} { 1184 + Func: func(c *CallCtxt) { 1185 + a := c.StringList(0) 1186 + if c.Do() { 1187 + c.Ret = func() interface{} { 1188 1188 return sort.StringsAreSorted(a) 1189 1189 }() 1190 1190 } 1191 1191 }, 1192 1192 }}, 1193 - cue: `{ 1193 + CUE: `{ 1194 1194 Comparer: { 1195 1195 T: _ 1196 1196 less: bool ··· 1214 1214 }`, 1215 1215 }, 1216 1216 "math": { 1217 - native: []*builtin{{ 1217 + Native: []*Builtin{{ 1218 1218 Name: "MaxExp", 1219 1219 Const: "2147483647", 1220 1220 }, { ··· 1254 1254 Name: "Jacobi", 1255 1255 Params: []kind{intKind, intKind}, 1256 1256 Result: intKind, 1257 - Func: func(c *callCtxt) { 1258 - x, y := c.bigInt(0), c.bigInt(1) 1259 - if c.do() { 1260 - c.ret = func() interface{} { 1257 + Func: func(c *CallCtxt) { 1258 + x, y := c.BigInt(0), c.BigInt(1) 1259 + if c.Do() { 1260 + c.Ret = func() interface{} { 1261 1261 return big.Jacobi(x, y) 1262 1262 }() 1263 1263 } ··· 1269 1269 Name: "Floor", 1270 1270 Params: []kind{numKind}, 1271 1271 Result: numKind, 1272 - Func: func(c *callCtxt) { 1273 - x := c.decimal(0) 1274 - if c.do() { 1275 - c.ret, c.err = func() (interface{}, error) { 1272 + Func: func(c *CallCtxt) { 1273 + x := c.Decimal(0) 1274 + if c.Do() { 1275 + c.Ret, c.Err = func() (interface{}, error) { 1276 1276 var d internal.Decimal 1277 1277 _, err := apdContext.Floor(&d, x) 1278 1278 return &d, err ··· 1283 1283 Name: "Ceil", 1284 1284 Params: []kind{numKind}, 1285 1285 Result: numKind, 1286 - Func: func(c *callCtxt) { 1287 - x := c.decimal(0) 1288 - if c.do() { 1289 - c.ret, c.err = func() (interface{}, error) { 1286 + Func: func(c *CallCtxt) { 1287 + x := c.Decimal(0) 1288 + if c.Do() { 1289 + c.Ret, c.Err = func() (interface{}, error) { 1290 1290 var d internal.Decimal 1291 1291 _, err := apdContext.Ceil(&d, x) 1292 1292 return &d, err ··· 1297 1297 Name: "Trunc", 1298 1298 Params: []kind{numKind}, 1299 1299 Result: numKind, 1300 - Func: func(c *callCtxt) { 1301 - x := c.decimal(0) 1302 - if c.do() { 1303 - c.ret, c.err = func() (interface{}, error) { 1300 + Func: func(c *CallCtxt) { 1301 + x := c.Decimal(0) 1302 + if c.Do() { 1303 + c.Ret, c.Err = func() (interface{}, error) { 1304 1304 var d internal.Decimal 1305 1305 _, err := roundTruncContext.RoundToIntegralExact(&d, x) 1306 1306 return &d, err ··· 1311 1311 Name: "Round", 1312 1312 Params: []kind{numKind}, 1313 1313 Result: numKind, 1314 - Func: func(c *callCtxt) { 1315 - x := c.decimal(0) 1316 - if c.do() { 1317 - c.ret, c.err = func() (interface{}, error) { 1314 + Func: func(c *CallCtxt) { 1315 + x := c.Decimal(0) 1316 + if c.Do() { 1317 + c.Ret, c.Err = func() (interface{}, error) { 1318 1318 var d internal.Decimal 1319 1319 _, err := roundUpContext.RoundToIntegralExact(&d, x) 1320 1320 return &d, err ··· 1325 1325 Name: "RoundToEven", 1326 1326 Params: []kind{numKind}, 1327 1327 Result: numKind, 1328 - Func: func(c *callCtxt) { 1329 - x := c.decimal(0) 1330 - if c.do() { 1331 - c.ret, c.err = func() (interface{}, error) { 1328 + Func: func(c *CallCtxt) { 1329 + x := c.Decimal(0) 1330 + if c.Do() { 1331 + c.Ret, c.Err = func() (interface{}, error) { 1332 1332 var d internal.Decimal 1333 1333 _, err := roundEvenContext.RoundToIntegralExact(&d, x) 1334 1334 return &d, err ··· 1339 1339 Name: "MultipleOf", 1340 1340 Params: []kind{numKind, numKind}, 1341 1341 Result: boolKind, 1342 - Func: func(c *callCtxt) { 1343 - x, y := c.decimal(0), c.decimal(1) 1344 - if c.do() { 1345 - c.ret, c.err = func() (interface{}, error) { 1342 + Func: func(c *CallCtxt) { 1343 + x, y := c.Decimal(0), c.Decimal(1) 1344 + if c.Do() { 1345 + c.Ret, c.Err = func() (interface{}, error) { 1346 1346 var d apd.Decimal 1347 1347 cond, err := mulContext.Quo(&d, x, y) 1348 1348 return !cond.Inexact(), err ··· 1353 1353 Name: "Abs", 1354 1354 Params: []kind{numKind}, 1355 1355 Result: numKind, 1356 - Func: func(c *callCtxt) { 1357 - x := c.decimal(0) 1358 - if c.do() { 1359 - c.ret, c.err = func() (interface{}, error) { 1356 + Func: func(c *CallCtxt) { 1357 + x := c.Decimal(0) 1358 + if c.Do() { 1359 + c.Ret, c.Err = func() (interface{}, error) { 1360 1360 var d internal.Decimal 1361 1361 _, err := apdContext.Abs(&d, x) 1362 1362 return &d, err ··· 1367 1367 Name: "Acosh", 1368 1368 Params: []kind{numKind}, 1369 1369 Result: numKind, 1370 - Func: func(c *callCtxt) { 1371 - x := c.float64(0) 1372 - if c.do() { 1373 - c.ret = func() interface{} { 1370 + Func: func(c *CallCtxt) { 1371 + x := c.Float64(0) 1372 + if c.Do() { 1373 + c.Ret = func() interface{} { 1374 1374 return math.Acosh(x) 1375 1375 }() 1376 1376 } ··· 1379 1379 Name: "Asin", 1380 1380 Params: []kind{numKind}, 1381 1381 Result: numKind, 1382 - Func: func(c *callCtxt) { 1383 - x := c.float64(0) 1384 - if c.do() { 1385 - c.ret = func() interface{} { 1382 + Func: func(c *CallCtxt) { 1383 + x := c.Float64(0) 1384 + if c.Do() { 1385 + c.Ret = func() interface{} { 1386 1386 return math.Asin(x) 1387 1387 }() 1388 1388 } ··· 1391 1391 Name: "Acos", 1392 1392 Params: []kind{numKind}, 1393 1393 Result: numKind, 1394 - Func: func(c *callCtxt) { 1395 - x := c.float64(0) 1396 - if c.do() { 1397 - c.ret = func() interface{} { 1394 + Func: func(c *CallCtxt) { 1395 + x := c.Float64(0) 1396 + if c.Do() { 1397 + c.Ret = func() interface{} { 1398 1398 return math.Acos(x) 1399 1399 }() 1400 1400 } ··· 1403 1403 Name: "Asinh", 1404 1404 Params: []kind{numKind}, 1405 1405 Result: numKind, 1406 - Func: func(c *callCtxt) { 1407 - x := c.float64(0) 1408 - if c.do() { 1409 - c.ret = func() interface{} { 1406 + Func: func(c *CallCtxt) { 1407 + x := c.Float64(0) 1408 + if c.Do() { 1409 + c.Ret = func() interface{} { 1410 1410 return math.Asinh(x) 1411 1411 }() 1412 1412 } ··· 1415 1415 Name: "Atan", 1416 1416 Params: []kind{numKind}, 1417 1417 Result: numKind, 1418 - Func: func(c *callCtxt) { 1419 - x := c.float64(0) 1420 - if c.do() { 1421 - c.ret = func() interface{} { 1418 + Func: func(c *CallCtxt) { 1419 + x := c.Float64(0) 1420 + if c.Do() { 1421 + c.Ret = func() interface{} { 1422 1422 return math.Atan(x) 1423 1423 }() 1424 1424 } ··· 1427 1427 Name: "Atan2", 1428 1428 Params: []kind{numKind, numKind}, 1429 1429 Result: numKind, 1430 - Func: func(c *callCtxt) { 1431 - y, x := c.float64(0), c.float64(1) 1432 - if c.do() { 1433 - c.ret = func() interface{} { 1430 + Func: func(c *CallCtxt) { 1431 + y, x := c.Float64(0), c.Float64(1) 1432 + if c.Do() { 1433 + c.Ret = func() interface{} { 1434 1434 return math.Atan2(y, x) 1435 1435 }() 1436 1436 } ··· 1439 1439 Name: "Atanh", 1440 1440 Params: []kind{numKind}, 1441 1441 Result: numKind, 1442 - Func: func(c *callCtxt) { 1443 - x := c.float64(0) 1444 - if c.do() { 1445 - c.ret = func() interface{} { 1442 + Func: func(c *CallCtxt) { 1443 + x := c.Float64(0) 1444 + if c.Do() { 1445 + c.Ret = func() interface{} { 1446 1446 return math.Atanh(x) 1447 1447 }() 1448 1448 } ··· 1451 1451 Name: "Cbrt", 1452 1452 Params: []kind{numKind}, 1453 1453 Result: numKind, 1454 - Func: func(c *callCtxt) { 1455 - x := c.decimal(0) 1456 - if c.do() { 1457 - c.ret, c.err = func() (interface{}, error) { 1454 + Func: func(c *CallCtxt) { 1455 + x := c.Decimal(0) 1456 + if c.Do() { 1457 + c.Ret, c.Err = func() (interface{}, error) { 1458 1458 var d internal.Decimal 1459 1459 _, err := apdContext.Cbrt(&d, x) 1460 1460 return &d, err ··· 1498 1498 Name: "Copysign", 1499 1499 Params: []kind{numKind, numKind}, 1500 1500 Result: numKind, 1501 - Func: func(c *callCtxt) { 1502 - x, y := c.decimal(0), c.decimal(1) 1503 - if c.do() { 1504 - c.ret = func() interface{} { 1501 + Func: func(c *CallCtxt) { 1502 + x, y := c.Decimal(0), c.Decimal(1) 1503 + if c.Do() { 1504 + c.Ret = func() interface{} { 1505 1505 var d internal.Decimal 1506 1506 d.Set(x) 1507 1507 d.Negative = y.Negative ··· 1513 1513 Name: "Dim", 1514 1514 Params: []kind{numKind, numKind}, 1515 1515 Result: numKind, 1516 - Func: func(c *callCtxt) { 1517 - x, y := c.decimal(0), c.decimal(1) 1518 - if c.do() { 1519 - c.ret, c.err = func() (interface{}, error) { 1516 + Func: func(c *CallCtxt) { 1517 + x, y := c.Decimal(0), c.Decimal(1) 1518 + if c.Do() { 1519 + c.Ret, c.Err = func() (interface{}, error) { 1520 1520 var d internal.Decimal 1521 1521 _, err := apdContext.Sub(&d, x, y) 1522 1522 if err != nil { ··· 1533 1533 Name: "Erf", 1534 1534 Params: []kind{numKind}, 1535 1535 Result: numKind, 1536 - Func: func(c *callCtxt) { 1537 - x := c.float64(0) 1538 - if c.do() { 1539 - c.ret = func() interface{} { 1536 + Func: func(c *CallCtxt) { 1537 + x := c.Float64(0) 1538 + if c.Do() { 1539 + c.Ret = func() interface{} { 1540 1540 return math.Erf(x) 1541 1541 }() 1542 1542 } ··· 1545 1545 Name: "Erfc", 1546 1546 Params: []kind{numKind}, 1547 1547 Result: numKind, 1548 - Func: func(c *callCtxt) { 1549 - x := c.float64(0) 1550 - if c.do() { 1551 - c.ret = func() interface{} { 1548 + Func: func(c *CallCtxt) { 1549 + x := c.Float64(0) 1550 + if c.Do() { 1551 + c.Ret = func() interface{} { 1552 1552 return math.Erfc(x) 1553 1553 }() 1554 1554 } ··· 1557 1557 Name: "Erfinv", 1558 1558 Params: []kind{numKind}, 1559 1559 Result: numKind, 1560 - Func: func(c *callCtxt) { 1561 - x := c.float64(0) 1562 - if c.do() { 1563 - c.ret = func() interface{} { 1560 + Func: func(c *CallCtxt) { 1561 + x := c.Float64(0) 1562 + if c.Do() { 1563 + c.Ret = func() interface{} { 1564 1564 return math.Erfinv(x) 1565 1565 }() 1566 1566 } ··· 1569 1569 Name: "Erfcinv", 1570 1570 Params: []kind{numKind}, 1571 1571 Result: numKind, 1572 - Func: func(c *callCtxt) { 1573 - x := c.float64(0) 1574 - if c.do() { 1575 - c.ret = func() interface{} { 1572 + Func: func(c *CallCtxt) { 1573 + x := c.Float64(0) 1574 + if c.Do() { 1575 + c.Ret = func() interface{} { 1576 1576 return math.Erfcinv(x) 1577 1577 }() 1578 1578 } ··· 1581 1581 Name: "Exp", 1582 1582 Params: []kind{numKind}, 1583 1583 Result: numKind, 1584 - Func: func(c *callCtxt) { 1585 - x := c.decimal(0) 1586 - if c.do() { 1587 - c.ret, c.err = func() (interface{}, error) { 1584 + Func: func(c *CallCtxt) { 1585 + x := c.Decimal(0) 1586 + if c.Do() { 1587 + c.Ret, c.Err = func() (interface{}, error) { 1588 1588 var d internal.Decimal 1589 1589 _, err := apdContext.Exp(&d, x) 1590 1590 return &d, err ··· 1595 1595 Name: "Exp2", 1596 1596 Params: []kind{numKind}, 1597 1597 Result: numKind, 1598 - Func: func(c *callCtxt) { 1599 - x := c.decimal(0) 1600 - if c.do() { 1601 - c.ret, c.err = func() (interface{}, error) { 1598 + Func: func(c *CallCtxt) { 1599 + x := c.Decimal(0) 1600 + if c.Do() { 1601 + c.Ret, c.Err = func() (interface{}, error) { 1602 1602 var d internal.Decimal 1603 1603 _, err := apdContext.Pow(&d, two, x) 1604 1604 return &d, err ··· 1609 1609 Name: "Expm1", 1610 1610 Params: []kind{numKind}, 1611 1611 Result: numKind, 1612 - Func: func(c *callCtxt) { 1613 - x := c.float64(0) 1614 - if c.do() { 1615 - c.ret = func() interface{} { 1612 + Func: func(c *CallCtxt) { 1613 + x := c.Float64(0) 1614 + if c.Do() { 1615 + c.Ret = func() interface{} { 1616 1616 return math.Expm1(x) 1617 1617 }() 1618 1618 } ··· 1621 1621 Name: "Gamma", 1622 1622 Params: []kind{numKind}, 1623 1623 Result: numKind, 1624 - Func: func(c *callCtxt) { 1625 - x := c.float64(0) 1626 - if c.do() { 1627 - c.ret = func() interface{} { 1624 + Func: func(c *CallCtxt) { 1625 + x := c.Float64(0) 1626 + if c.Do() { 1627 + c.Ret = func() interface{} { 1628 1628 return math.Gamma(x) 1629 1629 }() 1630 1630 } ··· 1633 1633 Name: "Hypot", 1634 1634 Params: []kind{numKind, numKind}, 1635 1635 Result: numKind, 1636 - Func: func(c *callCtxt) { 1637 - p, q := c.float64(0), c.float64(1) 1638 - if c.do() { 1639 - c.ret = func() interface{} { 1636 + Func: func(c *CallCtxt) { 1637 + p, q := c.Float64(0), c.Float64(1) 1638 + if c.Do() { 1639 + c.Ret = func() interface{} { 1640 1640 return math.Hypot(p, q) 1641 1641 }() 1642 1642 } ··· 1645 1645 Name: "J0", 1646 1646 Params: []kind{numKind}, 1647 1647 Result: numKind, 1648 - Func: func(c *callCtxt) { 1649 - x := c.float64(0) 1650 - if c.do() { 1651 - c.ret = func() interface{} { 1648 + Func: func(c *CallCtxt) { 1649 + x := c.Float64(0) 1650 + if c.Do() { 1651 + c.Ret = func() interface{} { 1652 1652 return math.J0(x) 1653 1653 }() 1654 1654 } ··· 1657 1657 Name: "Y0", 1658 1658 Params: []kind{numKind}, 1659 1659 Result: numKind, 1660 - Func: func(c *callCtxt) { 1661 - x := c.float64(0) 1662 - if c.do() { 1663 - c.ret = func() interface{} { 1660 + Func: func(c *CallCtxt) { 1661 + x := c.Float64(0) 1662 + if c.Do() { 1663 + c.Ret = func() interface{} { 1664 1664 return math.Y0(x) 1665 1665 }() 1666 1666 } ··· 1669 1669 Name: "J1", 1670 1670 Params: []kind{numKind}, 1671 1671 Result: numKind, 1672 - Func: func(c *callCtxt) { 1673 - x := c.float64(0) 1674 - if c.do() { 1675 - c.ret = func() interface{} { 1672 + Func: func(c *CallCtxt) { 1673 + x := c.Float64(0) 1674 + if c.Do() { 1675 + c.Ret = func() interface{} { 1676 1676 return math.J1(x) 1677 1677 }() 1678 1678 } ··· 1681 1681 Name: "Y1", 1682 1682 Params: []kind{numKind}, 1683 1683 Result: numKind, 1684 - Func: func(c *callCtxt) { 1685 - x := c.float64(0) 1686 - if c.do() { 1687 - c.ret = func() interface{} { 1684 + Func: func(c *CallCtxt) { 1685 + x := c.Float64(0) 1686 + if c.Do() { 1687 + c.Ret = func() interface{} { 1688 1688 return math.Y1(x) 1689 1689 }() 1690 1690 } ··· 1693 1693 Name: "Jn", 1694 1694 Params: []kind{intKind, numKind}, 1695 1695 Result: numKind, 1696 - Func: func(c *callCtxt) { 1697 - n, x := c.int(0), c.float64(1) 1698 - if c.do() { 1699 - c.ret = func() interface{} { 1696 + Func: func(c *CallCtxt) { 1697 + n, x := c.Int(0), c.Float64(1) 1698 + if c.Do() { 1699 + c.Ret = func() interface{} { 1700 1700 return math.Jn(n, x) 1701 1701 }() 1702 1702 } ··· 1705 1705 Name: "Yn", 1706 1706 Params: []kind{intKind, numKind}, 1707 1707 Result: numKind, 1708 - Func: func(c *callCtxt) { 1709 - n, x := c.int(0), c.float64(1) 1710 - if c.do() { 1711 - c.ret = func() interface{} { 1708 + Func: func(c *CallCtxt) { 1709 + n, x := c.Int(0), c.Float64(1) 1710 + if c.Do() { 1711 + c.Ret = func() interface{} { 1712 1712 return math.Yn(n, x) 1713 1713 }() 1714 1714 } ··· 1717 1717 Name: "Ldexp", 1718 1718 Params: []kind{numKind, intKind}, 1719 1719 Result: numKind, 1720 - Func: func(c *callCtxt) { 1721 - frac, exp := c.float64(0), c.int(1) 1722 - if c.do() { 1723 - c.ret = func() interface{} { 1720 + Func: func(c *CallCtxt) { 1721 + frac, exp := c.Float64(0), c.Int(1) 1722 + if c.Do() { 1723 + c.Ret = func() interface{} { 1724 1724 return math.Ldexp(frac, exp) 1725 1725 }() 1726 1726 } ··· 1729 1729 Name: "Log", 1730 1730 Params: []kind{numKind}, 1731 1731 Result: numKind, 1732 - Func: func(c *callCtxt) { 1733 - x := c.decimal(0) 1734 - if c.do() { 1735 - c.ret, c.err = func() (interface{}, error) { 1732 + Func: func(c *CallCtxt) { 1733 + x := c.Decimal(0) 1734 + if c.Do() { 1735 + c.Ret, c.Err = func() (interface{}, error) { 1736 1736 var d internal.Decimal 1737 1737 _, err := apdContext.Ln(&d, x) 1738 1738 return &d, err ··· 1743 1743 Name: "Log10", 1744 1744 Params: []kind{numKind}, 1745 1745 Result: numKind, 1746 - Func: func(c *callCtxt) { 1747 - x := c.decimal(0) 1748 - if c.do() { 1749 - c.ret, c.err = func() (interface{}, error) { 1746 + Func: func(c *CallCtxt) { 1747 + x := c.Decimal(0) 1748 + if c.Do() { 1749 + c.Ret, c.Err = func() (interface{}, error) { 1750 1750 var d internal.Decimal 1751 1751 _, err := apdContext.Log10(&d, x) 1752 1752 return &d, err ··· 1757 1757 Name: "Log2", 1758 1758 Params: []kind{numKind}, 1759 1759 Result: numKind, 1760 - Func: func(c *callCtxt) { 1761 - x := c.decimal(0) 1762 - if c.do() { 1763 - c.ret, c.err = func() (interface{}, error) { 1760 + Func: func(c *CallCtxt) { 1761 + x := c.Decimal(0) 1762 + if c.Do() { 1763 + c.Ret, c.Err = func() (interface{}, error) { 1764 1764 var d, ln2 internal.Decimal 1765 1765 _, _ = apdContext.Ln(&ln2, two) 1766 1766 _, err := apdContext.Ln(&d, x) ··· 1776 1776 Name: "Log1p", 1777 1777 Params: []kind{numKind}, 1778 1778 Result: numKind, 1779 - Func: func(c *callCtxt) { 1780 - x := c.float64(0) 1781 - if c.do() { 1782 - c.ret = func() interface{} { 1779 + Func: func(c *CallCtxt) { 1780 + x := c.Float64(0) 1781 + if c.Do() { 1782 + c.Ret = func() interface{} { 1783 1783 return math.Log1p(x) 1784 1784 }() 1785 1785 } ··· 1788 1788 Name: "Logb", 1789 1789 Params: []kind{numKind}, 1790 1790 Result: numKind, 1791 - Func: func(c *callCtxt) { 1792 - x := c.float64(0) 1793 - if c.do() { 1794 - c.ret = func() interface{} { 1791 + Func: func(c *CallCtxt) { 1792 + x := c.Float64(0) 1793 + if c.Do() { 1794 + c.Ret = func() interface{} { 1795 1795 return math.Logb(x) 1796 1796 }() 1797 1797 } ··· 1800 1800 Name: "Ilogb", 1801 1801 Params: []kind{numKind}, 1802 1802 Result: intKind, 1803 - Func: func(c *callCtxt) { 1804 - x := c.float64(0) 1805 - if c.do() { 1806 - c.ret = func() interface{} { 1803 + Func: func(c *CallCtxt) { 1804 + x := c.Float64(0) 1805 + if c.Do() { 1806 + c.Ret = func() interface{} { 1807 1807 return math.Ilogb(x) 1808 1808 }() 1809 1809 } ··· 1812 1812 Name: "Mod", 1813 1813 Params: []kind{numKind, numKind}, 1814 1814 Result: numKind, 1815 - Func: func(c *callCtxt) { 1816 - x, y := c.float64(0), c.float64(1) 1817 - if c.do() { 1818 - c.ret = func() interface{} { 1815 + Func: func(c *CallCtxt) { 1816 + x, y := c.Float64(0), c.Float64(1) 1817 + if c.Do() { 1818 + c.Ret = func() interface{} { 1819 1819 return math.Mod(x, y) 1820 1820 }() 1821 1821 } ··· 1824 1824 Name: "Pow", 1825 1825 Params: []kind{numKind, numKind}, 1826 1826 Result: numKind, 1827 - Func: func(c *callCtxt) { 1828 - x, y := c.decimal(0), c.decimal(1) 1829 - if c.do() { 1830 - c.ret, c.err = func() (interface{}, error) { 1827 + Func: func(c *CallCtxt) { 1828 + x, y := c.Decimal(0), c.Decimal(1) 1829 + if c.Do() { 1830 + c.Ret, c.Err = func() (interface{}, error) { 1831 1831 var d internal.Decimal 1832 1832 _, err := apdContext.Pow(&d, x, y) 1833 1833 return &d, err ··· 1838 1838 Name: "Pow10", 1839 1839 Params: []kind{intKind}, 1840 1840 Result: numKind, 1841 - Func: func(c *callCtxt) { 1842 - n := c.int32(0) 1843 - if c.do() { 1844 - c.ret = func() interface{} { 1841 + Func: func(c *CallCtxt) { 1842 + n := c.Int32(0) 1843 + if c.Do() { 1844 + c.Ret = func() interface{} { 1845 1845 return apd.New(1, n) 1846 1846 }() 1847 1847 } ··· 1850 1850 Name: "Remainder", 1851 1851 Params: []kind{numKind, numKind}, 1852 1852 Result: numKind, 1853 - Func: func(c *callCtxt) { 1854 - x, y := c.float64(0), c.float64(1) 1855 - if c.do() { 1856 - c.ret = func() interface{} { 1853 + Func: func(c *CallCtxt) { 1854 + x, y := c.Float64(0), c.Float64(1) 1855 + if c.Do() { 1856 + c.Ret = func() interface{} { 1857 1857 return math.Remainder(x, y) 1858 1858 }() 1859 1859 } ··· 1862 1862 Name: "Signbit", 1863 1863 Params: []kind{numKind}, 1864 1864 Result: boolKind, 1865 - Func: func(c *callCtxt) { 1866 - x := c.decimal(0) 1867 - if c.do() { 1868 - c.ret = func() interface{} { 1865 + Func: func(c *CallCtxt) { 1866 + x := c.Decimal(0) 1867 + if c.Do() { 1868 + c.Ret = func() interface{} { 1869 1869 return x.Negative 1870 1870 }() 1871 1871 } ··· 1874 1874 Name: "Cos", 1875 1875 Params: []kind{numKind}, 1876 1876 Result: numKind, 1877 - Func: func(c *callCtxt) { 1878 - x := c.float64(0) 1879 - if c.do() { 1880 - c.ret = func() interface{} { 1877 + Func: func(c *CallCtxt) { 1878 + x := c.Float64(0) 1879 + if c.Do() { 1880 + c.Ret = func() interface{} { 1881 1881 return math.Cos(x) 1882 1882 }() 1883 1883 } ··· 1886 1886 Name: "Sin", 1887 1887 Params: []kind{numKind}, 1888 1888 Result: numKind, 1889 - Func: func(c *callCtxt) { 1890 - x := c.float64(0) 1891 - if c.do() { 1892 - c.ret = func() interface{} { 1889 + Func: func(c *CallCtxt) { 1890 + x := c.Float64(0) 1891 + if c.Do() { 1892 + c.Ret = func() interface{} { 1893 1893 return math.Sin(x) 1894 1894 }() 1895 1895 } ··· 1898 1898 Name: "Sinh", 1899 1899 Params: []kind{numKind}, 1900 1900 Result: numKind, 1901 - Func: func(c *callCtxt) { 1902 - x := c.float64(0) 1903 - if c.do() { 1904 - c.ret = func() interface{} { 1901 + Func: func(c *CallCtxt) { 1902 + x := c.Float64(0) 1903 + if c.Do() { 1904 + c.Ret = func() interface{} { 1905 1905 return math.Sinh(x) 1906 1906 }() 1907 1907 } ··· 1910 1910 Name: "Cosh", 1911 1911 Params: []kind{numKind}, 1912 1912 Result: numKind, 1913 - Func: func(c *callCtxt) { 1914 - x := c.float64(0) 1915 - if c.do() { 1916 - c.ret = func() interface{} { 1913 + Func: func(c *CallCtxt) { 1914 + x := c.Float64(0) 1915 + if c.Do() { 1916 + c.Ret = func() interface{} { 1917 1917 return math.Cosh(x) 1918 1918 }() 1919 1919 } ··· 1922 1922 Name: "Sqrt", 1923 1923 Params: []kind{numKind}, 1924 1924 Result: numKind, 1925 - Func: func(c *callCtxt) { 1926 - x := c.float64(0) 1927 - if c.do() { 1928 - c.ret = func() interface{} { 1925 + Func: func(c *CallCtxt) { 1926 + x := c.Float64(0) 1927 + if c.Do() { 1928 + c.Ret = func() interface{} { 1929 1929 return math.Sqrt(x) 1930 1930 }() 1931 1931 } ··· 1934 1934 Name: "Tan", 1935 1935 Params: []kind{numKind}, 1936 1936 Result: numKind, 1937 - Func: func(c *callCtxt) { 1938 - x := c.float64(0) 1939 - if c.do() { 1940 - c.ret = func() interface{} { 1937 + Func: func(c *CallCtxt) { 1938 + x := c.Float64(0) 1939 + if c.Do() { 1940 + c.Ret = func() interface{} { 1941 1941 return math.Tan(x) 1942 1942 }() 1943 1943 } ··· 1946 1946 Name: "Tanh", 1947 1947 Params: []kind{numKind}, 1948 1948 Result: numKind, 1949 - Func: func(c *callCtxt) { 1950 - x := c.float64(0) 1951 - if c.do() { 1952 - c.ret = func() interface{} { 1949 + Func: func(c *CallCtxt) { 1950 + x := c.Float64(0) 1951 + if c.Do() { 1952 + c.Ret = func() interface{} { 1953 1953 return math.Tanh(x) 1954 1954 }() 1955 1955 } ··· 1957 1957 }}, 1958 1958 }, 1959 1959 "math/bits": { 1960 - native: []*builtin{{ 1960 + Native: []*Builtin{{ 1961 1961 Name: "Lsh", 1962 1962 Params: []kind{intKind, intKind}, 1963 1963 Result: intKind, 1964 - Func: func(c *callCtxt) { 1965 - x, n := c.bigInt(0), c.uint(1) 1966 - if c.do() { 1967 - c.ret = func() interface{} { 1964 + Func: func(c *CallCtxt) { 1965 + x, n := c.BigInt(0), c.Uint(1) 1966 + if c.Do() { 1967 + c.Ret = func() interface{} { 1968 1968 var z big.Int 1969 1969 z.Lsh(x, n) 1970 1970 return &z ··· 1975 1975 Name: "Rsh", 1976 1976 Params: []kind{intKind, intKind}, 1977 1977 Result: intKind, 1978 - Func: func(c *callCtxt) { 1979 - x, n := c.bigInt(0), c.uint(1) 1980 - if c.do() { 1981 - c.ret = func() interface{} { 1978 + Func: func(c *CallCtxt) { 1979 + x, n := c.BigInt(0), c.Uint(1) 1980 + if c.Do() { 1981 + c.Ret = func() interface{} { 1982 1982 var z big.Int 1983 1983 z.Rsh(x, n) 1984 1984 return &z ··· 1989 1989 Name: "At", 1990 1990 Params: []kind{intKind, intKind}, 1991 1991 Result: intKind, 1992 - Func: func(c *callCtxt) { 1993 - x, i := c.bigInt(0), c.uint(1) 1994 - if c.do() { 1995 - c.ret, c.err = func() (interface{}, error) { 1992 + Func: func(c *CallCtxt) { 1993 + x, i := c.BigInt(0), c.Uint(1) 1994 + if c.Do() { 1995 + c.Ret, c.Err = func() (interface{}, error) { 1996 1996 if i > math.MaxInt32 { 1997 1997 return 0, fmt.Errorf("bit index too large") 1998 1998 } ··· 2004 2004 Name: "Set", 2005 2005 Params: []kind{intKind, intKind, intKind}, 2006 2006 Result: intKind, 2007 - Func: func(c *callCtxt) { 2008 - x, i, bit := c.bigInt(0), c.int(1), c.uint(2) 2009 - if c.do() { 2010 - c.ret = func() interface{} { 2007 + Func: func(c *CallCtxt) { 2008 + x, i, bit := c.BigInt(0), c.Int(1), c.Uint(2) 2009 + if c.Do() { 2010 + c.Ret = func() interface{} { 2011 2011 var z big.Int 2012 2012 z.SetBit(x, i, bit) 2013 2013 return &z ··· 2018 2018 Name: "And", 2019 2019 Params: []kind{intKind, intKind}, 2020 2020 Result: intKind, 2021 - Func: func(c *callCtxt) { 2022 - a, b := c.bigInt(0), c.bigInt(1) 2023 - if c.do() { 2024 - c.ret = func() interface{} { 2021 + Func: func(c *CallCtxt) { 2022 + a, b := c.BigInt(0), c.BigInt(1) 2023 + if c.Do() { 2024 + c.Ret = func() interface{} { 2025 2025 var z big.Int 2026 2026 z.And(a, b) 2027 2027 return &z ··· 2032 2032 Name: "Or", 2033 2033 Params: []kind{intKind, intKind}, 2034 2034 Result: intKind, 2035 - Func: func(c *callCtxt) { 2036 - a, b := c.bigInt(0), c.bigInt(1) 2037 - if c.do() { 2038 - c.ret = func() interface{} { 2035 + Func: func(c *CallCtxt) { 2036 + a, b := c.BigInt(0), c.BigInt(1) 2037 + if c.Do() { 2038 + c.Ret = func() interface{} { 2039 2039 var z big.Int 2040 2040 z.Or(a, b) 2041 2041 return &z ··· 2046 2046 Name: "Xor", 2047 2047 Params: []kind{intKind, intKind}, 2048 2048 Result: intKind, 2049 - Func: func(c *callCtxt) { 2050 - a, b := c.bigInt(0), c.bigInt(1) 2051 - if c.do() { 2052 - c.ret = func() interface{} { 2049 + Func: func(c *CallCtxt) { 2050 + a, b := c.BigInt(0), c.BigInt(1) 2051 + if c.Do() { 2052 + c.Ret = func() interface{} { 2053 2053 var z big.Int 2054 2054 z.Xor(a, b) 2055 2055 return &z ··· 2060 2060 Name: "Clear", 2061 2061 Params: []kind{intKind, intKind}, 2062 2062 Result: intKind, 2063 - Func: func(c *callCtxt) { 2064 - a, b := c.bigInt(0), c.bigInt(1) 2065 - if c.do() { 2066 - c.ret = func() interface{} { 2063 + Func: func(c *CallCtxt) { 2064 + a, b := c.BigInt(0), c.BigInt(1) 2065 + if c.Do() { 2066 + c.Ret = func() interface{} { 2067 2067 var z big.Int 2068 2068 z.AndNot(a, b) 2069 2069 return &z ··· 2074 2074 Name: "OnesCount", 2075 2075 Params: []kind{intKind}, 2076 2076 Result: intKind, 2077 - Func: func(c *callCtxt) { 2078 - x := c.bigInt(0) 2079 - if c.do() { 2080 - c.ret = func() interface{} { 2077 + Func: func(c *CallCtxt) { 2078 + x := c.BigInt(0) 2079 + if c.Do() { 2080 + c.Ret = func() interface{} { 2081 2081 var count int 2082 2082 for _, w := range x.Bits() { 2083 2083 count += bits.OnesCount64(uint64(w)) ··· 2090 2090 Name: "Len", 2091 2091 Params: []kind{intKind}, 2092 2092 Result: intKind, 2093 - Func: func(c *callCtxt) { 2094 - x := c.bigInt(0) 2095 - if c.do() { 2096 - c.ret = func() interface{} { 2093 + Func: func(c *CallCtxt) { 2094 + x := c.BigInt(0) 2095 + if c.Do() { 2096 + c.Ret = func() interface{} { 2097 2097 return x.BitLen() 2098 2098 }() 2099 2099 } ··· 2101 2101 }}, 2102 2102 }, 2103 2103 "net": { 2104 - native: []*builtin{{ 2104 + Native: []*Builtin{{ 2105 2105 Name: "SplitHostPort", 2106 2106 Params: []kind{stringKind}, 2107 2107 Result: listKind, 2108 - Func: func(c *callCtxt) { 2109 - s := c.string(0) 2110 - if c.do() { 2111 - c.ret, c.err = func() (interface{}, error) { 2108 + Func: func(c *CallCtxt) { 2109 + s := c.String(0) 2110 + if c.Do() { 2111 + c.Ret, c.Err = func() (interface{}, error) { 2112 2112 host, port, err := net.SplitHostPort(s) 2113 2113 if err != nil { 2114 2114 return nil, err ··· 2121 2121 Name: "JoinHostPort", 2122 2122 Params: []kind{topKind, topKind}, 2123 2123 Result: stringKind, 2124 - Func: func(c *callCtxt) { 2125 - host, port := c.value(0), c.value(1) 2126 - if c.do() { 2127 - c.ret, c.err = func() (interface{}, error) { 2124 + Func: func(c *CallCtxt) { 2125 + host, port := c.Value(0), c.Value(1) 2126 + if c.Do() { 2127 + c.Ret, c.Err = func() (interface{}, error) { 2128 2128 var err error 2129 2129 hostStr := "" 2130 2130 switch host.Kind() { ··· 2170 2170 Name: "FQDN", 2171 2171 Params: []kind{stringKind}, 2172 2172 Result: boolKind, 2173 - Func: func(c *callCtxt) { 2174 - s := c.string(0) 2175 - if c.do() { 2176 - c.ret = func() interface{} { 2173 + Func: func(c *CallCtxt) { 2174 + s := c.String(0) 2175 + if c.Do() { 2176 + c.Ret = func() interface{} { 2177 2177 for i := 0; i < len(s); i++ { 2178 2178 if s[i] >= utf8.RuneSelf { 2179 2179 return false ··· 2194 2194 Name: "ParseIP", 2195 2195 Params: []kind{stringKind}, 2196 2196 Result: listKind, 2197 - Func: func(c *callCtxt) { 2198 - s := c.string(0) 2199 - if c.do() { 2200 - c.ret, c.err = func() (interface{}, error) { 2197 + Func: func(c *CallCtxt) { 2198 + s := c.String(0) 2199 + if c.Do() { 2200 + c.Ret, c.Err = func() (interface{}, error) { 2201 2201 goip := net.ParseIP(s) 2202 2202 if goip == nil { 2203 2203 return nil, fmt.Errorf("invalid IP address %q", s) ··· 2210 2210 Name: "IPv4", 2211 2211 Params: []kind{topKind}, 2212 2212 Result: boolKind, 2213 - Func: func(c *callCtxt) { 2214 - ip := c.value(0) 2215 - if c.do() { 2216 - c.ret = func() interface{} { 2213 + Func: func(c *CallCtxt) { 2214 + ip := c.Value(0) 2215 + if c.Do() { 2216 + c.Ret = func() interface{} { 2217 2217 2218 2218 return netGetIP(ip).To4() != nil 2219 2219 }() ··· 2223 2223 Name: "IP", 2224 2224 Params: []kind{topKind}, 2225 2225 Result: boolKind, 2226 - Func: func(c *callCtxt) { 2227 - ip := c.value(0) 2228 - if c.do() { 2229 - c.ret = func() interface{} { 2226 + Func: func(c *CallCtxt) { 2227 + ip := c.Value(0) 2228 + if c.Do() { 2229 + c.Ret = func() interface{} { 2230 2230 2231 2231 return netGetIP(ip) != nil 2232 2232 }() ··· 2236 2236 Name: "LoopbackIP", 2237 2237 Params: []kind{topKind}, 2238 2238 Result: boolKind, 2239 - Func: func(c *callCtxt) { 2240 - ip := c.value(0) 2241 - if c.do() { 2242 - c.ret = func() interface{} { 2239 + Func: func(c *CallCtxt) { 2240 + ip := c.Value(0) 2241 + if c.Do() { 2242 + c.Ret = func() interface{} { 2243 2243 return netGetIP(ip).IsLoopback() 2244 2244 }() 2245 2245 } ··· 2248 2248 Name: "MulticastIP", 2249 2249 Params: []kind{topKind}, 2250 2250 Result: boolKind, 2251 - Func: func(c *callCtxt) { 2252 - ip := c.value(0) 2253 - if c.do() { 2254 - c.ret = func() interface{} { 2251 + Func: func(c *CallCtxt) { 2252 + ip := c.Value(0) 2253 + if c.Do() { 2254 + c.Ret = func() interface{} { 2255 2255 return netGetIP(ip).IsMulticast() 2256 2256 }() 2257 2257 } ··· 2260 2260 Name: "InterfaceLocalMulticastIP", 2261 2261 Params: []kind{topKind}, 2262 2262 Result: boolKind, 2263 - Func: func(c *callCtxt) { 2264 - ip := c.value(0) 2265 - if c.do() { 2266 - c.ret = func() interface{} { 2263 + Func: func(c *CallCtxt) { 2264 + ip := c.Value(0) 2265 + if c.Do() { 2266 + c.Ret = func() interface{} { 2267 2267 return netGetIP(ip).IsInterfaceLocalMulticast() 2268 2268 }() 2269 2269 } ··· 2272 2272 Name: "LinkLocalMulticastIP", 2273 2273 Params: []kind{topKind}, 2274 2274 Result: boolKind, 2275 - Func: func(c *callCtxt) { 2276 - ip := c.value(0) 2277 - if c.do() { 2278 - c.ret = func() interface{} { 2275 + Func: func(c *CallCtxt) { 2276 + ip := c.Value(0) 2277 + if c.Do() { 2278 + c.Ret = func() interface{} { 2279 2279 return netGetIP(ip).IsLinkLocalMulticast() 2280 2280 }() 2281 2281 } ··· 2284 2284 Name: "LinkLocalUnicastIP", 2285 2285 Params: []kind{topKind}, 2286 2286 Result: boolKind, 2287 - Func: func(c *callCtxt) { 2288 - ip := c.value(0) 2289 - if c.do() { 2290 - c.ret = func() interface{} { 2287 + Func: func(c *CallCtxt) { 2288 + ip := c.Value(0) 2289 + if c.Do() { 2290 + c.Ret = func() interface{} { 2291 2291 return netGetIP(ip).IsLinkLocalUnicast() 2292 2292 }() 2293 2293 } ··· 2296 2296 Name: "GlobalUnicastIP", 2297 2297 Params: []kind{topKind}, 2298 2298 Result: boolKind, 2299 - Func: func(c *callCtxt) { 2300 - ip := c.value(0) 2301 - if c.do() { 2302 - c.ret = func() interface{} { 2299 + Func: func(c *CallCtxt) { 2300 + ip := c.Value(0) 2301 + if c.Do() { 2302 + c.Ret = func() interface{} { 2303 2303 return netGetIP(ip).IsGlobalUnicast() 2304 2304 }() 2305 2305 } ··· 2308 2308 Name: "UnspecifiedIP", 2309 2309 Params: []kind{topKind}, 2310 2310 Result: boolKind, 2311 - Func: func(c *callCtxt) { 2312 - ip := c.value(0) 2313 - if c.do() { 2314 - c.ret = func() interface{} { 2311 + Func: func(c *CallCtxt) { 2312 + ip := c.Value(0) 2313 + if c.Do() { 2314 + c.Ret = func() interface{} { 2315 2315 return netGetIP(ip).IsUnspecified() 2316 2316 }() 2317 2317 } ··· 2320 2320 Name: "ToIP4", 2321 2321 Params: []kind{topKind}, 2322 2322 Result: listKind, 2323 - Func: func(c *callCtxt) { 2324 - ip := c.value(0) 2325 - if c.do() { 2326 - c.ret, c.err = func() (interface{}, error) { 2323 + Func: func(c *CallCtxt) { 2324 + ip := c.Value(0) 2325 + if c.Do() { 2326 + c.Ret, c.Err = func() (interface{}, error) { 2327 2327 ipdata := netGetIP(ip) 2328 2328 if ipdata == nil { 2329 2329 return nil, fmt.Errorf("invalid IP %q", ip) ··· 2340 2340 Name: "ToIP16", 2341 2341 Params: []kind{topKind}, 2342 2342 Result: listKind, 2343 - Func: func(c *callCtxt) { 2344 - ip := c.value(0) 2345 - if c.do() { 2346 - c.ret, c.err = func() (interface{}, error) { 2343 + Func: func(c *CallCtxt) { 2344 + ip := c.Value(0) 2345 + if c.Do() { 2346 + c.Ret, c.Err = func() (interface{}, error) { 2347 2347 ipdata := netGetIP(ip) 2348 2348 if ipdata == nil { 2349 2349 return nil, fmt.Errorf("invalid IP %q", ip) ··· 2356 2356 Name: "IPString", 2357 2357 Params: []kind{topKind}, 2358 2358 Result: stringKind, 2359 - Func: func(c *callCtxt) { 2360 - ip := c.value(0) 2361 - if c.do() { 2362 - c.ret, c.err = func() (interface{}, error) { 2359 + Func: func(c *CallCtxt) { 2360 + ip := c.Value(0) 2361 + if c.Do() { 2362 + c.Ret, c.Err = func() (interface{}, error) { 2363 2363 ipdata := netGetIP(ip) 2364 2364 if ipdata == nil { 2365 2365 return "", fmt.Errorf("invalid IP %q", ip) ··· 2371 2371 }}, 2372 2372 }, 2373 2373 "path": { 2374 - native: []*builtin{{ 2374 + Native: []*Builtin{{ 2375 2375 Name: "Split", 2376 2376 Params: []kind{stringKind}, 2377 2377 Result: listKind, 2378 - Func: func(c *callCtxt) { 2379 - path := c.string(0) 2380 - if c.do() { 2381 - c.ret = func() interface{} { 2378 + Func: func(c *CallCtxt) { 2379 + path := c.String(0) 2380 + if c.Do() { 2381 + c.Ret = func() interface{} { 2382 2382 file, dir := split(path) 2383 2383 return []string{file, dir} 2384 2384 }() ··· 2388 2388 Name: "Match", 2389 2389 Params: []kind{stringKind, stringKind}, 2390 2390 Result: boolKind, 2391 - Func: func(c *callCtxt) { 2392 - pattern, name := c.string(0), c.string(1) 2393 - if c.do() { 2394 - c.ret, c.err = func() (interface{}, error) { 2391 + Func: func(c *CallCtxt) { 2392 + pattern, name := c.String(0), c.String(1) 2393 + if c.Do() { 2394 + c.Ret, c.Err = func() (interface{}, error) { 2395 2395 return path.Match(pattern, name) 2396 2396 }() 2397 2397 } ··· 2400 2400 Name: "Clean", 2401 2401 Params: []kind{stringKind}, 2402 2402 Result: stringKind, 2403 - Func: func(c *callCtxt) { 2404 - path := c.string(0) 2405 - if c.do() { 2406 - c.ret = func() interface{} { 2403 + Func: func(c *CallCtxt) { 2404 + path := c.String(0) 2405 + if c.Do() { 2406 + c.Ret = func() interface{} { 2407 2407 return pathClean(path) 2408 2408 }() 2409 2409 } ··· 2412 2412 Name: "Ext", 2413 2413 Params: []kind{stringKind}, 2414 2414 Result: stringKind, 2415 - Func: func(c *callCtxt) { 2416 - path := c.string(0) 2417 - if c.do() { 2418 - c.ret = func() interface{} { 2415 + Func: func(c *CallCtxt) { 2416 + path := c.String(0) 2417 + if c.Do() { 2418 + c.Ret = func() interface{} { 2419 2419 return pathExt(path) 2420 2420 }() 2421 2421 } ··· 2424 2424 Name: "Base", 2425 2425 Params: []kind{stringKind}, 2426 2426 Result: stringKind, 2427 - Func: func(c *callCtxt) { 2428 - path := c.string(0) 2429 - if c.do() { 2430 - c.ret = func() interface{} { 2427 + Func: func(c *CallCtxt) { 2428 + path := c.String(0) 2429 + if c.Do() { 2430 + c.Ret = func() interface{} { 2431 2431 return pathBase(path) 2432 2432 }() 2433 2433 } ··· 2436 2436 Name: "IsAbs", 2437 2437 Params: []kind{stringKind}, 2438 2438 Result: boolKind, 2439 - Func: func(c *callCtxt) { 2440 - path := c.string(0) 2441 - if c.do() { 2442 - c.ret = func() interface{} { 2439 + Func: func(c *CallCtxt) { 2440 + path := c.String(0) 2441 + if c.Do() { 2442 + c.Ret = func() interface{} { 2443 2443 return pathIsAbs(path) 2444 2444 }() 2445 2445 } ··· 2448 2448 Name: "Dir", 2449 2449 Params: []kind{stringKind}, 2450 2450 Result: stringKind, 2451 - Func: func(c *callCtxt) { 2452 - path := c.string(0) 2453 - if c.do() { 2454 - c.ret = func() interface{} { 2451 + Func: func(c *CallCtxt) { 2452 + path := c.String(0) 2453 + if c.Do() { 2454 + c.Ret = func() interface{} { 2455 2455 return pathDir(path) 2456 2456 }() 2457 2457 } ··· 2459 2459 }}, 2460 2460 }, 2461 2461 "regexp": { 2462 - native: []*builtin{{ 2462 + Native: []*Builtin{{ 2463 2463 Name: "Valid", 2464 2464 Params: []kind{stringKind}, 2465 2465 Result: boolKind, 2466 - Func: func(c *callCtxt) { 2467 - pattern := c.string(0) 2468 - if c.do() { 2469 - c.ret, c.err = func() (interface{}, error) { 2466 + Func: func(c *CallCtxt) { 2467 + pattern := c.String(0) 2468 + if c.Do() { 2469 + c.Ret, c.Err = func() (interface{}, error) { 2470 2470 _, err := regexp.Compile(pattern) 2471 2471 return err == nil, err 2472 2472 }() ··· 2476 2476 Name: "Find", 2477 2477 Params: []kind{stringKind, stringKind}, 2478 2478 Result: stringKind, 2479 - Func: func(c *callCtxt) { 2480 - pattern, s := c.string(0), c.string(1) 2481 - if c.do() { 2482 - c.ret, c.err = func() (interface{}, error) { 2479 + Func: func(c *CallCtxt) { 2480 + pattern, s := c.String(0), c.String(1) 2481 + if c.Do() { 2482 + c.Ret, c.Err = func() (interface{}, error) { 2483 2483 re, err := regexp.Compile(pattern) 2484 2484 if err != nil { 2485 2485 return "", err ··· 2496 2496 Name: "FindAll", 2497 2497 Params: []kind{stringKind, stringKind, intKind}, 2498 2498 Result: listKind, 2499 - Func: func(c *callCtxt) { 2500 - pattern, s, n := c.string(0), c.string(1), c.int(2) 2501 - if c.do() { 2502 - c.ret, c.err = func() (interface{}, error) { 2499 + Func: func(c *CallCtxt) { 2500 + pattern, s, n := c.String(0), c.String(1), c.Int(2) 2501 + if c.Do() { 2502 + c.Ret, c.Err = func() (interface{}, error) { 2503 2503 re, err := regexp.Compile(pattern) 2504 2504 if err != nil { 2505 2505 return nil, err ··· 2516 2516 Name: "FindSubmatch", 2517 2517 Params: []kind{stringKind, stringKind}, 2518 2518 Result: listKind, 2519 - Func: func(c *callCtxt) { 2520 - pattern, s := c.string(0), c.string(1) 2521 - if c.do() { 2522 - c.ret, c.err = func() (interface{}, error) { 2519 + Func: func(c *CallCtxt) { 2520 + pattern, s := c.String(0), c.String(1) 2521 + if c.Do() { 2522 + c.Ret, c.Err = func() (interface{}, error) { 2523 2523 re, err := regexp.Compile(pattern) 2524 2524 if err != nil { 2525 2525 return nil, err ··· 2536 2536 Name: "FindAllSubmatch", 2537 2537 Params: []kind{stringKind, stringKind, intKind}, 2538 2538 Result: listKind, 2539 - Func: func(c *callCtxt) { 2540 - pattern, s, n := c.string(0), c.string(1), c.int(2) 2541 - if c.do() { 2542 - c.ret, c.err = func() (interface{}, error) { 2539 + Func: func(c *CallCtxt) { 2540 + pattern, s, n := c.String(0), c.String(1), c.Int(2) 2541 + if c.Do() { 2542 + c.Ret, c.Err = func() (interface{}, error) { 2543 2543 re, err := regexp.Compile(pattern) 2544 2544 if err != nil { 2545 2545 return nil, err ··· 2556 2556 Name: "FindNamedSubmatch", 2557 2557 Params: []kind{stringKind, stringKind}, 2558 2558 Result: structKind, 2559 - Func: func(c *callCtxt) { 2560 - pattern, s := c.string(0), c.string(1) 2561 - if c.do() { 2562 - c.ret, c.err = func() (interface{}, error) { 2559 + Func: func(c *CallCtxt) { 2560 + pattern, s := c.String(0), c.String(1) 2561 + if c.Do() { 2562 + c.Ret, c.Err = func() (interface{}, error) { 2563 2563 re, err := regexp.Compile(pattern) 2564 2564 if err != nil { 2565 2565 return nil, err ··· 2586 2586 Name: "FindAllNamedSubmatch", 2587 2587 Params: []kind{stringKind, stringKind, intKind}, 2588 2588 Result: listKind, 2589 - Func: func(c *callCtxt) { 2590 - pattern, s, n := c.string(0), c.string(1), c.int(2) 2591 - if c.do() { 2592 - c.ret, c.err = func() (interface{}, error) { 2589 + Func: func(c *CallCtxt) { 2590 + pattern, s, n := c.String(0), c.String(1), c.Int(2) 2591 + if c.Do() { 2592 + c.Ret, c.Err = func() (interface{}, error) { 2593 2593 re, err := regexp.Compile(pattern) 2594 2594 if err != nil { 2595 2595 return nil, err ··· 2620 2620 Name: "Match", 2621 2621 Params: []kind{stringKind, stringKind}, 2622 2622 Result: boolKind, 2623 - Func: func(c *callCtxt) { 2624 - pattern, s := c.string(0), c.string(1) 2625 - if c.do() { 2626 - c.ret, c.err = func() (interface{}, error) { 2623 + Func: func(c *CallCtxt) { 2624 + pattern, s := c.String(0), c.String(1) 2625 + if c.Do() { 2626 + c.Ret, c.Err = func() (interface{}, error) { 2627 2627 return regexp.MatchString(pattern, s) 2628 2628 }() 2629 2629 } ··· 2632 2632 Name: "QuoteMeta", 2633 2633 Params: []kind{stringKind}, 2634 2634 Result: stringKind, 2635 - Func: func(c *callCtxt) { 2636 - s := c.string(0) 2637 - if c.do() { 2638 - c.ret = func() interface{} { 2635 + Func: func(c *CallCtxt) { 2636 + s := c.String(0) 2637 + if c.Do() { 2638 + c.Ret = func() interface{} { 2639 2639 return regexp.QuoteMeta(s) 2640 2640 }() 2641 2641 } ··· 2643 2643 }}, 2644 2644 }, 2645 2645 "strconv": { 2646 - native: []*builtin{{ 2646 + Native: []*Builtin{{ 2647 2647 Name: "Unquote", 2648 2648 Params: []kind{stringKind}, 2649 2649 Result: stringKind, 2650 - Func: func(c *callCtxt) { 2651 - s := c.string(0) 2652 - if c.do() { 2653 - c.ret, c.err = func() (interface{}, error) { 2650 + Func: func(c *CallCtxt) { 2651 + s := c.String(0) 2652 + if c.Do() { 2653 + c.Ret, c.Err = func() (interface{}, error) { 2654 2654 return literal.Unquote(s) 2655 2655 }() 2656 2656 } ··· 2659 2659 Name: "ParseBool", 2660 2660 Params: []kind{stringKind}, 2661 2661 Result: boolKind, 2662 - Func: func(c *callCtxt) { 2663 - str := c.string(0) 2664 - if c.do() { 2665 - c.ret, c.err = func() (interface{}, error) { 2662 + Func: func(c *CallCtxt) { 2663 + str := c.String(0) 2664 + if c.Do() { 2665 + c.Ret, c.Err = func() (interface{}, error) { 2666 2666 return strconv.ParseBool(str) 2667 2667 }() 2668 2668 } ··· 2671 2671 Name: "FormatBool", 2672 2672 Params: []kind{boolKind}, 2673 2673 Result: stringKind, 2674 - Func: func(c *callCtxt) { 2675 - b := c.bool(0) 2676 - if c.do() { 2677 - c.ret = func() interface{} { 2674 + Func: func(c *CallCtxt) { 2675 + b := c.Bool(0) 2676 + if c.Do() { 2677 + c.Ret = func() interface{} { 2678 2678 return strconv.FormatBool(b) 2679 2679 }() 2680 2680 } ··· 2683 2683 Name: "ParseFloat", 2684 2684 Params: []kind{stringKind, intKind}, 2685 2685 Result: numKind, 2686 - Func: func(c *callCtxt) { 2687 - s, bitSize := c.string(0), c.int(1) 2688 - if c.do() { 2689 - c.ret, c.err = func() (interface{}, error) { 2686 + Func: func(c *CallCtxt) { 2687 + s, bitSize := c.String(0), c.Int(1) 2688 + if c.Do() { 2689 + c.Ret, c.Err = func() (interface{}, error) { 2690 2690 return strconv.ParseFloat(s, bitSize) 2691 2691 }() 2692 2692 } ··· 2698 2698 Name: "ParseUint", 2699 2699 Params: []kind{stringKind, intKind, intKind}, 2700 2700 Result: intKind, 2701 - Func: func(c *callCtxt) { 2702 - s, base, bitSize := c.string(0), c.int(1), c.int(2) 2703 - if c.do() { 2704 - c.ret, c.err = func() (interface{}, error) { 2701 + Func: func(c *CallCtxt) { 2702 + s, base, bitSize := c.String(0), c.Int(1), c.Int(2) 2703 + if c.Do() { 2704 + c.Ret, c.Err = func() (interface{}, error) { 2705 2705 return strconv.ParseUint(s, base, bitSize) 2706 2706 }() 2707 2707 } ··· 2710 2710 Name: "ParseInt", 2711 2711 Params: []kind{stringKind, intKind, intKind}, 2712 2712 Result: intKind, 2713 - Func: func(c *callCtxt) { 2714 - s, base, bitSize := c.string(0), c.int(1), c.int(2) 2715 - if c.do() { 2716 - c.ret, c.err = func() (interface{}, error) { 2713 + Func: func(c *CallCtxt) { 2714 + s, base, bitSize := c.String(0), c.Int(1), c.Int(2) 2715 + if c.Do() { 2716 + c.Ret, c.Err = func() (interface{}, error) { 2717 2717 return strconv.ParseInt(s, base, bitSize) 2718 2718 }() 2719 2719 } ··· 2722 2722 Name: "Atoi", 2723 2723 Params: []kind{stringKind}, 2724 2724 Result: intKind, 2725 - Func: func(c *callCtxt) { 2726 - s := c.string(0) 2727 - if c.do() { 2728 - c.ret, c.err = func() (interface{}, error) { 2725 + Func: func(c *CallCtxt) { 2726 + s := c.String(0) 2727 + if c.Do() { 2728 + c.Ret, c.Err = func() (interface{}, error) { 2729 2729 return strconv.Atoi(s) 2730 2730 }() 2731 2731 } ··· 2734 2734 Name: "FormatFloat", 2735 2735 Params: []kind{numKind, intKind, intKind, intKind}, 2736 2736 Result: stringKind, 2737 - Func: func(c *callCtxt) { 2738 - f, fmt, prec, bitSize := c.float64(0), c.byte(1), c.int(2), c.int(3) 2739 - if c.do() { 2740 - c.ret = func() interface{} { 2737 + Func: func(c *CallCtxt) { 2738 + f, fmt, prec, bitSize := c.Float64(0), c.Byte(1), c.Int(2), c.Int(3) 2739 + if c.Do() { 2740 + c.Ret = func() interface{} { 2741 2741 return strconv.FormatFloat(f, fmt, prec, bitSize) 2742 2742 }() 2743 2743 } ··· 2746 2746 Name: "FormatUint", 2747 2747 Params: []kind{intKind, intKind}, 2748 2748 Result: stringKind, 2749 - Func: func(c *callCtxt) { 2750 - i, base := c.uint64(0), c.int(1) 2751 - if c.do() { 2752 - c.ret = func() interface{} { 2749 + Func: func(c *CallCtxt) { 2750 + i, base := c.Uint64(0), c.Int(1) 2751 + if c.Do() { 2752 + c.Ret = func() interface{} { 2753 2753 return strconv.FormatUint(i, base) 2754 2754 }() 2755 2755 } ··· 2758 2758 Name: "FormatInt", 2759 2759 Params: []kind{intKind, intKind}, 2760 2760 Result: stringKind, 2761 - Func: func(c *callCtxt) { 2762 - i, base := c.int64(0), c.int(1) 2763 - if c.do() { 2764 - c.ret = func() interface{} { 2761 + Func: func(c *CallCtxt) { 2762 + i, base := c.Int64(0), c.Int(1) 2763 + if c.Do() { 2764 + c.Ret = func() interface{} { 2765 2765 return strconv.FormatInt(i, base) 2766 2766 }() 2767 2767 } ··· 2770 2770 Name: "Quote", 2771 2771 Params: []kind{stringKind}, 2772 2772 Result: stringKind, 2773 - Func: func(c *callCtxt) { 2774 - s := c.string(0) 2775 - if c.do() { 2776 - c.ret = func() interface{} { 2773 + Func: func(c *CallCtxt) { 2774 + s := c.String(0) 2775 + if c.Do() { 2776 + c.Ret = func() interface{} { 2777 2777 return strconv.Quote(s) 2778 2778 }() 2779 2779 } ··· 2782 2782 Name: "QuoteToASCII", 2783 2783 Params: []kind{stringKind}, 2784 2784 Result: stringKind, 2785 - Func: func(c *callCtxt) { 2786 - s := c.string(0) 2787 - if c.do() { 2788 - c.ret = func() interface{} { 2785 + Func: func(c *CallCtxt) { 2786 + s := c.String(0) 2787 + if c.Do() { 2788 + c.Ret = func() interface{} { 2789 2789 return strconv.QuoteToASCII(s) 2790 2790 }() 2791 2791 } ··· 2794 2794 Name: "QuoteToGraphic", 2795 2795 Params: []kind{stringKind}, 2796 2796 Result: stringKind, 2797 - Func: func(c *callCtxt) { 2798 - s := c.string(0) 2799 - if c.do() { 2800 - c.ret = func() interface{} { 2797 + Func: func(c *CallCtxt) { 2798 + s := c.String(0) 2799 + if c.Do() { 2800 + c.Ret = func() interface{} { 2801 2801 return strconv.QuoteToGraphic(s) 2802 2802 }() 2803 2803 } ··· 2806 2806 Name: "QuoteRune", 2807 2807 Params: []kind{intKind}, 2808 2808 Result: stringKind, 2809 - Func: func(c *callCtxt) { 2810 - r := c.rune(0) 2811 - if c.do() { 2812 - c.ret = func() interface{} { 2809 + Func: func(c *CallCtxt) { 2810 + r := c.Rune(0) 2811 + if c.Do() { 2812 + c.Ret = func() interface{} { 2813 2813 return strconv.QuoteRune(r) 2814 2814 }() 2815 2815 } ··· 2818 2818 Name: "QuoteRuneToASCII", 2819 2819 Params: []kind{intKind}, 2820 2820 Result: stringKind, 2821 - Func: func(c *callCtxt) { 2822 - r := c.rune(0) 2823 - if c.do() { 2824 - c.ret = func() interface{} { 2821 + Func: func(c *CallCtxt) { 2822 + r := c.Rune(0) 2823 + if c.Do() { 2824 + c.Ret = func() interface{} { 2825 2825 return strconv.QuoteRuneToASCII(r) 2826 2826 }() 2827 2827 } ··· 2830 2830 Name: "QuoteRuneToGraphic", 2831 2831 Params: []kind{intKind}, 2832 2832 Result: stringKind, 2833 - Func: func(c *callCtxt) { 2834 - r := c.rune(0) 2835 - if c.do() { 2836 - c.ret = func() interface{} { 2833 + Func: func(c *CallCtxt) { 2834 + r := c.Rune(0) 2835 + if c.Do() { 2836 + c.Ret = func() interface{} { 2837 2837 return strconv.QuoteRuneToGraphic(r) 2838 2838 }() 2839 2839 } ··· 2842 2842 Name: "IsPrint", 2843 2843 Params: []kind{intKind}, 2844 2844 Result: boolKind, 2845 - Func: func(c *callCtxt) { 2846 - r := c.rune(0) 2847 - if c.do() { 2848 - c.ret = func() interface{} { 2845 + Func: func(c *CallCtxt) { 2846 + r := c.Rune(0) 2847 + if c.Do() { 2848 + c.Ret = func() interface{} { 2849 2849 return strconv.IsPrint(r) 2850 2850 }() 2851 2851 } ··· 2854 2854 Name: "IsGraphic", 2855 2855 Params: []kind{intKind}, 2856 2856 Result: boolKind, 2857 - Func: func(c *callCtxt) { 2858 - r := c.rune(0) 2859 - if c.do() { 2860 - c.ret = func() interface{} { 2857 + Func: func(c *CallCtxt) { 2858 + r := c.Rune(0) 2859 + if c.Do() { 2860 + c.Ret = func() interface{} { 2861 2861 return strconv.IsGraphic(r) 2862 2862 }() 2863 2863 } ··· 2865 2865 }}, 2866 2866 }, 2867 2867 "strings": { 2868 - native: []*builtin{{ 2868 + Native: []*Builtin{{ 2869 2869 Name: "ByteAt", 2870 2870 Params: []kind{bytesKind | stringKind, intKind}, 2871 2871 Result: intKind, 2872 - Func: func(c *callCtxt) { 2873 - b, i := c.bytes(0), c.int(1) 2874 - if c.do() { 2875 - c.ret, c.err = func() (interface{}, error) { 2872 + Func: func(c *CallCtxt) { 2873 + b, i := c.Bytes(0), c.Int(1) 2874 + if c.Do() { 2875 + c.Ret, c.Err = func() (interface{}, error) { 2876 2876 if i < 0 || i >= len(b) { 2877 2877 return 0, fmt.Errorf("index out of range") 2878 2878 } ··· 2884 2884 Name: "ByteSlice", 2885 2885 Params: []kind{bytesKind | stringKind, intKind, intKind}, 2886 2886 Result: bytesKind | stringKind, 2887 - Func: func(c *callCtxt) { 2888 - b, start, end := c.bytes(0), c.int(1), c.int(2) 2889 - if c.do() { 2890 - c.ret, c.err = func() (interface{}, error) { 2887 + Func: func(c *CallCtxt) { 2888 + b, start, end := c.Bytes(0), c.Int(1), c.Int(2) 2889 + if c.Do() { 2890 + c.Ret, c.Err = func() (interface{}, error) { 2891 2891 if start < 0 || start > end || end > len(b) { 2892 2892 return nil, fmt.Errorf("index out of range") 2893 2893 } ··· 2899 2899 Name: "Runes", 2900 2900 Params: []kind{stringKind}, 2901 2901 Result: listKind, 2902 - Func: func(c *callCtxt) { 2903 - s := c.string(0) 2904 - if c.do() { 2905 - c.ret = func() interface{} { 2902 + Func: func(c *CallCtxt) { 2903 + s := c.String(0) 2904 + if c.Do() { 2905 + c.Ret = func() interface{} { 2906 2906 return []rune(s) 2907 2907 }() 2908 2908 } ··· 2911 2911 Name: "MinRunes", 2912 2912 Params: []kind{stringKind, intKind}, 2913 2913 Result: boolKind, 2914 - Func: func(c *callCtxt) { 2915 - s, min := c.string(0), c.int(1) 2916 - if c.do() { 2917 - c.ret = func() interface{} { 2914 + Func: func(c *CallCtxt) { 2915 + s, min := c.String(0), c.Int(1) 2916 + if c.Do() { 2917 + c.Ret = func() interface{} { 2918 2918 2919 2919 return len([]rune(s)) >= min 2920 2920 }() ··· 2924 2924 Name: "MaxRunes", 2925 2925 Params: []kind{stringKind, intKind}, 2926 2926 Result: boolKind, 2927 - Func: func(c *callCtxt) { 2928 - s, max := c.string(0), c.int(1) 2929 - if c.do() { 2930 - c.ret = func() interface{} { 2927 + Func: func(c *CallCtxt) { 2928 + s, max := c.String(0), c.Int(1) 2929 + if c.Do() { 2930 + c.Ret = func() interface{} { 2931 2931 2932 2932 return len([]rune(s)) <= max 2933 2933 }() ··· 2937 2937 Name: "ToTitle", 2938 2938 Params: []kind{stringKind}, 2939 2939 Result: stringKind, 2940 - Func: func(c *callCtxt) { 2941 - s := c.string(0) 2942 - if c.do() { 2943 - c.ret = func() interface{} { 2940 + Func: func(c *CallCtxt) { 2941 + s := c.String(0) 2942 + if c.Do() { 2943 + c.Ret = func() interface{} { 2944 2944 2945 2945 prev := ' ' 2946 2946 return strings.Map( ··· 2960 2960 Name: "ToCamel", 2961 2961 Params: []kind{stringKind}, 2962 2962 Result: stringKind, 2963 - Func: func(c *callCtxt) { 2964 - s := c.string(0) 2965 - if c.do() { 2966 - c.ret = func() interface{} { 2963 + Func: func(c *CallCtxt) { 2964 + s := c.String(0) 2965 + if c.Do() { 2966 + c.Ret = func() interface{} { 2967 2967 2968 2968 prev := ' ' 2969 2969 return strings.Map( ··· 2983 2983 Name: "SliceRunes", 2984 2984 Params: []kind{stringKind, intKind, intKind}, 2985 2985 Result: stringKind, 2986 - Func: func(c *callCtxt) { 2987 - s, start, end := c.string(0), c.int(1), c.int(2) 2988 - if c.do() { 2989 - c.ret, c.err = func() (interface{}, error) { 2986 + Func: func(c *CallCtxt) { 2987 + s, start, end := c.String(0), c.Int(1), c.Int(2) 2988 + if c.Do() { 2989 + c.Ret, c.Err = func() (interface{}, error) { 2990 2990 runes := []rune(s) 2991 2991 if start < 0 || start > end || end > len(runes) { 2992 2992 return "", fmt.Errorf("index out of range") ··· 2999 2999 Name: "Compare", 3000 3000 Params: []kind{stringKind, stringKind}, 3001 3001 Result: intKind, 3002 - Func: func(c *callCtxt) { 3003 - a, b := c.string(0), c.string(1) 3004 - if c.do() { 3005 - c.ret = func() interface{} { 3002 + Func: func(c *CallCtxt) { 3003 + a, b := c.String(0), c.String(1) 3004 + if c.Do() { 3005 + c.Ret = func() interface{} { 3006 3006 return strings.Compare(a, b) 3007 3007 }() 3008 3008 } ··· 3011 3011 Name: "Count", 3012 3012 Params: []kind{stringKind, stringKind}, 3013 3013 Result: intKind, 3014 - Func: func(c *callCtxt) { 3015 - s, substr := c.string(0), c.string(1) 3016 - if c.do() { 3017 - c.ret = func() interface{} { 3014 + Func: func(c *CallCtxt) { 3015 + s, substr := c.String(0), c.String(1) 3016 + if c.Do() { 3017 + c.Ret = func() interface{} { 3018 3018 return strings.Count(s, substr) 3019 3019 }() 3020 3020 } ··· 3023 3023 Name: "Contains", 3024 3024 Params: []kind{stringKind, stringKind}, 3025 3025 Result: boolKind, 3026 - Func: func(c *callCtxt) { 3027 - s, substr := c.string(0), c.string(1) 3028 - if c.do() { 3029 - c.ret = func() interface{} { 3026 + Func: func(c *CallCtxt) { 3027 + s, substr := c.String(0), c.String(1) 3028 + if c.Do() { 3029 + c.Ret = func() interface{} { 3030 3030 return strings.Contains(s, substr) 3031 3031 }() 3032 3032 } ··· 3035 3035 Name: "ContainsAny", 3036 3036 Params: []kind{stringKind, stringKind}, 3037 3037 Result: boolKind, 3038 - Func: func(c *callCtxt) { 3039 - s, chars := c.string(0), c.string(1) 3040 - if c.do() { 3041 - c.ret = func() interface{} { 3038 + Func: func(c *CallCtxt) { 3039 + s, chars := c.String(0), c.String(1) 3040 + if c.Do() { 3041 + c.Ret = func() interface{} { 3042 3042 return strings.ContainsAny(s, chars) 3043 3043 }() 3044 3044 } ··· 3047 3047 Name: "LastIndex", 3048 3048 Params: []kind{stringKind, stringKind}, 3049 3049 Result: intKind, 3050 - Func: func(c *callCtxt) { 3051 - s, substr := c.string(0), c.string(1) 3052 - if c.do() { 3053 - c.ret = func() interface{} { 3050 + Func: func(c *CallCtxt) { 3051 + s, substr := c.String(0), c.String(1) 3052 + if c.Do() { 3053 + c.Ret = func() interface{} { 3054 3054 return strings.LastIndex(s, substr) 3055 3055 }() 3056 3056 } ··· 3059 3059 Name: "IndexAny", 3060 3060 Params: []kind{stringKind, stringKind}, 3061 3061 Result: intKind, 3062 - Func: func(c *callCtxt) { 3063 - s, chars := c.string(0), c.string(1) 3064 - if c.do() { 3065 - c.ret = func() interface{} { 3062 + Func: func(c *CallCtxt) { 3063 + s, chars := c.String(0), c.String(1) 3064 + if c.Do() { 3065 + c.Ret = func() interface{} { 3066 3066 return strings.IndexAny(s, chars) 3067 3067 }() 3068 3068 } ··· 3071 3071 Name: "LastIndexAny", 3072 3072 Params: []kind{stringKind, stringKind}, 3073 3073 Result: intKind, 3074 - Func: func(c *callCtxt) { 3075 - s, chars := c.string(0), c.string(1) 3076 - if c.do() { 3077 - c.ret = func() interface{} { 3074 + Func: func(c *CallCtxt) { 3075 + s, chars := c.String(0), c.String(1) 3076 + if c.Do() { 3077 + c.Ret = func() interface{} { 3078 3078 return strings.LastIndexAny(s, chars) 3079 3079 }() 3080 3080 } ··· 3083 3083 Name: "SplitN", 3084 3084 Params: []kind{stringKind, stringKind, intKind}, 3085 3085 Result: listKind, 3086 - Func: func(c *callCtxt) { 3087 - s, sep, n := c.string(0), c.string(1), c.int(2) 3088 - if c.do() { 3089 - c.ret = func() interface{} { 3086 + Func: func(c *CallCtxt) { 3087 + s, sep, n := c.String(0), c.String(1), c.Int(2) 3088 + if c.Do() { 3089 + c.Ret = func() interface{} { 3090 3090 return strings.SplitN(s, sep, n) 3091 3091 }() 3092 3092 } ··· 3095 3095 Name: "SplitAfterN", 3096 3096 Params: []kind{stringKind, stringKind, intKind}, 3097 3097 Result: listKind, 3098 - Func: func(c *callCtxt) { 3099 - s, sep, n := c.string(0), c.string(1), c.int(2) 3100 - if c.do() { 3101 - c.ret = func() interface{} { 3098 + Func: func(c *CallCtxt) { 3099 + s, sep, n := c.String(0), c.String(1), c.Int(2) 3100 + if c.Do() { 3101 + c.Ret = func() interface{} { 3102 3102 return strings.SplitAfterN(s, sep, n) 3103 3103 }() 3104 3104 } ··· 3107 3107 Name: "Split", 3108 3108 Params: []kind{stringKind, stringKind}, 3109 3109 Result: listKind, 3110 - Func: func(c *callCtxt) { 3111 - s, sep := c.string(0), c.string(1) 3112 - if c.do() { 3113 - c.ret = func() interface{} { 3110 + Func: func(c *CallCtxt) { 3111 + s, sep := c.String(0), c.String(1) 3112 + if c.Do() { 3113 + c.Ret = func() interface{} { 3114 3114 return strings.Split(s, sep) 3115 3115 }() 3116 3116 } ··· 3119 3119 Name: "SplitAfter", 3120 3120 Params: []kind{stringKind, stringKind}, 3121 3121 Result: listKind, 3122 - Func: func(c *callCtxt) { 3123 - s, sep := c.string(0), c.string(1) 3124 - if c.do() { 3125 - c.ret = func() interface{} { 3122 + Func: func(c *CallCtxt) { 3123 + s, sep := c.String(0), c.String(1) 3124 + if c.Do() { 3125 + c.Ret = func() interface{} { 3126 3126 return strings.SplitAfter(s, sep) 3127 3127 }() 3128 3128 } ··· 3131 3131 Name: "Fields", 3132 3132 Params: []kind{stringKind}, 3133 3133 Result: listKind, 3134 - Func: func(c *callCtxt) { 3135 - s := c.string(0) 3136 - if c.do() { 3137 - c.ret = func() interface{} { 3134 + Func: func(c *CallCtxt) { 3135 + s := c.String(0) 3136 + if c.Do() { 3137 + c.Ret = func() interface{} { 3138 3138 return strings.Fields(s) 3139 3139 }() 3140 3140 } ··· 3143 3143 Name: "Join", 3144 3144 Params: []kind{listKind, stringKind}, 3145 3145 Result: stringKind, 3146 - Func: func(c *callCtxt) { 3147 - elems, sep := c.strList(0), c.string(1) 3148 - if c.do() { 3149 - c.ret = func() interface{} { 3146 + Func: func(c *CallCtxt) { 3147 + elems, sep := c.StringList(0), c.String(1) 3148 + if c.Do() { 3149 + c.Ret = func() interface{} { 3150 3150 return strings.Join(elems, sep) 3151 3151 }() 3152 3152 } ··· 3155 3155 Name: "HasPrefix", 3156 3156 Params: []kind{stringKind, stringKind}, 3157 3157 Result: boolKind, 3158 - Func: func(c *callCtxt) { 3159 - s, prefix := c.string(0), c.string(1) 3160 - if c.do() { 3161 - c.ret = func() interface{} { 3158 + Func: func(c *CallCtxt) { 3159 + s, prefix := c.String(0), c.String(1) 3160 + if c.Do() { 3161 + c.Ret = func() interface{} { 3162 3162 return strings.HasPrefix(s, prefix) 3163 3163 }() 3164 3164 } ··· 3167 3167 Name: "HasSuffix", 3168 3168 Params: []kind{stringKind, stringKind}, 3169 3169 Result: boolKind, 3170 - Func: func(c *callCtxt) { 3171 - s, suffix := c.string(0), c.string(1) 3172 - if c.do() { 3173 - c.ret = func() interface{} { 3170 + Func: func(c *CallCtxt) { 3171 + s, suffix := c.String(0), c.String(1) 3172 + if c.Do() { 3173 + c.Ret = func() interface{} { 3174 3174 return strings.HasSuffix(s, suffix) 3175 3175 }() 3176 3176 } ··· 3179 3179 Name: "Repeat", 3180 3180 Params: []kind{stringKind, intKind}, 3181 3181 Result: stringKind, 3182 - Func: func(c *callCtxt) { 3183 - s, count := c.string(0), c.int(1) 3184 - if c.do() { 3185 - c.ret = func() interface{} { 3182 + Func: func(c *CallCtxt) { 3183 + s, count := c.String(0), c.Int(1) 3184 + if c.Do() { 3185 + c.Ret = func() interface{} { 3186 3186 return strings.Repeat(s, count) 3187 3187 }() 3188 3188 } ··· 3191 3191 Name: "ToUpper", 3192 3192 Params: []kind{stringKind}, 3193 3193 Result: stringKind, 3194 - Func: func(c *callCtxt) { 3195 - s := c.string(0) 3196 - if c.do() { 3197 - c.ret = func() interface{} { 3194 + Func: func(c *CallCtxt) { 3195 + s := c.String(0) 3196 + if c.Do() { 3197 + c.Ret = func() interface{} { 3198 3198 return strings.ToUpper(s) 3199 3199 }() 3200 3200 } ··· 3203 3203 Name: "ToLower", 3204 3204 Params: []kind{stringKind}, 3205 3205 Result: stringKind, 3206 - Func: func(c *callCtxt) { 3207 - s := c.string(0) 3208 - if c.do() { 3209 - c.ret = func() interface{} { 3206 + Func: func(c *CallCtxt) { 3207 + s := c.String(0) 3208 + if c.Do() { 3209 + c.Ret = func() interface{} { 3210 3210 return strings.ToLower(s) 3211 3211 }() 3212 3212 } ··· 3215 3215 Name: "Trim", 3216 3216 Params: []kind{stringKind, stringKind}, 3217 3217 Result: stringKind, 3218 - Func: func(c *callCtxt) { 3219 - s, cutset := c.string(0), c.string(1) 3220 - if c.do() { 3221 - c.ret = func() interface{} { 3218 + Func: func(c *CallCtxt) { 3219 + s, cutset := c.String(0), c.String(1) 3220 + if c.Do() { 3221 + c.Ret = func() interface{} { 3222 3222 return strings.Trim(s, cutset) 3223 3223 }() 3224 3224 } ··· 3227 3227 Name: "TrimLeft", 3228 3228 Params: []kind{stringKind, stringKind}, 3229 3229 Result: stringKind, 3230 - Func: func(c *callCtxt) { 3231 - s, cutset := c.string(0), c.string(1) 3232 - if c.do() { 3233 - c.ret = func() interface{} { 3230 + Func: func(c *CallCtxt) { 3231 + s, cutset := c.String(0), c.String(1) 3232 + if c.Do() { 3233 + c.Ret = func() interface{} { 3234 3234 return strings.TrimLeft(s, cutset) 3235 3235 }() 3236 3236 } ··· 3239 3239 Name: "TrimRight", 3240 3240 Params: []kind{stringKind, stringKind}, 3241 3241 Result: stringKind, 3242 - Func: func(c *callCtxt) { 3243 - s, cutset := c.string(0), c.string(1) 3244 - if c.do() { 3245 - c.ret = func() interface{} { 3242 + Func: func(c *CallCtxt) { 3243 + s, cutset := c.String(0), c.String(1) 3244 + if c.Do() { 3245 + c.Ret = func() interface{} { 3246 3246 return strings.TrimRight(s, cutset) 3247 3247 }() 3248 3248 } ··· 3251 3251 Name: "TrimSpace", 3252 3252 Params: []kind{stringKind}, 3253 3253 Result: stringKind, 3254 - Func: func(c *callCtxt) { 3255 - s := c.string(0) 3256 - if c.do() { 3257 - c.ret = func() interface{} { 3254 + Func: func(c *CallCtxt) { 3255 + s := c.String(0) 3256 + if c.Do() { 3257 + c.Ret = func() interface{} { 3258 3258 return strings.TrimSpace(s) 3259 3259 }() 3260 3260 } ··· 3263 3263 Name: "TrimPrefix", 3264 3264 Params: []kind{stringKind, stringKind}, 3265 3265 Result: stringKind, 3266 - Func: func(c *callCtxt) { 3267 - s, prefix := c.string(0), c.string(1) 3268 - if c.do() { 3269 - c.ret = func() interface{} { 3266 + Func: func(c *CallCtxt) { 3267 + s, prefix := c.String(0), c.String(1) 3268 + if c.Do() { 3269 + c.Ret = func() interface{} { 3270 3270 return strings.TrimPrefix(s, prefix) 3271 3271 }() 3272 3272 } ··· 3275 3275 Name: "TrimSuffix", 3276 3276 Params: []kind{stringKind, stringKind}, 3277 3277 Result: stringKind, 3278 - Func: func(c *callCtxt) { 3279 - s, suffix := c.string(0), c.string(1) 3280 - if c.do() { 3281 - c.ret = func() interface{} { 3278 + Func: func(c *CallCtxt) { 3279 + s, suffix := c.String(0), c.String(1) 3280 + if c.Do() { 3281 + c.Ret = func() interface{} { 3282 3282 return strings.TrimSuffix(s, suffix) 3283 3283 }() 3284 3284 } ··· 3287 3287 Name: "Replace", 3288 3288 Params: []kind{stringKind, stringKind, stringKind, intKind}, 3289 3289 Result: stringKind, 3290 - Func: func(c *callCtxt) { 3291 - s, old, new, n := c.string(0), c.string(1), c.string(2), c.int(3) 3292 - if c.do() { 3293 - c.ret = func() interface{} { 3290 + Func: func(c *CallCtxt) { 3291 + s, old, new, n := c.String(0), c.String(1), c.String(2), c.Int(3) 3292 + if c.Do() { 3293 + c.Ret = func() interface{} { 3294 3294 return strings.Replace(s, old, new, n) 3295 3295 }() 3296 3296 } ··· 3299 3299 Name: "Index", 3300 3300 Params: []kind{stringKind, stringKind}, 3301 3301 Result: intKind, 3302 - Func: func(c *callCtxt) { 3303 - s, substr := c.string(0), c.string(1) 3304 - if c.do() { 3305 - c.ret = func() interface{} { 3302 + Func: func(c *CallCtxt) { 3303 + s, substr := c.String(0), c.String(1) 3304 + if c.Do() { 3305 + c.Ret = func() interface{} { 3306 3306 return strings.Index(s, substr) 3307 3307 }() 3308 3308 } ··· 3310 3310 }}, 3311 3311 }, 3312 3312 "struct": { 3313 - native: []*builtin{{ 3313 + Native: []*Builtin{{ 3314 3314 Name: "MinFields", 3315 3315 Params: []kind{structKind, intKind}, 3316 3316 Result: boolKind, 3317 - Func: func(c *callCtxt) { 3318 - object, n := c.structVal(0), c.int(1) 3319 - if c.do() { 3320 - c.ret, c.err = func() (interface{}, error) { 3317 + Func: func(c *CallCtxt) { 3318 + object, n := c.Struct(0), c.Int(1) 3319 + if c.Do() { 3320 + c.Ret, c.Err = func() (interface{}, error) { 3321 3321 iter := object.Fields(Hidden(false), Optional(false)) 3322 3322 count := 0 3323 3323 for iter.Next() { ··· 3331 3331 Name: "MaxFields", 3332 3332 Params: []kind{structKind, intKind}, 3333 3333 Result: boolKind, 3334 - Func: func(c *callCtxt) { 3335 - object, n := c.structVal(0), c.int(1) 3336 - if c.do() { 3337 - c.ret, c.err = func() (interface{}, error) { 3334 + Func: func(c *CallCtxt) { 3335 + object, n := c.Struct(0), c.Int(1) 3336 + if c.Do() { 3337 + c.Ret, c.Err = func() (interface{}, error) { 3338 3338 iter := object.Fields(Hidden(false), Optional(false)) 3339 3339 count := 0 3340 3340 for iter.Next() { ··· 3347 3347 }}, 3348 3348 }, 3349 3349 "text/tabwriter": { 3350 - native: []*builtin{{ 3350 + Native: []*Builtin{{ 3351 3351 Name: "Write", 3352 3352 Params: []kind{topKind}, 3353 3353 Result: stringKind, 3354 - Func: func(c *callCtxt) { 3355 - data := c.value(0) 3356 - if c.do() { 3357 - c.ret, c.err = func() (interface{}, error) { 3354 + Func: func(c *CallCtxt) { 3355 + data := c.Value(0) 3356 + if c.Do() { 3357 + c.Ret, c.Err = func() (interface{}, error) { 3358 3358 buf := &bytes.Buffer{} 3359 3359 tw := tabwriter.NewWriter(buf, 0, 4, 1, ' ', 0) 3360 3360 ··· 3394 3394 }}, 3395 3395 }, 3396 3396 "text/template": { 3397 - native: []*builtin{{ 3397 + Native: []*Builtin{{ 3398 3398 Name: "Execute", 3399 3399 Params: []kind{stringKind, topKind}, 3400 3400 Result: stringKind, 3401 - Func: func(c *callCtxt) { 3402 - templ, data := c.string(0), c.value(1) 3403 - if c.do() { 3404 - c.ret, c.err = func() (interface{}, error) { 3401 + Func: func(c *CallCtxt) { 3402 + templ, data := c.String(0), c.Value(1) 3403 + if c.Do() { 3404 + c.Ret, c.Err = func() (interface{}, error) { 3405 3405 t, err := template.New("").Parse(templ) 3406 3406 if err != nil { 3407 3407 return "", err ··· 3422 3422 Name: "HTMLEscape", 3423 3423 Params: []kind{stringKind}, 3424 3424 Result: stringKind, 3425 - Func: func(c *callCtxt) { 3426 - s := c.string(0) 3427 - if c.do() { 3428 - c.ret = func() interface{} { 3425 + Func: func(c *CallCtxt) { 3426 + s := c.String(0) 3427 + if c.Do() { 3428 + c.Ret = func() interface{} { 3429 3429 return template.HTMLEscapeString(s) 3430 3430 }() 3431 3431 } ··· 3434 3434 Name: "JSEscape", 3435 3435 Params: []kind{stringKind}, 3436 3436 Result: stringKind, 3437 - Func: func(c *callCtxt) { 3438 - s := c.string(0) 3439 - if c.do() { 3440 - c.ret = func() interface{} { 3437 + Func: func(c *CallCtxt) { 3438 + s := c.String(0) 3439 + if c.Do() { 3440 + c.Ret = func() interface{} { 3441 3441 return template.JSEscapeString(s) 3442 3442 }() 3443 3443 } ··· 3445 3445 }}, 3446 3446 }, 3447 3447 "time": { 3448 - native: []*builtin{{ 3448 + Native: []*Builtin{{ 3449 3449 Name: "Nanosecond", 3450 3450 Const: "1", 3451 3451 }, { ··· 3467 3467 Name: "Duration", 3468 3468 Params: []kind{stringKind}, 3469 3469 Result: boolKind, 3470 - Func: func(c *callCtxt) { 3471 - s := c.string(0) 3472 - if c.do() { 3473 - c.ret, c.err = func() (interface{}, error) { 3470 + Func: func(c *CallCtxt) { 3471 + s := c.String(0) 3472 + if c.Do() { 3473 + c.Ret, c.Err = func() (interface{}, error) { 3474 3474 if _, err := time.ParseDuration(s); err != nil { 3475 3475 return false, err 3476 3476 } ··· 3482 3482 Name: "ParseDuration", 3483 3483 Params: []kind{stringKind}, 3484 3484 Result: intKind, 3485 - Func: func(c *callCtxt) { 3486 - s := c.string(0) 3487 - if c.do() { 3488 - c.ret, c.err = func() (interface{}, error) { 3485 + Func: func(c *CallCtxt) { 3486 + s := c.String(0) 3487 + if c.Do() { 3488 + c.Ret, c.Err = func() (interface{}, error) { 3489 3489 d, err := time.ParseDuration(s) 3490 3490 if err != nil { 3491 3491 return 0, err ··· 3594 3594 Name: "Time", 3595 3595 Params: []kind{stringKind}, 3596 3596 Result: boolKind, 3597 - Func: func(c *callCtxt) { 3598 - s := c.string(0) 3599 - if c.do() { 3600 - c.ret, c.err = func() (interface{}, error) { 3597 + Func: func(c *CallCtxt) { 3598 + s := c.String(0) 3599 + if c.Do() { 3600 + c.Ret, c.Err = func() (interface{}, error) { 3601 3601 return timeFormat(s, time.RFC3339Nano) 3602 3602 }() 3603 3603 } ··· 3606 3606 Name: "Format", 3607 3607 Params: []kind{stringKind, stringKind}, 3608 3608 Result: boolKind, 3609 - Func: func(c *callCtxt) { 3610 - value, layout := c.string(0), c.string(1) 3611 - if c.do() { 3612 - c.ret, c.err = func() (interface{}, error) { 3609 + Func: func(c *CallCtxt) { 3610 + value, layout := c.String(0), c.String(1) 3611 + if c.Do() { 3612 + c.Ret, c.Err = func() (interface{}, error) { 3613 3613 return timeFormat(value, layout) 3614 3614 }() 3615 3615 } ··· 3618 3618 Name: "Parse", 3619 3619 Params: []kind{stringKind, stringKind}, 3620 3620 Result: stringKind, 3621 - Func: func(c *callCtxt) { 3622 - layout, value := c.string(0), c.string(1) 3623 - if c.do() { 3624 - c.ret, c.err = func() (interface{}, error) { 3621 + Func: func(c *CallCtxt) { 3622 + layout, value := c.String(0), c.String(1) 3623 + if c.Do() { 3624 + c.Ret, c.Err = func() (interface{}, error) { 3625 3625 t, err := time.Parse(layout, value) 3626 3626 if err != nil { 3627 3627 return "", err ··· 3634 3634 Name: "Unix", 3635 3635 Params: []kind{intKind, intKind}, 3636 3636 Result: stringKind, 3637 - Func: func(c *callCtxt) { 3638 - sec, nsec := c.int64(0), c.int64(1) 3639 - if c.do() { 3640 - c.ret = func() interface{} { 3637 + Func: func(c *CallCtxt) { 3638 + sec, nsec := c.Int64(0), c.Int64(1) 3639 + if c.Do() { 3640 + c.Ret = func() interface{} { 3641 3641 t := time.Unix(sec, nsec) 3642 3642 return t.UTC().Format(time.RFC3339Nano) 3643 3643 }() ··· 3646 3646 }}, 3647 3647 }, 3648 3648 "tool": { 3649 - native: []*builtin{}, 3650 - cue: `{ 3649 + Native: []*Builtin{}, 3650 + CUE: `{ 3651 3651 Command: { 3652 3652 $usage?: string 3653 3653 $short?: string ··· 3666 3666 }`, 3667 3667 }, 3668 3668 "tool/cli": { 3669 - native: []*builtin{}, 3670 - cue: `{ 3669 + Native: []*Builtin{}, 3670 + CUE: `{ 3671 3671 Print: { 3672 3672 $id: *"tool/cli.Print" | "print" 3673 3673 text: string ··· 3675 3675 }`, 3676 3676 }, 3677 3677 "tool/exec": { 3678 - native: []*builtin{}, 3679 - cue: `{ 3678 + Native: []*Builtin{}, 3679 + CUE: `{ 3680 3680 Run: { 3681 3681 $id: *"tool/exec.Run" | "exec" 3682 3682 cmd: string | [string, ...string] ··· 3691 3691 }`, 3692 3692 }, 3693 3693 "tool/file": { 3694 - native: []*builtin{}, 3695 - cue: `{ 3694 + Native: []*Builtin{}, 3695 + CUE: `{ 3696 3696 Read: { 3697 3697 $id: "tool/file.Read" 3698 3698 filename: !="" ··· 3718 3718 }`, 3719 3719 }, 3720 3720 "tool/http": { 3721 - native: []*builtin{}, 3722 - cue: `{ 3721 + Native: []*Builtin{}, 3722 + CUE: `{ 3723 3723 Get: Do & { 3724 3724 method: "GET" 3725 3725 } ··· 3760 3760 }`, 3761 3761 }, 3762 3762 "tool/os": { 3763 - native: []*builtin{}, 3764 - cue: `{ 3763 + Native: []*Builtin{}, 3764 + CUE: `{ 3765 3765 Name: !="" & !~"^[$]" 3766 3766 Value: bool | number | *string | null 3767 3767 Setenv: {

Configure Feed

Configure Feed