github.com/gotranspile/cxgo@v0.3.7/runtime/stdio/asserts.go (about)

     1  package stdio
     2  
     3  import (
     4  	"fmt"
     5  	"reflect"
     6  	"unsafe"
     7  
     8  	"github.com/gotranspile/cxgo/runtime/libc"
     9  )
    10  
    11  func asUint(v interface{}) (uint64, error) {
    12  	switch v := v.(type) {
    13  	case uint:
    14  		return uint64(v), nil
    15  	case int:
    16  		return uint64(v), nil
    17  	case uintptr:
    18  		return uint64(v), nil
    19  	case uint64:
    20  		return v, nil
    21  	case int64:
    22  		return uint64(v), nil
    23  	case uint32:
    24  		return uint64(v), nil
    25  	case int32:
    26  		return uint64(v), nil
    27  	case uint16:
    28  		return uint64(v), nil
    29  	case int16:
    30  		return uint64(v), nil
    31  	case uint8:
    32  		return uint64(v), nil
    33  	case int8:
    34  		return uint64(v), nil
    35  	case bool:
    36  		if v {
    37  			return 1, nil
    38  		}
    39  		return 0, nil
    40  	case unsafe.Pointer:
    41  		return uint64(uintptr(v)), nil
    42  	default:
    43  		rv := reflect.ValueOf(v)
    44  		switch rv.Kind() {
    45  		case reflect.Ptr, reflect.UnsafePointer, reflect.Slice:
    46  			return uint64(rv.Pointer()), nil
    47  		case reflect.Uint, reflect.Uintptr,
    48  			reflect.Uint64, reflect.Uint32,
    49  			reflect.Uint16, reflect.Uint8:
    50  			return rv.Uint(), nil
    51  		case reflect.Int,
    52  			reflect.Int64, reflect.Int32,
    53  			reflect.Int16, reflect.Int8:
    54  			return uint64(rv.Int()), nil
    55  		}
    56  		return 0, fmt.Errorf("cannot cast to uint: %T", v)
    57  	}
    58  }
    59  
    60  func asFloat(v interface{}) (float64, error) {
    61  	switch v := v.(type) {
    62  	case float64:
    63  		return v, nil
    64  	case float32:
    65  		return float64(v), nil
    66  	default:
    67  		rv := reflect.ValueOf(v)
    68  		switch rv.Kind() {
    69  		case reflect.Float64, reflect.Float32:
    70  			return rv.Float(), nil
    71  		}
    72  		return 0, fmt.Errorf("cannot cast to float: %T", v)
    73  	}
    74  }
    75  
    76  func asString(v interface{}) (string, error) {
    77  	switch v := v.(type) {
    78  	case string:
    79  		return v, nil
    80  	case *byte:
    81  		return libc.GoString(v), nil
    82  	case *libc.WChar:
    83  		return libc.GoWString(v), nil
    84  	case unsafe.Pointer:
    85  		return libc.GoString((*byte)(v)), nil
    86  	case uintptr:
    87  		return libc.GoString((*byte)(unsafe.Pointer(v))), nil
    88  	default:
    89  		if v := reflect.ValueOf(v); v.Kind() == reflect.Array && v.Type().Elem().Kind() == reflect.Uint8 {
    90  			b := make([]byte, v.Len())
    91  			reflect.Copy(reflect.ValueOf(b), v)
    92  			return libc.GoStringS(b), nil
    93  		}
    94  		p, err := libc.AsPtr(v)
    95  		if err != nil {
    96  			return "", err
    97  		}
    98  		return libc.GoString((*byte)(p)), nil
    99  	}
   100  }