238 lines
6.8 KiB
Ruby
238 lines
6.8 KiB
Ruby
|
|
|
|
module Parfait
|
|
# A word is a a short sequence of characters
|
|
# Characters are not modeled as objects but as (small) integers
|
|
# The small means two of them have to fit into a machine word, utf16 or similar
|
|
#
|
|
# Words are constant, maybe like js strings, ruby symbols
|
|
# Words are short, but may have spaces
|
|
|
|
# Words are objects, that means they carry Type as index 0
|
|
# So all indexes are offset by one in the implementation
|
|
# Object length is measured in non-type cells though
|
|
|
|
class Word < Data8
|
|
attr_reader :char_length ,:next_word
|
|
|
|
|
|
def self.type_length
|
|
3 # 0 type , 1 char_length , next_word
|
|
end
|
|
def self.get_length_index
|
|
type_length - 2
|
|
end
|
|
# initialize with length. For now we try to keep all non-parfait (including String) out
|
|
# String will contain spaces for non-zero length
|
|
# Risc provides methods to create Parfait objects from ruby
|
|
def initialize( len )
|
|
super()
|
|
@char_length = 0
|
|
raise "Must init with int, not #{len.class}" unless len.kind_of? ::Integer
|
|
raise "Must init with positive, not #{len}" if len < 0
|
|
fill_to( len , 32 ) unless len == 0 #32 being ascii space
|
|
#puts "type #{self.get_type} #{self.object_id.to_s(16)}"
|
|
end
|
|
|
|
|
|
# return a copy of self
|
|
def copy
|
|
cop = Word.new( @char_length )
|
|
index = 0
|
|
while( index < @char_length )
|
|
cop.set_char(index , get_char(index))
|
|
index = index + 1
|
|
end
|
|
cop
|
|
end
|
|
|
|
# return the number of characters
|
|
def length()
|
|
@char_length
|
|
end
|
|
|
|
# make every char equal the given one
|
|
def fill_with( char )
|
|
fill_from_with(0 , char)
|
|
end
|
|
|
|
def fill_from_with( from , char )
|
|
len = @char_length
|
|
return if from < 0
|
|
while( from < len)
|
|
set_char( from , char)
|
|
from = from + 1
|
|
end
|
|
from
|
|
end
|
|
|
|
# true if no characters
|
|
def empty?
|
|
return @char_length == 0
|
|
end
|
|
|
|
# pad the string with the given character to the given length
|
|
#
|
|
def fill_to(len , fill_char)
|
|
return if len <= 0
|
|
old = @char_length
|
|
return if old >= len
|
|
@char_length = len
|
|
check_length
|
|
fill_from_with( old , fill_char )
|
|
end
|
|
|
|
# set the character at the given index to the given character
|
|
# character must be an integer, as is the index
|
|
# the index starts at one, but may be negative to count from the end
|
|
# indexes out of range will raise an error
|
|
def set_char( at , char )
|
|
raise "char not fixnum #{char.class}" unless char.kind_of? ::Integer
|
|
index = range_correct_index(at)
|
|
set_internal_byte( index , char)
|
|
end
|
|
|
|
def set_internal_byte( index , char )
|
|
word_index = (index) / 4
|
|
rest = ((index) % 4)
|
|
shifted = char << (rest * 8)
|
|
was = get_internal_word( word_index )
|
|
was = 0 unless was.is_a?(Numeric)
|
|
mask = 0xFF << (rest * 8)
|
|
mask = 0xFFFFFFFF - mask
|
|
masked = was & mask
|
|
put = masked + shifted
|
|
set_internal_word( word_index , put )
|
|
msg = "set index=#{index} word_index=#{word_index} rest=#{rest}= "
|
|
msg += "char=#{char.to_s(16)} shifted=#{shifted.to_s(16)} "
|
|
msg += "was=#{was.to_s(16)} masked=#{masked.to_s(16)} put=#{put.to_s(16)}"
|
|
#puts msg
|
|
char
|
|
end
|
|
|
|
# get the character at the given index (lowest 1)
|
|
# the index starts at one, but may be negative to count from the end
|
|
# indexes out of range will raise an error
|
|
#the return "character" is an integer
|
|
def get_char( at )
|
|
index = range_correct_index(at)
|
|
get_internal_byte(index)
|
|
end
|
|
|
|
|
|
def get_internal_byte( index )
|
|
word_index = (index ) / 4
|
|
rest = ((index) % 4)
|
|
char = get_internal_word(word_index)
|
|
char = 0 unless char.is_a?(Numeric)
|
|
shifted = char >> (8 * rest)
|
|
ret = shifted & 0xFF
|
|
msg = "get index=#{index} word_index=#{word_index} rest=#{rest}= "
|
|
msg += " char=#{char.to_s(16)} shifted=#{shifted.to_s(16)} ret=#{ret.to_s(16)}"
|
|
#puts msg
|
|
return ret
|
|
end
|
|
|
|
# private method to account for
|
|
def range_correct_index( at )
|
|
index = at
|
|
# index = self.length + at if at < 0
|
|
raise "index not integer #{at.class}" unless at.is_a?(::Integer)
|
|
raise "index must be positive , not #{at}" if (index < 0)
|
|
raise "index too large #{at} >= #{self.length}" if (index >= self.length )
|
|
return index + Word.type_length * 4
|
|
end
|
|
|
|
# compare the word to another
|
|
# currently checks for same class, though really identity of the characters
|
|
# in right order would suffice
|
|
def compare( other )
|
|
return false if other.class != self.class
|
|
return false if other.length != self.length
|
|
len = self.length - 1
|
|
while(len >= 0)
|
|
return false if self.get_char(len) != other.get_char(len)
|
|
len = len - 1
|
|
end
|
|
return true
|
|
end
|
|
|
|
def == other
|
|
return false unless other.is_a?(String) or other.is_a?(Word)
|
|
as_string = self.to_string
|
|
unless other.is_a? String
|
|
other = other.to_string
|
|
end
|
|
as_string == other
|
|
end
|
|
|
|
def to_string
|
|
string = ""
|
|
index = 0
|
|
#puts "Length = #{char_length}"
|
|
while( index < @char_length)
|
|
char = get_char(index)
|
|
string += char ? char.chr : "*"
|
|
index = index + 1
|
|
end
|
|
string
|
|
end
|
|
|
|
# as we answered is_value? with true, rfx will create a basic node with this string
|
|
def to_rfx
|
|
"'" + to_s + "'"
|
|
end
|
|
|
|
def to_s
|
|
"Word:#{to_string}"
|
|
end
|
|
|
|
def padded_length
|
|
Object.padded( 4 * get_type().instance_length + @char_length )
|
|
end
|
|
|
|
# copy a chunk from the given word, to the current one
|
|
# start at to index at self
|
|
# start at from index at the given word
|
|
# copy length amount of characters
|
|
def copy_to_from(to , word , from , len)
|
|
raise "from not in range #{from}:#{len}" if (from + len) > word.length
|
|
raise "to not in range #{to}:#{len}" if (to + len) > self.length
|
|
while( len > 0)
|
|
len -= 1
|
|
set_char( to + len , word.get_char(from + len))
|
|
end
|
|
self
|
|
end
|
|
|
|
# insert the string other, at index index
|
|
# index may be negative in which case it counts from the end
|
|
def insert(index, other)
|
|
index += (length + 1) if index < 0
|
|
copy = Word.new( length + other.length )
|
|
copy.copy_to_from(0 , self , 0 , index )
|
|
copy.copy_to_from(index , other , 0 , other.length)
|
|
copy.copy_to_from(index + other.length , self , index , copy.length - index - other.length)
|
|
end
|
|
|
|
def start_with(other)
|
|
return false if other.length > self.length
|
|
s = other.length
|
|
i=0
|
|
while i<=s-1
|
|
if other.get_char(i) != self.get_char(i)
|
|
return false
|
|
end
|
|
i=i+1
|
|
end
|
|
return true
|
|
end
|
|
|
|
private
|
|
def check_length
|
|
raise "Length out of bounds #{char_length}" if @char_length > 1000
|
|
end
|
|
end
|
|
|
|
end
|