def make_bytes(length, byte): # assert byte_huh(byte) is values.w_true if isinstance(byte, values.W_Fixnum): v = byte.value else: raise SchemeException("make-bytes: not a byte") if not 0 <= v <= 255: raise SchemeException("make-bytes: argument out of range") bstr = [chr(v)] * length.value return values.W_MutableBytes(bstr)
def list_to_bytes(w_list): l = values.from_list(w_list) ll = [' '] * len(l) for (i, x) in enumerate(l): if not isinstance(x, values.W_Fixnum): raise SchemeException("list->bytes: expected fixnum, got %s" % x) if x.value < 0 or x.value >= 256: raise SchemeException( "list->bytes: expected number between 0 and 255, got %s" % x) ll[i] = chr(x.value) return values.W_MutableBytes(ll)
def bytes(args): if len(args) == 0: return values.W_MutableBytes([]) assert len(args) > 0 builder = StringBuilder() for char in args: if not (isinstance(char, values.W_Fixnum) and 0 <= char.value <= 255): raise SchemeException("string: expected a character int") builder.append(chr(char.value)) return values.W_Bytes.from_string(builder.build(), immutable=False)
def bytes_append(args): lens = 0 for a in args: if not isinstance(a, values.W_Bytes): raise SchemeException( "bytes-append: expected a byte string, but got %s" % a) lens += len(a.value) val = [' '] * lens # is this the fastest way to do things? cnt = 0 for a in args: assert isinstance(a, values.W_Bytes) val[cnt:cnt + len(a.value)] = a.value cnt += len(a.value) return values.W_MutableBytes(val)
def bytes_append(args): total_len = 0 for a in args: if not isinstance(a, values.W_Bytes): raise SchemeException( "bytes-append: expected a byte string, but got %s" % a) total_len += len(a.value) result = ['\0'] * total_len # is this the fastest way to do things? cnt = 0 for a in args: assert isinstance(a, values.W_Bytes) for byte in a.value: result[cnt] = byte cnt += 1 assert cnt == total_len return values.W_MutableBytes(result)
def list_to_bytes(w_list): if not w_list.is_proper_list(): raise SchemeException("list->bytes: expected proper list, got %s" % w_list.tostring()) ll = [] while isinstance(w_list, values.W_UnwrappedFixnumConsProper): val = w_list._car if not (0 <= val < 256): break ll.append(chr(val)) w_list = w_list.cdr() else: if w_list is values.w_null: return values.W_MutableBytes(ll[:]) assert isinstance(w_list, values.W_Cons) raise SchemeException("list->bytes: expected a number between 0 and 255, got %s" % w_list.car().tostring())
def subbytes(w_bytes, w_start, w_end): """ (subbytes bstr start [end]) → bytes? bstr : bytes? start : exact-nonnegative-integer? end : exact-nonnegative-integer? = (bytes-length str) """ bytes = w_bytes.value start = w_start.value if start > len(bytes) or start < 0: raise SchemeException("subbytes: end index out of bounds") if w_end is not None: end = w_end.value if end > len(bytes) or end < 0: raise SchemeException("subbytes: end index out of bounds") else: end = len(bytes) if end < start: raise SchemeException( "subbytes: ending index is smaller than starting index") return values.W_MutableBytes(bytes[start:end])