py/util.go

// Copyright 2022 The go-python 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 py

import (
	"errors"
	"strconv"
	"strings"
)

var (
	ErrUnsupportedObjType = errors.New("unsupported obj type")
)

// GetLen is a high-level convenience function that returns the length of the given Object.
func GetLen(obj Object) (Int, error) {
	getlen, ok := obj.(I__len__)
	if !ok {
		return 0, nil
	}

	lenObj, err := getlen.M__len__()
	if err != nil {
		return 0, err
	}

	return GetInt(lenObj)
}

// GetInt is a high-level convenience function that converts the given value to an int.
func GetInt(obj Object) (Int, error) {
	toIdx, ok := obj.(I__index__)
	if !ok {
		_, err := cantConvert(obj, "int")
		return 0, err
	}

	return toIdx.M__index__()
}

// LoadTuple attempts to convert each element of the given list and store into each destination value (based on its type).
func LoadTuple(args Tuple, vars []interface{}) error {

	if len(args) > len(vars) {
		return ExceptionNewf(RuntimeError, "%d args given, expected %d", len(args), len(vars))
	}

	if len(vars) > len(args) {
		vars = vars[:len(args)]
	}

	for i, rval := range vars {
		err := loadValue(args[i], rval)
		if err == ErrUnsupportedObjType {
			return ExceptionNewf(TypeError, "arg %d has unsupported object type: %s", i, args[i].Type().Name)
		}
	}

	return nil
}

// LoadAttr gets the named attribute and attempts to store it into the given destination value (based on its type).
func LoadAttr(obj Object, attrName string, dst interface{}) error {
	attr, err := GetAttrString(obj, attrName)
	if err != nil {
		return err
	}
	err = loadValue(attr, dst)
	if err == ErrUnsupportedObjType {
		return ExceptionNewf(TypeError, "attribute \"%s\" has unsupported object type: %s", attrName, attr.Type().Name)
	}
	return nil
}

// LoadIntsFromList extracts a list of ints contained given a py.List or py.Tuple
func LoadIntsFromList(list Object) ([]int64, error) {
	N, err := GetLen(list)
	if err != nil {
		return nil, err
	}

	getter, ok := list.(I__getitem__)
	if !ok {
		return nil, nil
	}

	if N <= 0 {
		return nil, nil
	}

	intList := make([]int64, N)
	for i := Int(0); i < N; i++ {
		item, err := getter.M__getitem__(i)
		if err != nil {
			return nil, err
		}

		var intVal Int
		intVal, err = GetInt(item)
		if err != nil {
			return nil, err
		}

		intList[i] = int64(intVal)
	}

	return intList, nil
}

func loadValue(src Object, data interface{}) error {
	var (
		v_str   string
		v_float float64
		v_int   int64
	)

	haveStr := false

	switch v := src.(type) {
	case Bool:
		if v {
			v_int = 1
			v_float = 1
			v_str = "True"
		} else {
			v_str = "False"
		}
		haveStr = true
	case Int:
		v_int = int64(v)
		v_float = float64(v)
	case Float:
		v_int = int64(v)
		v_float = float64(v)
	case String:
		v_str = string(v)
		haveStr = true
	case NoneType:
		// No-op
	default:
		return ErrUnsupportedObjType
	}

	switch dst := data.(type) {
	case *Int:
		*dst = Int(v_int)
	case *bool:
		*dst = v_int != 0
	case *int8:
		*dst = int8(v_int)
	case *uint8:
		*dst = uint8(v_int)
	case *int16:
		*dst = int16(v_int)
	case *uint16:
		*dst = uint16(v_int)
	case *int32:
		*dst = int32(v_int)
	case *uint32:
		*dst = uint32(v_int)
	case *int:
		*dst = int(v_int)
	case *uint:
		*dst = uint(v_int)
	case *int64:
		*dst = v_int
	case *uint64:
		*dst = uint64(v_int)
	case *float32:
		if haveStr {
			v_float, _ = strconv.ParseFloat(v_str, 32)
		}
		*dst = float32(v_float)
	case *float64:
		if haveStr {
			v_float, _ = strconv.ParseFloat(v_str, 64)
		}
		*dst = v_float
	case *Float:
		if haveStr {
			v_float, _ = strconv.ParseFloat(v_str, 64)
		}
		*dst = Float(v_float)
	case *string:
		*dst = v_str
	case *String:
		*dst = String(v_str)
	// case []uint64:
	// 	for i := range data {
	// 		dst[i] = order.Uint64(bs[8*i:])
	// 	}
	// case []float32:
	// 	for i := range data {
	// 		dst[i] = math.Float32frombits(order.Uint32(bs[4*i:]))
	// 	}
	// case []float64:
	// 	for i := range data {
	// 		dst[i] = math.Float64frombits(order.Uint64(bs[8*i:]))
	// 	}

	default:
		return ExceptionNewf(NotImplementedError, "%s", "unsupported Go data type")
	}
	return nil
}

// Println prints the provided strings to gpython's stdout.
func Println(self Object, args ...string) bool {
	sysModule, err := self.(*Module).Context.GetModule("sys")
	if err != nil {
		return false
	}
	stdout := sysModule.Globals["stdout"]
	write, err := GetAttrString(stdout, "write")
	if err != nil {
		return false
	}
	call, ok := write.(I__call__)
	if !ok {
		return false
	}
	for _, v := range args {
		if !strings.Contains(v, "\n") {
			v += " "
		}
		_, err := call.M__call__(Tuple{String(v)}, nil)
		if err != nil {
			return false
		}

	}
	_, err = call.M__call__(Tuple{String("\n")}, nil) // newline
	return err == nil
}