Godeps, vendor: convert dependency management to trash (#3198)

This commit converts the dependency management from Godeps to the vendor
folder, also switching the tool from godep to trash. Since the upstream tool
lacks a few features proposed via a few PRs, until those PRs are merged in
(if), use github.com/karalabe/trash.

You can update dependencies via trash --update.

All dependencies have been updated to their latest version.

Parts of the build system are reworked to drop old notions of Godeps and
invocation of the go vet command so that it doesn't run against the vendor
folder, as that will just blow up during vetting.

The conversion drops OpenCL (and hence GPU mining support) from ethash and our
codebase. The short reasoning is that there's noone to maintain and having
opencl libs in our deps messes up builds as go install ./... tries to build
them, failing with unsatisfied link errors for the C OpenCL deps.

golang.org/x/net/context is not vendored in. We expect it to be fetched by the
user (i.e. using go get). To keep ci.go builds reproducible the package is
"vendored" in build/_vendor.

1 files changed, 0 insertions, 527 deletions

diff --git a/Godeps/_workspace/src/github.com/robertkrimen/otto/runtime.go b/Godeps/_workspace/src/github.com/robertkrimen/otto/runtime.go
deleted file mode 100644
index a998f7acc..000000000
--- a/Godeps/_workspace/src/github.com/robertkrimen/otto/runtime.go
+++ /dev/null
@@ -1,527 +0,0 @@
-package otto
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"reflect"
-	"sync"
-
-	"github.com/robertkrimen/otto/ast"
-	"github.com/robertkrimen/otto/parser"
-)
-
-type _global struct {
-	Object         *_object // Object( ... ), new Object( ... ) - 1 (length)
-	Function       *_object // Function( ... ), new Function( ... ) - 1
-	Array          *_object // Array( ... ), new Array( ... ) - 1
-	String         *_object // String( ... ), new String( ... ) - 1
-	Boolean        *_object // Boolean( ... ), new Boolean( ... ) - 1
-	Number         *_object // Number( ... ), new Number( ... ) - 1
-	Math           *_object
-	Date           *_object // Date( ... ), new Date( ... ) - 7
-	RegExp         *_object // RegExp( ... ), new RegExp( ... ) - 2
-	Error          *_object // Error( ... ), new Error( ... ) - 1
-	EvalError      *_object
-	TypeError      *_object
-	RangeError     *_object
-	ReferenceError *_object
-	SyntaxError    *_object
-	URIError       *_object
-	JSON           *_object
-
-	ObjectPrototype         *_object // Object.prototype
-	FunctionPrototype       *_object // Function.prototype
-	ArrayPrototype          *_object // Array.prototype
-	StringPrototype         *_object // String.prototype
-	BooleanPrototype        *_object // Boolean.prototype
-	NumberPrototype         *_object // Number.prototype
-	DatePrototype           *_object // Date.prototype
-	RegExpPrototype         *_object // RegExp.prototype
-	ErrorPrototype          *_object // Error.prototype
-	EvalErrorPrototype      *_object
-	TypeErrorPrototype      *_object
-	RangeErrorPrototype     *_object
-	ReferenceErrorPrototype *_object
-	SyntaxErrorPrototype    *_object
-	URIErrorPrototype       *_object
-}
-
-type _runtime struct {
-	global       _global
-	globalObject *_object
-	globalStash  *_objectStash
-	scope        *_scope
-	otto         *Otto
-	eval         *_object // The builtin eval, for determine indirect versus direct invocation
-	debugger     func(*Otto)
-	random       func() float64
-
-	labels []string // FIXME
-	lck    sync.Mutex
-}
-
-func (self *_runtime) enterScope(scope *_scope) {
-	scope.outer = self.scope
-	self.scope = scope
-}
-
-func (self *_runtime) leaveScope() {
-	self.scope = self.scope.outer
-}
-
-// FIXME This is used in two places (cloning)
-func (self *_runtime) enterGlobalScope() {
-	self.enterScope(newScope(self.globalStash, self.globalStash, self.globalObject))
-}
-
-func (self *_runtime) enterFunctionScope(outer _stash, this Value) *_fnStash {
-	if outer == nil {
-		outer = self.globalStash
-	}
-	stash := self.newFunctionStash(outer)
-	var thisObject *_object
-	switch this.kind {
-	case valueUndefined, valueNull:
-		thisObject = self.globalObject
-	default:
-		thisObject = self.toObject(this)
-	}
-	self.enterScope(newScope(stash, stash, thisObject))
-	return stash
-}
-
-func (self *_runtime) putValue(reference _reference, value Value) {
-	name := reference.putValue(value)
-	if name != "" {
-		// Why? -- If reference.base == nil
-		// strict = false
-		self.globalObject.defineProperty(name, value, 0111, false)
-	}
-}
-
-func (self *_runtime) tryCatchEvaluate(inner func() Value) (tryValue Value, exception bool) {
-	// resultValue = The value of the block (e.g. the last statement)
-	// throw = Something was thrown
-	// throwValue = The value of what was thrown
-	// other = Something that changes flow (return, break, continue) that is not a throw
-	// Otherwise, some sort of unknown panic happened, we'll just propagate it
-	defer func() {
-		if caught := recover(); caught != nil {
-			if exception, ok := caught.(*_exception); ok {
-				caught = exception.eject()
-			}
-			switch caught := caught.(type) {
-			case _error:
-				exception = true
-				tryValue = toValue_object(self.newError(caught.name, caught.messageValue()))
-			case Value:
-				exception = true
-				tryValue = caught
-			default:
-				panic(caught)
-			}
-		}
-	}()
-
-	tryValue = inner()
-	return
-}
-
-// toObject
-
-func (self *_runtime) toObject(value Value) *_object {
-	switch value.kind {
-	case valueEmpty, valueUndefined, valueNull:
-		panic(self.panicTypeError())
-	case valueBoolean:
-		return self.newBoolean(value)
-	case valueString:
-		return self.newString(value)
-	case valueNumber:
-		return self.newNumber(value)
-	case valueObject:
-		return value._object()
-	}
-	panic(self.panicTypeError())
-}
-
-func (self *_runtime) objectCoerce(value Value) (*_object, error) {
-	switch value.kind {
-	case valueUndefined:
-		return nil, errors.New("undefined")
-	case valueNull:
-		return nil, errors.New("null")
-	case valueBoolean:
-		return self.newBoolean(value), nil
-	case valueString:
-		return self.newString(value), nil
-	case valueNumber:
-		return self.newNumber(value), nil
-	case valueObject:
-		return value._object(), nil
-	}
-	panic(self.panicTypeError())
-}
-
-func checkObjectCoercible(rt *_runtime, value Value) {
-	isObject, mustCoerce := testObjectCoercible(value)
-	if !isObject && !mustCoerce {
-		panic(rt.panicTypeError())
-	}
-}
-
-// testObjectCoercible
-
-func testObjectCoercible(value Value) (isObject bool, mustCoerce bool) {
-	switch value.kind {
-	case valueReference, valueEmpty, valueNull, valueUndefined:
-		return false, false
-	case valueNumber, valueString, valueBoolean:
-		isObject = false
-		mustCoerce = true
-	case valueObject:
-		isObject = true
-		mustCoerce = false
-	}
-	return
-}
-
-func (self *_runtime) safeToValue(value interface{}) (Value, error) {
-	result := Value{}
-	err := catchPanic(func() {
-		result = self.toValue(value)
-	})
-	return result, err
-}
-
-// convertNumeric converts numeric parameter val from js to that of type t if it is safe to do so, otherwise it panics.
-// This allows literals (int64), bitwise values (int32) and the general form (float64) of javascript numerics to be passed as parameters to go functions easily.
-func convertNumeric(val reflect.Value, t reflect.Type) reflect.Value {
-	if val.Kind() == t.Kind() {
-		return val
-	}
-
-	if val.Kind() == reflect.Interface {
-		val = reflect.ValueOf(val.Interface())
-	}
-
-	switch val.Kind() {
-	case reflect.Float32, reflect.Float64:
-		f64 := val.Float()
-		switch t.Kind() {
-		case reflect.Float64:
-			return reflect.ValueOf(f64)
-		case reflect.Float32:
-			if reflect.Zero(t).OverflowFloat(f64) {
-				panic("converting float64 to float32 would overflow")
-			}
-
-			return val.Convert(t)
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			i64 := int64(f64)
-			if float64(i64) != f64 {
-				panic(fmt.Sprintf("converting %v to %v would cause loss of precision", val.Type(), t))
-			}
-
-			// The float represents an integer
-			val = reflect.ValueOf(i64)
-		default:
-			panic(fmt.Sprintf("cannot convert %v to %v", val.Type(), t))
-		}
-	}
-
-	switch val.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		i64 := val.Int()
-		switch t.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			if reflect.Zero(t).OverflowInt(i64) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			if i64 < 0 {
-				panic(fmt.Sprintf("converting %v to %v would underflow", val.Type(), t))
-			}
-			if reflect.Zero(t).OverflowUint(uint64(i64)) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		}
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		u64 := val.Uint()
-		switch t.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			if u64 > math.MaxInt64 || reflect.Zero(t).OverflowInt(int64(u64)) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			if reflect.Zero(t).OverflowUint(u64) {
-				panic(fmt.Sprintf("converting %v to %v would overflow", val.Type(), t))
-			}
-			return val.Convert(t)
-		}
-	}
-
-	panic(fmt.Sprintf("unsupported type %v for numeric conversion", val.Type()))
-}
-
-// callParamConvert converts request val to type t if possible.
-// If the conversion fails due to overflow or type miss-match then it panics.
-// If no conversion is known then the original value is returned.
-func callParamConvert(val reflect.Value, t reflect.Type) reflect.Value {
-	if val.Kind() == reflect.Interface {
-		val = reflect.ValueOf(val.Interface())
-	}
-
-	switch t.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64:
-		if val.Kind() == t.Kind() {
-			// Types already match
-			return val
-		}
-		return convertNumeric(val, t)
-	case reflect.Slice:
-		if val.Kind() != reflect.Slice {
-			// Conversion from none slice type to slice not possible
-			panic(fmt.Sprintf("cannot use %v as type %v", val, t))
-		}
-	default:
-		// No supported conversion
-		return val
-	}
-
-	elemType := t.Elem()
-	switch elemType.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.Slice:
-		// Attempt to convert to slice of the type t
-		s := reflect.MakeSlice(reflect.SliceOf(elemType), val.Len(), val.Len())
-		for i := 0; i < val.Len(); i++ {
-			s.Index(i).Set(callParamConvert(val.Index(i), elemType))
-		}
-
-		return s
-	}
-
-	// Not a slice type we can convert
-	return val
-}
-
-// callSliceRequired returns true if CallSlice is required instead of Call.
-func callSliceRequired(param reflect.Type, val reflect.Value) bool {
-	vt := val.Type()
-	for param.Kind() == reflect.Slice {
-		if val.Kind() == reflect.Interface {
-			val = reflect.ValueOf(val.Interface())
-			vt = val.Type()
-		}
-
-		if vt.Kind() != reflect.Slice {
-			return false
-		}
-
-		vt = vt.Elem()
-		if val.Kind() != reflect.Invalid {
-			if val.Len() > 0 {
-				val = val.Index(0)
-			} else {
-				val = reflect.Value{}
-			}
-		}
-		param = param.Elem()
-	}
-
-	return true
-}
-
-func (self *_runtime) toValue(value interface{}) Value {
-	switch value := value.(type) {
-	case Value:
-		return value
-	case func(FunctionCall) Value:
-		return toValue_object(self.newNativeFunction("", value))
-	case _nativeFunction:
-		return toValue_object(self.newNativeFunction("", value))
-	case Object, *Object, _object, *_object:
-		// Nothing happens.
-		// FIXME We should really figure out what can come here.
-		// This catch-all is ugly.
-	default:
-		{
-			value := reflect.ValueOf(value)
-			switch value.Kind() {
-			case reflect.Ptr:
-				switch reflect.Indirect(value).Kind() {
-				case reflect.Struct:
-					return toValue_object(self.newGoStructObject(value))
-				case reflect.Array:
-					return toValue_object(self.newGoArray(value))
-				}
-			case reflect.Func:
-				// TODO Maybe cache this?
-				return toValue_object(self.newNativeFunction("", func(call FunctionCall) Value {
-					argsCount := len(call.ArgumentList)
-					in := make([]reflect.Value, argsCount)
-					t := value.Type()
-					callSlice := false
-					paramsCount := t.NumIn()
-					lastParam := paramsCount - 1
-					lastArg := argsCount - 1
-					isVariadic := t.IsVariadic()
-					for i, value := range call.ArgumentList {
-						var paramType reflect.Type
-						if isVariadic && i == lastArg && argsCount == paramsCount {
-							// Variadic functions last parameter and parameter numbers match incoming args
-							paramType = t.In(lastArg)
-							val := reflect.ValueOf(value.export())
-							callSlice = callSliceRequired(paramType, val)
-							if callSlice {
-								in[i] = callParamConvert(reflect.ValueOf(value.export()), paramType)
-								continue
-							}
-						}
-
-						if i >= lastParam {
-							if isVariadic {
-								paramType = t.In(lastParam).Elem()
-							} else {
-								paramType = t.In(lastParam)
-							}
-						} else {
-							paramType = t.In(i)
-						}
-						in[i] = callParamConvert(reflect.ValueOf(value.export()), paramType)
-					}
-
-					var out []reflect.Value
-					if callSlice {
-						out = value.CallSlice(in)
-					} else {
-						out = value.Call(in)
-					}
-
-					l := len(out)
-					switch l {
-					case 0:
-						return Value{}
-					case 1:
-						return self.toValue(out[0].Interface())
-					}
-
-					// Return an array of the values to emulate multi value return.
-					// In the future this can be used along side destructuring assignment.
-					s := make([]interface{}, l)
-					for i, v := range out {
-						s[i] = self.toValue(v.Interface())
-					}
-					return self.toValue(s)
-				}))
-			case reflect.Struct:
-				return toValue_object(self.newGoStructObject(value))
-			case reflect.Map:
-				return toValue_object(self.newGoMapObject(value))
-			case reflect.Slice:
-				return toValue_object(self.newGoSlice(value))
-			case reflect.Array:
-				return toValue_object(self.newGoArray(value))
-			}
-		}
-	}
-	return toValue(value)
-}
-
-func (runtime *_runtime) newGoSlice(value reflect.Value) *_object {
-	self := runtime.newGoSliceObject(value)
-	self.prototype = runtime.global.ArrayPrototype
-	return self
-}
-
-func (runtime *_runtime) newGoArray(value reflect.Value) *_object {
-	self := runtime.newGoArrayObject(value)
-	self.prototype = runtime.global.ArrayPrototype
-	return self
-}
-
-func (runtime *_runtime) parse(filename string, src interface{}) (*ast.Program, error) {
-	return parser.ParseFile(nil, filename, src, 0)
-}
-
-func (runtime *_runtime) cmpl_parse(filename string, src interface{}) (*_nodeProgram, error) {
-	program, err := parser.ParseFile(nil, filename, src, 0)
-	if err != nil {
-		return nil, err
-	}
-	return cmpl_parse(program), nil
-}
-
-func (self *_runtime) parseSource(src interface{}) (*_nodeProgram, *ast.Program, error) {
-	switch src := src.(type) {
-	case *ast.Program:
-		return nil, src, nil
-	case *Script:
-		return src.program, nil, nil
-	}
-	program, err := self.parse("", src)
-	return nil, program, err
-}
-
-func (self *_runtime) cmpl_runOrEval(src interface{}, eval bool) (Value, error) {
-	result := Value{}
-	cmpl_program, program, err := self.parseSource(src)
-	if err != nil {
-		return result, err
-	}
-	if cmpl_program == nil {
-		cmpl_program = cmpl_parse(program)
-	}
-	err = catchPanic(func() {
-		result = self.cmpl_evaluate_nodeProgram(cmpl_program, eval)
-	})
-	switch result.kind {
-	case valueEmpty:
-		result = Value{}
-	case valueReference:
-		result = result.resolve()
-	}
-	return result, err
-}
-
-func (self *_runtime) cmpl_run(src interface{}) (Value, error) {
-	return self.cmpl_runOrEval(src, false)
-}
-
-func (self *_runtime) cmpl_eval(src interface{}) (Value, error) {
-	return self.cmpl_runOrEval(src, true)
-}
-
-func (self *_runtime) parseThrow(err error) {
-	if err == nil {
-		return
-	}
-	switch err := err.(type) {
-	case parser.ErrorList:
-		{
-			err := err[0]
-			if err.Message == "Invalid left-hand side in assignment" {
-				panic(self.panicReferenceError(err.Message))
-			}
-			panic(self.panicSyntaxError(err.Message))
-		}
-	}
-	panic(self.panicSyntaxError(err.Error()))
-}
-
-func (self *_runtime) parseOrThrow(source string) *ast.Program {
-	program, err := self.parse("", source)
-	self.parseThrow(err) // Will panic/throw appropriately
-	return program
-}
-
-func (self *_runtime) cmpl_parseOrThrow(source string) *_nodeProgram {
-	program, err := self.cmpl_parse("", source)
-	self.parseThrow(err) // Will panic/throw appropriately
-	return program
-}