shotgun/lib/bytearray.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3
   4 #include "shotgun/lib/shotgun.h"
   5 #include "shotgun/lib/object.h"
   6 #include "shotgun/lib/bytearray.h"
   7
   8 OBJECT bytearray_new(STATE, unsigned int size) {
   9   unsigned int words;
  10   OBJECT obj;
  11
  12   words = size / SIZE_OF_OBJECT;
  13   if(size % SIZE_OF_OBJECT != 0) {
  14     words += 1;
  15   }
  16
  17   obj = bytearray_allocate_with_extra(state, words);
  18   object_make_byte_storage(state, obj);
  19   fast_memfill(BYTES_OF(obj), 0, words);
  20   object_initialize_bytes(state, obj);
  21   return obj;
  22 }
  23
  24 OBJECT bytearray_new_dirty(STATE, unsigned int size) {
  25   unsigned int words;
  26   OBJECT obj;
  27
  28   words = size / SIZE_OF_OBJECT;
  29   if(size % SIZE_OF_OBJECT != 0) {
  30     words += 1;
  31   }
  32
  33   obj = object_memory_new_dirty_object(state->om, BASIC_CLASS(bytearray), words);
  34   object_make_byte_storage(state, obj);
  35
  36   return obj;
  37 }
  38
  39 OBJECT bytearray_dup(STATE, OBJECT self) {
  40   OBJECT obj;
  41   int words = NUM_FIELDS(self);
  42
  43   obj = object_memory_new_dirty_object(state->om, BASIC_CLASS(bytearray), words);
  44   object_make_byte_storage(state, obj);
  45
  46   object_copy_body(state, self, obj);
  47
  48   return obj;
  49 }
  50
  51 char *bytearray_as_string(STATE, OBJECT self) {
  52   char *str;
  53   char *out;
  54   unsigned int sz;
  55
  56   str = (char*)bytearray_byte_address(state, self);
  57
  58   sz = object_size(state, self);
  59   out = ALLOC_N(char, sz);
  60   memcpy(out, str, sz);
  61
  62   return out;
  63 }
  64
  65 OBJECT iseq_new(STATE, unsigned int sz) {
  66   OBJECT obj;
  67   int fields;
  68
  69   fields = sz / SIZE_OF_OBJECT;
  70   if(sz % SIZE_OF_OBJECT != 0) {
  71     fields += 1;
  72   }
  73   obj = NEW_OBJECT(state->global->iseq, fields);
  74   object_make_byte_storage(state, obj);
  75
  76   return obj;
  77 }
  78
  79 static inline uint32_t read_int_from_be(uint8_t *str) {
  80   return (uint32_t)((str[0] << 24)
  81                   | (str[1] << 16)
  82                   | (str[2] << 8 )
  83                   |  str[3]      );
  84 }
  85
  86 void iseq_flip(STATE, OBJECT self, OBJECT output) {
  87   uint8_t *buf;
  88   uint32_t *ibuf;
  89   uint32_t val;
  90   int i, f;
  91
  92   f = object_size(state, self);
  93   buf = (uint8_t*)bytearray_byte_address(state, self);
  94   ibuf = (uint32_t*)bytearray_byte_address(state, output);
  95
  96   /* A sanity check. The first thing is always an instruction,
  97    * and we've got less that 1024 instructions, so if it's less
  98    * it's already been flipped. */
  99   if(*(uint32_t*)buf < 1024) return;
 100
 101   for(i = 0; i < f; i += 4, ibuf++) {
 102     val = read_int_from_be(buf + i);
 103     *ibuf = val;
 104   }
 105 }