mirror of
https://github.com/golang/go
synced 2024-11-20 06:44:40 -07:00
4224d81fae
These can be implemented with just a compare and a move instruction.
Do so, avoiding the overhead of a call into the runtime.
These assertions are a significant cost in Go code that uses interface{}
as a safe alternative to C's void* (or unsafe.Pointer), such as the
current version of the Go compiler.
*T here includes pointer to T but also any Go type represented as
a single pointer (chan, func, map). It does not include [1]*T or struct{*int}.
That requires more work in other parts of the compiler; there is a TODO.
Change-Id: I7ff681c20d2c3eb6ad11dd7b3a37b1f3dda23965
Reviewed-on: https://go-review.googlesource.com/7862
Reviewed-by: Rob Pike <r@golang.org>
89 lines
2.2 KiB
Go
89 lines
2.2 KiB
Go
// Copyright 2010 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package runtime
|
|
|
|
import "unsafe"
|
|
|
|
// The Error interface identifies a run time error.
|
|
type Error interface {
|
|
error
|
|
|
|
// RuntimeError is a no-op function but
|
|
// serves to distinguish types that are run time
|
|
// errors from ordinary errors: a type is a
|
|
// run time error if it has a RuntimeError method.
|
|
RuntimeError()
|
|
}
|
|
|
|
// A TypeAssertionError explains a failed type assertion.
|
|
type TypeAssertionError struct {
|
|
interfaceString string
|
|
concreteString string
|
|
assertedString string
|
|
missingMethod string // one method needed by Interface, missing from Concrete
|
|
}
|
|
|
|
func (*TypeAssertionError) RuntimeError() {}
|
|
|
|
func (e *TypeAssertionError) Error() string {
|
|
inter := e.interfaceString
|
|
if inter == "" {
|
|
inter = "interface"
|
|
}
|
|
if e.concreteString == "" {
|
|
return "interface conversion: " + inter + " is nil, not " + e.assertedString
|
|
}
|
|
if e.missingMethod == "" {
|
|
return "interface conversion: " + inter + " is " + e.concreteString +
|
|
", not " + e.assertedString
|
|
}
|
|
return "interface conversion: " + e.concreteString + " is not " + e.assertedString +
|
|
": missing method " + e.missingMethod
|
|
}
|
|
|
|
// An errorString represents a runtime error described by a single string.
|
|
type errorString string
|
|
|
|
func (e errorString) RuntimeError() {}
|
|
|
|
func (e errorString) Error() string {
|
|
return "runtime error: " + string(e)
|
|
}
|
|
|
|
type stringer interface {
|
|
String() string
|
|
}
|
|
|
|
func typestring(x interface{}) string {
|
|
e := (*eface)(unsafe.Pointer(&x))
|
|
return *e._type._string
|
|
}
|
|
|
|
// For calling from C.
|
|
// Prints an argument passed to panic.
|
|
// There's room for arbitrary complexity here, but we keep it
|
|
// simple and handle just a few important cases: int, string, and Stringer.
|
|
func printany(i interface{}) {
|
|
switch v := i.(type) {
|
|
case nil:
|
|
print("nil")
|
|
case stringer:
|
|
print(v.String())
|
|
case error:
|
|
print(v.Error())
|
|
case int:
|
|
print(v)
|
|
case string:
|
|
print(v)
|
|
default:
|
|
print("(", typestring(i), ") ", i)
|
|
}
|
|
}
|
|
|
|
// called from generated code
|
|
func panicwrap(pkg, typ, meth string) {
|
|
panic("value method " + pkg + "." + typ + "." + meth + " called using nil *" + typ + " pointer")
|
|
}
|