Implement bytes() constructor

Author: ncw

py/bytes.go

@@ -2,11 +2,113 @@
 
 package py
 
-varBytesType=NewType("bytes", "bytes(iterable_of_ints) -> bytes\nbytes(string, encoding[, errors]) -> bytes\nbytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\nbytes(int) -> bytes object of size given by the parameter initialized with null bytes\nbytes() -> empty bytes object\n\nConstruct an immutable array of bytes from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - any object implementing the buffer API.\n - an integer")
+import (
+"strings"
+)
+
+varBytesType=ObjectType.NewType("bytes",
+`bytes(iterable_of_ints) -> bytes
+bytes(string, encoding[, errors]) -> bytes
+bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
+bytes(int) -> bytes object of size given by the parameter initialized with null bytes
+bytes() -> empty bytes object
+
+Construct an immutable array of bytes from:
+ - an iterable yielding integers in range(256)
+ - a text string encoded using the specified encoding
+ - any object implementing the buffer API.
+ - an integer`, BytesNew, nil)
 
 typeBytes []byte
 
 // Type of this Bytes object
 func (oBytes) Type() *Type{
 returnBytesType
 }
+
+// BytesNew
+funcBytesNew(metatype*Type, argsTuple, kwargsStringDict) (resObject){
+varxObject
+varencodingObject
+varerrorsObject
+varNewObject
+kwlist:= []string{"source", "encoding", "errors"}
+
+ParseTupleAndKeywords(args, kwargs, "|Oss:bytes", kwlist, &x, &encoding, &errors)
+ifx==nil{
+ifencoding!=nil||errors!=nil{
+panic(ExceptionNewf(TypeError, "encoding or errors without sequence argument"))
+ }
+returnBytes{}
+ }
+
+ifs, ok:=x.(String); ok{
+// Encode via the codec registry
+ifencoding==nil{
+panic(ExceptionNewf(TypeError, "string argument without an encoding"))
+ }
+encodingStr:=strings.ToLower(string(encoding.(String)))
+ifencodingStr=="utf-8"||encodingStr=="utf8"{
+returnBytes([]byte(s))
+ }
+// FIXME
+// New = PyUnicode_AsEncodedString(x, encoding, errors)
+// assert(PyBytes_Check(New))
+// return New
+panic(ExceptionNewf(NotImplementedError, "String decode for %q not implemented", encodingStr))
+ }
+
+// We'd like to call PyObject_Bytes here, but we need to check for an
+// integer argument before deferring to PyBytes_FromObject, something
+// PyObject_Bytes doesn't do.
+varokbool
+ifI, ok:=x.(I__bytes__); ok{
+New=I.M__bytes__()
+ } elseifNew, ok=TypeCall0(x, "__bytes__"); ok{
+ } else{
+goto no_bytes_method
+ }
+if_, ok=New.(Bytes); !ok{
+panic(ExceptionNewf(TypeError, "__bytes__ returned non-bytes (type %s)", New.Type().Name))
+ }
+no_bytes_method:
+
+// Is it an integer?
+if_, ok:=x.(Int); ok{
+size:=IndexInt(x)
+ifsize<0{
+panic(ExceptionNewf(ValueError, "negative count"))
+ }
+returnmake(Bytes, size)
+ }
+
+// If it's not unicode, there can't be encoding or errors
+ifencoding!=nil||errors!=nil{
+panic(ExceptionNewf(TypeError, "encoding or errors without a string argument"))
+ }
+
+returnBytesFromObject(x)
+}
+
+// Converts an object into bytes
+funcBytesFromObject(xObject) Bytes{
+// Look for special cases
+// FIXME implement converting from any object implementing the buffer API.
+switchz:=x.(type){
+caseBytes:
+// Immutable type so just return what was passed in
+returnz
+caseString:
+panic(ExceptionNewf(TypeError, "cannot convert unicode object to bytes"))
+ }
+// Otherwise iterate through the whatever converting it into ints
+b:=Bytes{}
+Iterate(x, func(itemObject){
+value:=IndexInt(item)
+ifvalue<0||value>=256{
+panic(ExceptionNewf(ValueError, "bytes must be in range(0, 256)"))
+ }
+b=append(b, byte(value))
+ })
+returnb
+}