# Copyright 2018 Braxton Mckee

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

from nativepython.type_wrappers.refcounted_wrapper import RefcountedWrapper

import nativepython.type_wrappers.runtime_functions as runtime_functions

from typed_python import Bytes

import nativepython.native_ast as native_ast

import nativepython

from nativepython.native_ast import VoidPtr

typeWrapper = lambda t: nativepython.python_object_representation.typedPythonTypeToTypeWrapper(t)

class BytesWrapper(RefcountedWrapper):

is_pod = False

is_empty = False

is_pass_by_ref = True

def __init__(self):

super().__init__(Bytes)

self.layoutType = native_ast.Type.Struct(element_types=(

('refcount', native_ast.Int64),

('data', native_ast.UInt8)

), name='StringLayout').pointer()

def getNativeLayoutType(self):

return self.layoutType

def on_refcount_zero(self, context, instance):

assert instance.isReference

return runtime_functions.free.call(instance.nonref_expr.cast(native_ast.UInt8Ptr))

def convert_bin_op(self, context, left, op, right):

if right.expr_type == left.expr_type:

if op.matches.Add:

return context.push(

bytes,

lambda bytesRef: bytesRef.expr.store(

runtime_functions.bytes_concat.call(

left.nonref_expr.cast(VoidPtr),

right.nonref_expr.cast(VoidPtr)

).cast(self.layoutType)

)

)

return super().convert_bin_op(context, left, op, right)

def convert_getitem(self, context, expr, item):

item = item.toInt64()

len_expr = self.convert_len(context, expr)

with context.ifelse((item.nonref_expr.lt(len_expr.nonref_expr.negate())).bitor(item.nonref_expr.gte(len_expr.nonref_expr))) as (true, false):

with true:

context.pushException(IndexError, "index out of range")

return context.pushPod(

int,

expr.nonref_expr.ElementPtrIntegers(0, 1).elemPtr(

native_ast.Expression.Branch(

cond=item.nonref_expr.lt(native_ast.const_int_expr(0)),

false=item.nonref_expr,

true=item.nonref_expr.add(len_expr.nonref_expr)

).add(native_ast.const_int_expr(8))

).load().cast(native_ast.Int64)

)

def convert_len_native(self, expr):

return native_ast.Expression.Branch(

cond=expr,

false=native_ast.const_int_expr(0),

true=expr.ElementPtrIntegers(0, 1).ElementPtrIntegers(4).cast(native_ast.Int32.pointer()).load().cast(native_ast.Int64)

)

def convert_len(self, context, expr):

return context.pushPod(int, self.convert_len_native(expr.nonref_expr))

def constant(self, context, s):

return context.push(

bytes,

lambda bytesRef: bytesRef.expr.store(

runtime_functions.bytes_from_ptr_and_len.call(

native_ast.const_bytes_cstr(s),

native_ast.const_int_expr(len(s))

).cast(self.layoutType)

)

)