import pixie.vm2.rt as rt

from pixie.vm2.object import Object, Type, affirm, runtime_error

from pixie.vm2.code import extend_var, as_var, wrap_fn

from pixie.vm2.primitives import nil, true, false

from pixie.vm2.numbers import Integer

#import pixie.vm2.stdlib as proto

#import pixie.vm2.util as util

from rpython.rlib.rarithmetic import intmask, r_uint

import rpython.rlib.jit as jit

#from pixie.vm2.libs.pxic.util import add_marshall_handlers

class String(Object):

_type = Type(u"pixie.stdlib.String")

def type(self):

return String._type

def __init__(self, s):

#assert isinstance(s, unicode)

self._str = s

def get_name(self):

return self._str

def get_ns(self):

return None

@as_var("-str-len")

def str_len(self):

assert isinstance(self, String)

return rt.wrap(len(self._str))

@as_var("-str-nth")

def str_len(self, idx):

assert isinstance(self, String)

i = idx.int_val()

return char_cache.intern(ord(self._str[i]))

@as_var("pixie.string", "-substring")

def substring3(a, start, end):

affirm(isinstance(a, String), u"First argument must be a string")

affirm(isinstance(start, Integer) and isinstance(end, Integer), u"Second and third argument must be integers")

start = start.int_val()

end = end.int_val()

if start >= 0 and end >= 0:

return rt.wrap(a.get_name()[start:end])

else:

runtime_error(u"Second and third argument must be non-negative integers")

#

#

# @extend(proto._str, String)

# def _str(x):

# return x

#

# @extend(proto._repr, String)

# def _repr(self):

# res = u""

# assert isinstance(self, String)

# for c in self._str:

# if c == "\"":

# res += u"\\\""

# elif c == "\n":

# res += u"\\n"

# elif c == "\t":

# res += u"\\t"

# elif c == "\b":

# res += u"\\b"

# elif c == "\f":

# res += u"\\f"

# elif c == "\r":

# res += u"\\r"

# else:

# res += c

# return rt.wrap(u"\"" + res + u"\"")

#

# @extend(proto._count, String)

# def _count(self):

# assert isinstance(self, String)

# return rt.wrap(len(self._str))

#

# @extend(proto._nth, String)

# def _nth(self, idx):

# assert isinstance(self, String)

# i = idx.int_val()

# if 0 <= i < len(self._str):

# return Character(ord(self._str[i]))

# affirm(False, u"Index out of Range")

#

# @extend(proto._nth_not_found, String)

# def _nth_not_found(self, idx, not_found):

# assert isinstance(self, String)

# i = idx.int_val()

# if 0 <= i < len(self._str):

# return Character(ord(self._str[i]))

# return not_found

#

@extend_var(u"pixie.stdlib", u"-eq", String)

def _eq(self, v):

assert isinstance(self, String)

if not isinstance(v, String):

return false

return true if self._str == v._str else false

#

class Character(Object):

_type = Type(u"pixie.stdlib.Character")

_immutable_fields_ = ["_char_val"]

def type(self):

return Character._type

def __init__(self, i):

assert isinstance(i, int)

self._char_val = i

def char_val(self):

return self._char_val

def int_val(self):

return self._char_val

def to_str(self):

assert isinstance(self, Character)

return u"" + unichr(self.char_val())

def to_repr(self):

assert isinstance(self, Character)

cv = self.char_val()

if cv < 128:

return u"\\"+unicode(chr(cv))

return u"FIXME"

#hexv = rt.name(rt.bit_str(rt.wrap(self.char_val()), rt.wrap(4)))

#return rt.wrap(u"\\u" + u"0" * (4 - len(hexv)) + hexv)

class CharCache(object):

def __init__(self):

self._char_cache = {}

self._rev = 0

@jit.elidable_promote()

def intern_inner(self, ival, rev):

return self._char_cache.get(ival, None)

def intern(self, ival):

v = self.intern_inner(ival, self._rev)

if not v:

v = Character(ival)

self._char_cache[ival] = v

self._rev += 1

return v

char_cache = CharCache()

@as_var("char")

def char(val):

affirm(isinstance(val, Integer), u"First argument must be an Integer")

return char_cache.intern(val.int_val())

# @wrap_fn

# def write_char(obj):

# assert isinstance(obj, Character)

# return rt.wrap(obj._char_val)

#

# @wrap_fn

# def read_char(obj):

# return Character(obj.int_val())

#

# add_marshall_handlers(Character._type, write_char, read_char)

#

# @extend(proto._str, Character)

# def _str(self):

# assert isinstance(self, Character)

# return rt.wrap(u"" + unichr(self.char_val()))

#

# @extend(proto._repr, Character)

# def _repr(self):

# assert isinstance(self, Character)

# cv = self.char_val()

# if cv < 128:

# return rt.wrap(u"\\"+unicode(chr(cv)))

# hexv = rt.name(rt.bit_str(rt.wrap(self.char_val()), rt.wrap(4)))

# return rt.wrap(u"\\u" + u"0" * (4 - len(hexv)) + hexv)

#

# @extend(proto._eq, Character)

# def _eq(self, obj):

# assert isinstance(self, Character)

# if self is obj:

# return true

# if not isinstance(obj, Character):

# return false

# return true if self.char_val() == obj.char_val() else false

#

# @extend(proto._hash, Character)

# def _hash(self):

# return rt.wrap(intmask(util.hash_int(r_uint(self.char_val()))))

#

# @as_var("char")

# def char(val):

# affirm(isinstance(val, Integer), u"First argument must be an Integer")

# return Character(val.int_val())

#

# @extend(_add, Character._type, Integer._type)

# def _add(a, b):

# assert isinstance(a, Character) and isinstance(b, Integer)

# return rt._add(rt.wrap(a.char_val()), b)

#

# @extend(_add, Character._type, Character._type)

# def _add(a, b):

# assert isinstance(a, Character) and isinstance(b, Character)

# return Character(a.char_val() + b.char_val())

#

#

# @extend(proto._name, String)

# def _name(self):

# return self

#

# @extend(proto._namespace, String)

# def _namespace(self):

# return nil

#

# @extend(proto._hash, String)

# def _hash(self):

# assert isinstance(self, String)

# return rt.wrap(intmask(util.hash_unencoded_chars(self._str)))

@as_var("pixie.string", "starts-with?")

def startswith(a, b):

return rt.wrap(a.get_name().startswith(b.get_name()))

@as_var("pixie.string", "ends-with?")

def endswith(a, b):

return rt.wrap(a.get_name().endswith(b.get_name()))

@as_var("pixie.string", "replace")

def str_replace(s, sfrom, sto):

affirm(isinstance(s, String), u"Expected string")

affirm(isinstance(sfrom, String), u"Expected string")

affirm(isinstance(sto, String), u"Expected string")

return rt.wrap(s.get_name().replace(sfrom.get_name()[0], sto.get_name()[0]))