runtime.go 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859
  1. package otto
  2. import (
  3. "encoding"
  4. "encoding/json"
  5. "errors"
  6. "fmt"
  7. "math"
  8. "path"
  9. "reflect"
  10. "runtime"
  11. "strconv"
  12. "strings"
  13. "sync"
  14. "github.com/robertkrimen/otto/ast"
  15. "github.com/robertkrimen/otto/parser"
  16. )
  17. type _global struct {
  18. Object *_object // Object( ... ), new Object( ... ) - 1 (length)
  19. Function *_object // Function( ... ), new Function( ... ) - 1
  20. Array *_object // Array( ... ), new Array( ... ) - 1
  21. String *_object // String( ... ), new String( ... ) - 1
  22. Boolean *_object // Boolean( ... ), new Boolean( ... ) - 1
  23. Number *_object // Number( ... ), new Number( ... ) - 1
  24. Math *_object
  25. Date *_object // Date( ... ), new Date( ... ) - 7
  26. RegExp *_object // RegExp( ... ), new RegExp( ... ) - 2
  27. Error *_object // Error( ... ), new Error( ... ) - 1
  28. EvalError *_object
  29. TypeError *_object
  30. RangeError *_object
  31. ReferenceError *_object
  32. SyntaxError *_object
  33. URIError *_object
  34. JSON *_object
  35. ObjectPrototype *_object // Object.prototype
  36. FunctionPrototype *_object // Function.prototype
  37. ArrayPrototype *_object // Array.prototype
  38. StringPrototype *_object // String.prototype
  39. BooleanPrototype *_object // Boolean.prototype
  40. NumberPrototype *_object // Number.prototype
  41. DatePrototype *_object // Date.prototype
  42. RegExpPrototype *_object // RegExp.prototype
  43. ErrorPrototype *_object // Error.prototype
  44. EvalErrorPrototype *_object
  45. TypeErrorPrototype *_object
  46. RangeErrorPrototype *_object
  47. ReferenceErrorPrototype *_object
  48. SyntaxErrorPrototype *_object
  49. URIErrorPrototype *_object
  50. }
  51. type _runtime struct {
  52. global _global
  53. globalObject *_object
  54. globalStash *_objectStash
  55. scope *_scope
  56. otto *Otto
  57. eval *_object // The builtin eval, for determine indirect versus direct invocation
  58. debugger func(*Otto)
  59. random func() float64
  60. stackLimit int
  61. traceLimit int
  62. labels []string // FIXME
  63. lck sync.Mutex
  64. }
  65. func (self *_runtime) enterScope(scope *_scope) {
  66. scope.outer = self.scope
  67. if self.scope != nil {
  68. if self.stackLimit != 0 && self.scope.depth+1 >= self.stackLimit {
  69. panic(self.panicRangeError("Maximum call stack size exceeded"))
  70. }
  71. scope.depth = self.scope.depth + 1
  72. }
  73. self.scope = scope
  74. }
  75. func (self *_runtime) leaveScope() {
  76. self.scope = self.scope.outer
  77. }
  78. // FIXME This is used in two places (cloning)
  79. func (self *_runtime) enterGlobalScope() {
  80. self.enterScope(newScope(self.globalStash, self.globalStash, self.globalObject))
  81. }
  82. func (self *_runtime) enterFunctionScope(outer _stash, this Value) *_fnStash {
  83. if outer == nil {
  84. outer = self.globalStash
  85. }
  86. stash := self.newFunctionStash(outer)
  87. var thisObject *_object
  88. switch this.kind {
  89. case valueUndefined, valueNull:
  90. thisObject = self.globalObject
  91. default:
  92. thisObject = self.toObject(this)
  93. }
  94. self.enterScope(newScope(stash, stash, thisObject))
  95. return stash
  96. }
  97. func (self *_runtime) putValue(reference _reference, value Value) {
  98. name := reference.putValue(value)
  99. if name != "" {
  100. // Why? -- If reference.base == nil
  101. // strict = false
  102. self.globalObject.defineProperty(name, value, 0111, false)
  103. }
  104. }
  105. func (self *_runtime) tryCatchEvaluate(inner func() Value) (tryValue Value, exception bool) {
  106. // resultValue = The value of the block (e.g. the last statement)
  107. // throw = Something was thrown
  108. // throwValue = The value of what was thrown
  109. // other = Something that changes flow (return, break, continue) that is not a throw
  110. // Otherwise, some sort of unknown panic happened, we'll just propagate it
  111. defer func() {
  112. if caught := recover(); caught != nil {
  113. if exception, ok := caught.(*_exception); ok {
  114. caught = exception.eject()
  115. }
  116. switch caught := caught.(type) {
  117. case _error:
  118. exception = true
  119. tryValue = toValue_object(self.newError(caught.name, caught.messageValue(), 0))
  120. case Value:
  121. exception = true
  122. tryValue = caught
  123. default:
  124. panic(caught)
  125. }
  126. }
  127. }()
  128. tryValue = inner()
  129. return
  130. }
  131. // toObject
  132. func (self *_runtime) toObject(value Value) *_object {
  133. switch value.kind {
  134. case valueEmpty, valueUndefined, valueNull:
  135. panic(self.panicTypeError())
  136. case valueBoolean:
  137. return self.newBoolean(value)
  138. case valueString:
  139. return self.newString(value)
  140. case valueNumber:
  141. return self.newNumber(value)
  142. case valueObject:
  143. return value._object()
  144. }
  145. panic(self.panicTypeError())
  146. }
  147. func (self *_runtime) objectCoerce(value Value) (*_object, error) {
  148. switch value.kind {
  149. case valueUndefined:
  150. return nil, errors.New("undefined")
  151. case valueNull:
  152. return nil, errors.New("null")
  153. case valueBoolean:
  154. return self.newBoolean(value), nil
  155. case valueString:
  156. return self.newString(value), nil
  157. case valueNumber:
  158. return self.newNumber(value), nil
  159. case valueObject:
  160. return value._object(), nil
  161. }
  162. panic(self.panicTypeError())
  163. }
  164. func checkObjectCoercible(rt *_runtime, value Value) {
  165. isObject, mustCoerce := testObjectCoercible(value)
  166. if !isObject && !mustCoerce {
  167. panic(rt.panicTypeError())
  168. }
  169. }
  170. // testObjectCoercible
  171. func testObjectCoercible(value Value) (isObject bool, mustCoerce bool) {
  172. switch value.kind {
  173. case valueReference, valueEmpty, valueNull, valueUndefined:
  174. return false, false
  175. case valueNumber, valueString, valueBoolean:
  176. return false, true
  177. case valueObject:
  178. return true, false
  179. default:
  180. panic("this should never happen")
  181. }
  182. }
  183. func (self *_runtime) safeToValue(value interface{}) (Value, error) {
  184. result := Value{}
  185. err := catchPanic(func() {
  186. result = self.toValue(value)
  187. })
  188. return result, err
  189. }
  190. // convertNumeric converts numeric parameter val from js to that of type t if it is safe to do so, otherwise it panics.
  191. // This allows literals (int64), bitwise values (int32) and the general form (float64) of javascript numerics to be passed as parameters to go functions easily.
  192. func (self *_runtime) convertNumeric(v Value, t reflect.Type) reflect.Value {
  193. val := reflect.ValueOf(v.export())
  194. if val.Kind() == t.Kind() {
  195. return val
  196. }
  197. if val.Kind() == reflect.Interface {
  198. val = reflect.ValueOf(val.Interface())
  199. }
  200. switch val.Kind() {
  201. case reflect.Float32, reflect.Float64:
  202. f64 := val.Float()
  203. switch t.Kind() {
  204. case reflect.Float64:
  205. return reflect.ValueOf(f64)
  206. case reflect.Float32:
  207. if reflect.Zero(t).OverflowFloat(f64) {
  208. panic(self.panicRangeError("converting float64 to float32 would overflow"))
  209. }
  210. return val.Convert(t)
  211. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  212. i64 := int64(f64)
  213. if float64(i64) != f64 {
  214. panic(self.panicRangeError(fmt.Sprintf("converting %v to %v would cause loss of precision", val.Type(), t)))
  215. }
  216. // The float represents an integer
  217. val = reflect.ValueOf(i64)
  218. default:
  219. panic(self.panicTypeError(fmt.Sprintf("cannot convert %v to %v", val.Type(), t)))
  220. }
  221. }
  222. switch val.Kind() {
  223. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  224. i64 := val.Int()
  225. switch t.Kind() {
  226. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  227. if reflect.Zero(t).OverflowInt(i64) {
  228. panic(self.panicRangeError(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t)))
  229. }
  230. return val.Convert(t)
  231. case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  232. if i64 < 0 {
  233. panic(self.panicRangeError(fmt.Sprintf("converting %v to %v would underflow", val.Type(), t)))
  234. }
  235. if reflect.Zero(t).OverflowUint(uint64(i64)) {
  236. panic(self.panicRangeError(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t)))
  237. }
  238. return val.Convert(t)
  239. case reflect.Float32, reflect.Float64:
  240. return val.Convert(t)
  241. }
  242. case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  243. u64 := val.Uint()
  244. switch t.Kind() {
  245. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  246. if u64 > math.MaxInt64 || reflect.Zero(t).OverflowInt(int64(u64)) {
  247. panic(self.panicRangeError(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t)))
  248. }
  249. return val.Convert(t)
  250. case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  251. if reflect.Zero(t).OverflowUint(u64) {
  252. panic(self.panicRangeError(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t)))
  253. }
  254. return val.Convert(t)
  255. case reflect.Float32, reflect.Float64:
  256. return val.Convert(t)
  257. }
  258. }
  259. panic(self.panicTypeError(fmt.Sprintf("unsupported type %v -> %v for numeric conversion", val.Type(), t)))
  260. }
  261. func fieldIndexByName(t reflect.Type, name string) []int {
  262. for i := 0; i < t.NumField(); i++ {
  263. f := t.Field(i)
  264. if !validGoStructName(f.Name) {
  265. continue
  266. }
  267. if f.Anonymous {
  268. if a := fieldIndexByName(f.Type, name); a != nil {
  269. return append([]int{i}, a...)
  270. }
  271. }
  272. if a := strings.SplitN(f.Tag.Get("json"), ",", 2); a[0] != "" {
  273. if a[0] == "-" {
  274. continue
  275. }
  276. if a[0] == name {
  277. return []int{i}
  278. }
  279. }
  280. if f.Name == name {
  281. return []int{i}
  282. }
  283. }
  284. return nil
  285. }
  286. var typeOfValue = reflect.TypeOf(Value{})
  287. var typeOfJSONRawMessage = reflect.TypeOf(json.RawMessage{})
  288. // convertCallParameter converts request val to type t if possible.
  289. // If the conversion fails due to overflow or type miss-match then it panics.
  290. // If no conversion is known then the original value is returned.
  291. func (self *_runtime) convertCallParameter(v Value, t reflect.Type) (reflect.Value, error) {
  292. if t == typeOfValue {
  293. return reflect.ValueOf(v), nil
  294. }
  295. if t == typeOfJSONRawMessage {
  296. if d, err := json.Marshal(v.export()); err == nil {
  297. return reflect.ValueOf(d), nil
  298. }
  299. }
  300. if v.kind == valueObject {
  301. if gso, ok := v._object().value.(*_goStructObject); ok {
  302. if gso.value.Type().AssignableTo(t) {
  303. // please see TestDynamicFunctionReturningInterface for why this exists
  304. if t.Kind() == reflect.Interface && gso.value.Type().ConvertibleTo(t) {
  305. return gso.value.Convert(t), nil
  306. } else {
  307. return gso.value, nil
  308. }
  309. }
  310. }
  311. if gao, ok := v._object().value.(*_goArrayObject); ok {
  312. if gao.value.Type().AssignableTo(t) {
  313. // please see TestDynamicFunctionReturningInterface for why this exists
  314. if t.Kind() == reflect.Interface && gao.value.Type().ConvertibleTo(t) {
  315. return gao.value.Convert(t), nil
  316. } else {
  317. return gao.value, nil
  318. }
  319. }
  320. }
  321. }
  322. tk := t.Kind()
  323. if tk == reflect.Interface {
  324. e := v.export()
  325. if e == nil {
  326. return reflect.Zero(t), nil
  327. }
  328. iv := reflect.ValueOf(e)
  329. if iv.Type().AssignableTo(t) {
  330. return iv, nil
  331. }
  332. }
  333. if tk == reflect.Ptr {
  334. switch v.kind {
  335. case valueEmpty, valueNull, valueUndefined:
  336. return reflect.Zero(t), nil
  337. default:
  338. var vv reflect.Value
  339. vv, err := self.convertCallParameter(v, t.Elem())
  340. if err != nil {
  341. return reflect.Zero(t), fmt.Errorf("can't convert to %s: %s", t, err.Error())
  342. }
  343. if vv.CanAddr() {
  344. return vv.Addr(), nil
  345. }
  346. pv := reflect.New(vv.Type())
  347. pv.Elem().Set(vv)
  348. return pv, nil
  349. }
  350. }
  351. switch tk {
  352. case reflect.Bool:
  353. return reflect.ValueOf(v.bool()), nil
  354. case reflect.String:
  355. switch v.kind {
  356. case valueString:
  357. return reflect.ValueOf(v.value), nil
  358. case valueNumber:
  359. return reflect.ValueOf(fmt.Sprintf("%v", v.value)), nil
  360. }
  361. case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
  362. switch v.kind {
  363. case valueNumber:
  364. return self.convertNumeric(v, t), nil
  365. }
  366. case reflect.Slice:
  367. if o := v._object(); o != nil {
  368. if lv := o.get(propertyLength); lv.IsNumber() {
  369. l := lv.number().int64
  370. s := reflect.MakeSlice(t, int(l), int(l))
  371. tt := t.Elem()
  372. if o.class == classArray {
  373. for i := int64(0); i < l; i++ {
  374. p, ok := o.property[strconv.FormatInt(i, 10)]
  375. if !ok {
  376. continue
  377. }
  378. e, ok := p.value.(Value)
  379. if !ok {
  380. continue
  381. }
  382. ev, err := self.convertCallParameter(e, tt)
  383. if err != nil {
  384. return reflect.Zero(t), fmt.Errorf("couldn't convert element %d of %s: %s", i, t, err.Error())
  385. }
  386. s.Index(int(i)).Set(ev)
  387. }
  388. } else if o.class == classGoArray {
  389. var gslice bool
  390. switch o.value.(type) {
  391. case *_goSliceObject:
  392. gslice = true
  393. case *_goArrayObject:
  394. gslice = false
  395. }
  396. for i := int64(0); i < l; i++ {
  397. var p *_property
  398. if gslice {
  399. p = goSliceGetOwnProperty(o, strconv.FormatInt(i, 10))
  400. } else {
  401. p = goArrayGetOwnProperty(o, strconv.FormatInt(i, 10))
  402. }
  403. if p == nil {
  404. continue
  405. }
  406. e, ok := p.value.(Value)
  407. if !ok {
  408. continue
  409. }
  410. ev, err := self.convertCallParameter(e, tt)
  411. if err != nil {
  412. return reflect.Zero(t), fmt.Errorf("couldn't convert element %d of %s: %s", i, t, err.Error())
  413. }
  414. s.Index(int(i)).Set(ev)
  415. }
  416. }
  417. return s, nil
  418. }
  419. }
  420. case reflect.Map:
  421. if o := v._object(); o != nil && t.Key().Kind() == reflect.String {
  422. m := reflect.MakeMap(t)
  423. var err error
  424. o.enumerate(false, func(k string) bool {
  425. v, verr := self.convertCallParameter(o.get(k), t.Elem())
  426. if verr != nil {
  427. err = fmt.Errorf("couldn't convert property %q of %s: %s", k, t, verr.Error())
  428. return false
  429. }
  430. m.SetMapIndex(reflect.ValueOf(k), v)
  431. return true
  432. })
  433. if err != nil {
  434. return reflect.Zero(t), err
  435. }
  436. return m, nil
  437. }
  438. case reflect.Func:
  439. if t.NumOut() > 1 {
  440. return reflect.Zero(t), fmt.Errorf("converting JavaScript values to Go functions with more than one return value is currently not supported")
  441. }
  442. if o := v._object(); o != nil && o.class == classFunction {
  443. return reflect.MakeFunc(t, func(args []reflect.Value) []reflect.Value {
  444. l := make([]interface{}, len(args))
  445. for i, a := range args {
  446. if a.CanInterface() {
  447. l[i] = a.Interface()
  448. }
  449. }
  450. rv, err := v.Call(nullValue, l...)
  451. if err != nil {
  452. panic(err)
  453. }
  454. if t.NumOut() == 0 {
  455. return nil
  456. }
  457. r, err := self.convertCallParameter(rv, t.Out(0))
  458. if err != nil {
  459. panic(self.panicTypeError(err.Error()))
  460. }
  461. return []reflect.Value{r}
  462. }), nil
  463. }
  464. case reflect.Struct:
  465. if o := v._object(); o != nil && o.class == classObject {
  466. s := reflect.New(t)
  467. for _, k := range o.propertyOrder {
  468. idx := fieldIndexByName(t, k)
  469. if idx == nil {
  470. return reflect.Zero(t), fmt.Errorf("can't convert property %q of %s: field does not exist", k, t)
  471. }
  472. ss := s
  473. for _, i := range idx {
  474. if ss.Kind() == reflect.Ptr {
  475. if ss.IsNil() {
  476. if !ss.CanSet() {
  477. return reflect.Zero(t), fmt.Errorf("can't convert property %q of %s: %s is unexported", k, t, ss.Type().Elem())
  478. }
  479. ss.Set(reflect.New(ss.Type().Elem()))
  480. }
  481. ss = ss.Elem()
  482. }
  483. ss = ss.Field(i)
  484. }
  485. v, err := self.convertCallParameter(o.get(k), ss.Type())
  486. if err != nil {
  487. return reflect.Zero(t), fmt.Errorf("couldn't convert property %q of %s: %s", k, t, err.Error())
  488. }
  489. ss.Set(v)
  490. }
  491. return s.Elem(), nil
  492. }
  493. }
  494. if tk == reflect.String {
  495. if o := v._object(); o != nil && o.hasProperty("toString") {
  496. if fn := o.get("toString"); fn.IsFunction() {
  497. sv, err := fn.Call(v)
  498. if err != nil {
  499. return reflect.Zero(t), fmt.Errorf("couldn't call toString: %s", err.Error())
  500. }
  501. r, err := self.convertCallParameter(sv, t)
  502. if err != nil {
  503. return reflect.Zero(t), fmt.Errorf("couldn't convert toString result: %s", err.Error())
  504. }
  505. return r, nil
  506. }
  507. }
  508. return reflect.ValueOf(v.String()), nil
  509. }
  510. if v.kind == valueString {
  511. var s encoding.TextUnmarshaler
  512. if reflect.PtrTo(t).Implements(reflect.TypeOf(&s).Elem()) {
  513. r := reflect.New(t)
  514. if err := r.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(v.string())); err != nil {
  515. return reflect.Zero(t), fmt.Errorf("can't convert to %s as TextUnmarshaller: %s", t.String(), err.Error())
  516. }
  517. return r.Elem(), nil
  518. }
  519. }
  520. s := "OTTO DOES NOT UNDERSTAND THIS TYPE"
  521. switch v.kind {
  522. case valueBoolean:
  523. s = "boolean"
  524. case valueNull:
  525. s = "null"
  526. case valueNumber:
  527. s = "number"
  528. case valueString:
  529. s = "string"
  530. case valueUndefined:
  531. s = "undefined"
  532. case valueObject:
  533. s = v.Class()
  534. }
  535. return reflect.Zero(t), fmt.Errorf("can't convert from %q to %q", s, t)
  536. }
  537. func (self *_runtime) toValue(value interface{}) Value {
  538. switch value := value.(type) {
  539. case Value:
  540. return value
  541. case func(FunctionCall) Value:
  542. var name, file string
  543. var line int
  544. pc := reflect.ValueOf(value).Pointer()
  545. fn := runtime.FuncForPC(pc)
  546. if fn != nil {
  547. name = fn.Name()
  548. file, line = fn.FileLine(pc)
  549. file = path.Base(file)
  550. }
  551. return toValue_object(self.newNativeFunction(name, file, line, value))
  552. case _nativeFunction:
  553. var name, file string
  554. var line int
  555. pc := reflect.ValueOf(value).Pointer()
  556. fn := runtime.FuncForPC(pc)
  557. if fn != nil {
  558. name = fn.Name()
  559. file, line = fn.FileLine(pc)
  560. file = path.Base(file)
  561. }
  562. return toValue_object(self.newNativeFunction(name, file, line, value))
  563. case Object, *Object, _object, *_object:
  564. // Nothing happens.
  565. // FIXME We should really figure out what can come here.
  566. // This catch-all is ugly.
  567. default:
  568. {
  569. value := reflect.ValueOf(value)
  570. switch value.Kind() {
  571. case reflect.Ptr:
  572. switch reflect.Indirect(value).Kind() {
  573. case reflect.Struct:
  574. return toValue_object(self.newGoStructObject(value))
  575. case reflect.Array:
  576. return toValue_object(self.newGoArray(value))
  577. }
  578. case reflect.Struct:
  579. return toValue_object(self.newGoStructObject(value))
  580. case reflect.Map:
  581. return toValue_object(self.newGoMapObject(value))
  582. case reflect.Slice:
  583. return toValue_object(self.newGoSlice(value))
  584. case reflect.Array:
  585. return toValue_object(self.newGoArray(value))
  586. case reflect.Func:
  587. var name, file string
  588. var line int
  589. if v := reflect.ValueOf(value); v.Kind() == reflect.Ptr {
  590. pc := v.Pointer()
  591. fn := runtime.FuncForPC(pc)
  592. if fn != nil {
  593. name = fn.Name()
  594. file, line = fn.FileLine(pc)
  595. file = path.Base(file)
  596. }
  597. }
  598. typ := value.Type()
  599. return toValue_object(self.newNativeFunction(name, file, line, func(c FunctionCall) Value {
  600. nargs := typ.NumIn()
  601. if len(c.ArgumentList) != nargs {
  602. if typ.IsVariadic() {
  603. if len(c.ArgumentList) < nargs-1 {
  604. panic(self.panicRangeError(fmt.Sprintf("expected at least %d arguments; got %d", nargs-1, len(c.ArgumentList))))
  605. }
  606. } else {
  607. panic(self.panicRangeError(fmt.Sprintf("expected %d argument(s); got %d", nargs, len(c.ArgumentList))))
  608. }
  609. }
  610. in := make([]reflect.Value, len(c.ArgumentList))
  611. callSlice := false
  612. for i, a := range c.ArgumentList {
  613. var t reflect.Type
  614. n := i
  615. if n >= nargs-1 && typ.IsVariadic() {
  616. if n > nargs-1 {
  617. n = nargs - 1
  618. }
  619. t = typ.In(n).Elem()
  620. } else {
  621. t = typ.In(n)
  622. }
  623. // if this is a variadic Go function, and the caller has supplied
  624. // exactly the number of JavaScript arguments required, and this
  625. // is the last JavaScript argument, try treating the it as the
  626. // actual set of variadic Go arguments. if that succeeds, break
  627. // out of the loop.
  628. if typ.IsVariadic() && len(c.ArgumentList) == nargs && i == nargs-1 {
  629. if v, err := self.convertCallParameter(a, typ.In(n)); err == nil {
  630. in[i] = v
  631. callSlice = true
  632. break
  633. }
  634. }
  635. v, err := self.convertCallParameter(a, t)
  636. if err != nil {
  637. panic(self.panicTypeError(err.Error()))
  638. }
  639. in[i] = v
  640. }
  641. var out []reflect.Value
  642. if callSlice {
  643. out = value.CallSlice(in)
  644. } else {
  645. out = value.Call(in)
  646. }
  647. switch len(out) {
  648. case 0:
  649. return Value{}
  650. case 1:
  651. return self.toValue(out[0].Interface())
  652. default:
  653. s := make([]interface{}, len(out))
  654. for i, v := range out {
  655. s[i] = self.toValue(v.Interface())
  656. }
  657. return self.toValue(s)
  658. }
  659. }))
  660. }
  661. }
  662. }
  663. return toValue(value)
  664. }
  665. func (runtime *_runtime) newGoSlice(value reflect.Value) *_object {
  666. self := runtime.newGoSliceObject(value)
  667. self.prototype = runtime.global.ArrayPrototype
  668. return self
  669. }
  670. func (runtime *_runtime) newGoArray(value reflect.Value) *_object {
  671. self := runtime.newGoArrayObject(value)
  672. self.prototype = runtime.global.ArrayPrototype
  673. return self
  674. }
  675. func (runtime *_runtime) parse(filename string, src, sm interface{}) (*ast.Program, error) {
  676. return parser.ParseFileWithSourceMap(nil, filename, src, sm, 0)
  677. }
  678. func (runtime *_runtime) cmpl_parse(filename string, src, sm interface{}) (*_nodeProgram, error) {
  679. program, err := parser.ParseFileWithSourceMap(nil, filename, src, sm, 0)
  680. if err != nil {
  681. return nil, err
  682. }
  683. return cmpl_parse(program), nil
  684. }
  685. func (self *_runtime) parseSource(src, sm interface{}) (*_nodeProgram, *ast.Program, error) {
  686. switch src := src.(type) {
  687. case *ast.Program:
  688. return nil, src, nil
  689. case *Script:
  690. return src.program, nil, nil
  691. }
  692. program, err := self.parse("", src, sm)
  693. return nil, program, err
  694. }
  695. func (self *_runtime) cmpl_runOrEval(src, sm interface{}, eval bool) (Value, error) {
  696. result := Value{}
  697. cmpl_program, program, err := self.parseSource(src, sm)
  698. if err != nil {
  699. return result, err
  700. }
  701. if cmpl_program == nil {
  702. cmpl_program = cmpl_parse(program)
  703. }
  704. err = catchPanic(func() {
  705. result = self.cmpl_evaluate_nodeProgram(cmpl_program, eval)
  706. })
  707. switch result.kind {
  708. case valueEmpty:
  709. result = Value{}
  710. case valueReference:
  711. result = result.resolve()
  712. }
  713. return result, err
  714. }
  715. func (self *_runtime) cmpl_run(src, sm interface{}) (Value, error) {
  716. return self.cmpl_runOrEval(src, sm, false)
  717. }
  718. func (self *_runtime) cmpl_eval(src, sm interface{}) (Value, error) {
  719. return self.cmpl_runOrEval(src, sm, true)
  720. }
  721. func (self *_runtime) parseThrow(err error) {
  722. if err == nil {
  723. return
  724. }
  725. switch err := err.(type) {
  726. case parser.ErrorList:
  727. {
  728. err := err[0]
  729. if err.Message == "Invalid left-hand side in assignment" {
  730. panic(self.panicReferenceError(err.Message))
  731. }
  732. panic(self.panicSyntaxError(err.Message))
  733. }
  734. }
  735. panic(self.panicSyntaxError(err.Error()))
  736. }
  737. func (self *_runtime) cmpl_parseOrThrow(src, sm interface{}) *_nodeProgram {
  738. program, err := self.cmpl_parse("", src, sm)
  739. self.parseThrow(err) // Will panic/throw appropriately
  740. return program
  741. }