if b == null then
return
end
- bitmap_header[x] = b
+ bitmap_header[x] = b.to_i
end
self.file_size = get_value(bitmap_header.subarray(2, 4))
self.data_offset = get_value(bitmap_header.subarray(10, 4))
for x in [0..39] do
var b = fileReader.read_byte
if b == null then return
- dib_header[x] = b
+ dib_header[x] = b.to_i
end
var dib_size = get_value(dib_header.subarray(0, 4))
# only support BITMAPINFOHEADER
var red = bts[0] << 16
var green = bts[1] << 8
var blue = bts[2]
- row.add(red + green + blue)
+ row.add(red.to_i + green.to_i + blue.to_i)
end
self.data.add(row)
end
init do ns = new NativeString(maxlen)
- fun [](i: Int): Char do return ns[i]
+ fun [](i: Int): Byte do return ns[i]
end
# Simple implementation of the iterator on Substrings for `Leaf`
var buf: ManualBuffer
var bns: NativeString is noinit
- redef var length: Int is noinit
+ redef var length is noinit
redef fun empty do return new Leaf(new ManualBuffer)
redef fun to_cstring do
var len = length
var ns = new NativeString(len + 1)
- ns[len] = '\0'
+ ns[len] = 0u8
buf.ns.copy_to(ns, len, 0, 0)
return ns
end
redef fun substrings do return new LeafSubstrings(self)
- redef fun [](i) do return buf[i]
+ redef fun [](i) do return buf[i].to_i.ascii
init do
bns = buf.ns
redef fun output do new FlatString.with_infos(buf.ns, length, 0, length - 1).output
redef fun to_upper do
- var x = new ManualBuffer
- var nns = x.ns
- var ns = bns
- var mlen = length
- for i in [0..mlen[ do
- nns[i] = ns[i].to_upper
- end
- x.pos = mlen - 1
- return new Leaf(x)
+ var x = new FlatBuffer
+ for i in chars do x.add(i.to_upper)
+ return x.to_s
end
redef fun to_lower do
- var x = new ManualBuffer
- var nns = x.ns
- var ns = bns
- var mlen = length
- for i in [0..mlen[ do
- nns[i] = ns[i].to_lower
- end
- x.pos = mlen - 1
- return new Leaf(x)
+ var x = new FlatBuffer
+ for i in chars do x.add(i.to_lower)
+ return x.to_s
end
redef fun reversed do
redef fun +(o) do
var s = o.to_s
- var slen = s.length
- var mlen = length
+ var slen = s.bytelen
+ var mlen = bytelen
if slen == 0 then return self
if mlen == 0 then return s
var nlen = mlen + slen
b = new ManualBuffer
bns.copy_to(b.ns, mlen, 0, 0)
end
- for i in s.chars do
+ for i in s.bytes do
bns[bpos] = i
bpos += 1
end
redef fun to_cstring do
var len = length
var ns = new NativeString(len + 1)
- ns[len] = '\0'
+ ns[len] = 0u8
var off = 0
for i in substrings do
var ilen = i.length
mypos += 1
end
var ns = new NativeString(sl + 1)
- ns[sl] = '\0'
+ ns[sl] = 0u8
i = 0
var off = 0
while i < mypos do
last_char = -1
return
end
- last_char = s
+ last_char = s.to_i
# XML 1.0 end-of-line handling
# Note: Regardless the XML version, any EOL defined by the
if was_cr and last_char == '\n'.ascii then
# EOL already reported. => Skip this byte.
s = input.read_byte
- if s == null then s = -1
- last_char = s
+ if s == null then
+ last_char = -1
+ else
+ last_char = s.to_i
+ end
end
was_cr = last_char == '\r'.ascii
if was_cr then
# A buffer containing Byte-manipulation facilities
#
# Uses Copy-On-Write when persisted
-#
-# TODO: Change the bound to Byte when available in stdlib and bootstrap
class Bytes
- super AbstractArray[Int]
+ super AbstractArray[Byte]
# A NativeString being a char*, it can be used as underlying representation here.
private var items: NativeString
redef fun is_empty do return length != 0
# var b = new Bytes.empty
- # b.add 101
- # assert b[0] == 101
+ # b.add 101u8
+ # assert b[0] == 101u8
redef fun [](i) do
assert i >= 0
assert i < length
- return items[i].ascii
+ return items[i]
end
# var b = new Bytes.with_capacity(1)
- # b[0] = 101
+ # b[0] = 101u8
# assert b.to_s == "e"
redef fun []=(i, v) do
if persisted then regen
assert i >= 0
assert i <= length
if i == length then add(v)
- items[i] = v.ascii
+ items[i] = v
end
# var b = new Bytes.empty
- # b.add 101
+ # b.add 101u8
# assert b.to_s == "e"
redef fun add(c) do
if persisted then regen
if length >= capacity then
enlarge(length)
end
- items[length] = c.ascii
+ items[length] = c
length += 1
end
# var b = new Bytes.empty
- # b.append([104, 101, 108, 108, 111])
+ # b.append([104u8, 101u8, 108u8, 108u8, 111u8])
# assert b.to_s == "hello"
redef fun append(arr) do
if arr isa Bytes then
end
private class BytesIterator
- super IndexedIterator[Int]
+ super IndexedIterator[Byte]
var tgt: NativeString
redef fun next do index += 1
- redef fun item do return tgt[index].ascii
+ redef fun item do return tgt[index]
end
redef class NativeString
last_error = new IOError("Stream has reached eof")
return null
end
- var c = _buffer[_buffer_pos]
+ # TODO: Fix when supporting UTF-8
+ var c = _buffer[_buffer_pos].to_i.ascii
_buffer_pos += 1
return c
end
last_error = new IOError("Stream has reached eof")
return null
end
- var c = _buffer[_buffer_pos].ascii
+ var c = _buffer[_buffer_pos]
_buffer_pos += 1
return c
end
var j = _buffer_pos
var k = _buffer_length
while j < k do
- s.add(_buffer[j].ascii)
+ s.add(_buffer[j])
j += 1
end
_buffer_pos = j
loop
# First phase: look for a '\n'
var i = _buffer_pos
- while i < _buffer_length and _buffer[i] != '\n' do
+ while i < _buffer_length and _buffer[i] != 0xAu8 do
i += 1
end
var eol
if i < _buffer_length then
- assert _buffer[i] == '\n'
+ assert _buffer[i] == 0xAu8
i += 1
eol = true
else
# Copy from the buffer to the string
var j = _buffer_pos
while j < i do
- s.add(_buffer[j])
+ s.bytes.add(_buffer[j])
j += 1
end
_buffer_pos = i
# The string to read from.
var source: String
- # The current position in the string.
+ # The current position in the string (bytewise).
private var cursor: Int = 0
redef fun read_char do
if cursor < source.length then
+ # Fix when supporting UTF-8
var c = source[cursor]
-
cursor += 1
return c
else
redef fun read_byte do
if cursor < source.length then
- var c = source[cursor]
-
+ var c = source.bytes[cursor]
cursor += 1
- return c.ascii
+ return c
else
return null
end
var mypos = src_offset
var itspos = dest_offset
while n > 0 do
- dest[itspos] = self.chars[mypos]
+ dest[itspos] = self.bytes[mypos]
itspos += 1
mypos += 1
n -= 1
redef fun to_s do
var nslen = byte_to_s_len
var ns = new NativeString(nslen + 1)
- ns[nslen] = '\0'
+ ns[nslen] = 0u8
native_byte_to_s(ns, nslen + 1)
return ns.to_s_with_length(nslen)
end
# In other terms, if the index is valid
assert index >= 0
assert (index + index_from) <= index_to
- return items[index + index_from]
+ return items[index + index_from].to_i.ascii
end
################################################
else
var newItems = new NativeString(length + 1)
self.items.copy_to(newItems, length, index_from, 0)
- newItems[length] = '\0'
+ newItems[length] = 0u8
self.real_items = newItems
return newItems
end
end
end
- target_string[total_length] = '\0'
+ target_string[total_length] = 0u8
return target_string.to_s_with_length(total_length)
end
var target_string = new NativeString(final_length + 1)
- target_string[final_length] = '\0'
+ target_string[final_length] = 0u8
var current_last = 0
var myitems = items
while i <= index_to do
- h = h.lshift(5) + h + myitems[i].ascii
+ h = h.lshift(5) + h + myitems[i].to_i
i += 1
end
redef fun [](index)
do
assert index >= 0
- assert index < length
- return items[index]
+ assert index < length
+ return items[index].to_i.ascii
end
redef fun []=(index, item)
end
if written then reset
assert index >= 0 and index < length
- items[index] = item
+ items[index] = item.ascii.to_b
end
redef fun add(c)
do
if is_dirty then
var new_native = new NativeString(length + 1)
- new_native[length] = '\0'
+ new_native[length] = 0u8
if length > 0 then items.copy_to(new_native, length, 0, 0)
real_items = new_native
is_dirty = false
s.items.copy_to(items, length, 0, 0)
else
var curr_pos = 0
- for i in [0..s.length[ do
- var c = s.chars[i]
- items[curr_pos] = c
+ for i in s.bytes do
+ items[curr_pos] = i
curr_pos += 1
end
end
s.items.copy_to(items, sl, 0, length)
else
var curr_pos = self.length
- for i in [0..s.length[ do
- var c = s.chars[i]
- items[curr_pos] = c
+ for i in s.bytes do
+ items[curr_pos] = i
curr_pos += 1
end
end
end
-private class FlatBufferIterator
+private class FlatBufferCharIterator
super IndexedIterator[Char]
var target: FlatBuffer
- var target_items: NativeString
+ var max: Int
var curr_pos: Int
init with_pos(tgt: FlatBuffer, pos: Int)
do
target = tgt
- if tgt.length > 0 then target_items = tgt.items
+ max = tgt.length - 1
curr_pos = pos
end
redef fun index do return curr_pos
- redef fun is_ok do return curr_pos < target.length
+ redef fun is_ok do return curr_pos <= max
- redef fun item do return target_items[curr_pos]
+ redef fun item do return target[curr_pos]
redef fun next do curr_pos += 1
var new_self = new NativeString(length + 1)
copy_to(new_self, length, 0, 0)
var str = new FlatString.with_infos(new_self, length, 0, length - 1)
- new_self[length] = '\0'
+ new_self[length] = 0u8
str.real_items = new_self
return str
end
var nslen = int_to_s_len
var ns = new NativeString(nslen + 1)
- ns[nslen] = '\0'
+ ns[nslen] = 0u8
native_int_to_s(ns, nslen + 1)
return ns.to_s_with_length(nslen)
end
mypos += 1
end
var ns = new NativeString(sl + 1)
- ns[sl] = '\0'
+ ns[sl] = 0u8
i = 0
var off = 0
while i < mypos do
mypos += 1
end
var ns = new NativeString(sl + 1)
- ns[sl] = '\0'
+ ns[sl] = 0u8
i = 0
var off = 0
while i < mypos do
fun fast_cstring(index: Int): NativeString is intern
# Get char at `index`.
- fun [](index: Int): Char is intern
+ fun [](index: Int): Byte is intern
# Set char `item` at index.
- fun []=(index: Int, item: Char) is intern
+ fun []=(index: Int, item: Byte) is intern
# Copy `self` to `dest`.
fun copy_to(dest: NativeString, length: Int, from: Int, to: Int) is intern
fun cstring_length: Int
do
var l = 0
- while self[l] != '\0' do l += 1
+ while self[l] != 0u8 do l += 1
return l
end
redef var to_cstring is lazy do
var len = length
var ns = new NativeString(len + 1)
- ns[len] = '\0'
+ ns[len] = 0u8
var off = 0
for i in substrings do
var ilen = i.length
nitlanguage / nit.git / commitdiff